Newsgroup: it.comp.lang.c++
Titolo: Vettore di vettore di puntatori

La domanda è semplice: devo fare una matrice n x m di puntatori ad una
classe che chiamiamo TClasse.
Insomma, ogni Matrice[i][j] deve essere un *TClasse.
Come si fa a gestire dinamicamente questa situazione?
Per un vettore di vettore di interi mi bastava fare
Matrice = new int*[righe];
e poi
for (int i = 0; i < right; i++) Matrice[i] = new int[colonne];
e lo dichiaravo come
int **Matrice;
adesso come devo fare? come lo devo dichiarare?
MadMage

 La domanda č semplice: devo fare una matrice n x m di puntatori ad una

Stesso identico modo:
TClasse ***Matrice;
Ricordandoti che i cicli annidati di inizializzazione devono diventare tre,
non due, e che le allocazioni diventano un po' piů complesse.
Se puň aiutarti, eccoti la versione con typedef:
typedef *TClasse punt;
punt **Matrice;
Ma probabilmente sarebbe piů comodo usare una classe per gestire la matrice,
non pensi ?
Massimo

Piccola correzione:
typedef TClasse* pTClasse;	// L'asterisco segue il nome del tipo
pTClasse** Matrice;
Inoltre, nelle dichiarazioni, lo stile C++ e' quello di porre l'asterisco,
o gli asterichi, a ridosso del tipo e non a ridosso dell'oggetto
dichiarato. In C++ si predilige il tipo, in C si predilige l'espressione.
CeareP.
-- 
Posted from 
dsiaq1.ing.univaq.it
 [192.150.194.32] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

dichiarato. In C++ si predilige il tipo, in C si predilige l'espressione.
certo, ma se io scrivo
char* pippo, topolino;
come viene considerato?
MadMage

Ma certo... il problema col mio programma č che avevo scritto, nel
secondo ciclo di allocazione
TCasse invece che TClasse e quindi era un semplice errore di
sintassi...
beh, era notte tarda, comprendetemi :-DD
MadMage

 dichiarato. In C++ si predilige il tipo, in C si predilige l'espressione.
Mai sentito o letto niente del genere. Mi risulta che la posizione degli
asterischi sia puro stile personale.
EMG

 ha scritto nel
messaggio news:3A166367...@flashnet.it...

Ecco cosa dice lo Stroustrup nelle sue
"C++ Style and Technique FAQ".
La domanda č:
"Is ``int* p;'' right or is ``int *p;'' right?"
Ecco la risposta
(spero di non violare qualche copyright...):
"Both are "right" in the sense that both are valid C and C++ and
 both have exactly the same meaning. As far as the language
 definitions and the compilers are concerned we could just as well
 say ``int*p;'' or ``int * p;''
 The choice between ``int* p;'' and ``int *p;'' is not about right and
 wrong, but about style and emphasis. C emphasized expressions;
 declarations were often considered little more than a necessary evil.
 C++, on the other hand, has a heavy emphasis on types.
 A ``typical C programmer'' writes ``int *p;'' and explains it ``*p is
 what is the int'' emphasizing syntax, and may point to the C (and
 C++) declaration grammar to argue for the correctness of the style.
 Indeed, the * binds to the name p in the grammar.
 A ``typical C++ programmer'' writes ``int* p;'' and explains it ``p
 is a pointer to an int'' emphasizing type. Indeed the type of p is
 int*. I clearly prefer that emphasis and see it as important for
 using the more advanced parts of C++ well.
 The critical confusion comes (only) when people try to declare
 several pointers with a single declaration:
 [...]"
Manlio Perillo

 [...]"
This means that the "typical C++ programmer" is just making
the code less clear on intention or doesn't understand the
proper binding (that's what "C" dictates) and is going to
make errors in case declarations of more than one variable.
If you can't live without it then go for a typedef.
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

Ma non è più chiaro int *p invece che int* p?
Se ad es. scrivo
int*   p, x;  potrebbe pensare (chi non lo sa) che p e x siano puntatori a
int
invece con
int   *p, x si capisce meglio che * è solo riferito a p.
Ciao
-- 
Posted from [195.223.215.6] 


 ha scritto nel messaggio
news:3a17eb91...@news.interbusiness.it...

Questa parte era spiegata in [...].
Comunque personalmente non dichiaro *mai* più di una variabile
in casi come questi.
Inoltre anche io preferisco scrivere
    int* p;
al posto di
    int *p;
Manlio Perillo

 MadMage

    int *p;
La trovo una posizione strana ... il binding sintattico lega
l'asterisco alla p e (so che ti spiace) non puoi farci proprio
un bel niente... comunque contento tu contenti tutti...
mettici anche due o tre newline e qualche commento fra
l'asterisco e la p se questo ti aggrada.
La spaziatura presente nella dichiarazione
  int* p;
e' semplicemente sbagliata ... il fatto che tu sia
*obbligato* a mettere una sola variabile e' un segno
evidente che quella spaziatura non sta seguendo le
regole del linguaggio.
Personalmente io trovo leggibilissimo
  class ListNode
  {
    ...
    private:
      ListNode *prev,*next;
    ...
  };
Ma so di soffrire di una forma di attrazione malsana
verso i puntatori.
HTH


 [...]
Innanzitutto era chiaro che la sintassi andava contro le
regole del linguaggio.
Ma non pensi che Stroustrup possa aver lasciato questa sintassi
solo per compatibilità per il C?
Comunque ognuno è libero di fare quello che vuole, le due
scritture sono la stessa cosa.
Riguardo al fatto di non poter dichiarare più puntatori
insieme, be, io non dichiaro mai più di una *variabile*
insieme; trovo che porti ad una leggibilità minore.
Inoltre in C++ una variabile dovrebbe essere dichiarata
non appena si usa (ossia dichiarata ed inizializzata).
Ovviamente chi segue questo approccio non ha bisogno
di dichiarare più variabili assieme; questa è una
prassi ereditata dal C.
Ciao
Manlio Perillo

 char* pippo, topolino;
Equivale a
char * pippo;
char topolino;
Trovo molto brutto dichiarare piu' variabili nella stessa istruzione. A
maggior ragione se non sono dello stesso identico tipo.
Ciao,
Nicola

Ciista. E ho detto tutto ;-)
Ciao,
Nicola
P.S. io scrivo int * p; per non fare ingiustizie (e perche' l'asterisco
sia piu' evidente).

Lo stesso Stroustrup sconsiglia scritture del tipo:
char* pippo, topolino;
Al suo posto e' meglio scrivere:
char* pippo;
char topolino;
Non dimenstichiamo che il C++ ha avuto il gravoso problema di dover
mantenere una certa compatibilita' con il C. Le stranezze di certe
dichiarazioni sono dovute a cio'.
CesareP.
-- 
Posted from 
dsiaq1.ing.univaq.it
 [192.150.194.32] 


Personalmente io trovo leggibilissimo


Nella dichiarazione
int * p;
il binding sintattico lega l'asterisco all'identificatore, pero' il tipo
dell'identificatore e' int*. E quando si dice cio', automaticamente
l'occhio lega l'asterisco al nome del tipo! Tutto nasce dall'aver mantenuta
la compatibilita' con il C (nel bene e nel male: si pensi alle conversioni
fra tipi base: a un complex puoi assegnare un char :-((( ). Le
dichiarazioni del tipo:
int *p1, *p2;
e' meglio evitarle, in uno stile che predilige i tipi. Certo che quando
l'occhio si e' abituato, e' difficile mantenere una regola. Se io risesco a
parlare bene sia in italiano che in inglese e se sto fra persone per le
quali accade la stessa cosa, allora come niente inizieremo a mischiare
tutti parole italiane e inglesi, senza che nessuno abbia problemi.
Normalmente, nel software, non si fa questa ipotesi, quindi e' meglio
attenersi il piu' possibile a delle regole, per il bene dell'Azienda per la
quale si lavora o del gruppo in cui si lavora.
A proposito delle conversioni fra tipi base, lo stesso Stroustrup dice che
secondo lui troppe conversioni sono permesse.


quale si lavora o del gruppo in cui si lavora.
Secondo me, non conviene neanche mischiare i termini di una lingua con
quelli dell'altra per il bene della Sana Comprensione ;)
--
Andrea Laforgia (ICQ 87230455)
"Esistono due modi per elaborare il progetto di un software.
 Il primo consiste nel renderlo semplice al punto che non
 manifesti lacune evidenti. Il secondo consiste nel renderlo
 complicato al punto che non manifesti lacune evidenti.
 Il primo metodo e' di gran lunga piu' difficile." [C.A.R. Hoare]

 qualche parte ?
Tutt'al piu' nel passo di Stroustrup citato altrove nel thread; anche
perche' il compilatore se ne frega di quanti spazi (o token equivalenti)
possono esserci tra la parola chiave "int" ed il simbolo "*" o tra il
simbolo "*" ed il nome della variabile. E' solo ed esclusivamente
questione di gusti e le razionalizzazioni a posteriori lasciano il tempo
che trovano (la veridicita' della tesi *non* dimostra la veridicita'
dell'ipotesi!)
Ciao,
Nicola