Ergänzungen

Virtual Destructor:
Basisklassen, die virtual functions enthalten, also potentiell polymorph benutzt, werden sollten immer einen virtual destructor deklarieren. Nur dann ist garantiert, dass auch Destructor der abgeleitetem Klasse gerufen wird $\bgroup\color{green}\ensuremath{\Rightarrow}\egroup$ sonst memory leak!


class Shape {
  //..
  virtual ~Shape() =0; // declare virtual destructor
  //..
};
class Rectangle : public Shape {
  TwoDPoint * points; 
  Rectangle () { 
    points = new TwoDPoint[4]; // allocate memory for points
  };
  ~Rectangle () { 
    delete [] points;
  }
  // ..
}

Casting und Run-Time-Type ID:
Casting ( = Typumwandlung) sollte möglichst wenig benutzt werden, ist aber manchmal unvermeidlich. Im letzten Kurs wurden C-Style casts gezeigt:
int n = (int) 30.65;

Diese Art von casts sollte in C++ nicht mehr verwendet werden, stattdessen

static_cast $\bgroup\color{blue}$<$\egroup$ type $\bgroup\color{blue}$>$\egroup$ () entspricht i.W. dem C cast:
int n = static_cast <int> (30.65) ; C++ Compiler akzeptiert static_cast wenn ursprünglicher Typ und neuer Typ verwandt sind, z.B.
double $\bgroup\color{dgreen}\ensuremath{\Rightarrow}\egroup$ int , int $\bgroup\color{dgreen}\ensuremath{\Rightarrow}\egroup$ double, Rectangle $\bgroup\color{dgreen}\ensuremath{\Rightarrow}\egroup$ Shape, Shape $\bgroup\color{dgreen}\ensuremath{\Rightarrow}\egroup$ Rectangle , ....
Aber nicht: double $\bgroup\color{dgreen}\ensuremath{\Rightarrow}\egroup$ Rectangle, ...
reinterpret_cast $\bgroup\color{blue}$<$\egroup$ type $\bgroup\color{blue}$>$\egroup$ () erzingt Neu-Interpretation, damit auch z.B. double $\bgroup\color{dgreen}\ensuremath{\Rightarrow}\egroup$ Rectangle möglich:
double x = 0.7; Rectangle r = reinterpret_cast <Rectangle> (x) ;
Sehr gefährlich, nur in Ausnahmefällen benutzen !

dynamic_cast $\bgroup\color{blue}$<$\egroup$ type $\bgroup\color{blue}$>$\egroup$ () Nützlich im Zusammenhang mit Polymorphismus: Umwandlung wird nur gemacht wenn type stimmt:


  vector<Shape*> vecshape;  // vector with base-class pointers
  // add some concrete shapes
  vecshape.push_back( new Rectangle());
  vecshape.push_back( new Oval());
  vecshape.push_back( new Rectangle());
  vecshape.push_back( new RoundRect());
  vecshape.push_back( new Oval());
  vecshape.push_back( new Oval());

  // make the shapes all red, move and draw them 
  for ( int i=0; i<vecshape.size(); i++ ){
    Rectangle * rp;
    rp = dynamic_cast<Rectangle *>( vecshape[3] );
    if ( rp ) {                                // cast ok for i=0,2
      cout << " Can cast into rectangle" << endl; 
      rp->Draw();
    }
    else {                                     // cast not ok for i=1,3,4,5
      cout << " Cannot cast into rectangle" << endl;
    }
  }

Damit Typ-Identifizierung zur Laufzeit möglich ( = RTTI ) !

Up-Cast geht immer : Abgeleitete Klasse $\bgroup\color{green}\ensuremath{\Rightarrow}\egroup$ Basisklasse.
Down-Cast : Basis-Klasse $\bgroup\color{green}\ensuremath{\Rightarrow}\egroup$ Abgeleitet Klasse. Mit static_cast erzwingen auch wenn falsch, besser mit dynamic_cast testen und ausführen.

GDuckeck 2019-08-01