Da C++ eine Weiterentwicklung von C ist, sollte man sich auch den Wikiartikel über [[C]] zu Gemüte führen.

= Überblick =
Die meisten C++ Features sind ohne zusätzlichen Aufwand sofort verfügbar. Nur für die folgenden Features werden Hilfsfunktionen benötigt, welche der C++ Compiler von Haus aus nicht zur Verfügung stellt:
* [[C++#Startup-Code | Startup-Code]]
* [[C++#rein virtuelle Funktionen | rein virtuelle Funktionen]]
* [[C++#globale/statische Objekte | globale/statische Objekte]]
* [[C++#new/delete | new/delete]]
* [[C++#RTTI | RTTI (= Runtime type information)]]
* [[C++#Exceptions | Exceptions]]
Da jeder Compilerhersteller eine eigene ABI (= Application Binary Interface) zur Verfügung stellt sind auch die Funktionsnamen sowie auch der Funktionsumfang, von Compiler zu Compiler verschieden.

= Startup-Code =

Dieser Code wird ausgeführt bevor die main-Funktion des Programmes/Kernels aufgerufen wird und muss zumindest die Kommandozeilenargumente, mit denen das Programm aufgerufen wurde, an die main-Funktion weiterreichen.

= rein virtuelle Funktionen =

Wenn eine Klasse eine rein virtuelle Funktion nicht implementiert hat und diese Funktion aufgerufen wird, wird zur Fehlerbehandlung eine Hilfsfunktion aufgerufen, welche im Normalfall das Programm beendet.

== g++ ==
<cpp>
// Lizenz: public domain

extern "C" void __cxa_pure_virtual()
{
  // Fehlermeldung anzeigen
  // Programm/Kernel beenden
}
</cpp>

= globale/statische Objekte =

Da diese vor dem Eintritt in die main-Funktion initialisiert sein sollen, müssen auch Konstruktoren und Destruktoren aufgerufen werden.

== g++ ==

Die Konstruktion der globalen/statischen Objekte ist unter g++ immer gleich. Nur die Destruktion der selben hängt von der Verwendung des configure-flags --enable-__cxa_atexit und vom Kommandozeilenparameter -fuse-cxa-atexit / -fno-use-cxa-atexit ab.

=== Konstruktoren ===

G++ erstellt eine "ctors*" Sektion, welche ein Array aus Funktionszeigern ist. Diese Funktionszeiger zeigen jeweils auf einen Konstruktor. Man muss nun nur dieses Array durchgehen und alle Funktionen aufrufen und schon hat man alle globalen/statischen Objekte initialisiert.

<cpp>
// Lizenz: public domain

// Im Linkerskript definiert
uintptr_t start_ctors;
uintptr_t end_ctors;

// Ruft die Konstruktoren für globale/statische Objekte auf
void initialiseConstructors()
{
  uintptr_t *iterator = reinterpret_cast<uintptr_t*>(&start_ctors);
  while (iterator < reinterpret_cast<uintptr_t*>(&end_ctors))
  {
    void (*fp)(void) = reinterpret_cast<void (*)(void)>(*iterator);
    fp();
    iterator++;
  }
}
</cpp>

Diese Funktion muss explizit aufgerufen werden bevor globale/statische Objekte verwendet werden. Dies kann beispielsweise im [[C++#Startup-Code | Startup-Code]] geschehen.

=== Destruktoren (ohne --enable-__cxa_atexit und ohne -fuse-cxa-atexit) ===

G++ erstellt eine "dtors*" Sektion, analog zur "ctors*" Sektion und speicher dort wiederum ein Array aus Funktionszeigern. Diesmal zeigen diese Funktionszeiger aber auf Destruktoren.

=== Destruktoren (mit --enable-__cxa_atexit oder mit -fuse-cxa-atexit) ===

Im Konstruktor eines globalen/statischen Objekts wird die folgende Funktion aufgerufen:

<cpp>
 int __cxa_atexit(void (* f)(void *), void *p, void *d);
</cpp>

f ist ein Funktionszeiger zu einem Destruktor, p der Parameter, der dem Destruktor übergeben werden soll und d ist das sog. "home DSO" (DSO = dynamic shared object).  Diese Funktion sollte alle drei Parameter speichern und bei Erfolg 0, andernfalls nicht 0 zurückgeben. Wenn der Kernel/das Programm dann beendet wird, sollte man die Funktion

<cpp>
 void __cxa_finalize(void *d);
</cpp>

mit d = 0 aufrufen, um alle mit __cxa_atexit registrierten Funktionen mit passenden Paramtern aufzurufen. Die registrierten Funktionen müssen in umgekehrter Reihenfolge aufgerugen werden.
Außerdem muss man ein Symbol namens __dso_handle bereitstellen. Es wird allerdings nur die Adresse des Symbols verwendet um ein DSO zu identifizieren und um __cxa_atexit aufzurufen.

<cpp>
// Lizenz: public domain

extern "C"
{
  int __cxa_atexit(void (*f)(void *), void *p, void *d);
  void __cxa_finalize(void *d);
};

void *__dso_handle;

struct object
{
  void (*f)(void*);
  void *p;
  void *d;
} object[32] = {0};
unsigned int iObject = 0;

int __cxa_atexit(void (*f)(void *), void *p, void *d)
{
  if (iObject >= 32) return -1;
  object[iObject].f = f;
  object[iObject].p = p;
  object[iObject].d = d;
  ++iObject;
  return 0;
}

/* NOTE: Zerstört momentan unabhängig von d alle Objekte */
void __cxa_finalize(void *d)
{
  unsigned int i = iObject;
  for (; i > 0; --i)
  {
    --iObject;
    object[iObject].f(object[iObject].p);
  }
}
</cpp>

= new/delete =
Um dynamisch Objekte mit new erstellen bzw. mit delete zerstören zu können muss man die vier Operatoren 
*new
*new[]
*delete
*delete[] 
implementieren.

Eine einfache Implementation ist z.B.:
<cpp>
void *operator new( size_t size )
{
  return kcalloc( size );
}

void *operator new[]( size_t  size )
{
  return kcalloc( size );
}

void operator delete( void *ojb )
{
  kfree( obj );
}

void operator delete[]( void *obj )
{
  kfree( obj );
}
</cpp>

= RTTI =
RTTI (Runtime Type Information) wird am besten innerhalb des Kernels komplett deaktiviert. Mit g++ geschieht dies mittels des Kommandozeilenparameter ''-fno-rtti''.

= Exceptions =

Exceptions sollten auch am besten innerhalb des Kernels deaktiviert werden. Mit g++ können Exceptions über den Kommandozeilenparameter ''-fno-exceptions'' deaktiviert werden.

= Links =
* [http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2006/n2135.pdf Draft des C++ Standards]
* [http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1836.pdf Draft des TR1 (=Technical Report 1)]
* [http://www.codesourcery.com/cxx-abi/abi.html g++ ABI] (Nicht nur die ABI für Itanium, sondern auch für x86 und x86-64)
* [http://www.codesourcery.com/cxx-abi/abi-eh.html g++ ABI: Exception Handling] (Nicht nur die ABI für Itanium, sondern auch für x86 und x86-64)
* [http://www.osdev.org/wiki/C_PlusPlus OSDev.org wiki]
== C++0x ==
* [http://video.google.de/videoplay?docid=2768126766555555011&q=c%2B%2B0x New Features in the Next C++ Standard] (video)
* [http://video.google.de/videoplay?docid=5262479012306588324&q=c%2B%2B0x Initialization Lists] (video)
* [http://video.google.de/videoplay?docid=-1790714981047186825&q=c%2B%2B0x Concepts Extending C++ Templates For Generic Programming] (video)
* [http://www.c-plusplus.de/forum/viewtopic-var-t-is-204654.html C++09 (Teil 1) - Ein Überblick: Sprachfeatures]

[[Kategorie:Programmiersprache]]