Comment réaliser la spécialisation des membres dans les modèles C ?

Spécialisation des membres dans les modèles

Il n'est pas possible de spécialiser partiellement des membres spécifiques d'une classe de modèles. Une spécialisation partielle doit fournir tous les arguments du modèle. Cependant, il existe des approches alternatives pour obtenir des fonctionnalités similaires.

Fonctions surchargées

Une solution de contournement consiste à introduire des fonctions surchargées dans la classe de modèle. Cela fournit le même accès aux variables et fonctions membres que les fonctions membres spécialisées.

<code class="cpp">template <typename t bool b>
struct X {
    void Specialized();
};

template <typename t>
void X<t true>::Specialized() {
    // True-specialized implementation
}

template <typename t>
void X<t false>::Specialized() {
    // False-specialized implementation
}</t></typename></t></typename></typename></code>

Surcharge de fonctions avec le paramètre de modèle

Une autre option consiste à transmettre le paramètre de spécialisation comme un argument de fonction supplémentaire utilisant un paramètre de modèle enveloppé dans une structure.

<code class="cpp">template <typename t bool b>
struct X {
    void Specialized() { SpecializedImpl(i2t<b>()); }

private:
    void SpecializedImpl(i2t<true>) {
        // True-specialized implementation
    }

    void SpecializedImpl(i2t<false>) {
        // False-specialized implementation
    }
};</false></true></b></typename></code>

Modèle de classe séparé pour la spécialisation

Un comportement spécialisé peut également être implémenté dans un modèle de classe distinct et invoqué à partir de la classe de modèle principale.

<code class="cpp">template <typename t bool b>
struct SpecializedImpl {
    static void call() {
        // True- or false-specialized implementation
    }
};

template <typename t bool b>
struct X {
    void Specialized() { SpecializedImpl<t b>::call(); }
};</t></typename></typename></code>

Classe de modèle imbriquée pour la spécialisation

Le comportement spécialisé peut être imbriqué dans la classe de modèle principale en tant que classe de modèle .

<code class="cpp">template <typename t bool b>
struct X {
private:
    template <bool b>
    struct SpecializedImpl { };

public:
    void Specialized() { SpecializedImpl<b>::call(); }

private:
    template 
    struct SpecializedImpl<true> {
        static void call() {
            // True-specialized implementation
        }
    };

    template 
    struct SpecializedImpl<false> {
        static void call() {
            // False-specialized implementation
        }
    };
};</false></true></b></bool></typename></code>

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!