C++ template de la spécialisation de constructeur

J'ai basé sur un modèle de classe A<T, int>, et de deux typedefs Un<string, 20> et Un<string, 30>.
Comment puis-je remplacer le constructeur pour Un<string, 20> ? Le code suivant ne fonctionne pas:

template <typename T, int M> class A;
typedef  A<std::string, 20> one_type;
typedef  A<std::string, 30> second_type;


template <typename T, int M>
class A {
public:
  A(int m) {test= (m>M);}

  bool test;

};


template<>
one_type::one_type() { cerr << "One type" << endl;}

Je voudrais la classe A<std::string,20> pour faire quelque chose que les autres n'ont pas. Comment puis-je le faire sans modifier le constructeur A:A(int) ?

Qu'essayez-vous d'obtenir les classes?
La question n'est pas claire. BTW, one_type n'a pas de constructeur vide, elle a constructeur avec un paramètre de type int.

OriginalL'auteur user231536 | 2009-12-14

c++constructor specialization templates

8

La seule chose que vous ne pouvez pas faire est d'utiliser la typedef pour définir le constructeur. Autre que cela, vous devez vous spécialiser les A<string,20> constructeur comme suit:
```
template<> A<string,20>::A(int){}
```
Si vous voulez A<string,20> d'avoir un différents constructeur que le générique A, vous avez besoin de spécialiser l'ensemble de la A<string,20> classe:
```
template<> class A<string,20> {
public:
   A( const string& takethistwentytimes ) { cerr << "One Type" << std::endl; }
};
```
OriginalL'auteur xtofl

En supposant que votre vraiment signifiait pour A::test à être accessibles au public, vous pourriez faire quelque chose comme ceci:

#include <iostream>


template <int M>
struct ABase
{
  ABase(int n) : test_( n > M )
  {}

  bool const test_;
};


template <typename T, int M>
struct A : ABase<M>
{
  A(int n) : ABase<M>(n)
  {}
};


template <typename T>
A<T, 20>::A(int n)
  : ABase<20>(n)
  { std::cerr << "One type" << std::endl; }

Coup de pied les pneus:

int main(int argc, char* argv[])
{
  A<int, 20> a(19);
  std::cout << "a:" << a.test_ << std::endl;
  A<int, 30> b(31);
  std::cout << "b:" << b.test_ << std::endl;
  return 0;
}

Bonne réponse, va noix avec le type de système 😛

OriginalL'auteur seh

1

Vous ne pouvez pas avec votre approche. one_type est un alias pour un modèle particulier de spécialisation, de sorte qu'il devient quoi le code du template.

Si vous souhaitez ajouter du code spécifique à one_type, vous devez le déclarer comme une sous-classe d'Une spécialisation, comme ceci:
```
  class one_type:
    public A<std::string>, 20>
  {
    one_type(int m)
      : A<str::string, 20>(m)
    {
      cerr << "One type" << endl;
    }
  };
```
La pensée aussi. du constructeur ne peut pas être spécialisé que les fonctions de membres, pouvez-vous donner un argument pour expliquer pourquoi pas ?
Réponse ci-dessous :

OriginalL'auteur Franci Penov

Cela peut être un peu de retard, mais si vous avez accès à c++11 vous pouvez utiliser SFINAE à accomplir tout ce que vous voulez:

  template <class = typename std::enable_if< 
    std::is_same<A<T,M>, A<std::string, 20>>::value>::type //Can be called only on A<std::string, 20>
  > 
  A() {
    //Default constructor
  }

Exemple de travail

OriginalL'auteur amc176

Comment sur :

template<typename T, int M, bool dummy = (M > 20) >
class A {
public:
  A(int m){
      //this is true
  }

};

template<typename T, int M>
class A<T,M,false> {
public:
    A(int m) {
    //something else
    }
};

OriginalL'auteur OneOfOne

La meilleure solution que j'ai été en mesure de venir avec cette situation est d'utiliser un "constructeur fonction d'assistance":

template <typename T, int M> class A;
typedef  A<std::string, 20> one_type;
typedef  A<std::string, 30> second_type;

template <typename T, int M>
class A {
private:
  void cons_helper(int m) {test= (m>M);}
public:
  A(int m) { cons_helper(m); }

  bool test;
};

template <>
void one_type::cons_helper(int) { cerr << "One type" << endl;}

OriginalL'auteur WaltK

Vous devez vous connecter pour publier un commentaire.