Newsgroup: it.comp.lang.c++
Titolo: Nascondere il numero di elem. massimi di un array

Per definire il numero max di elementi di un vettore:
int v[nmax];
nmax deve essere una costante a tempo di compilazione.
Se lo devo fare in una classe, mi è sembrato di capire che le 
opportunità sono solo due:
///////////////////////////////////
// 1) old-hack di enum:
///////////////////////////////////
class Vettore{
	enum {nmax=100};
	int v[nmax];
public:
         //....
};
///////////////////////////////////
// 2) uso di una costante statica:
///////////////////////////////////
class Vettore{
	static const int nmax=100;
	int v[nmax];
public:
         //....
};
'nmax', in entrambi i casi, deve essere definita/inizializzata nel corpo 
della classe, immediatamente prima della definizione di v[], quindi è 
un'informazione presente  nella specifica pubblica della classe.
C'è un modo di rendere quel '100' non pubblico, magari occultarlo 
nell'implementazione?
Ho provato a dichiarare nmax nella classe e a inizializzarlo 
nell'implementazione, cioè:
//vettore.h
class Vettore{
	static const int nmax;
	int v[nmax];
public:
         //....
};
// vettore.cpp
const int Vettore::nmax = 100;
Ma ottengo un errore di compilazione. Come se il compilatore volesse 
nmax inizializzata _prima_ della definizione
di v[nmax].

 nmax inizializzata _prima_ della definizione di v[nmax].
Esatto.
Max

 opportunità sono solo due:
io preferisco di gran lunga una terza, con effetti 
collaterali però, che è la via templatica
template <unsigned nmax> class Vettore {
     int v [nmax];
public:
 >         //....
l'effetto collaterale è che non esiste in effetti la classe 
Vettore, ma una famiglia di classi distinte a seconda dei 
valori del parametro.
Tuttavia nel tuo contesto è un non-problema, infatti tu 
avresti comunque definito un solo tipo di Vettore di 
dimensione costante e prefissata, e nessuno ti vieta quindi 
di dichiarare solo istanze templatiche omogenee tra loro
ciao
Soviet


 nmax deve essere una costante a tempo di compilazione.
Hai motivi concreti per non usare std::vector?
Ciao,
Nicola

 Hai motivi concreti per non usare std::vector?
Ancora non ci sono arrivato con il corso ;-)

 opportunità sono solo due:
Te ne propongo una terza. Usa new[] nel costruttore e delete[] nel
distruttore, così eviti tutti i problemi di quel tipo (avendo ben
presente che usare gli array grezzi in C++ è comunque segno di
appartenenza al Lato Oscuro).
class Vettore
{
public:
	Vettore( int n = 100 );
	~Vettore();
private:
	const int* v;
};
Vettore::Vettore( int n ) : v( new int[n] )
{
}
Vettore::~Vettore()
{
	delete[] v;
}
Ho messo v come const, in questo modo sei sicuro che il codice della
classe non possa mai cambiare il valore del puntatore; però ciò vuol
dire che devi inizializzarlo nel costruttore come mostrato sopra, già
nel corpo del costruttore non è più possibile.
Nota: se funzionasse con gli array, cosa che *non* fa, potresti
semplicemente usare auto_ptr, in questo modo non dovresti preoccuparti
di ~Vettore(). Però auto_ptr use delete, non delete[], quindi non
provarci neanche (una volta mi sono implementato un mio auto_array allo
scopo).
Ciao,
- -Federico
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: Using GnuPG with SUSE - 
http://enigmail.mozdev.org
iD8DBQFIc419BIpu+y7DlLcRAkOYAJ9GcDR6UFTHBJ7DlLUneJWDSM9KugCglsVI
7ElyXpGDEIiJwv4Tr5FsWX0=
=eVEF
-----END PGP SIGNATURE-----

 }
Bleeergh che strafalcione, scusate l'autorisposta... è il caso di tener
traccia del numero totale di elementi allocati!
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: Using GnuPG with SUSE - 
http://enigmail.mozdev.org
iD8DBQFIc5fQBIpu+y7DlLcRAlx+AKC0w+MTuCgi7QdiqPyEONjGOiYfKwCfTcK2
8EtmvFx6TlMQDgwVymLIVkU=
=PmLe
-----END PGP SIGNATURE-----

 appartenenza al Lato Oscuro).
:-) ROTFL ! !
(una volta che usato il C tu avrai, mai più nella luce 
camminerai)
Soviet_Fener
CUT



Bel corso del menga ;-)
Io mi domando com'e' che chi insegna Java insegna il Java di oggi e
non quello del '96; chi insegna C# oggi nel '96 non c'era; e invece
chi insegna C++ si ostina ad insegnarlo come si faceva nel 1986 o giu'
di li'... sigh.
Ciao,
Nicola