¿Qué es un puntero inteligente y cuándo debo usar uno?
¿Qué es un puntero inteligente y cuándo debo usar
1821
Un tipo de datos abstracto que simula un puntero mientras proporciona características adicionales, como recolección automática de basura o verificación de límites.
¿Qué es un puntero inteligente y cuándo debo usar
std::unique_ptr tiene soporte para matrices, por ejemplo: std::unique_ptr<int[]> p(new int[10]); pero es necesario? probablemente sea más conveniente usar std::vectoro std::array. ¿Encuentra algún uso para esa
Ok, entonces la última vez que escribí C ++ para ganarme la vida, std::auto_ptrera todo lo que tenía disponible la biblioteca estándar , y boost::shared_ptrestaba de moda. Realmente nunca examiné el aumento de otros tipos de punteros inteligentes proporcionados. Entiendo que C ++ 11 ahora...
¿Cuál es la diferencia entre el siguiente conjunto de punteros? ¿Cuándo utiliza cada puntero en el código de producción, si es que lo hace? ¡Los ejemplos serían apreciados! scoped_ptr shared_ptr weak_ptr intrusive_ptr ¿Usas boost en el código de
¿Qué tiene de malo este programa? #include <memory> #include <vector> int main() { std::vector<std::unique_ptr<int>> vec; int x(1); std::unique_ptr<int> ptr2x(&x); vec.push_back(ptr2x); //This tiny command has a vicious error. return 0; } El error: In...
En la práctica con C ++, ¿qué es RAII , qué son los punteros inteligentes , cómo se implementan en un programa y cuáles son los beneficios de usar RAII con punteros
Con la llegada del nuevo estándar (y partes ya disponibles en algunos compiladores), std::unique_ptrse supone que el nuevo tipo es un reemplazo std::auto_ptr. ¿Su uso se superpone exactamente (por lo que puedo hacer una búsqueda / reemplazo global en mi código (no es que lo haría, pero si lo...
Tengo problemas para entender el uso de punteros inteligentes como miembros de clase en C ++ 11. He leído mucho sobre punteros inteligentes y creo que entiendo cómo unique_ptry shared_ptr/ o weak_ptrtrabajo en general. Lo que no entiendo es el uso real. Parece que todo el mundo recomienda usarlo...
Leí en algunos artículos que los punteros en bruto casi nunca deberían usarse. En su lugar, siempre deben estar envueltos dentro de punteros inteligentes, ya sean punteros de alcance o compartidos. Sin embargo, noté que marcos como Qt, wxWidgets y bibliotecas como Boost nunca regresan ni esperan...
He estado buscando el código fuente de Clang y encontré este fragmento: void CompilerInstance::setInvocation( std::shared_ptr<CompilerInvocation> Value) { Invocation = std::move(Value); } ¿Por qué querría std::moveun std::shared_ptr? ¿Hay algún punto para transferir la propiedad de un...
¿ std::make_uniqueTiene algún beneficio de eficiencia como std::make_shared? En comparación con la construcción manual std::unique_ptr: std::make_unique<int>(1); // vs std::unique_ptr<int>(new
Comparaciones, ventajas, desventajas y cuándo usar Este es un spin-off de un hilo de recolección de basura donde lo que pensé que era una respuesta simple generó muchos comentarios sobre algunas implementaciones específicas de puntero inteligente, por lo que parecía que valía la pena comenzar una...
Es difícil saber qué se pregunta aquí. Esta pregunta es ambigua, vaga, incompleta, demasiado amplia o retórica y no puede responderse razonablemente en su forma actual. Para obtener ayuda para aclarar esta pregunta y poder volver a abrirla, visite el Centro de ayuda .
Estoy tan frustrado en este momento después de varias horas tratando de encontrar dónde se encuentra shared_ptr. Ninguno de los ejemplos que veo muestra un código completo para incluir los encabezados shared_ptr(y en funcionamiento). Simplemente diciendo std, ¡ tr1y <memory>no está ayudando...
¿Cuánto es la sobrecarga de los punteros inteligentes en comparación con los punteros normales en C ++ 11? En otras palabras, ¿mi código será más lento si utilizo punteros inteligentes y, de ser así, cuánto más lento? Específicamente, estoy preguntando sobre C ++ 11 std::shared_ptry...
La pregunta realmente encaja en el título: tengo curiosidad por saber cuál es la razón técnica de esta diferencia, pero también la justificación. std::shared_ptr<void> sharedToVoid; // legal; std::unique_ptr<void> uniqueToVoid; //
Digamos que tengo una clase con un método que devuelve un shared_ptr. ¿Cuáles son los posibles beneficios e inconvenientes de devolverlo por referencia o por valor? Dos posibles pistas: Destrucción temprana de objetos. Si devuelvo la shared_ptrreferencia by (const), el contador de referencia no...
¿Cuál es el mejor método para pasar a shared_ptrde un tipo derivado a una función que toma a shared_ptrde un tipo base? Generalmente paso shared_ptrs por referencia para evitar una copia innecesaria: int foo(const shared_ptr<bar>& ptr); pero esto no funciona si trato de hacer algo...
Escuché que auto_ptrestá siendo obsoleto en C ++ 11. ¿Cuál es la razón para esto? También me gustaría saber la diferencia entre auto_ptry shared_ptr.
El Sr. Lidström y yo tuvimos una discusión :) La afirmación del Sr. Lidström es que una construcción shared_ptr<Base> p(new Derived);no requiere que Base tenga un destructor virtual: Armen Tsirunyan : "¿En serio? ¿El shared_ptr se limpiará correctamente? ¿Podrías demostrar en este caso...