Newsgroup: it.comp.lang.c++
Titolo: funzioni const e funzioni non const

Ciao,
ho un problema legato a funzioni definite const.
Sto usando una libreria per ottimizzare una funzione.
Questa libreria definisce la funzione creadno una classe che eredita da 
TxGradFuncIfc e chiedendomi di definire l'operatore ().
La definizione della classe classe č:
class PostureReconstructor: public TxGradFuncIfc  < double, VarsVectorType >
{
public:
	PostureReconstructor	( VectorSurfaceType *surface, TexturedModel * model );
	PostureReconstructor	( void );
	~PostureReconstructor	( void );
	// Opt++ functions
	size_t	getArgDim() const;
	double	operator()(const VarsVectorType& x) const throw (TxBadEvalExcept);
[..snip..]
}
Fin qui tutto regolare. Il mio problema nasce quando definisco l'operatore:
double PostureReconstructor::operator()(const VarsVectorType& x) const
		throw (TxBadEvalExcept)
{
	assignGslVectorToModel( x );
	calculateDistance();
 
	return getTotalDistance();
}
ovviamente il compilatore mi avvisa e mi da degli errori come questo:
error C2662: "PostureReconstructor::calculateDistance": impossibile 
convertire il puntatore "this" da "const PostureReconstructor" a 
"PostureReconstructor &"
Perche' il mio operatore č definito const e non posso modificare 
l'oggetto (this) richiamando funzioni che lo alterino 
(calculateDistance() calcola un valore e lo memorizza in una variabile 
privata, assignGslVectorToModel() assegna i valori del vettore x ad un 
oggetto puntato da un puntatore privato).
Mentre calculateDistance posso renderlo const, e getTotalDistance posso 
anche eliminarlo, assignGslVectorToModel() fa esattamente quello che non 
puň fare: modificare l'oggetto this.
C'e' un modo che consenta di aggirare questo ostacolo?
Ad esempio se definisco un operatore operator() (const VarsVectorType 
&x) non const, c'e' un modo per far sě che il C++ usi questo (come se 
fosse in overload)? (questa ultima cosa l'ho provata e mi da errore, ma 
forse sbaglio io...)
matteo!
Considerando che

 forse sbaglio io...)
Forse sbagli nell'overload del metodo const:
//metodo const (aggiungi un const all'inizio della tua dichiarazione)
const double PostureReconstructor::operator()(const int& x) const {
...
//puoi richiamare il metodo const della classe base, o lasciarlo vuoto...
}
//metodo non const
double PostureReconstructor::operator()(const int& x) {
modify ((int) x)
}
Questo secondo metodo non è proprio un overload (perchè il metodo const è
comunque visibile e richiamabile), ma verrà chiamato SOLO ogni volta che usi
l'operatore dentro una funzione o metodo della classe di tipo const.
Quando invece usi l'operatore normalmente verrà richiamato il metodo sotto,
cioè quello non const

 cioè quello non const
La classe da cui eredito definisce l'operatore virtual, quindi devo 
fornire per forza un operatre const (anche se solo vuoto).
Ma se la libreria che io uso richiama *da una sua funzione membro const* 
l'operatore, verrà usato l'operatore const, giusto?
Quindi io sono fregato comunque perche' verrà usato la funzione const, 
se ho capito bene quello che dici :(
E se io facessi riferimento all'interno della mia funzione const a 
funzioni non const richiamate attraverso un puntatore che si riferisce 
ad un'altra classe, queste chiamate sarebbero valide?
Faccio un esempio:
//----------------------------------------
class MiaClasse
{
   public:
	void myfunz ( void ) const;
   private:
      AltraMiaClasse *ptr;
}
void MiaClass::myfunz ( void ) const
{
	ptr->modify ( ... );
}
class AltraMiaClasse
{
   public:
	void modify ( int x ) const;
   private:
	int var;
}
void AltraMiaClass modify (int x)
{
	var = x;
}
//----------------------------------------
La chiamata che modifica il valore della variabile AltraMiaClass::var 
che effettuo in myfunz dovrebbe essere valida perche' modifico una 
seconda classe (non const) attraverso una funzione non const, ma il 
valore del puntatore MiaClass::ptr non è alterato (quindi nessun 
elemento della classe in cui ho definito la funzione const è cambiato).
Che dite, la cosa permetterebbe di aggirare il problema se usassi un 
puntatore per riferirmi ai dati che devo modificare?
matteo!

puntatore per riferirmi ai dati che devo modificare?
Si in questo modo puoi modificare tutto quello che vuoi in AltraMiaClasse
(modify dichiarata non const!) , ma comunque non puoi modificare niente in
MiaClasse attraverso ptr->modify (...) perchè potresti passare solo
parametri const
Spero di esserti stato utile
Ciao

 Spero di esserti stato utile
Assolutamente molto utile.
Mi hai fatto notare alcune mie idee inesatte e ho avuto interessanti 
coordinate per approfondire, tks!
matteo!