Newsgroup: it.comp.lang.c++
Titolo: come assegnare un array ad un puntatore e non forlo sparire all'uscita della funzione?

Mi spiego meglio: ho un puntatore nella classe grafico ( *nodi) e nel
costruttore lo inizializzo con un array:
 int nodi_grafo[]={0,0,3,4,9,11,0};
 nodi= nodi_grafo;
richiamo i valori di nodi in mst_prim č come se l''array fosse stato
deallocato.
Come fare ?
Grazie in anticipo, Mario.
Il cosdice a cui faccio riferimento č:
class grafo{
 public:
     int *nodi;
 public:
  grafo();
  void mst_prim();
};//class grafo{
grafo::grafo()
{
 int nodi_grafo[]={0,0,3,4,9,11,0};
 nodi= nodi_grafo;
cout<<"nel grafo_in:"<<*(nodi+2)<<" . \n";
}
void grafo::mst_prim(){
cout<<"nel main:"<<*(nodi+2)<<" .. \n";
}
main(int argc,char* argv[])
{
 grafo g;
 g.grafo_in();
 g.mst_prim();
}

 Come fare ?
Usi uno std::vector<int>, come e' giusto che si faccia.
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://www.cs.unibo.it/~mbellett
Linux registered user 299762 @ Linux registered machine 213003

> Usi uno std::vector<int>, come e' giusto che si faccia.
esiste una soluzione senza usare le std?
so che è la scelta migliore ma... è meglio se non le uso (per scelta di
progetto... molto discutibile ma non mia!).
Grazie in anticipo, Mario.


Usi new e delete. Ti riporto il tuo codice, con un po' di correzione, e 
due modi alternativi per completare l'operazione:
#include <iostream>
#include <algorithm>  // se usi std::copy
//#include <string.h>   // se usi memcpy
using namespace std;
class grafo
{
   public:
     int *nodi;
   public:
     grafo();
     ~grafo();
     void mst_prim();
};
grafo::grafo()
{
   const int numnodi = 7;
   int nodi_grafo[numnodi] = {0, 0, 3, 4, 9, 11, 0};
   nodi = new int[numnodi];
   copy(nodi_grafo, nodi_grafo+numnodi, nodi);
   // oppure la versione C:
   //memcpy(nodi, nodi_grafo, sizeof(int)*numnodi);
   cout << "in grafo(): " << *(nodi+2) << ".\n";
}
grafo::~grafo()
{
   delete nodi;
}
void grafo::mst_prim()
{
   cout << "in mst_prim(): " << *(nodi+2) << "..\n";
}
int main(int argc, char* argv[])
{
   grafo g;
   g.mst_prim();
   return 0;


 ha scritto nel messaggio
news:ccj6u6$3j0$1...@le1.cs.unibo.it...



La deallocazione dell'array non è realmente un problema in quanto è previsto
che le variabili create nello stack siano deallocate all'uscita delle stesse
dallo spazio i visibilità ( scope ).
Come ti è stato consigliato sarebbe meglio utilizzare sempre la Libreria
Standard in modo da liberarti di tutte le problematiche di più basso livello
e per ottenere codice più efficente e sicuro.
In ogni caso ciò non toglie che devi conoscere i principi di funzionamento
del C++, anche per potere meglio utilizzare ciò che la Libreria offre.
Tornando al problema, il punto è che se una variabile ( nel caso specifico
l'array ) ti serve al di fuori della funzione in cui è stata creata ne devi
allocare lo spazio di memoria nel cosiddetto "free store" o "heap".
Questo si fa tramite "new" oppure "new[]", e poi ricordandosi di operare la
restituzione della memoria così riservata tramite "delete" oppure "delete[]"
( al momento opportuno, magari nel distruttore della classe ).
Quindi se vogliamo, ad esempio, un array di nome "array" di dieci char:
	char *array = new char[10];
E al momento in cui non è più necessario:
	delete[] array;
Buon lavoro,
FabioMDF
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 Grazie in anticipo, Mario.
Fatti una tua classe array e poi passi questa... se la ritorni da una
funzione ne passi una copia, altrimenti puoi pasarla per riferimento.
Fatti qualcosa del tipo...
#include <iostream>
template<typename T>
class mioPointer
{
        T* data;
        int p_size;
        void alloc(unsigned long size)
        {
                if (p_size>0) data=new T[p_size];
                else data=static_cast<T*>(0);
        }
        public:
        mioPointer(unsigned long size) : p_size(size)
        {
                alloc(p_size);
        }
        mioPointer(T* p_array,unsigned long size) : p_size(size)
        {
                alloc(p_size);
                for(unsigned int i=0;i<p_size;++i) data[i]=p_array[i];
        }
        mioPointer(const mioPointer& P) : p_size(P.p_size)
        {
                alloc(p_size);
                for(unsigned int i=0;i<p_size;++i) data[i]=P.data[i];
        }
        ~mioPointer()
        {
                if (data) delete [] data;
        }
        int size() const { return p_size; }
        T& operator[](int index) { return data[index]; }
};
// Esempio di funzione che ritorna un mioPointer<int>
mioPointer<int> prova_func()
{
        int prova_array[] = { 1 , 2 , 3 ,4 ,5 };
        int l=sizeof(prova_array)/sizeof(*prova_array);
        return mioPointer<int>(prova_array,l);
}
using namespace std;
int main(int argc, char* argv[])
{
        mioPointer<int> pA=prova_func();
        // stampa l'array
        for (int i=0;i<pA.size();++i) cout << pA[i] << " ";cout << endl;
        // cambia un elemento dell'array
        pA[2]=-10;
        for (int i=0;i<pA.size();++i) cout << pA[i] << " ";cout << endl;
        char qc;
        cin.get(qc);
        return 0;
}
Attenzione l'esempio fa un pň pena e l'ho scritto in 2 minuti (mancano tante
funzioni membro che sarebbero utili e manca ad esempio un costruttore di
default, che va invece fatto), spero che non ci siano troppe cacchiate,
comunque voglio solo suggerirti l'idea.
ciao.

 }