Template ou virtuel [Résolu]

Signaler
Messages postés
26
Date d'inscription
dimanche 6 décembre 2009
Statut
Membre
Dernière intervention
12 décembre 2009
-
Messages postés
1905
Date d'inscription
mercredi 22 janvier 2003
Statut
Membre
Dernière intervention
17 septembre 2012
-
Bonjour les amis,

supposons un pointeur sur un Objet A, et fct une fonction membre de l'objet.

quelle est la différence fondamentale entre:

1/ La classe est définie dans un template de type T, et on fait:
T * A;
A->fct()

2/ La classe n'est pas définie dans un template, mais sa fonction fct est virtuelle
Objet * A;
A->fct()

Cette question m'a été posée en entretien d'embauche, et j'ai séché.

Merci

17 réponses

Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
1) La méthode appelée est une méthode généré à la compilation. Il y aura autant de méthode construites que de type l'utilisant.

2) Si la méthode est virtuelle, alors cela veut dire qu'elle peut être redéfinit dans les classes filles. Dans le premier cas, si la méthode n'est pas virtuelle, il n'est pas dit qu'elle soit redéfinit, dans certains cas.
Messages postés
26
Date d'inscription
dimanche 6 décembre 2009
Statut
Membre
Dernière intervention
12 décembre 2009

Bonjour Pingu,

donc toi tu dis que la différence fondamentale entre 1 et 2, c'est le moment ou sont prises en compte les fonctions?
Une très tot, lors de la compilation (cas 1/), et l'autre au moment de l'exécution (cas 2/)?
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
Non, l'une est construite, donc écrite à la compilation, l'autre non. En revanhce les deux, sont construites à la compilation. Il peut y avoir plusieurs versions d'une méthode templaté, mais une seule d'une méthode "normale".
Les deux ne sont pas en opposition et servent deux but différents, donc j'ai du mal à comprendre ce que l'on voulait te faire dire.
Messages postés
26
Date d'inscription
dimanche 6 décembre 2009
Statut
Membre
Dernière intervention
12 décembre 2009

On m'a parlé d'une différence fondamentale... (et pas de les comparer en disant l'une est mieux..)

Donc j'suis parti dans un délire (je pense) de temps d'exécution, en disant que le template doit checker le type, l'adapter...

Mais bon je me sentais comme sur du sable mouvant où mes mots faisaient vibrer le sol :)

Dans ton dernier commentaire Mr Pingu, tu dis que la version Template est écrite a la compilation et l'autre non?
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
Soit:
template <typename T>
void func(T x)
{
...
}


Ce code "n'existe pas". Tant que tu ne l'utilise pas, il ne sera pas présent dans ton code compilé. A chaque fois que tu l'utilise, une nouvelle version est créée.

Ex:
func(4);
func<MaClasse>(new MaClass());

Lancera de manière transparente l'écriture de deux fonctions:
void func(int x)
{
...
}
void func(MaClasse x)
{
...
}
Messages postés
26
Date d'inscription
dimanche 6 décembre 2009
Statut
Membre
Dernière intervention
12 décembre 2009

d'accord, alors que le virtual...?
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
N'a rien à voir.
Virtual veut dire: Il est possible de redéfinir une méthode dans une méthode fille, en cas d'upcasting. (L'upcasting est le fait de faire rentrer une classe fille dans une classe mère).

Ex:
#include 

class Mother
{
public:
  void aff() { std::cout << "mother" << std::endl; }
};

class Daughter : public Mother
{
public:
  void aff() { std::cout << "daughter" << std::endl; }
};

class MotherWithVirtual : public Mother
{
public:
  virtual void aff() { std::cout << "mother" << std::endl; }
};

class Daughter2 : public MotherWithVirtual
{
public:
  void aff() { std::cout << "daughter" << std::endl; }
};

int main()
{
  Daughter d;
  d.aff(); // Affichera bien "daughter"

  Daughter* b = new Daughter;
  b->aff(); // Affichera bien "daughter"

  Mother* m = new Daughter;
  m->aff(); // N'affichera pas "daughter", mais "mother"

  MotherWithVirtual* k = new Daughter2;
  k->aff();  // Affichera bien "daughter"

  return 0;
}
Messages postés
26
Date d'inscription
dimanche 6 décembre 2009
Statut
Membre
Dernière intervention
12 décembre 2009

Merci Pingu,

C est les deux cas de fonctionnements des Template et des Virtual. Cependant j'pense pas que le mec attendait ça. Il m'a vraiment dit, il y a une différence fondamentale.

Ne serait-ce pas dans l'appel des fonctions?

Que se passe-t-il quand on appelle une fonction d'un template (point par point) ?
Que se passe-t-il exactement qu'on appelle un fonction virtuelle (étant une classe fille je suppose..) ?

Il doit y avoir un détail qui rend ces deux cas très différents
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
il y a une différence fondamentale

Ca ne s'oppose pas. On peut faire un template virtual. Donc à part ce que je t'ai dit, je ne vois pas.

Ne serait-ce pas dans l'appel des fonctions?

Non, une fois créée les méthodes sont techniquement de même nature.

Que se passe-t-il quand on appelle une fonction d'un template (point par point) ?

Rien de spécial.

Que se passe-t-il exactement qu'on appelle un fonction virtuelle (étant une classe fille je suppose..) ?

Relis ce que j'ai posté sur le virtuel, tout est dedans. Tout les cas particuliers sont présents.

Il doit y avoir un détail qui rend ces deux cas très différents

Ou alors c'était une question piège, et tu es tombé dedans à pieds joints !
Messages postés
26
Date d'inscription
dimanche 6 décembre 2009
Statut
Membre
Dernière intervention
12 décembre 2009

Merci Pingu,

Vu qu'ils était vachement axés temps réel a l'entretien, a mon avis il doit y avoir une différence sur le temps d'exécution, ou la manière d'exécution...
Messages postés
1905
Date d'inscription
mercredi 22 janvier 2003
Statut
Membre
Dernière intervention
17 septembre 2012
3
salut,
A mon avis la différence fondamentale, c'est qu'au moment de l'exécution on sait précisément quelle méthode sera appelé dans le cas du template, alors que dans le cas de la fonction virtuelle on ne sait pas.
Pour ce qui est du temps d'exécution, la fonction virtuelle est par définition plus longue à appeler qu'une fonction ou une méthode normale.
Ce qui est vraiment moche, c'est de ne pas t'avoir donné la bonne réponse à la fin de l'entretient ...
Messages postés
26
Date d'inscription
dimanche 6 décembre 2009
Statut
Membre
Dernière intervention
12 décembre 2009

merci aardman,

ca peut etre ca!

Non ils ne m'ont pas donné les réposnes, car ils m'ont dit que cetaient des questions générique qu'ils posaient a tous le monde à chaque entretien. Au même titre je n'avais pas le droit d'utiliser mes brouillons non plus..
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
Pour ce qui est du temps d'exécution, la fonction virtuelle est par définition plus longue à appeler qu'une fonction ou une méthode normale.

Ce n'est juste pas la même chose, c'est tout. Quid des méthodes virtuelles templatés ?
Messages postés
1905
Date d'inscription
mercredi 22 janvier 2003
Statut
Membre
Dernière intervention
17 septembre 2012
3
oui ce n'est pas la même chose, c'est pour ça qu'il y a une différence de temps au niveau des appels. Qu'appeles-tu méthodes virtuelles templatés ?
Messages postés
3833
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
11 juin 2021
122
Qu'appeles-tu méthodes virtuelles templatés ?

J'entends par là, que les deux ne sont pas forcément incompatibles. On peut réaliser des méthodes virtuelles, générées par des templates.

Un exemple pour étayer mes dires:
#include 

template <typename T>
class Mother
{
public:
  virtual void whoAndWhat();
  T t;
};

template <typename T>
void Mother<T>::whoAndWhat()
{
  std::cout << "Who : Mother" << std::endl
            << "What :" << t << std::endl;
}

template <typename T>
class Daughter : public Mother<T>
{
public:
  virtual void whoAndWhat();
};

template <typename T>
void Daughter<T>::whoAndWhat()
{
  Mother<T>::whoAndWhat();
  std::cout << "Who : Daughter" << std::endl
            << "What :" << this->t << std::endl;
}

int main()
{
  Daughter object;
  object.t = 123;

  object.whoAndWhat();

  return 0;
}
Messages postés
1905
Date d'inscription
mercredi 22 janvier 2003
Statut
Membre
Dernière intervention
17 septembre 2012
3
je disais juste qu'une méthode virtuelle est plus longue à appeler qu'une méthode normale (qu'elles soient dans un template ou pas).
Messages postés
26
Date d'inscription
dimanche 6 décembre 2009
Statut
Membre
Dernière intervention
12 décembre 2009

je ne pense pas que ce soit une différence fonctionnelle