Comment transférer déclarer une classe de modèle C ++?

Étant donné une classe de modèle comme celle-ci:

template<typename Type, typename IDType=typename Type::IDType>
class Mappings
{
public:
    ...
    Type valueFor(const IDType& id) { // return value }
    ...
};

Comment quelqu'un peut-il déclarer cette classe dans un fichier d'en-tête?

Voici comment vous feriez:

template<typename Type, typename IDType=typename Type::IDType>
class Mappings;

template<typename Type, typename IDType>
class Mappings
{
public:
    ...
    Type valueFor(const IDType& id) { // return value }
    ...
};

Notez que la valeur par défaut est dans la déclaration avant et non dans la définition réelle.

Vous pouvez déclarer des arguments par défaut pour un modèle uniquement pour la première déclaration du modèle. Si vous souhaitez autoriser les utilisateurs à transmettre la déclaration d'un modèle de classe, vous devez fournir un en-tête de transfert. Si vous souhaitez transférer déclarer le modèle de classe de quelqu'un d'autre en utilisant les valeurs par défaut, vous n'avez pas de chance!

Vous pouvez déclarer une classe basée sur un modèle dont la définition indique les arguments par défaut, mais chaque fois que vous référencez la classe, vous devez inclure tous ses arguments jusqu'à ce que la définition soit introduite.

par exemple. Utilisons std::vectorsans l'inclure (le deuxième argument de std::vectorest défini avec une valeur par défaut):

namespace std
{
    template<typename, typename>
    class vector;
}

#include <iostream>

template <typename S, typename T>
void Foo (const std::vector<S,T> & vector)
{
    std::cout << "do vector stuff, eg., display size = "
        << vector.size() << std::endl;
}

template <typename T>
void Foo (const T & t)
{
    std::cout << "do non-vector stuff..." << std::endl;
}

On peut alors l'utiliser sans inclure le vecteur, par exemple:

int main()
{
    Foo(3);
}

Et nous pouvons l'utiliser avec std::vector , par exemple:

#include <vector>

// Now the compiler understands how to handle
// std::vector with one argument
// (making use of its default argument)

int main()
{
    Foo(std::vector<int>(3));
}

Je n'ai pas vérifié les normes, mais cela fonctionne sur clang/ gccavec -std=c++98jusqu'à -std=c++17, donc si ce n'est pas officiellement une norme, cela semble être officieusement le cas.