[C++] Uso di template ed errori di compilazione

[thesalien]

salve a tutti,
so che il codice seguente da errori in fase di compilazione ma vorrei fare un qualcosa di questo tipo:

class A
{
protected:
 const int size;
 A(int s) size(s): 
};

class B: public A
{
int b;
const int pippo;
B(int p):pippo(p){b=size}
};

//.cpp file
int parA =2;
int parB = 4;

BditipoA<parA>  myobj(parB);

sono convinto che si possa fare ma non so come..
qualche suggerimento?


edit:
stavo pensando anche a qualcosa che non c'entra nulla con i template:

A ogg1(3);

B ogg2 = ogg1.foo(3);

//con B foo(int x);

[MItaly]

Francamente ho riletto un paio di volte il tuo post ma non ho capito cosa tu voglia fare.

[thesalien]

ciao,
si non mi sono espresso in modo molto chiaro, hai ragione..

Il mio problema è il seguente:

ho una classe X che ha un costruttore che prende in ingresso un valore. All'interno di questa classe devo utilizzare degli oggetti di una certa classe Y, anche questa classe Y ha un costruttore con alcuni parametri in input. Io vorrei fare in modo che la classe Y sia legata in qualche modo ai parametri forniti al costruttore della classe X.

vorrei fare una cosa del tipo: (ovviamente questo non funzionerà..)

class Y 
{
public:
int ciao;
const int var2;
Y(int b) : var2(b){  ciao = var1 + var2 }
}

class X
{
public:
const int var1;
X(int a):var1(a){   }
int foo();
};

//cpp
int X::foo()
{
Y hello(2);
return  Y.ciao ;
}

Scrivendo qualcosa del tipo: X myx(5); la funzione foo restituirà 7 (ossia 5+2)
con X myx(10) restituirà 12 ecc


Se non mi son spiegato bene neanche ora, fammi sapere
ps non voglio usare variabili statiche

EDIT: rimodificato l'esempio

[MacApp]

Originariamente inviato da thesalien
Io vorrei fare in modo che la classe Y sia legata in qualche modo ai parametri forniti al costruttore della classe X.

Puoi ad esempio passare il membro di X al costrutore di Y ad esempio:

class Y 
{
public:
int ciao;
const int var2;
Y(int b, int valueFromX) : var2(b){  ciao = valueFromX + var2 }
}

class X
{
public:
const int var1;
X(int a):var1(a){   }
int foo();
};

//cpp
int X::foo()
{
Y hello(2, var1);
return  Y.ciao ;
}

[thesalien]

ciao, thx per la risposta.
Si, per ora il mio codice funziona in questo modo ma purtroppo questa soluzione non mi va bene perché vorrei rendere questo codice un pò più ottimizzato diciamo.. e penso che non abbia troppo senso passare al costruttore di Y un valore che è praticamente sempre lo stesso una volta istanziato X

[thesalien]

un'altra possibile soluzione potrebbe essere quella di usare una variabile globale, ma mi è sempre stato detto che queste sono da evitare come la peste..

[MacApp]

Intendi una cosa del genere?

// $ g++ -Wall -ansi -pedantic -Wextra -Wconversion main.cpp 
// $ ./a.out 
// $ x.foo (): 7


#include <iostream>

template <int TValueFromX>
class Y{
	public:
	const int ciao;
	Y(int b) : ciao (TValueFromX + b){
	}
};

template <int TVar1>
class X{
	public:
	int foo();
};

template <int TVar1>
int X<TVar1>::foo(){
	Y <TVar1> hello(2);
	return  hello.ciao ;
}

int main (){
	X <5> x;
	std::cout << "x.foo (): "  << x.foo () << std::endl;
	return 0;
}

[thesalien]

ciao scusa per la mia tarda risposta ma ero fuori casa..
Ho provato a fare alcune prove ed effettivamente cosi' funziona anche se mi sa che abbandonerò quest'idea dei template perché probabilmente dovrò utilizzare anche degli input a runtime e quindi con i template non posso fare un bel niente in questo caso..

Thanks very much