méthodes surcharger et surcharger

Question

puis-je surcharger ou remplacer les méthodes en utilisant simplement une valeur de retour différente? est la matière virtuelle dans ce cas?

par exemple:

class A{ 

    virtual int Foo(); // is this scenario possible with/without the keyword virtual 
} 

class B : public A { 
    virtual double Foo(); 
} 

A* Base = new B(); 
int i = Base->Foo(); // will this just convert double to int ? 

et en ce qui concerne SURCHARGE:

class A{ 

    virtual int Foo(); 
    virtual float Foo(); // is this possible ? 

    int Goo(); 
    float Goo(); // or maybe this ? 
} 

Class B{ 
    double Foo(); 
} 

grâce

Answer 1

La valeur de retour ne fait pas partie de la signature de la fonction, comment le compilateur maintenant quelle version choisir ?

Si vous supprimez virtual de Foo dans votre premier exemple, cela fonctionnera et appellera Base::Foo.

Answer 2

Le type de retour d'une fonction ne fait pas partie de sa signature, elle ne peut donc pas être surchargée.

Answer 3

Une surcharge avec uniquement un changement de la valeur de retour n'est pas possible.

considérez ceci:

Base->Foo(); 

appelé sans valeur de retour attribuer alors compilateur ne peut pas en déduire la méthode à invoquer. Le mot-clé est utilisé pour créer VTable et ainsi prouver le polymorphisme dynamique. Cela n'a aucun impact sur les méthodes de surcharge.

Answer 4

La valeur de retour ne fait malheureusement pas partie de la signature, donc non.

Answer 5

Non, vous ne pouvez pas faire cela. Ce que vous pouvez faire dans une méthode surchargée est de renvoyer un pointeur/une référence à un type qui est un descendant du type renvoyé par la méthode parent.

Exemple:

struct VA {} 
struct VB : struct VA {} 

class A 
{ 
public: 
    virtual VA * get(); 
} 

class B 
{ 
public: 
    virtual VB * get(); 
} 

Answer 6

Non, il y a quelque chose de similaire, vous pouvez le faire cependant par exemple modélisez la valeur de retour (éventuellement avec des spécialisations) et spécifiez le type de modèle lors de l'appel par ex.

template<T> 
T Foo() 
{ 
    return 0; 
} 

template<> 
double Foo<double>() 
{ 
    return 3.14; 
} 

int i = Foo<int>(); // 0 
double d = Foo<double>(); //3.14 

Answer 7

En ce qui concerne le dépassement, il est concerné par la classe hirarchie et il est possible d'obtenir un polymorhisme d'exécution.

class Abstract 
{ 
    public : 
    virtual Abstract* Clone() const = 0; 
}; 

class Concrete1 : public Abstract 
{ 
    public : 
    Concrete1* Clone() const { return new Concrete1(*this); } 
}; 

class Concrete2 : public Abstract 
{ 
    public : 
    Concrete2* Clone() const { return new Concrete2(*this); } 
}; 

Une surcharge sur des étendues n'est pas possible selon la norme C++.

Answer 8

Vous obtiendrez un type d'erreur "méthode surchargée ne diffère qu'en type de retour" si vous utilisez VC++. En effet, les signatures de méthode/fonction n'incorporent pas le type de retour. Je suppose que c'est à cause de l'ambiguïté que cela peut causer si la valeur de retour n'est assignée à rien. par exemple

int iMyvar = objet.méthode(); // évident quel type doit être retourné

contraste avec: -

object.method(); // quelle surcharge l'appel du compilateur si le type de retour faisait partie de la signature? Ambiguos.