[C++] Abgeleitete Klasse umwandeln

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/

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).

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.

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?

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.

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.

1

int main(void)

2

{

3

  std::cout << "A" << std::endl;/* Ausgabe: A */

4

  /* tu was */

5

  std::cout << "B" << std::endl /* Ausgabe: B */

6

7

  return 0;

8

}

Supersicher und supereinfach ;)

Oliver

Oliver S. schrieb:
> Supersicher und supereinfach ;)

... und Super am Thema vorbei :-)

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;

1

  ... = new derivedA;

schreibt man dann:

1

  ... = 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.

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

Ich habe die Sache nun so gelöst:

1

#include <iostream>

2

#include <memory>

3

4

class base{

5

  public:

6

    typedef std::shared_ptr<base> shared_ptr;

7

    typedef std::shared_ptr<const base> const_shared_ptr;

8

9

    virtual ~base() {}

10

    virtual char GetSymbol() const = 0;

11

};

12

13

class derivedA : public base{

14

  public:

15

    static shared_ptr CreateShared() {return shared_ptr(new derivedA{});}

16

    static const_shared_ptr CreateConstShared(){return const_shared_ptr(new const derivedA{});}

17

18

    virtual char GetSymbol() const {return 'A';}

19

};

20

21

class derivedB : public base{

22

  public:

23

    static shared_ptr CreateShared() {return shared_ptr(new derivedB{});}

24

    static const_shared_ptr CreateConstShared(){return const_shared_ptr(new const derivedB{});}

25

26

    virtual char GetSymbol() const {return 'B';}

27

};

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.