Pourquoi les spécialisations partielles des modèles de fonctions sont-elles interdites en C ?

Non-existence de spécialisation de modèles de fonctions partielles : justification et solutions de contournement

Pourquoi les spécialisations partielles de modèles de fonctions sont-elles interdites dans le langage C ? Bien que le modèle principal et les spécialisations spécifiques soient autorisés, les spécialisations partielles qui contraignent partiellement les types dans les paramètres du modèle ne le sont pas.

La spécification du langage C interdit explicitement les spécialisations partielles car elles ont été jugées inutiles. La fonctionnalité obtenue par la spécialisation partielle peut être répliquée à l'aide de méthodes alternatives, telles que l'inclusion d'instances de fonction individuelles dans des classes ou des espaces de noms ou l'utilisation de blocs de code conditionnels pour instancier sélectivement le modèle.

Considérez l'exemple suivant, où la spécialisation partielle n'est pas autorisé :

template<typename T, typename U>
void f() {}   //allowed!
template<>
void f<int, char>() {}   //allowed!
template<typename T>
void f<char, T>() {}   //not allowed!
template<typename T>
void f<T, int>() {}     //not allowed!

Ce comportement peut sembler contre-intuitif, mais la justification est claire. Les spécialisations partielles peuvent créer des ambiguïtés lors de l'instanciation du modèle et conduire à un comportement inattendu. En imposant une séparation stricte entre les modèles principaux et les spécialisations spécifiques, le langage garantit une instanciation de modèles prévisible et bien définie.

Cependant, cela ne signifie pas qu'une spécialisation partielle est totalement inutile. En incorporant la fonction dans une classe ou un espace de noms, vous pouvez effectivement obtenir un effet similaire :

#include <iostream>
using namespace std;

void say(const char s[]) { std::cout << s << std::endl; }

namespace detail {
    template< class T, class U >
    struct F {
        static void impl() { say("1. primary template"); }
    };

    template<>
    struct F<int, char> {
        static void impl() { say("2. <int, char> explicit specialization"); }
    };

    template< class T >
    struct F< char, T > {
        static void impl() { say("3. <char, T> partial specialization"); }
    };

    template< class T >
    struct F< T, int > {
        static void impl() { say("4. <T, int> partial specialization"); }
    };
}  // namespace detail

template< class T, class U >
void f() { detail::F<T, U>::impl(); }    

int main() {
    f<char const*, double>();       // 1
    f<int, char>();                 // 2
    f<char, double>();              // 3
    f<double, int>();               // 4
}

Ce code montre comment utiliser les membres de la classe pour émuler une spécialisation partielle. Chaque instanciation spécifique de la fonction est enfermée dans sa propre fonction membre statique, offrant un niveau de spécialisation similaire sans violer les restrictions de langage. En adoptant ces solutions de contournement, vous pouvez obtenir efficacement la fonctionnalité souhaitée de spécialisation partielle tout en respectant les conventions linguistiques établies.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!