C-plus-plus

Links

• C-plus-plus-Scrambler
• STL C++
• [C++-Shell online]

Klassen

Beispiel Klasse Complex

class Complex
{
public:
    double _real;
    double _imag;
public:
    Complex(): _real(0), _imag(0) {}
    Complex(double real, double imag):  _real(real), _imag(imag) {}
    Complex(const Complex &src):  _real(src._real), _imag(src._imag) {}
    Complex& operator =(const Complex& source){
        _real = source._real;
        _imag = source._imag;
        return *this;
    }
};
class Vector : public Complex {
  Vector(): Complex() {}
  ~Vector() {}
  Vector(const Vector &src): Vector(src): Complex(src) {}
  Vector& operator =(const Vector& src): { Complex::operator =(src); return *this; }
}

Beispiel Interface

class Box {
   public:
      // pure virtual function
      virtual double getVolume() = 0;
};

Exception

class ReException {
public:
  ReException(const char* message);
  ReException(const char* message, const char* file, int line);
  virtual ~ReException();
public:
  ReException(const ReException& source): _message(source._message){};
  ReException& operator =(const ReException& source){ _message = source._message; }
protected:
  ReException();
public:
  inline void setMessage(const char* message) {
    if (m_message != NULL)
      free((void *) m_message);
      m_message = _strdup(message);
    }
  }
  inline const char* getMessage() const {
    return m_message;
  }
protected:
  const char* m_message;
};

try {
  throw ArgumentException ("too many positional parameters:", arg0);
catch (const ArgumentException &e){
  doIt(e.message();
catch (char param) { 
  doIt(); }
catch (...) { 
  doIt();
}

Casts

const_cast

Entfernt const Attribut.

const A a1;
const_cast<A&>(a1).f();                // remove const

• static_cast:

void *ptr = fromStorage();
auto ptr2 = static_cast<char*>(ptr);

reinterpreter_cast

Diese kann zur Konvertierung zwischen Zeiger- und Ganzzahltypen, zwischen nicht verwandten Zeigertypen, zwischen Zeiger-zu-Glied-Typen und zwischen Zeiger-zu-Funktions-Typen verwendet werden.

class A {int a; public: A();};
class B: public A {int b, c;};
void use_of_reinterpret_cast()
{
     A a1;
     long l = reinterpret_cast<long>(&a1);
     A* ap = reinterpret_cast<A*>(l);      // safe
     B* bp = reinterpret_cast<B*>(&a1);    // unsafe
     const A a2;
     ap = reinterpret_cast<A*>(&a2);  // error, const removed
}

dynamic_cast

Ein Zeiger (oder Verweis) auf eine Klasse kann auf eine beliebige von dieser Klasse abgeleitete Klasse zeigen (verweisen). Gelegentlich kann es wünschenswert sein, einen Zeiger auf die vollständig abgeleitete Klasse oder auf ein anderes Unterobjekt des vollständigen Objekts zu erhalten. Der dynamische Cast bietet diese Möglichkeit.

class A {public: virtual void f();};
class B {public: virtual void g();};
class AB: public virtual A, public B {};
void simple_dynamic_casts()
{
  AB ab;
  B* bp = &ab;        // no casts needed
  A* ap = &ab;
  AB& abr = dynamic_cast<AB&>(*bp);  // succeeds
  ap = dynamic_cast<A*>(bp);         assert(ap!= NULL);
  bp = dynamic_cast<B*>(ap);         assert(bp!= NULL);
  ap = dynamic_cast<A*>(&abr);       assert(ap!= NULL);
  bp = dynamic_cast<B*>(&abr);       assert(bp!= NULL); 
}

static_cast

In allen anderen Fällen. Ersetzt den C-Cast.

auto size = static_cast<int>(size);

Lambda

using DecisionFn = bool(*)();

class Decide
{
public:
    Decide(DecisionFn dec) : _dec{dec} {}
private:
    DecisionFn _dec;
};

int main()
{
    int x = 5;
    Decide greaterThanThree{ [x](){ return x > 3; } };
    return 0;
}