Dynamiczna tablica w obiektach klas.

Witam. Utworzyłem tablicę obiektów. I w każdym z tych obiektów chcę umieścić tablicę dynamiczną znajdującą sie w funkcji... przy uzupełnianiu tablicy dynamicznej w drugim z kolei obiekcie wyskakuje mi błąd... nie mam pojęcia co może być źle...

 #include <cstdlib>
#include <iostream>

using namespace std;


class wierz                     //class wierzcholek
{
public:
     int * t;

      void relacje(int w);
      wierz(int b);
      ~wierz();
       wierz() {};
};
 wierz:: wierz (int b)           //definicja konstruktora
        {

                t =new int[b];
        }
 wierz :: ~wierz ()             //destruktor
        {
                delete[] t;
        }

class kraw                              // class krawedz
{
       };




int main(int argc, char *argv[])
{               wierz *q;
                int num;
        cout<< " Podaj ilosc wierzcholkow w grafie: ";
        cin >> num;
                        wierz * p ;
                        p = new wierz[num];


   for (int i=0; i < num; i++)
                {
                cout << " relacje " ;

                p[i].relacje(i);
                }

    for (int r=0; r < num; r++)
    {
        p[r].~wierz();
    }
    delete[] p;

    system("PAUSE");
    return EXIT_SUCCESS;
}
void wierz:: relacje(int w)
{       int l=0;
        int *e;
        e = t;
                int r=0;
                r=w;
                l=-1;
                cout <<" (wpisz '0' jezeli nie ma polaczen) "<<
                "wierzcholek " << r+1 << " laczy sie z " << endl;
                do{ l++;
                    cin >> e[l];
                      cout <<" l= " << l<< endl;

                      }
                while(e[l]!=0);




}

nie działa ci bo nie możesz w c++ stworzyć tablicy obiektów klas, które nie posiadają konstruktora domyślnego. Rezerwujesz pamięć dla tablicy w konstruktorze z parametrem, którego nie możesz wywołać przy tworzeniu tablicy obiektów.

A mógłbyś jeszcze podpowiedzieć mi gdzie umieścić deklarację dynamicznej tablicy skoro nie w konstruktorze...i jak potem zwolnić pamięć?

Dzięki... Definicje dynamicznej tabicy "t =new int[b];" umieściłem w konstruktorze bezparametrowym... i wszystko działa tak jak się należy...

Prawie wszystko działa, oprócz jednego - podwójne wywołanie destruktorów.
tego nie trzeba robić:
for (int r=0; r < num; r++)
{
p[r].~wierz();
}
zrobi się samo podczas:
delete[] p;

W ogóle nie powinno się wywoływać destruktorów, bo można się naciąć.

byku_guzio napisał(a)

W ogóle nie powinno się wywoływać destruktorów, bo można się naciąć.

To akurat nieprawda, kiedy piszesz własny allocator pamięci to bez jawnego wywołania destruktora ani rusz.

No wszystko by było ok gdyby nie jeden mały problem a mianowicie gdy chcę utworzyć tablice obiektów class wierz i w automatycznie tworzą mi się tablica dynamiczna w konstruktorze bezparametrowym to tablica dynamiczna tez musi mieć wartość określającą wielkość tej tablicy t=new int[ nr]; a nr przy tworzeniu tablicy obiektów poprzez konstruktor bezparametrowy nie jest jeszcze przypisana... wstawiłem definicje tej tablicy do konstruktora z parametrem mając także konstruktor bezparametrowy ale nie działa. wstawiłem też tablice dynamiczną do funkcji ale też nie zadziałało...

 #include <cstdlib>
#include <iostream>
#include <stack>
#include <algorithm>
using namespace std;


class wierz                     //class wierzcholek
{
public:
friend void wag();
     int * t;
     bool odwiedzony;
     int nr;
     int *r;
     int ipol;
      void relacje(int w);
      void waga (int e);
      //int * ostatni(int * w );
      wierz(){
      t =new int[nr];
        
      //void tablice(int wierzcholki);
       ~wierz();
       

};
/*void wierz::tablice(int wierzcholki)           **** nie działa **** 
        {
                nr = wierzcholki;
                t =new int[nr];
                if(!t) cout << " nie mozna utworzyc tablicy" ;
                else cout << "mozna" ;
                //r =new int[nr];
        }  */
 wierz :: ~wierz ()             //destruktor
        {
        delete [] t;
        
        }


stack<int>stos;
void dfs( wierz *wsk, int ile );








 /////////////////////////////////////////////////////////////////////
int main(int argc, char *argv[])
{               wierz *q;
                int num;
        cout<< " Podaj ilosc wierzcholkow w grafie: ";
        cin >> num;
                        wierz *p ;
                        p = new wierz[num];


   for (int i=0; i < num; i++)
              {
                cout << " relacje  " <<i<<endl; ;
                //p[i].tablice(num); //tworzenie tablic dynamicznych w tab obj ale nie działa
                p[i].nr=num;
                p[i].relacje(i);
               

              }
                int i=0;
                q=&p[0];

                do
                {    cout << " wykonuje sie" ;
                     dfs(q,i);

                }
                while((stos.empty())!=true) ;
                cout <<endl<< " koniec " << endl;



    for (int r=0; r < num; r++)
    {
        p[r].~wierz();
    }
    delete[] p;

    system("PAUSE");
    return EXIT_SUCCESS;
    //////////////////////////////////////////////////////////////////////
}
void wierz:: relacje(int w)
{       int l=-1;
        int *e;
        e = t;
                int r=0;
                r=w;
                int p=0;
                cout <<" wpisz '9' jezeli nie ma polaczen\n "<<
                "wierzcholek " << r << " laczy sie z " << endl;


                do
                {       
                        l++;
                        cout<< " l= " << l << endl;
                        p=l;
                        cin >> e[l];
                        
                                if((e[l])> (nr))
                                {cout << " wierzcholkow jest tylko " << nr<<endl;
                                l--;}
                                if (l>nr-1)
                                {
                                ipol= l;
                                e[l]=9;
                                }
                                if( (e[l]==9))
                                {
                                 ipol= p;
                                }
                }
                while(e[l]!=9);
                cout << " ipol="  << ipol<< endl;
                for( int il=0; il < ipol+1; il++)
                cout<<  e[il];



}
/////////////////////////////////////////////////////////





//przeszukiwanie grafu w głąb
void dfs(wierz *wsk, int i)
{  //for( int l=0; l < wsk[i].ipol; l++){ cout <<  wsk[i].t[l];}

int * cos = new int[wsk[i].nr];

    for (int j=0; j<wsk[i].ipol;j++)
        {
                stos.push(wsk[i].t[j]);
                wsk[i].odwiedzony=true;

        }
    if ( ((wsk[stos.top()].odwiedzony)==true))
        {
                dfs(wsk, stos.top());
                wsk[stos.top()].odwiedzony=false;
    
                stos.pop();
                cout <<  stos.top();
        }

    else
    {stos.pop();
    }
    delete[]cos;



    
}

Czyli nie wiecie jak coś takiego zrobić czy reprezentacje grafu muszę przedstawić w inny sposób ?

Chcę po prostu mieć tablicę dynamiczną w klasie... i tych klas chcę mić bardzo dużo...i tyle.

użyj:
wiektora - vector<typ>
listy - list<list>
lib napisz coś własnego na ten wzór (chociaż wnioskując z kodu który przedstawiłeś i pytań które zadajesz - nie dasz rady).

Z wektorem bardzo dobry pomysł ale uparłem się na te teblice dynamiczne... Wszystko działa prawidłowo. Podaje kod dla kolejnych nie douczonych:-) #include <cstdlib>
#include <iostream>
#include <stack>
#include <algorithm>
using namespace std;

class wierz //class wierzcholek
{
private:
int numer;
int * tablica;
public:
friend int dfs(int, wierz*);
friend void uzupelnij(wierz *element, int ilosc);
bool odwiedzony;
int ipol;

             void relacje(int w);
             void waga   (int e);
             
 wierz(){}

 void tab (int nr)
 {

    tablica =new int[numer];
 }

};

stack<int>stos;
int dfs( int numery, wierz *wsk );

/////////////////////////////////////////////////////////////////////
int main(int argc, char *argv[])
{ wierz *q;
int num;
cout<< " Podaj ilosc wierzcholkow w grafie: ";
cin >> num;
wierz *wierzcholek ;
wierzcholek = new wierz[num];

    uzupelnij(wierzcholek,num);

for (int i=0; i < num; i++)
{

             wierzcholek[i].relacje(i);


            }
            int i=0;

           if( dfs(i,wierzcholek)==1)
           {
              delete[] wierzcholek;

system("PAUSE");
return EXIT_SUCCESS;
}
//////////////////////////////////////////////////////////////////////

}
void wierz:: relacje(int ktory)
{ int licznik=-1;
int *polaczenia;
polaczenia = tablica;
int numerek=0;
numerek=ktory;

            cout <<" wpisz '9' jezeli nie ma polaczen\n "<<
            "wierzcholek " << numerek << " laczy sie z " << endl;


            do
            {       
                    licznik++;
                    cin >> polaczenia[licznik];
                             if(polaczenia[licznik]==9)
                            {
                             ipol= licznik;
                             break;
                            }
                            if((polaczenia[licznik])> (numer))
                            {cout << " wierzcholkow jest tylko " << numer<<endl;
                            licznik--;}
                            if (licznik>numer-1)
                            {
                            ipol= licznik;
                            polaczenia[licznik]=9;
                            }
                           
            }
            while((polaczenia[licznik])!=9);

            cout << " ipol="  << ipol<< endl;
            for( int il=0; il < ipol+1; il++)
            cout<<  polaczenia[il];

}
/////////////////////////////////////////////////////////

int dfs( int numery, wierz *wsk)
{
wierz *elementy;
elementy=wsk;
int i;
i=numery;
int pamieta=0;
cout <<"\nPrzeszukiwany " << i<<endl;
cout <<"\nstos size1 " << stos.size()<<endl;

                 if((elementy[i].odwiedzony)==true)

    {       elementy[i].odwiedzony=false;
            cout <<" A wiec najpierw " <<i<<endl;



                    if((elementy[i].ipol)>0)
                    {
                            if( stos.empty()==false )
                                    {
                                            pamieta = stos.top();
                                            cout << " usuwanie 1" ;
                                            //stos.pop();
                                    }




                            for(int j=0; j<elementy[i].ipol; j++)
                            {
                                    stos.push(elementy[i].tablica[j]);

                                    cout <<" Dodajemy do stosu " <<elementy[i].tablica[j]<< endl;
                            }

                                    if( stos.empty()==false )
                                    {

                                             pamieta = stos.top();

                                             cout << " usuwanie 2" ;
                                            stos.pop();

                                            dfs(pamieta,elementy);
                                    }
                                    else
                                    {return 1;}
                    }


                    else
                    {      cout <<"\nstos size3 " << stos.size()<<endl;
                            if( stos.empty()!=true )
                            {
                                     dfs(i+1,elementy);
                            }
                            else

                            {
                                    cout <<" else else"<<endl;
                                    dfs(stos.top(),elementy);
                            }
                   }

             } else


            {              cout <<"\nstos size4 " << stos.size()<<endl;
                            cout <<"przeszukujemy" <<stos.top()<<endl;
                            cout << " usuwanie 3" ;
                            stos.pop();
                            if( stos.empty()==true )
                                    {       cout << " koniec" <<endl;
                                            return 1;

                                    }
                            else
                                    {      cout <<"\nstos size5 " << stos.size()<<endl;
                                            cout << " jeszcze" << endl;
                                            
                                            dfs(stos.top(),elementy);
                                    }





            }

if( stos.empty()!=true )
{ return 1; }

cout <<"\nstos size koniec " << stos.size()<<endl;
return 1; system("PAUSE");
return EXIT_SUCCESS;
}
void uzupelnij(wierz *element, int ilosc)
{ for (int i=0; i < ilosc; i++ )
{
cout<<" dziala uzupelnij";
element[i].numer=ilosc;
element[i].tab(ilosc);
element[i].odwiedzony=true;
}}