[c++] variabili "virtual"

[thesalien]

Salve a tutti,
io ho un qualcosa del genere:

Class A
{
protected:
const int pippo = 5;
int pluto;

public:
A()
{
pluto = pippo;
}

};


Class B : public A
{
const int pippo = 10;

}

Nella class B che estende A ho ridefinito pippo e giustamente quando creo un oggetto di tipo B alla variabile pluto gli viene assegnato il valore 5 invece che il valore 10.
Io vorrei invece che gli venisse assegnato il valore 10. Questo si può fare scrivendo opportuno codice nel costruttore di B ma questo vorrei evitarlo. Penso che si possa fare scrivendo una funzione virtuale che restituisca il valore di pippo ma non so quale sia il metodo più efficiente e più usato in questi casi..
qualche suggerimento?

[MItaly]

Non credo che con i const si possa fare... non mi pare che una variabile dichiarata in quel modo sia davvero resa come una variabile, mi pare che il compilatore la tratti, appunto, come una costante, per cui in tutto il codice che ne fa uso la sostituisce con il suo valore.

[thesalien]

mi sono scordato di mettere il modificatore static nelle due dichiarazioni di pippo..
dunque erano const static int pippo = x;

uhm..Scrivendo codice nel costruttore di B funziona sicuramente, l'ho già provato..

[MItaly]

http://forums.whirlpool.net.au/forum...fm/197266.html

[thesalien]

thx, ora provo a guardare

[thesalien]

Mi sa proprio che non c'è soluzione.. damn it!
Quel che dicono di fare, nel mio caso è praticamente la stessa cosa che stavo dicendo prima che sono riuscito a fare.. speravo ci fosse qualche altro metodo..

[MItaly]

Ma non puoi fare una cosa del genere?

class A
{
    protected:
    virtual int getPippo() { return 5; };
    //...
}

class B : public A
{
    protected:
    virtual int getPippo() { return 10; };
    //...
}

[thesalien]

no.. il problema è che non voglio scrivere codice ridondante nella classe B. Con quella soluzione certo, funziona.. ma è proprio quello che voglio evitare.

Il mio problema è che sto realizzando un gioco turn-based dove vi sono delle unità di vario tipo (ad es. leoni, cani, insetti ecc) ognuna delle quali ha diverse caratteristiche (vita iniziale, numero di passi per turno ecc e molte altre cose).
Tutte queste unità hanno in comune alcune cose come ad esempio il fatto che la vita corrente nel costruttore dovrà esser settata uguale alla vita iniziale ecc, e dunque implementando queste cose a livello della classe padre (Unit) mi risparmierei tantissime righe di codice.

[MacApp]

Forse intendi una delle tre seguenti?

#include <iostream>

/*
$ g++ -Wall -ansi -pedantic -Wextra -Wconversion main.cpp
$ ./a.out

aBase.fValue: 5;
aDerivata.fValue: 10;
aBase15.fValue: 15;
aBase20.fValue: 20;
aModello25.fValue: 25;
aModello30.fValue: 30;
*/
namespace ig{
	class Base{
		public:
		const int fValue;
		
		public:
		Base (void):
		fValue (5){
		}
		
		Base (const int theValue):
		fValue (theValue){
		}
	};
	
	class Derivata: public Base{
		public:
		Derivata (void):
		Base (10){
		}
	};
	
	
	template <int TInt>
	class Modello{
		public:
		const int fValue;
		
		Modello (void):
		fValue (TInt){
		}		
	};
}

int main (void){
	// one
	const ig::Base aBase;
	const ig:: Derivata aDerivata;
	std::cout << "aBase.fValue: " << aBase.fValue << ";" << std::endl;
	std::cout << "aDerivata.fValue: " << aDerivata.fValue << ";" << std::endl;

	// two
	const ig::Base aBase15 (15);
	const ig::Base aBase20 (20);
	std::cout << "aBase15.fValue: " << aBase15.fValue << ";" << std::endl;
	std::cout << "aBase20.fValue: " << aBase20.fValue << ";" << std::endl;
	
	// three
	const ig::Modello <25> aModello25;
	const ig::Modello <30> aModello30;
	std::cout << "aModello25.fValue: " << aModello25.fValue << ";" << std::endl;
	std::cout << "aModello30.fValue: " << aModello30.fValue << ";" << std::endl;
	
	return 0;
}

[KrOW]

Ciao ... Se ho capito bene il tuo problema, potresti fare una cosa del genere:

struct ConstantData
{
   ConstantData( int inHP, int inMP, int speed ) : initialHP(inHP), initialMP(inMP), speed(speed) {}
   // Qui tutte le costanti condivise
   const int initialHP;
   const int initialMP;
   const int speed;
};


class Unit
{
   // Qui tutte le variabili condivise
   int m_currHP;
   int m_currMP;
protected:
   // Il costruttore deve inizializzare le variabili secondo i valori delle costanti
   Unit( const ConstantData& init ) : currHP(init.m_initialHP), currMP(init.m_initialMP) {}
   virtual ~Base() {}
};

class Lion : public Unit
{
   static ConstantData initialData;
public:
   Lion( ) : Unit( initialData ) {}
};

class Snake : public Unit
{
   static ConstData initialData;
   Snake( ) : Unit( initialData ) {}
};

Quindi l' inizializzazione delle varie costanti condivise:

ConstantData Lion::initialData( 200,150,20 );
ConstantData Snake::initialData( 100,50,13 );