C-plus-plus: Unterschied zwischen den Versionen

Aus Info-Theke
Zur Navigation springen Zur Suche springen
 
(12 dazwischenliegende Versionen von 6 Benutzern werden nicht angezeigt)
Zeile 3: Zeile 3:
== Links ==
== Links ==
* [[C-plus-plus-Scrambler]]
* [[C-plus-plus-Scrambler]]
* [[STL C++]]
* [[https://cpp.sh/ C++-Shell online]]


= Beispiel Klasse Complex =
= Klassen =
<pre>class Complex
== Beispiel Klasse Complex ==
<syntaxhighlight lang="c++">
class Complex
{
{
public:
public:
Zeile 20: Zeile 24:
     }
     }
};
};
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>


</pre>
== 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>
 
= 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>

Aktuelle Version vom 25. Dezember 2022, 21:16 Uhr


Links[Bearbeiten]

Klassen[Bearbeiten]

Beispiel Klasse Complex[Bearbeiten]

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[Bearbeiten]

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

Exception[Bearbeiten]

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[Bearbeiten]

const_cast[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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

auto size = static_cast<int>(size);