significado - punteros c++

el operador "nuevo" en c++, pregunta de puntero

Question

Pregunta tonta, pero cada vez que llamas nueva, ¿siempre tienes un puntero?

SomeClass *person = new SomeClass();

¿Y eso es porque necesita un puntero para apuntar a ese nuevo espacio de memoria que se asignó para la persona variable SomeClass? ¡Gracias!

Answer 1

La nueva expresión devuelve un puntero, pero puede usarlo con clases de "puntero inteligente" (por ejemplo, de Boost ). Asi que:

boost::shared_ptr<SomePerson> person(new SomePerson);

También debo señalar que, aunque es posible que esté acostumbrado a utilizar los paréntesis si proviene de un fondo Java, en C ++, los paréntesis no son necesarios cuando se utiliza el constructor predeterminado. Entonces, por ejemplo, normalmente se escribe una new T cuando se construye por defecto, pero se escribe una new T(param) , o una new T(param1,...,paramN) cuando se construye un objeto utilizando un constructor diferente al predeterminado.

Si, eso es correcto; uno podría, teóricamente, escribir (nuevo SomePerson) -> doSomething (), pero eso sería una pérdida de memoria; C ++ no tiene recolección de basura, por lo que es necesario almacenar el resultado de la nueva expresión en algo (un puntero o un puntero inteligente) para poder desasignarlo adecuadamente.

Answer 2

Sí, siempre un puntero. Incluso si desea sobrecargar nuevo , el tipo de devolución debe ser nulo * .
Y tienes razón sobre el propósito

Answer 3

Sí. Si pregunta por qué no devuelve una referencia, ya que las referencias son más bonitas que las indicadoras, la respuesta es patrimonio histórico.

Cuando C ++ estaba en desarrollo, si la máquina no podía obtener memoria para el objeto, se devolvía un puntero especial NULL . Así es como se hace en C:

SomeClass *person;
person = (SomeClass*) malloc( sizeof( SomeClass ) );
if ( person == NULL ) fprintf( stderr, "no more people allowed!" );

En C ++ estándar, los errores son devueltos por excepción en su lugar:

try {
    SomeClass *person = new SomeClass;
    // do something
} catch ( std::bad_alloc ) {
    std::cerr << "no more people!" << std::endl;
} catch ( ... ) {
    // using exceptions allows for other errors
    // from inside SomeClass::SomeClass too
}

Sin embargo, todavía puedes hacerlo a la vieja usanza con nothrow :

SomeClass *person = new( std::nothrow ) SomeClass;
if ( person == NULL ) std::cerr << "no more people allowed!" << std::endl;

El resultado es que este es un estilo perfectamente razonable y bueno:

SomeClass &person = * new SomeClass; // don''t need no stinkin pointers!

Answer 4

Si el new completa con éxito, siempre devuelve un puntero (si no se completa con éxito, se lanza una excepción y no se devuelve nada).

El puntero es al objeto que se creó, o en el caso de una matriz, un puntero al primer elemento de la matriz.

Answer 5

new crea un objeto en el montón y todo lo que puede devolver es su dirección: un puntero.