¿Por qué debería usar un puntero en lugar del objeto mismo?

Vengo de un fondo Java y he comenzado a trabajar con objetos en C ++. Pero una cosa que se me ocurrió es que las personas a menudo usan punteros a los objetos en lugar de los objetos en sí, por ejemplo, esta declaración:

Object *myObject = new Object;

más bien que:

Object myObject;

O en lugar de usar una función, digamos testFunc(), así:

myObject.testFunc();

tenemos que escribir:

myObject->testFunc();

Pero no puedo entender por qué deberíamos hacerlo de esta manera. Supongo que tiene que ver con la eficiencia y la velocidad, ya que tenemos acceso directo a la dirección de memoria. Estoy en lo cierto?

Es muy lamentable que vea la asignación dinámica tan a menudo. Eso solo muestra cuántos malos programadores de C ++ hay.

En cierto sentido, tiene dos preguntas agrupadas en una. La primera es ¿cuándo debemos usar la asignación dinámica (usando new)? La segunda es ¿cuándo debemos usar punteros?

El mensaje importante para llevar a casa es que siempre debe usar la herramienta adecuada para el trabajo . En casi todas las situaciones, hay algo más apropiado y más seguro que realizar una asignación dinámica manual y / o usar punteros sin procesar.

Asignación dinámica

En su pregunta, ha demostrado dos formas de crear un objeto. La principal diferencia es la duración del almacenamiento del objeto. Al hacerlo Object myObject;dentro de un bloque, el objeto se crea con una duración de almacenamiento automática, lo que significa que se destruirá automáticamente cuando salga del alcance. Cuando lo hace new Object(), el objeto tiene una duración de almacenamiento dinámico, lo que significa que permanece vivo hasta que lo explicite delete. Solo debe usar la duración del almacenamiento dinámico cuando lo necesite. Es decir, siempre debe preferir crear objetos con una duración de almacenamiento automática cuando pueda .

Las dos situaciones principales en las que puede requerir una asignación dinámica:

1. Necesita el objeto para sobrevivir al alcance actual : ese objeto específico en esa ubicación de memoria específica, no una copia del mismo. Si está de acuerdo con copiar / mover el objeto (la mayoría de las veces debería hacerlo), debería preferir un objeto automático.
2. Necesita asignar mucha memoria , que puede llenar fácilmente la pila. Sería bueno si no tuviéramos que preocuparnos por esto (la mayoría de las veces no debería tener que hacerlo), ya que está realmente fuera del alcance de C ++, pero desafortunadamente, tenemos que lidiar con la realidad de los sistemas estamos desarrollando para

Cuando realmente requiera una asignación dinámica, debe encapsularla en un puntero inteligente o en algún otro tipo que realice RAII (como los contenedores estándar). Los punteros inteligentes proporcionan semántica de propiedad de objetos asignados dinámicamente. Echa un vistazo a std::unique_ptry std::shared_ptr, por ejemplo. Si los usa de manera adecuada, puede evitar casi por completo realizar su propia administración de memoria (consulte la Regla de cero ).

Punteros

Sin embargo, existen otros usos más generales para los punteros sin procesar más allá de la asignación dinámica, pero la mayoría tiene alternativas que debería preferir. Como antes, siempre prefiera las alternativas a menos que realmente necesite punteros .

1. Necesita semántica de referencia . A veces, desea pasar un objeto utilizando un puntero (independientemente de cómo se asignó) porque desea que la función a la que lo pasa tenga acceso a ese objeto específico (no una copia del mismo). Sin embargo, en la mayoría de las situaciones, debe preferir los tipos de referencia a los punteros, porque esto es específicamente para lo que están diseñados. Tenga en cuenta que esto no se trata necesariamente de extender la vida útil del objeto más allá del alcance actual, como en la situación 1 anterior. Como antes, si está de acuerdo con pasar una copia del objeto, no necesita semántica de referencia.

2. Necesitas polimorfismo . Solo puede llamar a las funciones polimórficamente (es decir, según el tipo dinámico de un objeto) a través de un puntero o referencia al objeto. Si ese es el comportamiento que necesita, entonces necesita usar punteros o referencias. Nuevamente, se deben preferir las referencias.

3. Desea representar que un objeto es opcional al permitir nullptrque se pase uno cuando se omite el objeto. Si se trata de un argumento, debería preferir utilizar argumentos predeterminados o sobrecargas de funciones. De lo contrario, debe usar preferiblemente un tipo que encapsule este comportamiento, como std::optional(introducido en C ++ 17 - con estándares anteriores de C ++, use boost::optional).

4. Desea desacoplar unidades de compilación para mejorar el tiempo de compilación . La propiedad útil de un puntero es que solo necesita una declaración directa del tipo señalado (para usar realmente el objeto, necesitará una definición). Esto le permite desacoplar partes de su proceso de compilación, lo que puede mejorar significativamente el tiempo de compilación. Ver el idioma Pimpl .

5. Necesita interactuar con una biblioteca C o una biblioteca de estilo C. En este punto, te ves obligado a usar punteros en bruto. Lo mejor que puede hacer es asegurarse de que solo suelte sus punteros crudos en el último momento posible. Puede obtener un puntero sin formato a partir de un puntero inteligente, por ejemplo, utilizando su getfunción miembro. Si una biblioteca realiza una asignación para usted que espera que desasigne a través de un identificador, a menudo puede envolver el identificador en un puntero inteligente con un eliminador personalizado que desasignará el objeto adecuadamente.

Hay muchos casos de uso para punteros.

Comportamiento polimórfico . Para los tipos polimórficos, se utilizan punteros (o referencias) para evitar el corte:

class Base { ... };
class Derived : public Base { ... };

void fun(Base b) { ... }
void gun(Base* b) { ... }
void hun(Base& b) { ... }

Derived d;
fun(d);    // oops, all Derived parts silently "sliced" off
gun(&d);   // OK, a Derived object IS-A Base object
hun(d);    // also OK, reference also doesn't slice

Semántica de referencia y evitando copiar . Para los tipos no polimórficos, un puntero (o una referencia) evitará copiar un objeto potencialmente costoso

Base b;
fun(b);  // copies b, potentially expensive 
gun(&b); // takes a pointer to b, no copying
hun(b);  // regular syntax, behaves as a pointer

Tenga en cuenta que C ++ 11 tiene una semántica de movimiento que puede evitar muchas copias de objetos caros en argumentos de función y como valores de retorno. Pero usar un puntero definitivamente los evitará y permitirá múltiples punteros en el mismo objeto (mientras que un objeto solo se puede mover de una vez).

Adquisición de recursos . Crear un puntero a un recurso utilizando el newoperador es un antipatrón en C ++ moderno. Utilice una clase de recurso especial (uno de los contenedores estándar) o un puntero inteligente ( std::unique_ptr<>o std::shared_ptr<>). Considerar:

{
    auto b = new Base;
    ...       // oops, if an exception is thrown, destructor not called!
    delete b;
}

vs.

{
    auto b = std::make_unique<Base>();
    ...       // OK, now exception safe
}

Un puntero en bruto solo debe usarse como una "vista" y no de ninguna manera involucrado en la propiedad, ya sea a través de la creación directa o implícitamente a través de valores de retorno. Consulte también estas preguntas y respuestas de las preguntas frecuentes de C ++ .

Control de vida útil más detallado Cada vez que se copia un puntero compartido (por ejemplo, como argumento de función), el recurso al que apunta se mantiene vivo. Los objetos normales (no creados por newusted, ya sea directamente por usted o dentro de una clase de recurso) se destruyen cuando salen del alcance.

Hay muchas respuestas excelentes a esta pregunta, incluidos los casos de uso importantes de declaraciones directas, polimorfismo, etc.

Examinemos la situación comparando los dos idiomas:

Java:

Object object1 = new Object(); //A new object is allocated by Java
Object object2 = new Object(); //Another new object is allocated by Java

object1 = object2; 
//object1 now points to the object originally allocated for object2
//The object originally allocated for object1 is now "dead" - nothing points to it, so it
//will be reclaimed by the Garbage Collector.
//If either object1 or object2 is changed, the change will be reflected to the other

El equivalente más cercano a esto es:

C ++:

Object * object1 = new Object(); //A new object is allocated on the heap
Object * object2 = new Object(); //Another new object is allocated on the heap
delete object1;
//Since C++ does not have a garbage collector, if we don't do that, the next line would 
//cause a "memory leak", i.e. a piece of claimed memory that the app cannot use 
//and that we have no way to reclaim...

object1 = object2; //Same as Java, object1 points to object2.

Veamos la forma alternativa de C ++:

Object object1; //A new object is allocated on the STACK
Object object2; //Another new object is allocated on the STACK
object1 = object2;//!!!! This is different! The CONTENTS of object2 are COPIED onto object1,
//using the "copy assignment operator", the definition of operator =.
//But, the two objects are still different. Change one, the other remains unchanged.
//Also, the objects get automatically destroyed once the function returns...

La mejor manera de pensarlo es que, más o menos, Java maneja (implícitamente) punteros a objetos, mientras que C ++ puede manejar punteros a objetos o los propios objetos. Hay excepciones a esto: por ejemplo, si declara tipos "primitivos" de Java, son valores reales que se copian y no punteros. Entonces,

Java:

int object1; //An integer is allocated on the stack.
int object2; //Another integer is allocated on the stack.
object1 = object2; //The value of object2 is copied to object1.

Dicho esto, el uso de punteros NO es necesariamente la forma correcta o incorrecta de manejar las cosas; sin embargo, otras respuestas lo han cubierto satisfactoriamente. Sin embargo, la idea general es que en C ++ tienes mucho más control sobre la vida útil de los objetos y sobre dónde vivirán.

Punto de referencia: la Object * object = new Object()construcción es en realidad lo más parecido a la semántica típica de Java (o C # para el caso).

Otra buena razón para usar punteros sería para las declaraciones a futuro . En un proyecto lo suficientemente grande, realmente pueden acelerar el tiempo de compilación.

Prefacio

Java no se parece en nada a C ++, a diferencia del bombo publicitario. La máquina exagerada de Java quiere que creas que debido a que Java tiene una sintaxis similar a C ++, los lenguajes son similares. Nada puede estar más lejos de la verdad. Esta información errónea es parte de la razón por la cual los programadores de Java van a C ++ y usan una sintaxis similar a Java sin comprender las implicaciones de su código.

En adelante vamos

Pero no puedo entender por qué deberíamos hacerlo de esta manera. Supongo que tiene que ver con la eficiencia y la velocidad, ya que tenemos acceso directo a la dirección de memoria. Estoy en lo cierto?

Por el contrario, en realidad. El montón es mucho más lento que la pila, porque la pila es muy simple en comparación con el montón. Las variables de almacenamiento automático (también conocidas como variables de pila) tienen sus destructores llamados una vez que salen del alcance. Por ejemplo:

{
    std::string s;
}
// s is destroyed here

Por otro lado, si usa un puntero asignado dinámicamente, su destructor debe llamarse manualmente. deletellama a este destructor por ti.

{
    std::string* s = new std::string;
}
delete s; // destructor called

Esto no tiene nada que ver con la newsintaxis prevalente en C # y Java. Se usan para propósitos completamente diferentes.

Beneficios de la asignación dinámica

1. No tiene que saber el tamaño de la matriz de antemano

Uno de los primeros problemas con los que se encuentran muchos programadores de C ++ es que cuando aceptan entradas arbitrarias de los usuarios, solo se puede asignar un tamaño fijo para una variable de la pila. Tampoco puede cambiar el tamaño de las matrices. Por ejemplo:

char buffer[100];
std::cin >> buffer;
// bad input = buffer overflow

Por supuesto, si usó un std::stringen su lugar, std::stringinternamente cambia su tamaño para que no sea un problema. Pero esencialmente la solución a este problema es la asignación dinámica. Puede asignar memoria dinámica en función de la entrada del usuario, por ejemplo:

int * pointer;
std::cout << "How many items do you need?";
std::cin >> n;
pointer = new int[n];

Nota al margen : un error que cometen muchos principiantes es el uso de matrices de longitud variable. Esta es una extensión de GNU y también una en Clang porque reflejan muchas de las extensiones de GCC. Por lo tanto int arr[n], no se debe confiar en lo siguiente.

Debido a que el montón es mucho más grande que la pila, uno puede asignar / reasignar arbitrariamente tanta memoria como necesite, mientras que la pila tiene una limitación.

2. Las matrices no son punteros

¿Cómo es esto un beneficio que pides? La respuesta quedará clara una vez que comprenda la confusión / mito detrás de las matrices y los punteros. Se supone comúnmente que son iguales, pero no lo son. Este mito proviene del hecho de que los punteros se pueden suscribir al igual que las matrices y debido a que las matrices decaen a punteros en el nivel superior en una declaración de función. Sin embargo, una vez que una matriz se descompone en un puntero, el puntero pierde su sizeofinformación. Por sizeof(pointer)lo tanto , dará el tamaño del puntero en bytes, que generalmente es de 8 bytes en un sistema de 64 bits.

No puede asignar a matrices, solo inicializarlas. Por ejemplo:

int arr[5] = {1, 2, 3, 4, 5}; // initialization 
int arr[] = {1, 2, 3, 4, 5}; // The standard dictates that the size of the array
                             // be given by the amount of members in the initializer  
arr = { 1, 2, 3, 4, 5 }; // ERROR

Por otro lado, puedes hacer lo que quieras con punteros. Desafortunadamente, debido a que la distinción entre punteros y matrices se agita a mano en Java y C #, los principiantes no entienden la diferencia.

3. Polimorfismo

Java y C # tienen funciones que le permiten tratar los objetos como otro, por ejemplo, utilizando la aspalabra clave. Entonces, si alguien quisiera tratar un Entityobjeto como un Playerobjeto, uno podría hacerlo. Player player = Entity as Player;Esto es muy útil si tiene la intención de llamar a funciones en un contenedor homogéneo que solo debería aplicarse a un tipo específico. La funcionalidad se puede lograr de manera similar a continuación:

std::vector<Base*> vector;
vector.push_back(&square);
vector.push_back(&triangle);
for (auto& e : vector)
{
     auto test = dynamic_cast<Triangle*>(e); // I only care about triangles
     if (!test) // not a triangle
        e.GenericFunction();
     else
        e.TriangleOnlyMagic();
}

Entonces, si solo Triángulos tuviera una función Rotar, sería un error del compilador si intentara llamarlo en todos los objetos de la clase. Usando dynamic_cast, puede simular la aspalabra clave. Para ser claros, si un lanzamiento falla, devuelve un puntero no válido. Entonces, !testes esencialmente una abreviatura para verificar si testes NULL o un puntero no válido, lo que significa que el lanzamiento falló.

Beneficios de las variables automáticas.

Después de ver todas las excelentes cosas que puede hacer la asignación dinámica, probablemente se esté preguntando por qué nadie NO usaría la asignación dinámica todo el tiempo. Ya te dije una razón, el montón es lento. Y si no necesita toda esa memoria, no debe abusar de ella. Así que aquí hay algunas desventajas sin ningún orden en particular:

• Es propenso a errores. La asignación manual de memoria es peligrosa y es propenso a fugas. Si no dominas el uso del depurador o valgrind(una herramienta de pérdida de memoria), puedes sacarte el cabello de la cabeza. Afortunadamente, los modismos RAII y los punteros inteligentes alivian un poco esto, pero debes estar familiarizado con prácticas como La regla de tres y La regla de cinco. Es una gran cantidad de información, y los principiantes que no saben o no les importa caerán en esta trampa.

• No es necesario. A diferencia de Java y C #, donde es idiomático usar la newpalabra clave en todas partes, en C ++, solo debe usarla si es necesario. La frase común dice, todo parece un clavo si tienes un martillo. Mientras que los principiantes que comienzan con C ++ tienen miedo de los punteros y aprenden a usar variables de pila por hábito, los programadores de Java y C # comienzan usando punteros sin entenderlo. Eso es literalmente pisar el pie equivocado. Debes abandonar todo lo que sabes porque la sintaxis es una cosa, aprender el idioma es otra.

1. (N) RVO - Aka, (Nombre) Optimización del valor de retorno

Una optimización que hacen muchos compiladores son las llamadas elisión y optimización del valor de retorno . Estas cosas pueden obviar copias innecesarias que son útiles para objetos que son muy grandes, como un vector que contiene muchos elementos. Normalmente, la práctica común es usar punteros para transferir la propiedad en lugar de copiar los objetos grandes para moverlos . Esto ha llevado al inicio de la semántica del movimiento y los punteros inteligentes .

Si está utilizando punteros, (N) RVO NO se produce. Es más beneficioso y menos propenso a errores aprovechar (N) RVO en lugar de devolver o pasar punteros si le preocupa la optimización. Pueden producirse fugas de error si el llamador de una función es responsable de deletecrear un objeto asignado dinámicamente y tal. Puede ser difícil rastrear la propiedad de un objeto si los punteros se pasan como una papa caliente. Simplemente use variables de pila porque es más simple y mejor.

C ++ le ofrece tres formas de pasar un objeto: por puntero, por referencia y por valor. Java lo limita con el último (la única excepción son los tipos primitivos como int, boolean, etc.). Si desea utilizar C ++ no solo como un juguete extraño, será mejor que conozca la diferencia entre estas tres formas.

Java pretende que no existe un problema como "¿quién y cuándo debería destruir esto?". La respuesta es: El recolector de basura, genial y horrible. Sin embargo, no puede proporcionar una protección del 100% contra pérdidas de memoria (sí, Java puede perder memoria ). En realidad, GC te da una falsa sensación de seguridad. Cuanto más grande sea tu SUV, más largo será tu camino hacia el evacuador.

C ++ te deja cara a cara con la gestión del ciclo de vida del objeto. Bueno, hay medios para lidiar con eso ( familia de punteros inteligentes , QObject en Qt y así sucesivamente), pero ninguno de ellos se puede usar de manera 'dispara y olvida' como GC: siempre debes tener en cuenta el manejo de la memoria. No solo deberías preocuparte por destruir un objeto, también debes evitar destruir el mismo objeto más de una vez.

¿Todavía no tienes miedo? Ok: referencias cíclicas, trátalos tú mismo, humano. Y recuerda: mata cada objeto con precisión una vez, a los tiempos de ejecución de C ++ no nos gustan los que se meten con los cadáveres, dejamos a los muertos en paz.

Entonces, volviendo a tu pregunta.

Cuando pasa su objeto por valor, no por puntero o por referencia, copia el objeto (todo el objeto, ya sea un par de bytes o un gran volcado de la base de datos; es lo suficientemente inteligente como para evitar este último, no t you?) cada vez que haces '='. Y para acceder a los miembros del objeto, usa '.' (punto).

Cuando pasa su objeto por puntero, copia solo unos pocos bytes (4 en sistemas de 32 bits, 8 en sistemas de 64 bits), a saber, la dirección de este objeto. Y para mostrar esto a todos, utiliza este elegante operador '->' cuando accedes a los miembros. O puede usar la combinación de '*' y '.'.

Cuando usa referencias, obtiene el puntero que pretende ser un valor. Es un puntero, pero accede a los miembros a través de '.'.

Y, para volverte loco una vez más: cuando declaras varias variables separadas por comas, entonces (mira las manos):

• El tipo se le da a todos
• El modificador de valor / puntero / referencia es individual

Ejemplo:

struct MyStruct
{
    int* someIntPointer, someInt; //here comes the surprise
    MyStruct *somePointer;
    MyStruct &someReference;
};

MyStruct s1; //we allocated an object on stack, not in heap

s1.someInt = 1; //someInt is of type 'int', not 'int*' - value/pointer modifier is individual
s1.someIntPointer = &s1.someInt;
*s1.someIntPointer = 2; //now s1.someInt has value '2'
s1.somePointer = &s1;
s1.someReference = s1; //note there is no '&' operator: reference tries to look like value
s1.somePointer->someInt = 3; //now s1.someInt has value '3'
*(s1.somePointer).someInt = 3; //same as above line
*s1.somePointer->someIntPointer = 4; //now s1.someInt has value '4'

s1.someReference.someInt = 5; //now s1.someInt has value '5'
                              //although someReference is not value, it's members are accessed through '.'

MyStruct s2 = s1; //'NO WAY' the compiler will say. Go define your '=' operator and come back.

//OK, assume we have '=' defined in MyStruct

s2.someInt = 0; //s2.someInt == 0, but s1.someInt is still 5 - it's two completely different objects, not the references to the same one

En C ++, los objetos asignados en la pila (usando la Object object;instrucción dentro de un bloque) solo vivirán dentro del alcance en el que se declaran. Cuando el bloque de código finaliza la ejecución, el objeto declarado se destruye. Mientras que si asigna memoria en el montón, usando Object* obj = new Object(), continúan viviendo en el montón hasta que llame delete obj.

Crearía un objeto en el montón cuando quisiera usar el objeto no solo en el bloque de código que lo declaró / asignó.

Pero no puedo entender por qué deberíamos usarlo así.

Compararé cómo funciona dentro del cuerpo de la función si usa:

Object myObject;

Dentro de la función, myObjectse destruirá una vez que esta función regrese. Esto es útil si no necesita su objeto fuera de su función. Este objeto se colocará en la pila de subprocesos actual.

Si escribe dentro del cuerpo de la función:

 Object *myObject = new Object;

entonces la instancia de clase de objeto señalada por myObjectno se destruirá una vez que finalice la función, y la asignación esté en el montón.

Ahora, si usted es un programador de Java, el segundo ejemplo está más cerca de cómo funciona la asignación de objetos en Java. Esta línea: Object *myObject = new Object;es equivalente a java: Object myObject = new Object();. La diferencia es que bajo java myObject se recolectará basura, mientras que bajo c ++ no se liberará, debe llamar explícitamente a `delete myObject; ' de lo contrario, introducirá pérdidas de memoria.

Desde c ++ 11 puede usar formas seguras de asignaciones dinámicas: new Objectalmacenando valores en shared_ptr / unique_ptr.

std::shared_ptr<std::string> safe_str = make_shared<std::string>("make_shared");

// since c++14
std::unique_ptr<std::string> safe_str = make_unique<std::string>("make_shared"); 

Además, los objetos se almacenan muy a menudo en contenedores, como mapas-s o vectores-s, administrarán automáticamente una vida útil de sus objetos.

Técnicamente es un problema de asignación de memoria, sin embargo, aquí hay dos aspectos más prácticos de esto. Tiene que ver con dos cosas: 1) Alcance, cuando define un objeto sin puntero, ya no podrá acceder a él después del bloque de código en el que está definido, mientras que si define un puntero con "nuevo", entonces puede acceder desde cualquier lugar donde tenga un puntero a esta memoria hasta que llame "eliminar" en el mismo puntero. 2) Si desea pasar argumentos a una función, quiere pasar un puntero o una referencia para ser más eficiente. Cuando pasa un Objeto, el objeto se copia; si se trata de un objeto que utiliza mucha memoria, puede consumir CPU (por ejemplo, copia un vector lleno de datos). Cuando pasa un puntero, todo lo que pasa es un int (dependiendo de la implementación, pero la mayoría de ellos son un int).

Aparte de eso, debe comprender que "nuevo" asigna memoria en el montón que debe liberarse en algún momento. Cuando no tenga que usar "nuevo", le sugiero que use una definición de objeto regular "en la pila".

Bueno, la pregunta principal es ¿Por qué debería usar un puntero en lugar del objeto en sí? Y mi respuesta es que (casi) nunca debe usar el puntero en lugar del objeto, porque C ++ tiene referencias , es más seguro que los punteros y garantiza el mismo rendimiento que los punteros.

Otra cosa que mencionaste en tu pregunta:

Object *myObject = new Object;

¿Como funciona? Crea un puntero de Objecttipo, asigna memoria para adaptarse a un objeto y llama al constructor predeterminado, suena bien, ¿verdad? Pero en realidad no es tan bueno, si asignó memoria dinámicamente (palabra clave utilizada new), también debe liberar memoria manualmente, eso significa que en el código debe tener:

delete myObject;

Esto llama al destructor y libera memoria, parece fácil, sin embargo, en grandes proyectos puede ser difícil detectar si un hilo liberó memoria o no, pero para ese propósito puede probar punteros compartidos , estos disminuyen ligeramente el rendimiento, pero es mucho más fácil trabajar con ellos. ellos.

Y ahora se acabó alguna introducción y volvemos a la pregunta.

Puede usar punteros en lugar de objetos para obtener un mejor rendimiento mientras transfiere datos entre funciones.

Eche un vistazo, tiene std::string(también es un objeto) y contiene mucha información, por ejemplo, XML grande, ahora necesita analizarlo, pero para eso tiene una función void foo(...)que puede declararse de diferentes maneras:

1. void foo(std::string xml); En este caso, copiará todos los datos de su variable a la pila de funciones, lleva un tiempo, por lo que su rendimiento será bajo.
2. void foo(std::string* xml); En este caso, pasará el puntero al objeto, a la misma velocidad que la size_tvariable de paso , sin embargo, esta declaración es propensa a errores, ya que puede pasar el NULLpuntero o un puntero no válido. Los punteros generalmente se usan Cporque no tiene referencias.
3. void foo(std::string& xml); Aquí pasa la referencia, básicamente es lo mismo que pasar el puntero, pero el compilador hace algunas cosas y no puede pasar una referencia no válida (en realidad, es posible crear una situación con una referencia no válida, pero está engañando al compilador).
4. void foo(const std::string* xml); Aquí es lo mismo que el segundo, solo el valor del puntero no se puede cambiar.
5. void foo(const std::string& xml); Aquí es lo mismo que el tercero, pero el valor del objeto no se puede cambiar.

Lo que más quiero mencionar es que puede usar estas 5 formas de pasar datos sin importar la forma de asignación que haya elegido (con newo regular ).

Otra cosa para mencionar, cuando crea objetos de manera regular , asigna memoria en la pila, pero mientras la crea con el newmontón. Asignar la pila es mucho más rápido, pero es un poco pequeño para matrices de datos realmente grandes, por lo que si necesita un objeto grande, debe usar el montón, porque puede obtener un desbordamiento de la pila, pero generalmente este problema se resuelve usando contenedores STL y recuerde std::stringtambién es contenedor, algunos chicos lo olvidaron :)

Digamos que tiene class Aese contenido. class BCuando desee llamar a alguna función de class Bafuera class A, simplemente obtendrá un puntero a esta clase y podrá hacer lo que quiera y también cambiará el contexto class Ben suclass A

Pero ten cuidado con el objeto dinámico

Hay muchos beneficios de usar punteros para objetar:

1. Eficiencia (como ya señaló). Pasar objetos a funciones significa crear nuevas copias de objetos.
2. Trabajando con objetos de bibliotecas de terceros. Si su objeto pertenece a un código de un tercero y los autores pretenden el uso de sus objetos solo a través de punteros (sin constructores de copia, etc.), la única forma en que puede pasar este objeto es mediante punteros. Pasar por valor puede causar problemas. (Problemas de copia profunda / copia superficial).
3. si el objeto posee un recurso y desea que la propiedad no se comparta con otros objetos.

Esto se ha discutido extensamente, pero en Java todo es un puntero. No hace distinción entre las asignaciones de pila y montón (todos los objetos se asignan en el montón), por lo que no se da cuenta de que está utilizando punteros. En C ++, puede mezclar los dos, según sus requisitos de memoria. El rendimiento y el uso de memoria es más determinista en C ++ (duh).

Object *myObject = new Object;

Hacer esto creará una referencia a un Objeto (en el montón) que debe eliminarse explícitamente para evitar pérdidas de memoria .

Object myObject;

Hacer esto creará un objeto (myObject) del tipo automático (en la pila) que se eliminará automáticamente cuando el objeto (myObject) salga del alcance.

Un puntero hace referencia directamente a la ubicación de la memoria de un objeto. Java no tiene nada como esto. Java tiene referencias que hacen referencia a la ubicación del objeto a través de tablas hash. No puede hacer nada como la aritmética de puntero en Java con estas referencias.

Para responder a su pregunta, es solo su preferencia. Prefiero usar la sintaxis similar a Java.

Con punteros ,

• puede hablar directamente a la memoria.

• puede evitar muchas pérdidas de memoria de un programa manipulando punteros.

Una razón para usar punteros es interactuar con las funciones de C. Otra razón es para ahorrar memoria; por ejemplo: en lugar de pasar un objeto que contiene muchos datos y tiene un constructor de copia intensivo en procesador a una función, simplemente pase un puntero al objeto, ahorrando memoria y velocidad, especialmente si está en un bucle, sin embargo, un referencia sería mejor en ese caso, a menos que esté utilizando una matriz de estilo C.

En áreas donde la utilización de la memoria es primordial, los punteros son útiles. Por ejemplo, considere un algoritmo minimax, donde se generarán miles de nodos usando la rutina recursiva, y luego úselos para evaluar el siguiente mejor movimiento en el juego, la capacidad de desasignar o restablecer (como en los punteros inteligentes) reduce significativamente el consumo de memoria. Mientras que la variable sin puntero continúa ocupando espacio hasta que su llamada recursiva devuelve un valor.

Incluiré un caso de uso importante del puntero. Cuando está almacenando algún objeto en la clase base, pero podría ser polimórfico.

Class Base1 {
};

Class Derived1 : public Base1 {
};


Class Base2 {
  Base *bObj;
  virtual void createMemerObects() = 0;
};

Class Derived2 {
  virtual void createMemerObects() {
    bObj = new Derived1();
  }
};

Entonces, en este caso no puede declarar bObj como un objeto directo, debe tener un puntero.

"La necesidad es la madre de la invención." La diferencia más importante que me gustaría señalar es el resultado de mi propia experiencia de codificación. A veces necesitas pasar objetos a funciones. En ese caso, si su objeto es de una clase muy grande, pasarlo como un objeto copiará su estado (que puede que no desee ... Y PUEDE SER GRANDE SOBRE LA CARGA), lo que da como resultado una sobrecarga de copia del objeto. Tamaño de 4 bytes (suponiendo 32 bits). Otras razones ya se mencionan anteriormente ...

Ya hay muchas respuestas excelentes, pero déjame darte un ejemplo:

Tengo una clase de artículo simple:

 class Item
    {
    public: 
      std::string name;
      int weight;
      int price;
    };

Hago un vector para contener un montón de ellos.

std::vector<Item> inventory;

Creo un millón de objetos Item, y los empujo hacia el vector. Ordeno el vector por nombre y luego hago una búsqueda binaria iterativa simple para un nombre de elemento en particular. Pruebo el programa y me lleva más de 8 minutos terminar de ejecutarlo. Luego cambio mi vector de inventario así:

std::vector<Item *> inventory;

... y crear mi millón de objetos Item a través de nuevo. Los ÚNICOS cambios que hago en mi código son usar los punteros a los Elementos, excepto un ciclo que agrego para la limpieza de la memoria al final. Ese programa se ejecuta en menos de 40 segundos, o mejor que un aumento de velocidad de 10x. EDITAR: El código está en http://pastebin.com/DK24SPeW. Con las optimizaciones del compilador, muestra solo un aumento de 3.4x en la máquina en la que lo probé, lo que aún es considerable.