Discussion :

[youpi-h]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[ternel]

Veux-tu que la classe soit template?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[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).

[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>).