die Überladung von Funktionen in C++ nur mit Rückgabewert und const erfolgen kann?

Question

Ist es möglich, zwei Versionen der gleichen Funktion zu haben, die bis auf den Rückgabetyp und die Konstante identisch sind?

Das glaube ich nicht. Das folgende Beispiel zeigt das. Aber ich kenne den Grund nicht.

#include<iostream>
using namespace std;
class A
{
 private:
       int bb ;
 public:
       double f1(int a) const {cout << "double f1 is called " << endl; return 0.0; }
       int f1(int a) {cout << "int f1 is called " << endl ; return 0; }

};

int main()
{
     int b = 6;
     A aa;

     double c= aa.f1(b);
     return 0 ;
}

Ausgabe:

int f1 wird aufgerufen

Warum kann double f1(int a) const nicht gezählt werden?

Answer 1

Aus offensichtlichen Gründen können Sie den Rückgabetyp nicht überladen.

Sie puede jedoch die Konstante des impliziten Instanzarguments überladen. Vergleiche:

aa.f1(b);
static_cast<A const &>(aa).f1(b);

(Dieses Beispiel verdeutlicht auch, warum es keinen Sinn macht, zu versuchen, den Rückgabetyp zu überladen: Wie würden Sie die Entscheidung in diesem Beispiel treffen?)

Answer 2

Ich denke, das Hauptproblem ist, dass es leicht zu Unklarheiten kommt. Zum Beispiel:

int main()
{
  int b = 6;
  A aa;

  float c= aa.f1(b); // which version of f1 is called here?
  return 0 ;
}

Handelt es sich um die int-Version, bei der der Wert in einen Float-Wert umgewandelt wird, oder handelt es sich um die double-Version, bei der der Wert abgeschnitten wird?

Eine mögliche Lösung besteht darin, den Rückgabewert in einen Referenzparameter zu verschieben:

void f1(int a, double &out);
void f1(int a, int &out);

und dann kann der Compiler herausfinden, welcher Typ aufgerufen werden soll oder einen Fehler erzeugen, wenn es keinen passenden Typ gibt.

Answer 3

Ich stimme mit Skizz überein, die Zweideutigkeit ist hier unsicher. In dem Beispiel, das Sie geben, wissen wir nie, welche der beiden Methoden letztendlich aufgerufen wird aufgerufen wird (ich frage mich sogar, ob das vom Compiler abhängen könnte?).

Meiner Meinung nach besteht das Hauptinteresse an der Erstellung von Mitgliedsfunktionen mit gleichem Namen, aber unterschiedlicher Konstante in C++ in der Erstellung von Konst-/Nicht-Konst-Zugriffsfunktionen auf Mitgliedsdaten.

Exemple :

class Foo {
    private: Data m_Data;

    public: Data& getData(void) { return m_Data; }
    public: const Data& getData(void) const { return m_Data; }
};

Beide Zugriffsfunktionen getData() rufen den Verweis auf das Mitgliedsattribut m_Data ab. Der erste gibt ein modifizierbares Data zurück, wenn Sie eine modifizierbare Foo-Instanz aufrufen. Der zweite gibt ein const Data zurück, wenn man eine const Foo-Instanz aufruft.

Andernfalls würde ich raten, ein solches Design zu vermeiden.

Ihr,

Answer 4

Es sei denn, Sie deklarieren den Rückgabetyp als allgemeinen Supertyp, wie void*, und casten dann das Ergebnis zurück auf das, was Sie brauchen. Das ist natürlich höchst böse.

Sie könnten in Erwägung ziehen, den Rückgabetyp in ein Objekt zu verpacken, das in Bezug auf den Inhalt intelligent sein kann, was das Problem in gewisser Weise löst. Das ist, was die meisten OO-Systeme am Ende ziemlich häufig tun, es ist ein Grund, warum Kapselung so verdammt hilfreich sein kann.

Das ist auch der Grund, warum Generika so großartig sind. Ich müsste meine C++-Syntax überprüfen, aber man kann eine Funktion deklarieren, deren Rückgabetyp mit dem Typ ihres Arguments zusammenhängt oder auf dem generischen Typ der Unterklasse basiert.

Aber bei Grundtypen, nein, nicht wirklich.