C++ "Rückgabewert" vom Konstruktor

[Mr. T (Gast)]

Hallo zusammen,

ist es möglich unter C++ vom Konstruktor einen Rückgabewert zu bekommen?
Man kann bei beim Instanziieren ja Argumente an den Konstruktor 
übergeben, warum also nicht auch einen Pointer und so mittels Call by 
Reference einen Rückgabewert "durch die Hintertür" erreichen?

viele Grüße!

[Peter II (Gast)]

Mr. T schrieb:
> ist es möglich unter C++ vom Konstruktor einen Rückgabewert zu bekommen?

wie soll denn die Verwendung dann aussehen?

[Cyblord -. (cyblord)]

Natürlich kann man einen Pointer übergeben und der Konstruktor schreibt 
da was rein. Und dann? Das ist aber kein Rückgabewert.
Dass es pfuschig und unübersichtlich (weil gänzlich unerwartet) ist, 
muss ich wohl gar nicht erst erwähnen.

[Karl H. (kbuchegg)]

Mr. T schrieb:
> Hallo zusammen,
>
> ist es möglich unter C++ vom Konstruktor einen Rückgabewert zu bekommen?
> Man kann bei beim Instanziieren ja Argumente an den Konstruktor
> übergeben, warum also nicht auch einen Pointer und so mittels Call by
> Reference einen Rückgabewert "durch die Hintertür" erreichen?

Nichts und niemand hindert dich daran, das zu tun. Wie sinnvoll es ist, 
musst du entscheiden. Dem Compiler ist das egal, solange du dich im 
Rahmen der Sprachregeln bewegst.

Aber einen Returnwert, so wie bei normalen Funktionen, gibt es bei einem 
Konstruktor nicht.

[Klaus W. (mfgkw)]

Manchmal ist es halt nötig (z.B. wenn man keine Exceptions nehmen kann, 
und im ctor etwas schief gehen kann).

Eine Alternative zu einem übergebenen Pointer oder Referenz zur 
Rückmeldung wäre noch ein interner Status, der je nach Erfolg des ctor 
gesetzt wird (evtl. auch von anderen Methoden später) und mit einer 
getStatus() o.ä. abgefragt werden kann.

PS: das hat dann eine gewisse Ählichkeit zu errno, nur halt ein Exemplar 
pro Objekt.

[Peter II (Gast)]

Klaus Wachtler schrieb:
> Manchmal ist es halt nötig (z.B. wenn man keine Exceptions nehmen kann,
> und im ctor etwas schief gehen kann).

schon klar, aber wie sollte man es dann aufrufen?


Cx x(param)

wie würde man dann jetzt den Returnwert abfragen wollen?

[Klaus W. (mfgkw)]

halt hinterher (vorher geht  ja nicht :-)

class Cx
{
public:

    enum eStatus
    {
        eStatusOk,
        eStatusOioioi,
        ...
    };

    eStatus getStatus()
    {
        return status;
    }

    Cx()
       : status(eStatusOioioi)
    {
        ... initiiaze something ...
        if( ichhabemigraene ) return;
        status = eStatusOk;´
    }

private:
    eStatus   status;
};

   Cx x(param);
   if( x.getStatus()!=Cx::eStatusOk ) ...

[Cyblord -. (cyblord)]

Peter II schrieb:
> Klaus Wachtler schrieb:
>> Manchmal ist es halt nötig (z.B. wenn man keine Exceptions nehmen kann,
>> und im ctor etwas schief gehen kann).
>
> schon klar, aber wie sollte man es dann aufrufen?
>
>
> Cx x(param)
>
> wie würde man dann jetzt den Returnwert abfragen wollen?

Peter, oben beschreibt doch der TE dass er es über einen Pointer lösen 
will. Natürlich hat ein Konstruktor keinen Rückgabewert.

[Peter II (Gast)]

cyblord ---- schrieb:
> Peter, oben beschreibt doch der TE dass er es über einen Pointer lösen
> will.
nein, er will es nicht über den Umweg Parameter lösen

[Cyblord -. (cyblord)]

Peter II schrieb:
> cyblord ---- schrieb:
>> Peter, oben beschreibt doch der TE dass er es über einen Pointer lösen
>> will.
> nein, er will es nicht über den Umweg Parameter lösen

Er schreibt aber genau das hier:

> Man kann bei beim Instanziieren ja Argumente an den Konstruktor
> übergeben, warum also nicht auch einen Pointer und so mittels Call by
> Reference einen Rückgabewert "durch die Hintertür" erreichen?

[Oliver S. (oliverso)]

Karl Heinz schrieb:
> Nichts und niemand hindert dich daran, das zu tun. Wie sinnvoll es ist,
> musst du entscheiden. Dem Compiler ist das egal, solange du dich im
> Rahmen der Sprachregeln bewegst.

Dem ist doch nichts weiter hinzuzufügen.

Oliver

[Amateur (Gast)]

In vielerlei Hinsicht ist ein Konstruktor eine ganz einfache Funktion. 
Natürlich kannst Du der auch einen Zeiger oder eine Adressreferenz 
mitgeben.

Mir stellt sich dabei aber die einfache Frage: Was soll's?

Was hindert Dich daran das Ergebnis in der Klasse zu speichern und über:
Klassenreferenz.Rueckgabewert zu ermitteln?

[Bastler (Gast)]

Wobei der Compiler auch einfach mal einen Default- und/oder 
Copy-Konstruktor bei Bedarf selbst anlegt. Diese arbeiten dann ohne 
"Fehlerausgang".

[Oliver S. (oliverso)]

Bastler schrieb:
> Wobei der Compiler auch einfach mal einen Default- und/oder
> Copy-Konstruktor bei Bedarf selbst anlegt.

Nur, wenn er darf. Wenn nicht, dann nicht...

Oliver

[Dr. Sommer (Gast)]

Alternative: Eine "optional" Klasse verwenden (wie zB Boost.Optional, 
kann man sich auch leicht selber bauen) und eine Factory-Funktion:

class MyClass;

// Factory-Funktion
inline optional<MyClass> createMyClass (int a, int b, int c);

class MyClass {
  friend optional<MyClass> createMyClass (int a, int b, int c);
  public:
    void doSomething ();
  private:
    // Konstruktor private, und Factory-Funktion ist "friend"; somit können nur über die Factory-Funktion Instanzen erstellt werden.
    MyClass (int a, int b, int c);
};

inline optional<MyClass> createMyClass (int a, int b, int c) {
  // Parameter gültig?
  if (a < 42 && b < c)
    // Instanz erstellen und zurückgeben
    return optional<MyClass> ( MyClass { a, b, c });
  // Parameter ungültig => Nichts zurückgeben
  return;
}

int main () {
  // Factory aufrufen zum Instanz erstellen...
  auto x = createMyClass ();
  // Instanz erstellt?
  if (x)
    x->doSomething ();
  else
    std::cout << "Fehler beim Anlegen der Instanz von MyClass.\n";
}

So spart man sich hässliche Dinge wie Output-Parameter und zusätzliche 
Member in der Klasse (Speicher-Verbrauch).

[Vlad T. (vlad_tepesch)]

Dr. Sommer schrieb:
> Alternative: Eine "optional" Klasse verwenden (wie zB Boost.Optional,
> kann man sich auch leicht selber bauen) und eine Factory-Funktion:

schöner wäre eine imho eine statische Memberfunktion. Da entfällt auch 
die leidliche friend-Deklaration.

class MyClass {
  public:
    void doSomething ();

    static optional<MyClass> create(int a, int b, int c) 
    {
      // Parameter gültig?
      if (a < 42 && b < c){
        // Instanz erstellen und zurückgeben
        return optional<MyClass> ( MyClass { a, b, c });
      }
      // Parameter ungültig => Nichts zurückgeben
      return;
    }

  private:
    // Konstruktor privat; somit können nur über die Factory-Funktion Instanzen erstellt werden.
    MyClass (int a, int b, int c);
};

int main () {
  // Factory aufrufen zum Instanz erstellen...
  auto x = MyClass::create (1,2,3);
  // Instanz erstellt?
  if (x)
    x->doSomething ();
  else
    std::cout << "Fehler beim Anlegen der Instanz von MyClass.\n";
}

[Dr. Sommer (Gast)]

Vlad Tepesch schrieb:
> schöner wäre eine imho eine statische Memberfunktion.
Ob schöner ist Ansichtssache. Die Factory-Funktionen in der Standard 
Library sind auch keine Member-Funktionen (std::make_shared zB).

[(prx) A. K. (prx)]

Dr. Sommer schrieb:
> Alternative: Eine "optional" Klasse verwenden

Wie verbreitet ist das? Eine Doku sagt: "After reviewing national body 
comments to N3690, this library component was voted out from C++14 
working paper into a separate Technical Specification. It is not a part 
of the draft C++14 as of n3797."

[Dr. Sommer (Gast)]

A. K. schrieb:
> Wie verbreitet ist das? Eine Doku sagt: "After reviewing national body
> comments to N3690, this library component was voted out from C++14
> working paper into a separate Technical Specification.
Ja, total bescheuert. Boost.Optional kann man aber immer 
nachinstallieren oder es eben selber implementieren.