Newsgroup: it.comp.lang.c++
Titolo: Maledette costanti...

E' solo mia ignoranza, si vede da 1 km di distanza (rima)...
Mi dite perché, scrivendo in VC++4,
[...]
private:
 CONST INT NNUMBER = 10000;
 CONST INT NLINKSNUMBER = 10;
 CONST INT ACTIVATIONLEVEL = 100;
 CONST INT MINACTIVATIONOUTPUT = 30;
 INT NLinks[NNUMBER][NLINKSNUMBER];
 INT NData[NNUMBER];
};
egli si lamenta mitragliandomi
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(39) : error C2258:
illegal pure syntax, must be '= 0'
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(39) : error C2252:
'NNUMBER' : pure specifier can only be specified for functions
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(40) : error C2258:
illegal pure syntax, must be '= 0'
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(40) : error C2252:
'NLINKSNUMBER' : pure specifier can only be specified for functions
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(41) : error C2258:
illegal pure syntax, must be '= 0'
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(41) : error C2252:
'ACTIVATIONLEVEL' : pure specifier can only be specified for functions
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(42) : error C2258:
illegal pure syntax, must be '= 0'
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(42) : error C2252:
'MINACTIVATIONOUTPUT' : pure specifier can only be specified for functions
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(43) : error C2065:
'NNUMBER' : undeclared identifier
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(43) : error C2057:
expected constant expression
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(43) : error C2065:
'NLINKSNUMBER' : undeclared identifier
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(43) : error C2057:
expected constant expression
C:\Documenti\Microsoft Visual C++\NNTest\NNTestDlg.h(44) : error C2057:
expected constant expression
?
Per evitare che la vostra curiosità vi ispiri a chiedere cazzate riguardo il
codice scritto, sappiate pure che sto facendo un esperimento di reti
neurali.
AZIE!
E.G. er Cicca
er_c...@usa.net
Art. 1: L'Italia è una repubblica progettata per Windows 95.

 };
Perché scrivi CONST e INT maiuscoli? Le parole chiave sono const ed int,
minuscole.
Ho provato:
class prova
{
private:
    const int i = 100;
};
sotto DJGPP e mi va tutto bene.
--
Flavio Poletti
e-mail:   
pol...@writeme.com
web page: 
http://poletti.freeweb.org/
La libertà [americana] è lì, alla portata di tutti...
     ... come la chitarra ....
... ognuno suona come vuole ...
     ... e tutti suonano come vuole la libertà!
                                  (G. Gaber)


Ma non dovrebbe essere un errore inizializzare
membri const nella dichiarazione di classe?
O sono io che ho perso qualche pezzo dello standard?
Paolo
----------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
  e-mail: 
mar...@cli.di.unipi.it
 
----------------------------------------------------------


spero volessi scrivere
#define CONST const
#define INT int
class MyClass {
private:
CONST INT NNUMBER = 10000;
CONST INT NLINKSNUMBER = 10;
CONST INT ACTIVATIONLEVEL = 100;
CONST INT MINACTIVATIONOUTPUT = 30;
INT NLinks[NNUMBER][NLINKSNUMBER];
INT NData[NNUMBER];
};
che comunque non funziona.
Vuoi mettere dei valori predefiniti per alcune variabili membro
della classe oppure stabilire a priori che tutte le istanze della classe
avranno quie valori per le variabili membro?
Se la risposta e' uno prova
class MyClass {
   MyClass():m_MyInt(1){};
private:
    int m_MyInt;
}
dove specifichi un inizializzatore nel costruttore di default.
Se la risposta e' due prova con
class MyClass {
private:
    static int M_MyInt =1 ;
}
dove specifichi il modificateore static

 CONST INT NNUMBER = 10000;
A parte il problema delle maiuscole (const e int
andranno in minuscolo), il C++ "di una volta"
non permetteva la dichiarazione in-linea di valori
int costanti entro una classe (men che meno per
variabili _di istanza_, cioe` che chiedi vengano
ripetute separatamente per ogni oggetto di quella
classe, come qui fai omettendo l'aggettivo "static").
Senza "static", continua a non essere standard; con
static, oggi, lo Standard lo ammette -- purche` da
qualche parte sia anche riservata la memoria (nel
file C++ della classe, scriverai
    int nomedellaclasse::NNUMBER;
senza inizializzatore).
La soluzione tradizionale (che continua a funzionare
benissimo) e` di usare una enum, che non presenta
alcuno di questi problemi:
    private:
        enum costanti {NNUMBER=10000, ecc ecc};
Con questo scommetto che funziona anche VC++4
(e magari anche qualche compilatore anche + antico!).
Alex

minuscole.
Solo per adeguarmi allo standard. In fondo, in mezzo a quel labirinto di
simboli chiamato MFC ho trovato le definizioni di CONST e INT che
effettivamente corrispondono a const e int. In ogni modo, anche a lettere
minuscole il problema rimane.


Mi sono dovuto ridurre a quattro misere #define, ho compilato e tutto andò
liscio come l'olio
VC++4, non m'importa il tuo nome sballato, ma questa me la pagherai!



spero volessi scrivere
#define CONST const
#define INT int
class MyClass {
private:
CONST INT NNUMBER = 10000;


 senza inizializzatore).
Non dovrebbe essere
  const int nomeclasse::NNUMBER; ?
Secondo lo Stroustrup 3ed, la definizione nel file c++ e'
necessaria solo se c'e' effettivamente bisogno di riservare
memoria per la costante (ad esempio se si usa il suo indirizzo).
(Penso che sia una modifica recente delle standard.)
	Mauro

 liscio come l'olio
Evita le #define. Il medo piu' semplice per avere delle costanti intere
e' con enum:
class Qualcosa {
...
private:
  enum { NNUMBER = 10000, NLINKSNUMBER = 10, ... };
...
};
Se poi sono private e non le usi in qualche funzione inline definita
nel .h, ti conviene mettere l'enum direttamente nel file .c
	Mauro

 Solo per adeguarmi allo standard. 
Ma nello standard sono minuscole.
	Mauro

(Penso che sia una modifica recente delle standard.)
Tutta la possibilita` di definire il valore di una const nella
dichiarazione della classe e` una modifica molto recente;
per come leggo io lo Standard (acquistabile in linea, US$10,
dall'American National Standards Institute, ANSI, che lo
vende su licenza dell'International Standards Organization,
ISO), la definizione _e`_ necessaria in generale (il testo di
Stroustrup e` uscito un annetto prima dello standard, quindi
non ci sarebbe da stupirsi se minuzie del genere siano poi
cambiate; ho rinunciato a riportare sul testo stesso gli errata,
dal 3o printing che ho a quello attuale, dopo piu` di due ore
non ero arrivato a 1/3 del libro, lo ricomprero`...!).  Il testo
dello standard, d'altra parte, e` "legalese stretto" e non poco
intricato, quindi non ci sarebbe da stupirsi se ad essere errata
fosse la mia lettura di esso; merita forse postare su comp.std.c++
se si ha bisogno di una risposta decisiva in merito (li` di esperti
di ogni dettaglio dello standard se ne trovano parecchi).
Alex

 
[snip]
Quando definisci una costante privata, o pubblica di una classe la
costante stessa deve
essere inizializzata nella implementazione del costruttore della classe.
Es.
class Pippo {
 const bool ON;
 const bool OFF;
public:
 Pippo();
 virtual ~Pippo() {}
};
Pippo::Pippo()
: ON(true), OFF(false)
{}
Pero', in questo modo non puoi utilizzare la costante per determinare la
dimensione
di un vettore definito nella classe (come nel tuo esempio). Il problema
si risolve
definendo le costanti come "enum" oppure allocando dinamicamente la
dimensione
del vettore nel costruttore o, meglio, in una funzione di
inizializzazione apposita.
Es.
class Pippo {
 enum { MAX_DIM=1000};
 int vect[MAX_DIM];
public:
 Pippo();
 virtual ~Pippo() {}
};


No è meglio se provi con
class MyClass {
private:
    const static int MyInt;
};
e, nel sorgente cpp:
const int MyClass::MyInt = 23;
PS: questo lo compila, a differenza del precedente :-)