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

= Kernelprogrammierung in C++ =
Die meisten C++ Features sind ohne zusätzlichen Aufwand sofort verfügbar. Nur für die folgenden Features werden Hilffunktionen benötigt, welche der C++ Compiler von Haus aus nicht zur Verfügung stellt:
* Startup-Code
* rein virtuelle Funktionen
* globale/statische Objekte
* new/delete
* RTTI (= Runtime type information)
* Exceptions
Da jeder Compilerhersteller eine eigene ABI (= Application Binary Interface) zur Verfügung stellt sind auch die Namen und 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>
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.

=== 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>
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 *obj )
{
        kfree( obj );
}

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

= RTTI =
= Exceptions =
= 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]

[[Category:Sprachen]]
[[Kategorie:Lizenz ungeklärt]]