[C++]: Classi annidate

[zuffff]

Ho realizzalizzato la seguente classe per effettuare alcune operazioni su un vettore di interi:

class vettore
{
	int *v,size;
public:
	vettore(int); //costruttore normale
	~vettore();//distruttore
	vettore(const vettore &op2); //costruttore di copia
	vettore operator+(vettore op2);
	vettore operator=(vettore op2);
	vettore operator++(int notused);
	vettore operator*(int op2);
	void dispay();
};

in seguito ho realizzato una classe matrice e voglio che sfrutti le caratteristiche della classe vettore in questo modo:

class matrice 
{
	int righe,colonne;
	vettore *m;
public:
	matrice(int,int); //costruttore normale
	~matrice();//distruttore
	matrice(const matrice &op2); //costruttore di copia
	matrice operator+(matrice op2);
	matrice operator=(matrice op2);
	matrice operator++(int notused);
	matrice operator*(int op2);
	void dispay();
};

E fin qui tutto ok (almeno credo)

Il problema è nel costruttore della classe matrice:

matrice::matrice(int dimr,int dimc)
{	
	righe=dimr;
	m=new vettore [righe];  //ho un errore qui errore 
	if(!m)
	{
		cout << "Errore";
		exit(1);
	}
}

perchè?

se può essere utile il costruttore di vettore è:

vettore::vettore(int dim=3)
{	
	size=dim;
	int i;
	v=new int[size];
	if(!v)
	{
		cout << "Errore";
		exit(1);
	}
	for(i=0;i<size;i++)
		v[i]=rand()%100;
}

[XWolverineX]

Devi specificare quale è l'errore.

[fastcoder]

Spero di aver capito
Se definisco almeno un costruttore (anche se poi questo costruttore ha solo un parametro di default) il costrutture di default (quello senza parametri per intenderci) non viene creato.
Siccome l'operatore di new può creare solo oggetti con costruttore di default il problema è proprio lì.
Io avrei fatto così:

class vettore
{
	int *v,size;
public:
	vettore(int); //costruttore normale
        explicit vettore(); // costruttore di default che inizializza v a NULL.
	~vettore();//distruttore
        void resize(int); // Per ridimensionare il vettore.
	vettore(const vettore &op2); //costruttore di copia
	vettore operator+(vettore op2);
	vettore operator=(vettore op2);
	vettore operator++(int notused);
	vettore operator*(int op2);
	void dispay();
};

Ovviamente costruita la matrice avrei chiamato resize per ridimensionare i singoli vettori al numero delle colonne.
Poi avrei aggiunto un controllo sull'uso di vettore nel caso non fosse stato inizializzato.
Ancora meglio avrei fatto:

class vettore
{
	int *v,size;
protected:
        explicit vettore(); // costruttore di default che inizializza v a NULL.
        friend class matrice;
public:
	vettore(int); //costruttore normale
	~vettore();//distruttore
        void resize(int); // Per ridimensionare il vettore.
	vettore(const vettore &op2); //costruttore di copia
	vettore operator+(vettore op2);
	vettore operator=(vettore op2);
	vettore operator++(int notused);
	vettore operator*(int op2);
	void dispay();
};

In questo modo solo la matrice avrebbe potuto creare i vettori non inizializzati e successivamente inizializzarli, eliminando così il controllo sui vettori non inizializzati (perchè sicuramente matrice sa quello che fa).

Spero di averci acchiappato

[zuffff]

Si, fastcoder credo che tu ci abbia azzeccato; proverò il tuo codice e ti farò sapere; l'errore era il seguente:

error C2512: 'vettore' : no appropriate default constructor available
Error executing cl.exe.

[zuffff]

funziona tutto. grazie. ma che vuol dire explicit nella classe vettore?

[XWolverineX]

Originariamente inviato da zuffff
funziona tutto. grazie. ma che vuol dire explicit nella classe vettore?

Explicit indica un costruttore esplicito.
E' un concetto un po difficile da spiegare.
Un costruttore che usa argomenti può essere soggetto a conversioni implice dal compilatore. Praticamente un tipo di dato inserito in un costruttore, magari se questo non è appropriato, può essere implicitamente convertito in un tipo di oggetto idoneo per il costruttore.

Mettiamo caso di avere una classe che prende come costruttore un int

class MiaClasse
[
    MiaClasse();
    MiaClasse(int i = 10);
];

Mettiamo ora caso di avere una funzione che invece prende una istanza di questa tua classe

void Print(MiaClasse &cls);

Adesso, metti il caso in cui tu stai scrivendo del codice con queste due definizioni e utilizzi in modo sbagliato la funzione print

Print(15);

Come puoi vedere è sbagliato in quando Print vuole una istanza di MiaClasse mentre tu gli hai appena passato un intero.Cosa fa il compilatore? dato che il costruttore della MiaClasse prende un intero, crea una classe MiaClasse al volo utilizzando come costruttore il parametro che gli hai passato (in questo caso 15) e la utilizza per la funzione print.
Ciò può essere molto confusionario e dunque si utilizzano i costruttori explicit.
Mettendo explicit prima di un costruttore di una classe vuol dire che il costruttore vuole solo un parametro reale e niente conversioni implicite e quindi implica il passaggio di parametri corretti.
Se il costruttore fosse stato cosi

explicit MiaClasse(int i = 10);

Chiamando la funzione Print(15) il compilatore ti avrebbe dato un errore.

[zuffff]

ok credo di aver capito; nel dubbio è meglio mettere sempre explicit. ciao

[fastcoder]

Direi di no...nel dubbio è meglio riflettere...non come ho fatto io che ho messo explic quando non serviva