[C++] Abgeleitete Klasse umwandeln

[B. S. (bestucki)]

Hallo zusammen

Ich bin noch relativ frisch mit C++ unterwegs und habe ein Problem, für 
das mir die richtigen Stichworte für eine erfolgreiche Suche fehlen 
(deswegen auch der unpräzise Titel).

Hier mein Minimalbeispiel:

#include <new>
#include <iostream>

class base{
  public:
    virtual ~base() {}
    virtual char GetSymbol() const = 0;
};

class derivedA : public base{
  public:
    virtual char GetSymbol() const {return 'A';}
};

class derivedB : public base{
  public:
    virtual char GetSymbol() const {return 'B';}
};

int main(void){
  base * Var = new derivedA;
  std::cout << Var->GetSymbol() << '\n'; /* Ausgabe: A */
  /* tu was */
  delete Var;
  Var = new derivedB;
  std::cout << Var->GetSymbol() << '\n'; /* Ausgabe: B */
  
  return 0;
}

Das Beispiel funktioniert wie gewünscht, jedoch gefallen mir die new und 
delete Operatoren nicht. Dies ist mir zu fehleranfällig und möchte diese 
Operationen in eine Funktion oder ein Template verbannen, habe jedoch 
keine Ahnung wie ich das tun soll. Ich nehme an, dass ich nicht der 
erste mit diesem Problem bin und es eine elegante Lösung dafür gibt.

Vielen Dank für eure Hilfe!

[Bjørn (Gast)]

Du kannst das delete loswerden, wenn du Smart Pointer benutzt (ein C++11 
Feature), aber um das new kommst du nicht herum:

#include <memory>

[...]

int main(void){
  std::shared_ptr<base> Var(new derivedA);
  std::cout << Var->GetSymbol() << std::endl; /* Ausgabe: A */
  /* tu was */
  Var = std::shared_ptr<base>(new derivedB);
  std::cout << Var->GetSymbol() << std::endl; /* Ausgabe: B */
  return 0;
}

In der Zeile mit der Zuweisung wird der ursprüngliche Pointer 
automatisch gelöscht.
Den Header <new> musst du übrigens nicht explizit einbinden.
Außerdem benutze bitte std::endl anstelle von '\n'.

Viele liebe Grüße,
Bjørn

[Tom (Gast)]

Bjørn schrieb:
> benutze bitte std::endl anstelle von '\n'.

Warum?

[Karl H. (kbuchegg)]

Ermessensfrage.

Bei Debug Ausgaben wäre es schon gut, wenn Ausgaben auch tatsächlich 
sofort geflushed werden und nicht in irgendeinem Cache rumlungern. Sonst 
kann es passieren, dass mit dem Programmabsturz auch die letzten paar 
Debug Ausgaben den Bach runtergehen und man mit Fehlersuche an der 
falschen Stelle anfängt

std::endl   ein Ausgabepuffer wird geflushed
\n          nichts dergleichen passiert

Sonst gibt es keinen Unterschied zwischen den beiden.

https://cppkid.wordpress.com/2008/08/27/why-i-prefer-n-to-stdendl/

[Klaus W. (mfgkw)]

Karl Heinz schrieb:
> Bei Debug Ausgaben wäre es schon gut, wenn Ausgaben auch tatsächlich
> sofort geflushed werden und nicht in irgendeinem Cache rumlungern.

Genau deshalb schreibt man aber Debugausgaben ja nicht nach cout, 
sondern cerr...

Trotzdem ist es eher empfehlenswert, nicht \n zu verwenden, sondern 
std::endl, auch wenn es auf aktuellen Systemen aufs gleiche rausläuft 
(ggf.abgesehen von der Pufferung).

[Tom (Gast)]

Karl Heinz schrieb:
> Bei Debug Ausgaben wäre es schon gut, wenn Ausgaben auch tatsächlich
> sofort geflushed werden und nicht in irgendeinem Cache rumlungern.

Diagnoseausgaben gehören eigentlich nach stderr. Da in der Windows-Welt 
cout sowieso nur zum Debuggen benutzt wird und niemand Pipes benutzt, 
nimmt den Unterscheid keiner so richtig ernst.

[B. S. (bestucki)]

Bjørn schrieb:
> Du kannst das delete loswerden, wenn du Smart Pointer benutzt (ein C++11
> Feature), aber um das new kommst du nicht herum:

Das sieht gut aus, daran hatte ich gar nicht gedacht. Wenn das new 
bleibt, ist das in Ordnung. Habe nur keine Lust wegen einem vergessenen 
delete ein Speicherleck zu produzieren.

Bjørn schrieb:
> Außerdem benutze bitte std::endl anstelle von '\n'.

Komme aus der C-Ecke, deshalb bin ich mir das so gewohnt. Ausserdem 
führe ich ein flush immer manuell aus, wenn es nötig ist. Bei kleinen 
Ausgaben ist es auch egal, wenn nach jedem Zeichen ein flush ausgeführt 
wird, bei einigen MB, die in eine Datei geschrieben werden, siehts 
wieder anders aus.

[nocheinGast (Gast)]

Also ich schreib ja Debug-Ausgaben immer nach "clog" ;) .
Das new kannst du zumindest verstecken, wenn dus so machst:

auto obj = std::make_shared<base>();

[Bernd K. (prof7bit)]

Karl Heinz schrieb:

> std::endl   ein Ausgabepuffer wird geflushed
> \n          nichts dergleichen passiert
>
> Sonst gibt es keinen Unterschied zwischen den beiden.

Ist es nicht so dass es auch zusätzlich je nach Platform die dort 
übliche Zeilenende-Sequenz (\r oder \r\n oder \n) sendet, je nach dem wo 
es kompiliert wurde?

[Klaus W. (mfgkw)]

Das betrifft ja primär den MSDOS-Mist mit CR+LF statt LF, und da werden 
sowohl bei \n als auch bei std::endl unter DOS/Windows das CR+LF 
generiert (es sein denn, man macht eine Binärdatei und nimmt \n, dann 
erhält man nur LF - aber da ist man selbst schuld).

Analog, wenn bei kranken Betrübssystemen nur ein CR als Zeileende 
genommen wird.

[jgdo (Gast)]

nocheinGast schrieb:
> Also ich schreib ja Debug-Ausgaben immer nach "clog" ;) .
> Das new kannst du zumindest verstecken, wenn dus so machst:auto obj =
> std::make_shared<base>();

Dann aber

std::make_shared<derivedA/B>()

, weil man keine Objekte von base instanziieren kann. Natürlich kann man 
das Ergebnis auch in einem base-Smartpointer speichern:

std::shared_ptr<base> var = std::make_shared<derivedA>(...)

.

Wenn man viel mit Smartpointern arbeitet, lohnt es sich auch, 
entsprechende Typedefs in den Klassen zu machen

class base{
  public:
    typedef std::shared_ptr<base> Ptr;
    typedef std::shared_ptr<const base> ConstPtr;
  ...
};

typedef basePtr base::Ptr;
typedef baseConstPtr base::ConstPtr;

class derivedA : public base{
  public:
    typedef std::shared_ptr<derivedA> Ptr;
    typedef std::shared_ptr<const derivedA> ConstPtr;
  ...
};


typedef derivedAPtr derivedA::Ptr;
typedef derivedAConstPtr derivedA::ConstPtr;

um dann später

basePtr var; bzw. base::Ptr var;

 anstatt

std::shared_ptr<base> var

 schreiben zu können.

[Oliver S. (oliverso)]

be stucki schrieb:
> Dies ist mir zu fehleranfällig und möchte diese
> Operationen in eine Funktion oder ein Template verbannen, habe jedoch
> keine Ahnung wie ich das tun soll.

Kein Problem.

int main(void)
{
  std::cout << "A" << std::endl;/* Ausgabe: A */
  /* tu was */
  std::cout << "B" << std::endl /* Ausgabe: B */
  
  return 0;
}

Supersicher und supereinfach ;)

Oliver

[Klaus W. (mfgkw)]

Oliver S. schrieb:
> Supersicher und supereinfach ;)

... und Super am Thema vorbei :-)

[Klaus W. (mfgkw)]

be stucki schrieb:
> Das Beispiel funktioniert wie gewünscht, jedoch gefallen mir die new und
> delete Operatoren nicht.

Die Idee mit den diversen shared-ptr wurde ja schon erwähnt (gibt 
mehrere, je nachdem welchen C++-Standard man nimmt oder ggf. boost oder 
anderes).

Die werden jeweils mit einem Zeiger initialisiert, den man aus einem new 
erhält, letztlich spart man sich dadurch das delete.
Falls du das new auch noch loswerden willst, ist der übliche Weg, in die 
Klasse eine factory-Methode einzubauen. Das ist eine statische Methode 
(heißt häufig create()), in der das new versteckt ist und die dann den 
Zeiger liefert.
In der Basisklasse wird es bereits definiert (bzw. in deinem Fall als 
pure virtual, da es eine ABC ist) und in den abgeleiteten Klassen 
überschrieben.

(Häufig paart man create() gleich mit einer nicht statischen Methode 
clone(), die eine Kopie eines Objekts liefert und ebenfalls einen Zeiger 
darauf liefert).

Anstatt;

  ... = new derivedA;

schreibt man dann:

  ... = derivedA::create();;

Damit hat man das new auch aus dem eigenen Code verbannt.

Zudem kann man den Zeiger dann in einem smart pointer speichern je nach 
Belieben, das bleibt davon unberührt.

[B. S. (bestucki)]

Vielen Dank für die Hilfe, ihr habt mir sehr geholfen.

Ich habe die Sache nun so gelöst:

#include <iostream>
#include <memory>

class base{
  public:
    typedef std::shared_ptr<base> shared_ptr;
    typedef std::shared_ptr<const base> const_shared_ptr;
    
    virtual ~base() {}
    virtual char GetSymbol() const = 0;
};

class derivedA : public base{
  public:
    static shared_ptr CreateShared() {return shared_ptr(new derivedA{});}
    static const_shared_ptr CreateConstShared(){return const_shared_ptr(new const derivedA{});}
    
    virtual char GetSymbol() const {return 'A';}
};

class derivedB : public base{
  public:
    static shared_ptr CreateShared() {return shared_ptr(new derivedB{});}
    static const_shared_ptr CreateConstShared(){return const_shared_ptr(new const derivedB{});}
    
    virtual char GetSymbol() const {return 'B';}
};

Das typedef gefällt mir, jedoch wollte ich die Tatsache, dass es ein 
shared_ptr ist, nicht nicht unterschlagen. Evt. will ich auch mal 
zusätzlich einen unigue_ptr verwenden. Etwas unschön empfinde ich, dass 
man Zeiger auf const separat behandeln muss, sehe aber keinen Weg, wie 
sich das ändern lassen könnte.

[Sebastian (Gast)]

Geht auch ohne shared_ptr, wenn es ok ist, dass das Objekt zum Ende des 
scopes freigegeben wird, in dem es angelegt wird. In anderen Worten: Der 
Zeiger sollte nicht in Variablen gespeichert werden, die länger leben 
als die Funktion läuft, in der du es anlegst.

int main(void){
  derivedA a;
  base * Var = &a;
  std::cout << Var->GetSymbol() << '\n'; /* Ausgabe: A */
  derivedB b;
  Var = &b;
  std::cout << Var->GetSymbol() << '\n'; /* Ausgabe: B */
  
  return 0;
}

Nicht arg sinnvoll in diesem Beispiel - du könnest auch a und b direkt 
verwenden, statt über Var. Ist aber z.B. sinnvoll wenn du so eine 
Funktion aufrufen willst:

void zeigDenBuchstaben(const base* Var)
{
    std::cout << Var->GetSymbol() << '\n';
}