Bearbeiten von „C-plus-plus“

[[Kategorie:Sprache]]

== Links ==
* [[C-plus-plus-Scrambler]]
* [[STL C++]]
* [[https://cpp.sh/ C++-Shell online]]

= Klassen =
== Beispiel Klasse Complex ==
<syntaxhighlight lang="c++">
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; }
}
</syntaxhighlight>

== Beispiel Interface ==
<syntaxhighlight lang="c++">
class Box {
   public:
      // pure virtual function
      virtual double getVolume() = 0;
};
</syntaxhighlight>

= Exception =
<syntaxhighlight lang="c++">
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();
}
</syntaxhighlight>
@@ Zeile 76: / Zeile 76: @@
    doIt();
 }
-</syntaxhighlight>
-= Casts =
-== const_cast ==
-Entfernt const Attribut.
-<syntaxhighlight lang="c++">
-const A a1;
-const_cast<A&>(a1).f();                // remove const
-</syntaxhighlight>
-* static_cast:
-<syntaxhighlight lang="c++">
-void *ptr = fromStorage();
-auto ptr2 = static_cast<char*>(ptr);
-</syntaxhighlight>
-== 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.
-<syntaxhighlight lang="c++">
-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
-}
-</syntaxhighlight>
-== 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.
-<syntaxhighlight lang="c++">
-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);
-}
-</syntaxhighlight>
-== static_cast ==
-In allen anderen Fällen. Ersetzt den C-Cast.
-<syntaxhighlight lang="c++">
-auto size = static_cast<int>(size);
 </syntaxhighlight>