Syntaxe de constructeur template

Version imprimable

Bonjour,
J'aimerais faire la chose suivante.
Appeler un constructeur template depuis une classe enfant et instancier
un objet avec un constructeur template. Toutefois, je ne dois pas avoir les bonnes syntaxes, j'ai deux erreurs de compil'.

Voila un exemple minimal :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 #include <iostream> class Base { public: template<int A = 10> Base():a_(A){} const int a_; }; class Child : public Base { public: template<int B = true> Child() :Base::template Base<B>() //<--erreur !! {} }; int main() { Child var<5>; //<--erreur !! std::cout << var.a_ << std::endl; return 0; }
Une idée ? Merci pour votre aide.

Veux-tu que la classe soit template?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//code en en-tête
template<int A = 10>
struct Base {
  int a() const {return A;}
};
 
template<int B = 1>
class Child : public Base<B> {
public:
  Child(): Base<B>() {}
};
 
//code dans un .cpp
#include <iostream>
int main() {
  Child<5> var;
  std::cout << var.a() << std::endl;
  return 0;
}

ou préfères-tu une solution "non template"

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//code en en-tête
Struct Base
{
public:
  Base(int A): a_(A){}
  const int a_;
};
 
class Child : public Base {
public:
  Child(int B): Base(B) {}
};
 
//code dans un .cpp
#include <iostream>
int main() {
  Child var(5);
  std::cout << var.a_ << std::endl;
  return 0;
}

Cela dit, ta solution ressemblerait à ceci, mais je n'aime pas l'idée:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
 
class Base {
public:
  template<int A = 10>
  Base():a_(A){}
  const int a_;
};
 
class Child : public Base {
public:
  template<int B = true> Child()
    :Base(Base<B>())//espérons que ca passe, en trichant avec le constructeur de copie
  {}
};
 
 
int main() {
  Child var = Child<5>(); //le template est sur le constructeur, pas le type. Et surtout pas sur la variable
  std::cout << var.a_ << std::endl;
  return 0;
}

24/06/2013, 16h21
youpi-h

Bonjour, c'est bien la dernière méthode qui m’intéresse.
Je suis tombé sur ce problème en faisant des tests. Je ne pense pas implémenter "pour de vrai" cette solution.
C'est juste de la curiosité... Cela me semble juste un problème de syntaxe.

Sinon le code ne passe pas, je compile avec g++ 4.6.3 avec l'option de prise en charge du c++0x (-std=c++0x).
24/06/2013, 16h31
ternel

En effet, je n'en vois pas d'usage correcte, ce serait plutôt que la classe elle-même qui serait template.
En général, pour une fonction, un argument remplace avantageusement une valeur template (template <int I>).