Los punteros inteligentes son punteros debajo, ¿hay alguna manera de definir un parámetro shared_ptr para una función como no asociar otro shared_ptr u otro puntero de cualquier tipo?¿Se puede aplicar __restrict__ a shared_ptr <T>?
¿O es esto, por alguna razón, innecesario?
Me preocupan los compiladores gcc> = 4.2 y llvm-clang> = 2.0 (las respuestas para otros compiladores también serían interesantes).
Simplemente extraiga los punteros con .get() y márquelos como __restrict__. Recuerde, poner __restrict__ en los parámetros de función es lo mismo que poner __restrict__ en variables locales. En particular, el compilador no intenta evitar que llame a la función con dos punteros que obviamente apuntan al mismo objeto; p.ej. foo(i,i).
Si desea hacer una promesa al compilador que ciertos indicadores no hacen referencia a unos de otros, lo que permite al compilador para hacer más optimizaciones, a continuación, utilizar el código de abajo y hacer sus operaciones a través de xp y yp en lugar de x y y .
#include<iostream>
#include<memory>
using namespace std;
void foo(shared_ptr<int> x, shared_ptr<int> y) {
int * __restrict__ xp = x.get();
int * __restrict__ yp = y.get();
}
int main() {
shared_ptr<int> i = make_shared<int>(3);
shared_ptr<int> j = make_sharet<int>(4);
foo(i,j);
}
¿Por qué dice que marcar los parámetros de la función como 'restringir' es diferente de declarar variables de puntero' restrict' locales? ¿Tiene algo que ver con la optimización 'gcc' o es un comportamiento subyacente de' restrict' (que no entiendo actualmente;)) –
Digo que es * no * diferente. Intentaré reformularlo para que sea más claro. –
Iba a escribir esto, pero no pude encontrar CUALQUIER gramática para '__restrict__' que dijera si estaba permitido en variables locales. ¿Hay documentación en alguna parte? –
Si desea realizar operaciones no-alias en el objeto subyacente asociada con un puntero compartida que podría delegar de forma explícita a una rutina trabajador que toma un parámetro de puntero no-alias:
void worker (mytype *__restrict x, mytype *__restrict y)
{
// do something with x, y with a no-alias guarantee
}
int main()
{
std::shared_ptr<mytype> p(new mytype);
std::shared_ptr<mytype> q(new mytype);
// explicitly delegate the shared object
worker(p.get(), q.get());
return 0;
}
No estoy Asegúrese exactamente de lo que tiene en mente, pero esto permitiría que la gestión de memoria de alto nivel sea tratada de manera segura por el puntero inteligente, mientras que hace el trabajo de bajo nivel posiblemente de manera más eficiente con punteros sin alias.
Como @BenVoigt señaló, restrict es solo oficialmente parte de c99 - c++ se supone que no debe saber nada al respecto. MSVC lo admite de todos modos a través de __restrict y como ha dicho GCC tiene __restrict__.
Espero que esto ayude.
C++ no tiene ninguna palabra clave 'restrict' o' __restrict__'. Si pregunta por las extensiones de idioma en un compilador en particular, debe indicar cuál. –
@BenVoigt lo siento - aclarado en la edición. – James
Parece poco probable que un elemento que desee trabajar con punteros restringidos desee reclamar la propiedad compartida del puntero. Sin mencionar que en un sistema con propiedad compartida terminas sabiendo que los indicadores son realmente distintos. En cualquier caso, supongo que su función realky quiere tomar punteros [restringidos] en lugar de 'std :: shared_ptr' s. –