Restituzione degli indirizzi degli oggetti creati al di fuori della funzione main ()

Question

Sto cercando di creare un elenco di collegamenti, ma sto riscontrando problemi nella creazione di oggetti all'interno di una funzione e nell'assegnazione di puntatori ai loro indirizzi, dal momento che credo che vadano fuori dallo scopo quando la funzione esce. È vero? E, in tal caso, come posso creare un oggetto al di fuori del main e continuare a usarlo?

Answer 1

Crea gli oggetti con il nuovo operatore. vale a dire

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

Hai ragione, le variabili locali usciranno dall'ambito alla fine del blocco funzione. È necessario creare puntatori agli oggetti e allocarli con new . E non dimenticare di eliminare l'oggetto quando lo rimuovi dal tuo elenco.

Se non si desidera gestire le seccature e i bug associati ai puntatori, consultare boost :: shared_ptr invece.

Answer 3

usa il nuovo operatore:

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

Presta attenzione alla cancellazione degli oggetti quando il tuo elenco viene distrutto.

Answer 4

Perché non memorizzi gli oggetti (non i puntatori agli oggetti) nell'elenco? La funzione Creatore restituirà l'oggetto.

Se hai davvero bisogno di un elenco di puntatori prendi in considerazione l'uso di speciali contenitori di elenchi di puntatori ( boost :: ptr_list ) o la memorizzazione di puntatori intelligenti in esso ( boost :: shared_ptr ). Per evitare che gli oggetti escano dall'ambito dopo il ritorno dalla funzione, è necessario allocarli dinamicamente con l'operatore new.

Answer 5

La risposta accettata non è corretta. Nella funzione

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

l'oggetto appena allocato viene assegnato alle variabili locali. Non influiscono sui valori dei puntatori nella funzione chiamante.

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;
}

Ciò di cui hai bisogno è:

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
}