7
votes

Remplacer une fonction uniquement pour certains types de modèle

J'ai une classe de base avec une fonction virtuelle: xxx pre>

et une classe de modèle dérivée: p> xxx pré>

existe un moyen de Faire fonctionner () code> être tiré de la classe de base pour tous les types, à l'exception des éléments choisis? Donc, ce que je veux, c'est de pouvoir définir une fonction de remplacement () code> pour, dire, int code> et long code>: p>

overriden version 1
overriden version 2
default version

c++ overriding templates

0 commentaires

3 Réponses :

3
votes

Oui, en spécialisant dérivé .


 Écrivez la version générique sans elle (elle l'héritera de  base ) 
 Spécialise  dérivé  pour remplacer 


 schéma simple, mais cela fonctionne.



                                                                    
                                    
                                    
                                        0 commentaires


                        
                                            
                            
                                
                                    8
 votes
                                
                            
                            
                                
                                     Les fonctions de membre des modèles de classe sont en fait des modèles de fonction, de sorte que vous pouvez les spécialiser: 
template <typename T> class Foo
{
    void Function();
};

template <typename T> void Foo::Function() { /* ... */ }

template <> void Foo<int>::Function() { /* ... */ }

                                

                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    Si vous l'appliquez dans le problème d'origine, le  non spécifié Dérive :: fonction ()  serait défini mais simplement appeler  base :: fonction () .                                                

                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    4
 votes
                                
                            
                            
                                
                                      première solution  forte> (utilisation de l'opérateur  typeid  code>) :  strong>  xxx  pré> 
 i Utilisez le  Typeid  code> Opérateur pour vérifier si T est un  int  code> ou un  long int  code>, et si c'est le cas, je imprime "la version ultérieure de la version [numéro]". Si ce n'est pas le cas, j'appelle  base :: Fonction ()  code>, qui imprimera "Version par défaut"  p> 
 
  STRY> NOTE:  FORT> Pour utiliser le  Typeid  code> Opérateur Vous devez inclure le fichier d'en-tête  typeinfo  code>  p> 
  deuxième solution  strong> (Utilisation de spécialisations de modèle) :  strong>  P> 
// class declarations as before

template<typename T>
void Derived<T>::Function()
{
    Base::Function(); // call default version
}

template<>
void Derived<int>::Function()
{
    cout << "overriden version 1\n";
}

template<>
void Derived<long>::Function()
{
    cout << "overriden version 2\n";
}

int main()
{
    Derived<int> di;
    Derived<long> dl;
    Derived<float> df;

    di.Function();
    dl.Function();
    df.Function();

    return 0;
}

                                

                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    L'OMI implémente une fonction virtuelle utilisant ELLE-IF-Heimer's est un pas en arrière.