C-plus-plus: Unterschied zwischen den Versionen

Aus Info-Theke
Zur Navigation springen Zur Suche springen
Zeile 66: Zeile 66:
   const char* m_message;
   const char* m_message;
};
};
</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>
</syntaxhighlight>

Version vom 20. Dezember 2022, 09:39 Uhr


Links

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;
};

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