Modèle de classes avec des constructeurs

Je pense découlant de votre classe à partir d'une classe de base n'est pas pertinente à la question ici, c'est un simple détail de l'implémentation. Ce qui vous semble vraiment être après si il y a une partie de spécialiser les fonctions de membres, comme le constructeur. Voulez-vous quelque chose de ce genre?

template <typename T, int N> class Foo
{
    Foo(); //general
    template <typename U> Foo<U, 2>(); //specialized, NOT REAL CODE
};

Cela ne fonctionne pas. Vous avez toujours à se spécialiser la classe entière. La raison en est simple: Vous devez connaître le type complet de la classe de première avant vous savez même membre dont les fonctions existent. Considérez les points suivants simples situation:

template <typename  T> class Bar
{
  void somefunction(const T&);
};

template <> class Bar<int>
{
  double baz(char, int);
};

Maintenant Bar<T>::somefunction() dépend T, mais uniquement la fonction existe quand T n'est pas int, parce que Bar<int> est tout à fait différent de la classe.

Ou même envisager une autre spécialisation template <> class Bar<double> : public Zip {}; - même le caractère polymorphe d'une classe peut être totalement différente dans un domaine de spécialité!

Donc la seule façon que vous pouvez fournir spécialisations nouvelles déclarations de membres, y compris les constructeurs, est par la spécialisation de l'ensemble de la classe. (Vous peut de spécialiser les définition de fonctions existantes, voir @Alf réponse.)

OriginalL'auteur Kerrek SB

Vous pouvez toujours spécialiser un membre, par exemple

#include <stdio.h>

template< class Type >
struct Foo
{
    void bar() const
    { printf( "Single's bar.\n" ); }
};

template<>
void Foo< double >::bar() const
{ printf( "double's bar.\n" ); }

int main()
{
    Foo<int>().bar();
    Foo<double>().bar();
}

Mais vous voulez effectivement des signatures différentes, il n'est donc pas directement un cas de spécialisation d'un membre.

Une solution consiste alors à déclarer un constructeur avec un argument simple, d'un type dépend des paramètres de modèle.

Alors vous pouvez vous spécialiser que, comme vous le souhaitez.

Cheers & hth.,

OriginalL'auteur Cheers and hth. - Alf

Vous pourriez donner les définitions les plus courantes dans le non-classe spécialisée et static_assert (BOOST_STATIC_ASSERT pour non C++0x) sur la longueur du tableau. Cela pourrait être considéré comme un hack mais c'est une solution simple à votre problème et coffre-fort.

template<typename T, unsigned int n>
struct Foo {
  Foo(const T& x) { static_assert(n == 1, "Mooh!"); }
  Foo(const T& x1, const T& x2) { static_assert(n == 2, "Mooh!"); }
};

Le "mal" serait variadic arguments.

template<typename T, unsigned int n>
struct Foo {
  Foo(...) { 
    va_list ap;
    va_start(ap, n);
    for(int j=0; j < n; ++j)
      bork[j] = va_arg(ap, T);
    va_end(ap);
  }
};

Puis il y a aussi en C++0x et le bon vieux make_something truc qui est plus difficile que l'on pourrait penser.

template<typename... T, unsigned int n>
Foo<T, n> make_foo(T&&...) {
  //figure out the common_type of the argument list
  //to our Foo object with setters or as a friend straight to the internals
  Foo< std::common_type< T... >::type, sizeof(T) > foo;
  //recursive magic to pick the list apart and assign 
  //...
  return foo;
}

OriginalL'auteur pmr