Un modèle de fonction membre d'une classe peut-il être virtuel ?

Question

J'ai entendu dire que les modèles de fonctions membres de classes C++ ne peuvent pas être virtuels. Est-ce bien le cas ?

Si elles peuvent être virtuelles, quel est un exemple de scénario dans lequel on utiliserait une telle fonction ?

Answer 1

Les modèles consistent à ce que le compilateur génère du code à temps de compilation . Les fonctions virtuelles permettent au système d'exécution de déterminer quelle fonction appeler au moment de l'exécution. temps d'exécution .

Une fois que le système d'exécution a compris qu'il devait appeler une fonction virtuelle modélisée, la compilation est terminée et le compilateur ne peut plus générer l'instance appropriée. Par conséquent, vous ne pouvez pas avoir de modèles de fonctions membres virtuelles.

Cependant, il existe quelques techniques puissantes et intéressantes issues de la combinaison du polymorphisme et des modèles, notamment ce que l'on appelle les _effacement de type_ .

Answer 2

Le C++ n'autorise pas les fonctions membres virtuelles des modèles pour le moment. La raison la plus probable est la complexité de son implémentation. Rajendra donne de bonnes raisons pour lesquelles ce n'est pas possible pour le moment, mais cela pourrait être possible avec des modifications raisonnables de la norme. En particulier, déterminer combien d'instanciations d'une fonction modèle existent réellement et construire la table virtuelle semble difficile si l'on considère la place de l'appel de la fonction virtuelle. Les responsables de la normalisation ont tout simplement beaucoup d'autres choses à faire en ce moment et C++1x représente également beaucoup de travail pour les auteurs de compilateurs.

Quand auriez-vous besoin d'une fonction membre modèle ? J'ai rencontré une fois une telle situation où j'ai essayé de refactoriser une hiérarchie avec une classe de base virtuelle pure. C'était un mauvais style pour mettre en œuvre différentes stratégies. Je voulais changer l'argument de l'une des fonctions virtuelles en un type numérique et, au lieu de surcharger la fonction membre et de surcharger chaque surcharge dans toutes les sous-classes, j'ai essayé d'utiliser des fonctions modèles virtuelles (et j'ai dû découvrir qu'elles n'existaient pas).

Answer 3

Les Tables De Fonctions Virtuelles

Commençons par quelques rappels sur la fonction virtuelle tables et comment ils fonctionnent (source):

[20.3] Quelle est la différence entre virtuel et non virtuel les fonctions de membres sont appelés?

Non-membre virtuel fonctions sont résolus de manière statique. Qui est, le fonction membre est sélectionné de manière statique (à la compilation), basé sur la type de l'indicateur (ou de référence) à l'objet.

En revanche, les fonctions membre virtuelles sont résolus de manière dynamique (à au moment de l'exécution). Qui est, la fonction membre est choisi dynamiquement (à au moment de l'exécution) en fonction du type de l'objet, pas le type de l' pointeur/référence à cet objet. Cette opération est appelée "liaison dynamique." La plupart des compilateurs utilisent une variante de la technique suivante: si l' l'objet a une ou plusieurs fonctions virtuelles, le compilateur met un caché pointeur sur l'objet appelé "virtual-pointeur" ou "v-pointeur." Cette v-un pointeur sur un tableau global appelé le "virtuel" table ou "v-table".

Le compilateur crée un v-table pour chaque classe qui possède au moins un une fonction virtuelle. Par exemple, si la classe Cercle a des fonctions virtuelles pour dessiner() et move() et de les redimensionner(), il y a exactement un v-table associée à la classe Cercle, même si il y avait une foule de Cercle des objets, et le v-pointeur de chacun de ces Cercle objets point le Cercle v-table. La v-table elle-même a des pointeurs vers chaque de la fonctions virtuelles de la classe. Par exemple, le Cercle v-table ont trois pointeurs: un pointeur vers le Cercle::draw(), un pointeur vers Cercle::move(), et un pointeur vers le Cercle::resize().

Lors d'un envoi d'une fonction virtuelle, le système d'exécution suit l'objet de la v-pointeur vers la classe v-table, puis suit la fente appropriée dans la v-table pour le code de la méthode.

L'espace-frais généraux de la technique ci-dessus est nominale: un supplément de pointeur par objet (mais seulement pour les objets qu'il sera nécessaire de faire dynamique de liaison), plus un supplément de pointeur par méthode (mais seulement pour virtuel les méthodes). Le temps frais généraux est également assez minime: par rapport à un normal appel de fonction, un appel de fonction virtuelle nécessite deux extra extrait (un pour obtenir la valeur de la v-pointeur, une seconde pour obtenir la l'adresse de la méthode). Rien de tout cela exécution de l'activité qui se passe avec non virtuelle fonctions, car le compilateur résout non virtuelle fonctions exclusivement au moment de la compilation en fonction du type de la pointeur.

---

Mon problème, ou comment j'en suis venu ici

Je suis d'essayer d'utiliser quelque chose comme cela maintenant pour un cubefile de la classe de base avec basé sur un modèle optimisé charge des fonctions qui seront mis en œuvre différemment pour les différents types de cubes (certains stockées par pixel, par l'image, etc).

Un peu de code:

virtual void  LoadCube(UtpBipCube<float> &Cube,long LowerLeftRow=0,long LowerLeftColumn=0,
        long UpperRightRow=-1,long UpperRightColumn=-1,long LowerBand=0,long UpperBand=-1) = 0;
virtual void  LoadCube(UtpBipCube<short> &Cube, long LowerLeftRow=0,long LowerLeftColumn=0,
        long UpperRightRow=-1,long UpperRightColumn=-1,long LowerBand=0,long UpperBand=-1) = 0;
virtual void  LoadCube(UtpBipCube<unsigned short> &Cube, long LowerLeftRow=0,long LowerLeftColumn=0,
        long UpperRightRow=-1,long UpperRightColumn=-1,long LowerBand=0,long UpperBand=-1) = 0;

Ce que j'aimerais qu'il soit, mais il ne compile pas en raison d'un virtuel basé sur un modèle de liste déroulante:

template<class T>
    virtual void  LoadCube(UtpBipCube<T> &Cube,long LowerLeftRow=0,long LowerLeftColumn=0,
            long UpperRightRow=-1,long UpperRightColumn=-1,long LowerBand=0,long UpperBand=-1) = 0;

J'ai fini par déménager le modèle de déclaration au niveau de la classe. Cette solution aurait forcé les programmes à savoir à propos des types de données spécifiques, ils auraient lu avant de lire, ce qui est inacceptable.

Solution

attention, ce n'est pas très jolie, mais elle m'a permis de supprimer répétitif exécution de code

1) dans la classe de base

virtual void  LoadCube(UtpBipCube<float> &Cube,long LowerLeftRow=0,long LowerLeftColumn=0,
            long UpperRightRow=-1,long UpperRightColumn=-1,long LowerBand=0,long UpperBand=-1) = 0;
virtual void  LoadCube(UtpBipCube<short> &Cube, long LowerLeftRow=0,long LowerLeftColumn=0,
            long UpperRightRow=-1,long UpperRightColumn=-1,long LowerBand=0,long UpperBand=-1) = 0;
virtual void  LoadCube(UtpBipCube<unsigned short> &Cube, long LowerLeftRow=0,long LowerLeftColumn=0,
            long UpperRightRow=-1,long UpperRightColumn=-1,long LowerBand=0,long UpperBand=-1) = 0;

2) et dans les classes d'enfants

void  LoadCube(UtpBipCube<float> &Cube, long LowerLeftRow=0,long LowerLeftColumn=0,
        long UpperRightRow=-1,long UpperRightColumn=-1,long LowerBand=0,long UpperBand=-1)
{ LoadAnyCube(Cube,LowerLeftRow,LowerLeftColumn,UpperRightRow,UpperRightColumn,LowerBand,UpperBand); }

void  LoadCube(UtpBipCube<short> &Cube, long LowerLeftRow=0,long LowerLeftColumn=0,
        long UpperRightRow=-1,long UpperRightColumn=-1,long LowerBand=0,long UpperBand=-1)
{ LoadAnyCube(Cube,LowerLeftRow,LowerLeftColumn,UpperRightRow,UpperRightColumn,LowerBand,UpperBand); }

void  LoadCube(UtpBipCube<unsigned short> &Cube, long LowerLeftRow=0,long LowerLeftColumn=0,
        long UpperRightRow=-1,long UpperRightColumn=-1,long LowerBand=0,long UpperBand=-1)
{ LoadAnyCube(Cube,LowerLeftRow,LowerLeftColumn,UpperRightRow,UpperRightColumn,LowerBand,UpperBand); }

template<class T>
void  LoadAnyCube(UtpBipCube<T> &Cube, long LowerLeftRow=0,long LowerLeftColumn=0,
        long UpperRightRow=-1,long UpperRightColumn=-1,long LowerBand=0,long UpperBand=-1);

Notez que LoadAnyCube n'est pas déclarée dans la classe de base.

---

Voici un autre débordement de pile de répondre avec un travail autour de: besoin d'un modèle virtuel membre de la solution de contournement.

Answer 4

Le code suivant peut être compilé et s'exécute correctement, en utilisant MinGW G++ 3.4.5 sur windows 7:

#include <iostream>
#include <string>

using namespace std;

template <typename T>
class A{
public:
    virtual void func1(const T& p)
    {
        cout<<"A:"<<p<<endl;
    }
};

template <typename T>
class B
: public A<T>
{
public:
    virtual void func1(const T& p)
    {
        cout<<"A<--B:"<<p<<endl;
    }
};

int main(int argc, char** argv)
{
    A<string> a;
    B<int> b;
    B<string> c;

    A<string>* p = &a;
    p->func1("A<string> a");
    p = dynamic_cast<A<string>*>(&c);
    p->func1("B<string> c");
    B<int>* q = &b;
    q->func1(3);
}

et la sortie est:

A:A<string> a
A<--B:B<string> c
A<--B:3

Et plus tard, j'ai ajouté une nouvelle classe X:

class X
{
public:
    template <typename T>
    virtual void func2(const T& p)
    {
        cout<<"C:"<<p<<endl;
    }
};

Quand j'ai essayé d'utiliser la classe de X dans main() comme ceci:

X x;
x.func2<string>("X x");

g++ rapport d'erreur suivants:

vtempl.cpp:34: error: invalid use of `virtual' in template declaration of `virtu
al void X::func2(const T&)'

Il est donc évident que:

• fonction membre virtuelle peut être utilisée dans un modèle de classe. Il est facile pour le compilateur de construire vtable
• Il est impossible de définir un modèle de classe de la fonction membre virtuelle, comme vous pouvez le voir, il est difficile de déterminer la fonction de signature et d'allouer vtable des entrées.

Answer 5

Pensez-y pendant un moment :

Q.1. Comment faire une fonction virtuelle modélisée ?
Q.2. Quelle est sa signature ?
Q.3. Combien d'entrées de vtable réservez-vous ?
Q.4 : Comment faire la différence entre un override/hide et une overload ?

J'espère que cela vous aidera.