Newsgroup: it.comp.lang.c++
Titolo: Torno alla carica, matrice di puntatori a oggetto.

Tento di spiegare cosa voglio fare:
abbiamo una classe foo, e una compositFoo. La mia intenzione ï¿½ 
istanziare una matrice (chiamata myFoo) di puntatori a foo come dato 
membro di compositFoo, ovvero, mettiamo caso avessi un source che 
include questo, poter fare una cosa come:
compositFoo* bar = new compositFoo();
bar->myFoo[2][5]->printFoo(); //che ï¿½ un metodo della classe foo
Spero di essermi spiegato ;)
Il codice ï¿½ un tantino contorto, premetto.
Data la lunghezza, ho usato un nopaste, spero non sia "illegale"
http://pastebin.com/f4aafe01b
L'output del compilatore:
me@heaven:~/sources/cpp/test$ g++ -o main main.cpp
In file included from main.cpp:3:
foo.hpp: In constructor ï¿½nameFoo::compositFoo::compositFoo()ï¿½:
foo.hpp:36: error: expected type-specifier before ï¿½*ï¿½ token
foo.hpp:36: error: cannot convert ï¿½int***ï¿½ to ï¿½nameFoo::foo***ï¿½ in 
assignment
foo.hpp:36: error: expected `;' before ï¿½fooï¿½


Dimenticavo, il main.cpp non ï¿½ altro che un source che include l'header, 
contiene solo un main con un return 0;

 foo.hpp:36: error: expected type-specifier before ï¿½*ï¿½ token
Invece di:
compositFoo::myfoo = new **foo;
avresti dovuto scrivere:
compositFoo::myfoo = new foo**;
in quanto "new" richiede un tipo e, dato che "foo" e' un tipo, "**foo" 
non e' un tipo, mentre "foo**" lo e'. Rappresenta un puntatore a un 
puntatore a un foo.
Tuttavia io sconsiglio vivamente questo approccio in C++ (in C a volte 
e' necessario). Penso che in un buon programma C++ non dovrebbero mai 
comparire due asterischi accoppiati, e a maggior ragione tre.
Innanzitutto, quello che allochi non e' un puntatore a una matrice 
bidimensionale, anche se puo' essere acceduta con la stessa sintassi, 
bensi' un puntatore a un array di puntatori ad array di puntatori.
Questo comporta una forte inefficienza di allocazione e una certa 
inefficienza di accesso, ma soprattutto un codice soggetto a errori di 
programmazione.
In primo luogo, devi decidere se si tratta proprio di una matrice, cioe' 
se le righe sono tutte lunghe uguali, oppure se ogni righe puo' avere 
una lunghezza diversa.
Poi devi decidere le due dimensioni della matrice sono entrambe definite 
a tempo di compilazione o entrambe solo a tempo di esecuzione o una si' 
e una no.
A questo punto ci sono varie opzioni.
Nel caso di entrambe le dimensioni definite a tempo di esecuzioni ed 
eventualmente a righe di lunghezza diversa, la soluzione piu' semplice e':
auto_ptr<vector< vector<foo> > > myfoo;
Nel caso di matrice rettangolare di dimensioni definite in fase di 
compilazione, la soluzione piu' semplice e':
const int n_righe = 20;
const int n_colonne = 30;
typedef foo arr[n_righe][n_colonne];
auto_ptr<arr> myfoo;
Alternativamente, puoi definirti una tua classe (o template di classe) 
che definisce un array bidimensionale.
-- 
Carlo Milanesi
http://digilander.libero.it/carlmila

 
Bï¿½ guarda, io ho bisogno di una matrice rettangolare, ma le dimensioni 
sono da decidersi in fase di runtime, a seconda dell'input dell'utente. 
Ora, non so come comportarmi con gli oggetti vector utilizzati in questa 
maniera, con l'auto_ptr, non ï¿½ che sapresti linkarmi qualche reference 
che tratta l'argomento?
Grazie mille per l'aiuto ;)