Pourquoi les fonctions membres de conversion implicite surcharge de travail par type de retour, alors qu'il n'est pas autorisé pour les fonctions normales?

Question

C ++ ne permet pas le polymorphisme des méthodes en fonction de leur type de retour. Cependant, en cas de surcharge d'une fonction de membre de la conversion implicite cela semble possible.

Quelqu'un sait pourquoi? Je pensais que les opérateurs sont traités comme des méthodes en interne.

Edit: Voici un exemple:

struct func {
    operator string() { return "1";}
    operator int() { return 2; }
};

int main( ) {
    int x    = func(); // calls int version
    string y = func(); // calls string version
    double d = func(); // calls int version
    cout << func() << endl; // calls int version
}

Answer 1

Opérateurs de conversion ne sont pas vraiment considérés comme différents et ils sont les surcharges ne s'app'lait pas basés sur leur type de retour . Le compilateur ne les utiliser quand il doit (lorsque le type est incompatible et doit être converti) ou lorsqu'on lui a demandé explicitement d'utiliser l'un d'entre eux avec un opérateur de cast.

sémantiquement, ce que votre code est en train de faire est de déclarer plusieurs autre opérateurs de conversion de type et pas d'un seul surcharge opérateur .

Answer 2

Ce Retournons pas le type. C'est la conversion de type.

Considérez: func () crée un objet de type fonct. Il n'y a pas d'ambiguïté quant à la méthode (constructeur) sera invoqué.

La seule question qui reste est de savoir s'il est possible de le jeter aux types. Vous avez fourni le compilateur avec une conversion appropriée, il est heureux.

Answer 3

Il n'y a pas vraiment une raison technique pour éviter la surcharge des fonctions sur les types de résultats. Cela se fait dans certaines langues comme Ada par exemple, mais dans le contexte de C ++ qui a aussi des conversions implicites (et deux types d'entre eux), l'utilitaire est réduit, et les interactions des deux caractéristiques se conduit rapidement à des ambiguïtés.

Notez que vous pouvez utiliser le fait que les conversions implicites sont définies par l'utilisateur pour simuler une surcharge du type de résultat:

class CallFProxy;
CallFProxy f(int);

class CallFProxy {
   int myParameter;
   CallFProxy(int i) : myParameter(i) {}
public:
   operator double() { std::cout << "Calling f(int)->double\n"; return myParameter; }
   operator string() { std::cout << "Calling f(int)->string\n"; return "dummy"; }
};

Answer 4

Résolution de surcharge choisit entre plusieurs fonctions candidats. Dans ce processus, le type de retour des candidats est en effet pas pris en compte. Toutefois, dans le cas des opérateurs de conversion du « type de retour » est d'une importance cruciale pour déterminer si cet opérateur est un candidat du tout.