Warum befinden sich C ++ - Inline-Funktionen im Header?

_{Hinweis: Hier geht es nicht darum, wie Inline-Funktionen verwendet werden oder wie sie funktionieren, sondern darum, warum sie so ausgeführt werden, wie sie sind.}

Die Deklaration einer Klassenmitgliedsfunktion muss keine Funktion als definieren inline, sondern ist nur die tatsächliche Implementierung der Funktion. Zum Beispiel in der Header-Datei:

struct foo{
    void bar(); // no need to define this as inline
}

Warum also die Inline - Implementierung eines Klassen funktionieren müssen , um in der Header - Datei? Warum kann ich die Inline-Funktion nicht in die .cppDatei einfügen? Wenn ich versuchen würde, die Inline-Definition in die .cppDatei einzufügen, würde ich einen Fehler in der Art von: erhalten.

error LNK2019: unresolved external symbol 
"public: void __thiscall foo::bar(void)"
(?bar@foo@@QAEXXZ) referenced in function _main 
1>C:\Users\Me\Documents\Visual Studio 2012\Projects\inline\Debug\inline.exe 
: fatal error LNK1120: 1 unresolved externals

Die Definition einer inlineFunktion muss nicht in einer Header-Datei enthalten sein, sondern aufgrund der One Definition Rule ( ODR ). für Inline-Funktionen muss jedoch in jeder Übersetzungseinheit, die sie verwendet, eine identische Definition für die Funktion vorhanden sein.

Der einfachste Weg, dies zu erreichen, besteht darin, die Definition in eine Header-Datei einzufügen.

Wenn Sie die Definition einer Funktion in eine einzelne Quelldatei einfügen möchten, sollten Sie sie nicht deklarieren inline. Eine nicht deklarierte Funktioninline bedeutet nicht, dass der Compiler die Funktion nicht einbinden kann.

Ob Sie eine Funktion deklarieren sollten inlineoder nicht, ist normalerweise eine Entscheidung, die Sie treffen sollten, basierend auf der Version der Regeln für eine Definition , deren Befolgung für Sie am sinnvollsten ist. Das Hinzufügen inlineund anschließende Einschränken durch die nachfolgenden Einschränkungen ist wenig sinnvoll.

Es gibt zwei Möglichkeiten, es zu betrachten:

1. Inline-Funktionen werden im Header definiert, da der Compiler in der Lage sein muss, den Funktionskörper zu sehen, um einen Funktionsaufruf inline zu machen. Damit ein naiver Compiler dies tun kann, muss sich der Funktionskörper in derselben Übersetzungseinheit wie der Aufruf befinden. (Ein moderner Compiler kann über mehrere Übersetzungseinheiten hinweg optimieren. Daher kann ein Funktionsaufruf eingefügt werden, obwohl sich die Funktionsdefinition in einer separaten Übersetzungseinheit befindet. Diese Optimierungen sind jedoch teuer, nicht immer aktiviert und wurden von der nicht immer unterstützt Compiler)

2. Im Header definierte Funktionen müssen markiert werden, inlineda andernfalls jede Übersetzungseinheit, die den Header enthält, eine Definition der Funktion enthält und der Linker sich über mehrere Definitionen beschwert (ein Verstoß gegen die One Definition Rule). Das inlineSchlüsselwort unterdrückt dies, sodass mehrere Übersetzungseinheiten (identische) Definitionen enthalten können.

Die beiden Erklärungen laufen wirklich darauf hinaus, dass das inlineSchlüsselwort nicht genau das tut, was Sie erwarten würden.

Ein C ++ - Compiler kann die Inlining- Optimierung (einen Funktionsaufruf durch den Hauptteil der aufgerufenen Funktion ersetzen , den Aufrufaufwand sparen) jederzeit anwenden , sofern dies das beobachtbare Verhalten des Programms nicht verändert.

Das inlineSchlüsselwort macht es einfacher für den Compiler diese Optimierung anzuwenden, um die Funktionsdefinition ermöglicht in mehreren Übersetzungseinheiten sichtbar zu sein, aber das Schlüsselwort bedeutet nicht , den Compiler hat die Funktion inline, und nicht das Schlüsselwort nicht Verbieten Sie dem Compiler, die Funktion einzuschleusen.

Dies ist eine Grenze des C ++ - Compilers. Wenn Sie die Funktion in den Header einfügen, können alle CPP-Dateien, in die sie eingefügt werden können, die "Quelle" Ihrer Funktion sehen, und das Inlining kann vom Compiler durchgeführt werden. Andernfalls müsste das Inlining vom Linker durchgeführt werden (jede cpp-Datei wird separat in einer obj-Datei kompiliert). Das Problem ist, dass es viel schwieriger wäre, dies im Linker zu tun. Ein ähnliches Problem besteht bei "Vorlagen" -Klassen / -Funktionen. Sie müssen vom Compiler instanziiert werden, da der Linker Probleme haben würde, sie zu instanziieren (eine spezielle Version davon zu erstellen). Einige neuere Compiler / Linker können eine Kompilierung / Verknüpfung mit zwei Durchgängen durchführen, wobei der Compiler einen ersten Durchgang ausführt. Dann erledigt der Linker seine Arbeit und ruft den Compiler auf, um ungelöste Probleme zu lösen (Inline / Vorlagen ...).

Der Grund ist, dass der Compiler die Definition tatsächlich sehen muss, um sie anstelle des Aufrufs ablegen zu können.

Denken Sie daran, dass C und C ++ ein sehr vereinfachtes Kompilierungsmodell verwenden, bei dem der Compiler immer nur eine Übersetzungseinheit gleichzeitig sieht. (Dies schlägt beim Export fehl. Dies ist der Hauptgrund, warum nur ein Anbieter es tatsächlich implementiert hat.)

Das inlineSchlüsselwort c ++ ist irreführend und bedeutet nicht "Inline dieser Funktion". Wenn eine Funktion als Inline definiert ist, bedeutet dies einfach, dass sie mehrmals definiert werden kann, solange alle Definitionen gleich sind. Es ist völlig legal, dass eine Funktion inlineals echte Funktion markiert ist, die aufgerufen wird, anstatt an der Stelle, an der sie aufgerufen wird, Code inline zu setzen.

Das Definieren einer Funktion in einer Header-Datei ist für Vorlagen erforderlich, da beispielsweise eine Vorlagenklasse keine Klasse ist, sondern eine Vorlage für eine Klasse, von der Sie mehrere Variationen vornehmen können. Damit der Compiler zB eine Foo<int>::bar()Funktion erstellen kann, wenn Sie die Foo-Vorlage zum Erstellen einer Foo-Klasse verwenden , muss die tatsächliche Definition von Foo<T>::bar()sichtbar sein.

Ich weiß, dass dies ein alter Thread ist, dachte aber, ich sollte das externSchlüsselwort erwähnen . Ich bin kürzlich auf dieses Problem gestoßen und habe es wie folgt gelöst

Helper.h

namespace DX
{
    extern inline void ThrowIfFailed(HRESULT hr);
}

Helper.cpp

namespace DX
{
    inline void ThrowIfFailed(HRESULT hr)
    {
        if (FAILED(hr))
        {
            std::stringstream ss;
            ss << "#" << hr;
            throw std::exception(ss.str().c_str());
        }
    }
}

Weil der Compiler sie sehen muss, um sie inline zu machen. Und Header-Dateien sind die "Komponenten", die üblicherweise in anderen Übersetzungseinheiten enthalten sind.

#include "file.h"
// Ok, now me (the compiler) can see the definition of that inline function. 
// So I'm able to replace calls for the actual implementation.

Inline-Funktionen

In C ++ ist ein Makro nichts anderes als eine Inline-Funktion. Jetzt haben Makros die Kontrolle über den Compiler.

• Wichtig : Wenn wir eine Funktion innerhalb der Klasse definieren, wird sie automatisch zu Inline

Die Code of Inline-Funktion wird an der Stelle ersetzt, an der sie aufgerufen wird, wodurch der Overhead der aufrufenden Funktion verringert wird.

In einigen Fällen kann das Inlining der Funktion nicht funktionieren, wie z

• Wenn statische Variable innerhalb der Inline-Funktion verwendet wird.

• Wenn die Funktion kompliziert ist.

• Bei rekursivem Funktionsaufruf

• Wenn die Adresse der Funktion implizit oder explizit übernommen wurde

Funktionen, die außerhalb der Klasse wie folgt definiert sind, können inline werden

inline int AddTwoVar(int x,int y); //This may not become inline 

inline int AddTwoVar(int x,int y) { return x + y; } // This becomes inline

Innerhalb der Klasse definierte Funktionen werden ebenfalls inline

// Inline SpeedMeter functions
class SpeedMeter
{
    int speed;
    public:
    int getSpeed() const { return speed; }
    void setSpeed(int varSpeed) { speed = varSpeed; }
};
int main()
{
    SpeedMeter objSM;
    objSM.setSpeed(80);
    int speedValue = A.getSpeed();
} 

Hier werden sowohl die Funktionen getSpeed ​​als auch setSpeed ​​inline