Devolviendo las direcciones de objetos creados fuera de la función main ()

Question

Estoy tratando de crear una lista de enlaces, pero tengo problemas para crear objetos dentro de una función y asignar punteros a sus direcciones, ya que creo que salen del alcance cuando la función sale. ¿Es esto cierto? Y, si es así, ¿cómo puedo crear un objeto fuera del main y seguir utilizándolo?

Answer 1

Crea los objetos con el nuevo operador. es decir,

void foo( myObject* bar1, myObject* bar2 )
{
  bar1 = new myObject();
  bar2 = new myObject();
  // do something
}

int main( int argc, char* argv[] )
{
  myObject* thing1;
  myObject* thing2;
  foo( thing1, thing2 );

  // Don't forget to release the memory!
  delete thing1;
  delete thing2;

  return 0;
}

Answer 2

Usted tiene razón, las variables locales quedarán fuera del alcance al final del bloque de funciones. Debe crear punteros a los objetos y asignarlos con new . Y no olvide eliminar el objeto cuando lo elimine de su lista.

Si no quiere lidiar con las molestias y los errores que vienen con los punteros, consulte boost :: shared_ptr en su lugar.

Answer 3

usa el nuevo operador:

void f()
{
  CMyObject *p = new CMyObject();
  List.AddTail(p); // Or whatever call adds the opbject to the list
}

Preste atención a la eliminación de objetos cuando se destruya su lista.

Answer 4

¿Por qué no almacenas objetos (no punteros a objetos) en la lista? La función creadora devolverá el objeto.

Si realmente necesita una lista de punteros, considere usar contenedores de lista de punteros especiales ( boost :: ptr_list ) o almacenar punteros inteligentes en ella ( boost :: shared_ptr ). Para evitar que los objetos queden fuera del alcance después de regresar de la función, debe asignarlos dinámicamente con el operador nuevo.

Answer 5

La respuesta aceptada no es correcta. En la función

void foo( myObject* bar1, myObject* bar2 )
{
  bar1 = new myObject();
  bar2 = new myObject();
  // do something
}

el objeto recién asignado se asigna a las variables locales. No afectan los valores de los punteros en la función de llamada.

int main( int argc, char* argv[] )
{
  myObject* thing1;
  myObject* thing2;
  foo( thing1, thing2 ); // thing1 and thing2 don't get assigned
                         // They continue to be uninitialized in
                         // this function

  // Don't forget to release the memory!
  delete thing1;  // These two deletes will lead to undefined behavior.
  delete thing2;

  return 0;
}

Lo que necesitas es:

void foo( myObject*& bar1, myObject*& bar2 )
{
  bar1 = new myObject(); // Now the value of the pointers in the calling
  bar2 = new myObject(); // will be changed since the pointers are passed by reference.
  // do something
}