Inline-Funktionen

Nach oben zu Klassen - Index

Sie können eine Elementfunktion innerhalb einer Klasse deklarieren und an anderer Stelle definieren. Alternativ dazu ist es möglich, die Elementfunktion innerhalb einer Klasse zu deklarieren und zu definieren. In diesem Fall wird die Funktion Inline-Funktion genannt.

Der Compiler kann manchmal den normalen Funktionsaufruf-Overhead reduzieren, indem er anstelle des Funktionsaufrufs direkt den compilierten Code der Funktion einsetzt. Dieser Vorgang, der Inline-Erweiterung genannt wird, hat keinen Einfluss auf den Gültigkeitsbereich des Funktionsnamens oder seiner Argumente. Eine Inline-Ausdehnung ist aber nicht immer möglich oder nützlich. Der inline-Spezifizierer ist ein Hinweis für den Compiler, dass Sie eine Inline-Ausdehnung wünschen.

Hinweis:  Die Inline-Erweiterung kann durch den Compiler unterbunden werden.

Explizite und implizite inline-Anweisungen werden am besten nur für kleine, häufig benutzte Funktionen verwendet, wie z.B. Operatorfunktionen, die überladene Operatoren implementieren. So ist beispielsweise die Klassendeklaration von func:

 int i;                          // globale int
 class X {
 public:
    char* func(void) { return i; }  // standardmäßig Inline
    char* i;
 };

gleichbedeutend mit:

 inline char* X::func(void) { return i; }

func ist außerhalb der Klasse mit dem expliziten inline-Spezifizierer definiert. Das von func zurückgegebene i ist der char* i der Klasse X (siehe Gültigkeitsbereich von Elementen).

Inline-Funktionen und Exceptions

Die inline-Anweisung für Funktionen, die eine Exception-Angabe enthalten, wird vom Compiler ignoriert. Zum Beispiel:

 inline void f1() throw(int)
 {
    // Warnung: Funktionen mit Exception werden nicht inline erweitert
 }

Die übrigen Beschränkungen gelten nur, wenn das Aufräumen mit Destruktoren aktiviert ist.

Hinweis: Destruktoren werden standardmäßig aufgerufen. Informationen über Optionen zur Exception-Behandlung finden Sie unter Einstellungen von Exception-Behandlungsoptionen.

Eine Inline-Funktion, die mindestens einen Parameter übernimmt, der den Typ "Klasse mit Destruktor" hat, wird nicht inline behandelt. Beachten Sie, dass diese Beschränkungen nicht für Klassen gilt, die als Referenz übergeben werden.

Ein Beispiel:

 struct foo {
    foo();
    ~foo();
 };
 inline void f2(foo& x)
 {
    // keine Warnung; f2() lässt sich inline behandeln
 }
 inline void f3(foo x)
 {
    // Warnung: Funktionen, die Klassenargumente als Wertparameter
    //          übernehmen, werden in Funktion f3(foo) nicht inline
 }

Eine Inline-Funktion, die eine Klasse mit Destruktor als Wert zurückgibt, wird nicht inline behandelt, wenn innerhalb des Rückgabeausdrucks Variablen oder temporäre Objekte zu entfernen sind:

 struct foo {
    foo();
    ~foo();
 };
 inline foo f4()
 {
    return foo();
    // keine Warnung; f4() lässt sich inline behandeln
 }
 inline foo f5()
 {
    foo X;
    return foo(); // Objekt X muss entfernt werden
    // Warnung: Funktionen mit einigen Rückgabeanweisungen
    //          werden in Funktion f5() nicht behandelt
 }
 inline foo f6()
 {
    return ( foo(), foo() );  // temporär in Rückgabewert
    // Warnung: Funktionen mit bestimmten Rückgabeanweisungen
    //         werden in Funktion f6() nicht inline behandelt
 }

Siehe auch

• inline
• #pragma inline
• C++-Klassen
• Klassentypen
• Gültigkeitsbereich Klasse
• Klassenobjekte
• Klassen-Member-Liste
• Member-Funktionen
• Das Schlüsselwort this
• Statische Elemente
• Gültigkeitsbereich von Elementen
• Verschachtelte Typen
• Element-Zugriffskontrolle
• Zugriff auf Basisklassen und abgeleitete Klassen
• Virtuelle Basisklassen
• Friends von Klassen