Autor: Sebastian Viereck

Vererbung

Klassen können Funktionen und Member-Variablen vererben an anderen Klassen.

Class A{
public:
 void f();
};
Class B : public A{};//B erbt public von A
B* b = new B;
b.f(); //Funktion ist vorhanden, da geerbt

• public: auf diese Elemente kann von überall her zugegriffen werden
• protected: Zugriff auf Element nur von Elternklassen und abgeleitete Klassen (sowie die Klasse, die das Element definiert)
• private: nur die definierende Klasse
  Weiterlesen „Einführung in C++ – Klassen: Vererbung, Adjustment, Friends, abstrakt – Teil5“

Funktionen Überladen

• es ist möglich einen Funktionsnamen mehrmals zu verwenden, wenn die Übergabeparameter nicht gleich sind und damit für den Compiler klar ist, welche Funktion aufgerufen werden soll

int a(int b);
int a(double b);
int a(char*);

int x = a(5); //ist ok, 5 ist int, 5.0 wäre double

• nicht eindeutig ist:

int a(int b);
double a(int b);

int x = a(5); //welche Funktion nehmen, error

sowie bei Default-Argumenten:

int a(int b, int c = 3);
int a(int b);

int x = a(5); //welche Funktion nehmen, error

Das Überladen der Funktionen ist möglich durch Name-Mangeling:

Datentypen

Implizite Typumwandlung

• automatisches Casting bei Zahlen „von kleineren zu größeren“ Datentypen

Rangfolge:

unsigned long long ("größter Wert") long long long double double float unsigned long long unsigned (int) int short bool

• casting non const zu const, Referenzen

T->T& T&->T T->const T T*->const T* T&->const T&

Explzite Typumwandlung

• mit static_cast<>
• bei elementaren (einfachen) Datentypen

bool i = true; int y = static_cast<int> i; //y ist 1

• zu Konstanten casten, mit const_cast<>

• kritische Typumwandlung mit  reinterpret_cast<>

struct A{} a; struct B{} b; struct A *pa = &a; struct B *pb = pa; //Fehler, nicht derselbe Datentyp, obwohl selber Struct-Inhalt struct B *pb = reinterpret_cast<B*>(pa); //ist ok

Inline Funktionen

Weiterlesen „Einführung in C++ – Datentypen, Casting, Klassen – Teil3“

Ein Zeiger ist eine Variable, die die Speicheradresse (des RAMs) einer anderen Variablen  enthält.

int i = 100;
int* pi = &i;
cout << pi; //Speicheradresse: z.B. 0x000026

Dereferenzieren von Zeigern: *Operator

• auf den Wert zugreifen, auf den ein Zeiger(Pointer) zeigt

int i = 100;
int* pi = &i;
cout << *pi; //100
cout << pi; //Speicheradresse: z.B. 0x000026

void Zeiger

• Zeiger auf unbekannten Typ -> dynamisch
• muss gecastet werden bei Zugriff

int i=10;
void* pi;
pi=&i;
cout << *(int*) pi;

NULL-Zeiger

• Speicher freigeben des Pointers, z.B. um Zombie Zeiger zu vermeiden, die auf nicht mehr existierende Objekte zeigen

int i = 100;
int* pi = &i;
pi = NULL;

Zeiger auf Konstanten

• müssen auch const sein, damit nicht änderbar

const int i = 100;
const int* pi = &i;

Zeiger auf Funktionen

int f(float a){return 1;};
int (*pf)(float) = &f;
int x = (*pf)(1,5);

Zeiger bei Funktionen

Call by Value

Weiterlesen „Einführung in C++ – Zeiger, Pointer,Referenzen – Teil2“

Vorteile von C++

• sehr gute Performance, Code wird kompiliert und vom Betriebssystem ausgeführt wird. Keine Interpretation wie Java, Code kann nur von der JVM ausgeführt werden
• es kann auch C eingebaut werden, selber Compiler: GNU C-Compiler

Vorteile von C++ gegenüber dem Vorgänger C

• strengere Typprüfung, zur Laufzeit/Late Binding
• Objektorientierung möglich
• verbessertes Speichermanagement
• Exceptions Handling

Der C++ Kompilationsvorgang: Wie arbeitet der GNU-Compiler?

1. x.cc und x.h als Ausgangsdateien
2. x.i, Header Dateien inkludieren, Hardware Plattform abfragen, Präprozessor Direktiven ausführen (z.B. #define, Variablen /Funktionen werden ersetzt im Code)
3. x.o, mit C++ Compiler g++, Assembler Maschinencode erzeugen, dieser ist hardware- und betriebssystemabhängig
4.  Linker schreibt die Adressen der verwendeten libs und verbindet alle Objektdateien (.o) miteinander
5. x.exe, ausführbare Shell-Datei erzeugen

Deklaration, Definition, Initialisierung und Zuweisung in C++

Deklaration

• keine Speicherzuweisung
• beliebig oft möglich

inf f(char c);
extern char c;
inf f(char c);

Definition

Weiterlesen „Einführung in C++ – Vorteile, Compiler, Namespaces – Teil1“