C-plus-plus: Unterschied zwischen den Versionen

Aus Info-Theke
Zur Navigation springen Zur Suche springen
 
(7 dazwischenliegende Versionen von 4 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]]


= Klassen =
= Klassen =
Zeile 22: 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>
</syntaxhighlight>
== Beispiel Interface ==
== Beispiel Interface ==
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
Zeile 57: Zeile 66:
   const char* m_message;
   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>
</syntaxhighlight>


= STL =
= Casts =
== String ==
== const_cast ==
Konstruktoren:
Entfernt const Attribut.
* string() https://cplusplus.com/reference/string/string/string/
<syntaxhighlight lang="c++">
* string(data)
const A a1;
* string(int count, char c)
const_cast<A&>(a1).f();                // remove const
 
</syntaxhighlight>
Zugriff/Manipulation
* static_cast:
* size_t length() Aktuelle Länge
<syntaxhighlight lang="c++">
* size_t capacity() Liefert aktuell Puffergröße
void *ptr = fromStorage();
* void resize(size_t newLen, [char cc = '\0']) Setzt Länge durch Kürzen oder Auffüllen mit cc
auto ptr2 = static_cast<char*>(ptr);
* reserve(size_t newSize): Setzt Kapazität
</syntaxhighlight>
* clear() Kürzt auf 0
== reinterpreter_cast ==
* bool empty() Test auf Leerstring
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.  
* int compare(data) Vergleich: <0 0 >0 https://cplusplus.com/reference/string/string/compare/
* string substr(size_t pos, size_t len) Teilstring erstellen
 
* char& at(int position) Liefert Zeichen von Position
* char& back() Letztes Zeichen
* char& front() erstes Zeichen
* append(data) https://cplusplus.com/reference/string/string/append/
* push_back(char cc) Zeichen anfügen
* char pop_back() Letztes Zeichen entfernen und zurückgeben
* insert(size_t pos, data) https://cplusplus.com/reference/string/string/insert/
* string& erase(size_t pos, size_t len) Löschen https://cplusplus.com/reference/string/string/erase/
* iterator erase(iterator begin, iterator end) Löschen
Finden und Ersetzen
* replace(pos, len, data) https://cplusplus.com/reference/string/string/replace/
* size_t find(data) Substring finden https://cplusplus.com/reference/string/string/find/
* size_t rfind(data) Von hinten Substring finden
* find_first_of(char cc)
* find_last_of(char cc)
 
Konvertierung
* int stoi()  Wandlung in int
* const char* c_str() C-String
* string to_string(NUMERIC val) int, long, ... long double in String wandeln https://cplusplus.com/reference/string/to_string/
 
Iteratoren:
* begin
* end
* rbegin Vom Ende her
* rend
* cbegin Ein const-Iterator
* cend
* crbegin
* crend
 
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
#include <string>
class A {int a; public: A();};
std::string s;
class B: public A {int b, c;};
 
void use_of_reinterpret_cast()
for (auto rit=str.rbegin(); rit!=str.rend(); ++rit){
{
  std::cout << *rit;
    A a1;
}
    long l = reinterpret_cast<long>(&a1);
for (auto it=str.begin(); it!=str.end(); ++it)[
    A* ap = reinterpret_cast<A*>(l);     // safe
    std::cout << *it;
    B* bp = reinterpret_cast<B*>(&a1);   // unsafe
}
    const A a2;
for ( auto it=str.cbegin(); it!=str.cend(); ++it){
    ap = reinterpret_cast<A*>(&a2); // error, const removed
    std::cout << *it;
}
}
</syntaxhighlight>
</syntaxhighlight>
 
== dynamic_cast ==
== Vector ==
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++">
<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>
</syntaxhighlight>
 
== static_cast ==
== RegExpr ==
In allen anderen Fällen. Ersetzt den C-Cast.
<syntaxhighlight lang="c++">
<syntaxhighlight lang="c++">
auto size = static_cast<int>(size);
</syntaxhighlight>
</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);