Inlining von C++-Funktionen

1. Ersetzen Sie Makrocode durch Inline

Die Sprache C++ unterstützt Funktions-Inlining, dessen Zweck darin besteht, die Ausführungseffizienz (Geschwindigkeit) der Funktion zu verbessern.

In C-Programmen können Makrocodes verwendet werden, um die Ausführungseffizienz zu verbessern. Der Makrocode selbst ist keine Funktion, verhält sich aber wie eine Funktion. Der Präprozessor ersetzt Funktionsaufrufe durch das Kopieren von Makrocodes, wodurch die Notwendigkeit entfällt, Parameter auf den Stapel zu verschieben, CALL-Aufrufe in Assemblersprache zu generieren, Parameter zurückzugeben und Rückgaben auszuführen usw., wodurch die Geschwindigkeit verbessert wird. Der größte Nachteil der Verwendung von Makrocode besteht darin, dass er fehleranfällig ist. Der Präprozessor erzeugt beim Kopieren von Makrocode häufig unerwartete Nebenwirkungen.

Beispielsweise wird die

#define MAX(a, b)         (a) > (b) ? (a) : (b)

-Anweisung

result = MAX(i, j) + 2 ;

vom Präprozessor als

<🎜 interpretiert >

result = (i) > (j) ? (i) : (j) + 2 ;

Da der Operator „+“ eine höhere Priorität hat als der Operator „:“, entspricht die obige Aussage nicht dem erwarteten

result = ( (i) > (j) ? (i) : (j) ) + 2 ;

, wenn der Makrocode als

< umgeschrieben wird 🎜>

Sie können durch Prioritäten verursachte Fehler beheben. Aber selbst die Verwendung des geänderten Makrocodes ist nicht narrensicher, zum Beispiel wird die Anweisung

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )

vom Präprozessor als

result = MAX(i++, j);

interpretiert. Für C++ ist die Verwendung des Makrocodes auch eine andere Nachteil: Die privaten Datenmitglieder der Klasse können nicht bedient werden, was bedeutet, dass der Makrocode grundsätzlich für öffentliche oder globale Operationen bestimmt ist.

result = (i++) > (j) ? (i++) : (j);

Sehen wir uns an, wie „Function Inlining“ in C++ funktioniert. Für jede Inline-Funktion platziert der Compiler die Deklaration der Funktion (einschließlich Name, Parametertypen und Rückgabewerttyp) in der Symboltabelle. Wenn der Compiler keinen Fehler in der Inline-Funktion findet, wird der Code für die Funktion ebenfalls in die Symboltabelle gestellt. Beim Aufruf einer Inline-Funktion prüft der Compiler zunächst, ob der Aufruf korrekt ist (durch eine Typsicherheitsüberprüfung oder durch eine automatische Typkonvertierung, natürlich für alle Funktionen gleich). Wenn dies korrekt ist, ersetzt der Code für die Inline-Funktion den Funktionsaufruf direkt und eliminiert so den Overhead des Funktionsaufrufs. Dieser Prozess unterscheidet sich erheblich von der Vorverarbeitung, da der Präprozessor keine Typsicherheitsprüfungen oder automatische Typkonvertierungen durchführen kann. Wenn die Inline-Funktion eine Mitgliedsfunktion ist, wird die Adresse des Objekts (dieses) an der entsprechenden Stelle platziert, was der Präprozessor nicht tun kann.

Der Funktions-Inlining-Mechanismus der C++-Sprache bietet nicht nur die Effizienz von Makrocode, sondern erhöht auch die Sicherheit und kann die Datenelemente der Klasse frei bedienen. Daher sollten in C++-Programmen alle Makrocodes durch Inline-Funktionen ersetzt werden. „assert“ ist wahrscheinlich die einzige Ausnahme. Assert ist ein Makro, das nur in der Debug-Version funktioniert. Es wird verwendet, um nach Situationen zu suchen, die „nicht“ passieren sollten. Um keine Unterschiede zwischen der Debug- und der Release-Version des Programms zu verursachen, sollte Assert keine Nebenwirkungen haben. Wenn es sich bei Assert um eine Funktion handelt, gibt es einen Unterschied zwischen der Debug-Version und der Release-Version, da der Funktionsaufruf Änderungen im Speicher und Code verursacht. Assert ist also keine Funktion, sondern ein Makro.

2. Der Programmierstil von Inline-Funktionen

Das Schlüsselwort inline muss zusammen mit dem Funktionsdefinitionskörper platziert werden . Um eine Funktion inline zu machen, hat das einfache Einfügen von inline vor die Funktionsdeklaration keine Auswirkung. Die Funktion Foo im folgenden Stil kann nicht zu einer Inline-Funktion werden:

, während die Funktion Foo im folgenden Stil zu einer Inline-Funktion wird:

inline void Foo(int x, int y);   // inline 仅与函数声明放在一起,不起任何作用  
void Foo(int x, int y)  
{  
…  
}

void Foo(int x, int y);    
inline void Foo(int x, int y) // inline 与函数定义体放在一起  
{  
…  
}

Daher ist inline eher ein „Schlüsselwort für die Implementierung“ als ein „Schlüsselwort für die Deklaration“. Im Allgemeinen können Benutzer die Deklaration einer Funktion lesen, aber die Definition der Funktion nicht sehen. Obwohl das Schlüsselwort inline in den meisten Lehrbüchern vor der Deklaration und dem Definitionskörper von Inline-Funktionen eingefügt wird, denke ich, dass inline nicht in der Deklaration einer Funktion erscheinen sollte. Obwohl dieses Detail keinen Einfluss auf die Funktionalität der Funktion hat, spiegelt es ein Grundprinzip eines hochwertigen C++/C-Programmierstils wider: Deklaration und Definition dürfen nicht verwechselt werden, und Benutzer müssen und sollten nicht wissen, ob eine Funktion benötigt wird inline sein.

In der Klassendeklaration definierte Mitgliedsfunktionen werden automatisch zu Inline-Funktionen, z. B.

class A  
{  
public:  
    void Foo(int x, int y) { … }   // 自动地成为内联函数  
}

Platzieren der Der Definitionskörper der Mitgliedsfunktion in der Klassendeklaration kann beim Schreiben hilfreich sein, ist jedoch kein guter Programmierstil. Das obige Beispiel sollte wie folgt geändert werden:

3. Mit Vorsicht verwenden >

// 头文件  
class A  
{  
public:  
    void Foo(int x, int y)；  
}  
// 定义文件  
inline void A::Foo(int x, int y)  
{  
…  
}

Inline kann die Ausführungseffizienz von Funktionen verbessern. Warum nicht alle Funktionen als Inline-Funktionen definieren?

Wenn alle Funktionen Inline-Funktionen sind, wird dann noch das Schlüsselwort „inline“ benötigt?

Inlining geht auf Kosten der Codeerweiterung (Duplizierung) und spart nur den Overhead von Funktionsaufrufen, wodurch die Ausführungseffizienz der Funktion verbessert wird. Wenn die Zeit zum Ausführen des Codes im Funktionskörper größer ist als der Overhead der Funktionsaufrufe, sind die Effizienzgewinne sehr gering. Andererseits erfordert jeder Inline-Funktionsaufruf eine Duplizierung des Codes, was die Gesamtcodegröße des Programms erhöht und mehr Speicherplatz verbraucht. In den folgenden Situationen ist die Verwendung von Inlining nicht angebracht:

(1) Wenn der Code im Funktionskörper relativ lang ist, führt die Verwendung von Inlining zu höheren Kosten für den Speicherverbrauch .

(2) Wenn im Funktionskörper eine Schleife auftritt, ist die Zeit zum Ausführen des Codes im Funktionskörper größer als die Kosten des Funktionsaufrufs.

Die Konstruktoren und Destruktoren von Klassen werden leicht missverstanden, da die Verwendung von Inline effizienter ist. Hüten Sie sich vor Konstruktoren und Destruktoren, die bestimmte Verhaltensweisen verbergen können, beispielsweise die „heimliche“ Ausführung der Konstruktoren und Destruktoren von Basisklassen oder Mitgliedsobjekten. Platzieren Sie die Definitionen von Konstruktoren und Destruktoren also nicht beiläufig in der Klassendeklaration.

Das Obige ist der Inhalt des C++-Funktions-Inlinings. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).