Newsgroup: it.comp.lang.c++
Titolo: array di classi

il mio problema e' questo:
devo istanziare n classi del tipo :
MiaClasse* ciao[n];
for(int i=0,i<n;i++){
   	ciao[i]=new MiaClasse;
	    }     
dove n e' scelto dall'utente all'inizio del programma.Ho provato in
qualsiasi modo ma il compilatore mi da' errore,dato che n deve essere
costante.Come faccio?(devo comunque usare gli array per comodita').
Ciao

 ha scritto nel messaggio
news:39D8BE16...@katamail.com...

Rendi dinamico anche l'array:
MiaClasse *ciao;
ciao = new (MiaClasse *)[n];
ciao[n] = ...
Non c'è nulla che ti impedisca di creare un puntatore a puntatore a
MiaClasse, dopotutto :-)
Massimo
P.S.
Forse le parentesi tonde non servono, ma non sono sicuro.

 costante.Come faccio?(devo comunque usare gli array per comodita').
MiaClasse **ciao = new MiaClass * [ n ];
for ( int i = 0; i < n; ++i )
{
    ciao[ i ] = new MiaClasse;
}
EMG

 costante.Come faccio?(devo comunque usare gli array per comodita').
Usa uno std::vector che e' assai piu' comodo.
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

 Forse le parentesi tonde non servono, ma non sono sicuro.
Questo e' uno dei pochi casi in cui oltre a non servire
sono dannose. In particolare se si mettono le parentesi
il codice non e' corretto; la sintassi corretta e':
     ciao = new MiaClasse * [n];
HTH
Andrea
--
Andrea Griffini, programmer. 
http://www.netservers.com/~agriff
Sent via Deja.com 
http://www.deja.com/
Before you buy.

 qui dovrebbe essere **ciao;
Non hai tutti i torti :-)
Con le parentesi che succedeva di scorretto invece ?
Massimo

usa std::vector<>
Paolo
-------------------------------------------
  Paolo Marotta
 
http://web.tiscalinet.it/paolo_marotta/
-------------------------------------------



Dipende dal compilatore. Se ad esempio scrivi
   MiaClasse **p=new (MiaClasse *)[10];
il gcc non genera nessun errore e si comporta come
ti aspetti; se pero' includi l'opzione "--pedantic"
ti viene detto come warning che lo standard ANSI C++
non permette l'uso di parentesi all'interno del tipo
di una new.
Molto piu' strano e' quello che ad esempio accade
con BCC55: tale espressione viene interpertata
infatti come
   MiaClasse **p=((new MiaClasse *)[10]);
e genera quindi un errore di compilazione visto
che (new MiaClasse *) alloca un solo puntatore
a MiaClasse e restituisce un "MiaClasse **",
la parte "[10]" entra in azione successivamente
e dereferenziando questo puntatore a puntatore
restituisce un "MiaClasse *" (accedendo fra
l'altro fuori dai limiti allocati).
VC++ e il Watcom C++ indicano invece un errore di
sintassi fatale se vengono utilizzate le parentesi.
Io sarei portato a dire che il comportamento corretto
e' generare un errore/warning (gcc, vc++, watcom)
e non cambiare il senso del codice; ovviamente non e'
pero' un grosso problema visto che l'interpretazione
di bcc55 comunque porta ad un errore di tipo che non
puo' passare inosservato. Comunque credo che un
programma (assurdo) che facesse
   int main()
   {
     new (int *)[10];
     return 0;
   }
dovrebbe generare un messaggio diagnostico.
La regola e' "mai usare parentesi nel tipo usato
con l'operatore new". Per risolvere eventuali problemi
basta eventualmente appoggiarsi ad una opportuna typedef.
Personalmente io trovo la sintassi di new in generale
particolarmente infelice per vari motivi, ma questa
sintassi e' purtroppo quella che e' stata scelta e
bisogna conviverci.
HTH
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 Ciao
La mia risposta č molto piů semplice delle altre, non sono un espertissimo e
forse mi sbaglio, comunque tu prova.
queste righe di codice rappresentano come risolsi il problema tempo fa:
 int n;
 cout << "Quanti oggetti si desidera creare?\n";
 cin >> n;
 const int num_obj = n;
 myclass array_istanza[num_obj];
prima di mandarlo sul newsgroup l'ho compilato con diversi compilatori:
BCC5.5, Dev-C++ 3.95 e g++(sotto sistemi *nix), per essere sicuro di non
postare stronzate ;)
se mi sbaglio me lo fate notare?
ciao ciao
<---
+-sent by sgrung
 |
 `- 'Sono stato nessuno per diventare qualcuno'
--->

 se mi sbaglio me lo fate notare?
Non credo che tu l'abbia compilato. Non si può fare una cosa del genere
in C++.
EMG

 ha scritto nel messaggio
news:3A3A7E29...@flashnet.it...

Ma poi scusate... "new" è proprio passato di moda ? :-)
myclass *array_istanze = new myclass[num_obj];
E passa la paura...
Massimo

 E passa la paura...
Fa una cosa diversa ... ( ti devi gestire la deallocazione esplicitamente 
!! )
La soluzione pulita e'
vector<myclass> array_istanze( num_obj );

 non ti fidi è tutta un'altra questione, prova e fammi sapere :-|
A quanto pare il gcc lo accetta. Però, come già detto, non è C++
standard (almeno non ancora).
EMG

 wrote in message
3A3BD66E...@flashnet.it...


descritti dagli altri?
Non necessariamente, basta acquistare le specifiche del linguaggio e vedi
che i tuoi problemi sono risolti.
Inoltre se un array è statico, anche il numero che ne rappresenta l'indice
dev'essere tale.
Altrimenti giudicherei quelli dello standard dei cretini perché hanno
aggiunto operatori come new[] e delete[] che non servirebbero a nulla.

 descritti dagli altri?
Chiaro.
EMG


int main()
{
  int i=20;
  const int n=i;
  int v[n];       // Linea 5
  return 0;
}
BCC55:
  Error E2313 vardim.cpp 5: Constant expression
  required in function   main()
g++: (con l'opzione --pedantic)
  vardim.cpp: In function `int main()':
  vardim.cpp:5: warning: ANSI C++ forbids variable-size array `v'
Ho sentito che Dev-C++ lo accetta come anche g++ senza --pedantic
ma si tratta di una estensione (abbastanza diffusa) allo standard.
Chi accetta una cosa simile pero' di solito accetta anche v[n]
dove n non e' "const int" ma semplicemente un int.
Nota che le cose cambiano se scrivi:
  const int n=20;
  int v[n];
in questo caso infatti il compilatore puo' trattare effettivamente
n come una costante nota al momento della compilazione.


standard (almeno non ancora).
Se compili con l'opzione --pedantic ti viene segnalato che stai
usando una estensione non prevista nello standard ANSI.


 aggiunto operatori come new[] e delete[] che non servirebbero a nulla.
Perche'? Il caso descritto sopra e' particolare, per qualunque struttura
dati definita in modo ricorsivo non puoi che ricorrere all'allocazione
dinamica.
Ciao,
Nicola

Questo genere di meccanismo e' infatti previsto dal nuovo standard del
Hai ragione. Ma non riesco a capire perché il compilatore mi da un warinig
comunicandomi che la dichiarazione dell'array deve essere spostata nella
sezione dichiarativa del programma.
-- 
La classifica dei prodotti MS:
C#, la migliore barzelletta di Bill Gates.
J++, la copiatura piů riuscita.
Windows, il piů instabile.
Visual Basic, un esempio di prodotto decente della MS - forse l'unico -.
OutlookExpress, scandali su scandali.
 

Non e' che stai compilando un file C e non C++?
Ciao,
Nicola

>Non e' che stai compilando un file C e non C++?
No, č proprio un file .cpp e le impostazioni del compilatore sono per
codice C++.
