Funzione che richiama se stessa

[Absolut]

Salve ragazzi, ho un piccolo quesito:
sto leggendo un codice in c++ e.....

1) ho una funzione void pippo(bla bla bla)
dentro a questa vengono fatte delle operazioni e vengono definite due variabili:

Codice: Seleziona tutto

   int* Edges_First_hop = nNodeList[ID(sNode)].nNeighbours;
        bool* Edges_Label = new bool [nNumEdges];

2) se alcune cose sono rispettate, la funzione si richiama


Ora, dovendo pulire la memoria, se io alla fine della funzione faccio

Codice: Seleziona tutto

delete Edge_First_hop;
delete Edges_Label;

3) quelle due varibili dovrebbero essere locali giusto!? nel senso che
in pippo() chiamata la prima volta vengono create,
in pippo chiamata dentro pippo vengono nuovamente create, ma dovrebbero essere distinte dalle quelle di prima giusto!? quindi posso farci il delete!?

grazie!

[Vito]

Puoi fare sì il delete..
ma perchè le elimini?Devi riallocarle?

[lamarozzo]

Le variabili locali vanno deallocate con delete ogni volta che la funzione sta per uscire e cedere il controllo alla funzione che l'ha chiamata. Questo perchè sono variabili locali e quando esci dalla funzione perdi il puntatore alle aree di memoria, che quindi non puoi più deallocare, e hai memory leak. Non penso che questa strategia sia buona per delle funzioni ricorsive, sarebbe meglio allocare la memoria alla prima chiamata e poi farla usare da tutte le funzioni, passando i puntatori tramite l'interfaccia della funzione.

[Vito]

Ecco , non mi ricordavo questo...
Troppo tempo a non programmare fa male

[Absolut]

Il problema è che se dovessi allocare la memoria tutt aprima non basterebboero vari GByte!!!

comunque... perchè non dovrebbero andare bene per funioni ricorsive!?

Pippo() crea la variabile A
e poi dentro pippo chiamo Pippo()

il nuvo Pippo() crea una varibe A
che è diversa dalla variabile A del primo pippo

Quando finisce il prio Pippo, posso fare delete A alla fine del primo Pippo() no!?

quella della seconda funzione rimane ancora valida!?

almeno andando a logica...

[lamarozzo]

Il problema è che se dovessi allocare la memoria tutt aprima non basterebboero vari GByte!!!

Se il tuo programma usa cosi' tanta memoria rischi di esaurirla se la funzione ricorsiva viene chiamata troppo spesso. Il mio suggerimento era solo quello di riutilizzare
l'area di memoria che allochi la prima volta che chiami la funzione. Questo perche' comunque fai un delete ad ogni uscita di funzione e quindi immagino che quell'area
di memoria ti serva solo temporaneamente per lo svolgimento della funzione e non al di fuori di essa. Ma se hai bisogno di tenere copia di tutta la struttura dati
allora come hai fatto tu mi sembra giusto.

[targzeta]

Absolut, il consiglio di lamarozzo era quello (secondo me giusto) di riutilizzare la memoria dell'oggetto allocato, non di allocare tutta la memoria possibile . Se è come penso io, il consiglio era quello di fare qualcosa tipo:

Codice: Seleziona tutto

main()
{
  int* Edges_First_hop = nNodeList[ID(sNode)].nNeighbours;
  bool* Edges_Label = new bool [nNumEdges];
  ....
  pippo (Edges_First_hop, Edges_Label);
  ....
}

function pippo(int* Edges_First_hop, bool *Edges_Label)
{
  ...
  pippo(Edges_First_hop, Edges_Label);
}


In questo modo hai solo due oggetti allocati che però riutilizzi tutte le volte che ti richiami.

Un altra cosa, se non intendi fare in questo modo, ricorda che ci sono due possibili scenari nelle funzioni ricorsive. Il primo è quello in cui le variabili locali non ti servono più una volta eseguita la ricorsione, del tipo

Codice: Seleziona tutto

pippo()
{
  ...
  return pippo();
}


In questo caso la delete va, ovviamente, fatta prima della ricorsione.
Un altro scenario, più raro e meno consigliato, e quello in cui la funzione usa il risultato della sua ricorsione, tipo:

Codice: Seleziona tutto

pipp
{
  ...
  a=pippo();
  fai_qualcosa_con_a;
  return x;
}

in questo caso, ovviamente la delete va fatta prima del return.

Il tutto per dire, occhio a come usi la ricorsione, nel secondo caso, tutta la memoria rimane allocata sino a che la ricorsione non finisce, solo quando l'ultima funzione ricorsiva termina, iniziano le delete a cascata.

Emanuele