Inline Methoden/Funktionen

Wird eine als inline definiert Methode bzw. Funktion aufgerufen, kann (und diese ist kein Muss) der Compiler anstelle eines Funktionsaufrufs den Funktionscode einfügen.

inline-Methoden/Funktionen werden aus zwei Gründen eingesetzt:

1. Bei als inline definierten Funktionen ist sichergestellt, dass die Funktion nur einmal instanziiert wird, unabhängig davon, wie oft die Funktion definiert ist. Sehen Sie sich dazu das nachfolgende Beispiel an.

// Datei bibl.h
// Kleine Bibliothekfunktionen

bool Lesser(int val1, int val2)
{
    return val1<val2;
}

// Datei main.cpp
#include <print>
#include "bibl.h"
extern void AnyFunc();

int main()
{
    int var1 = 10, var2 = 20;
    std::println("{} kleiner {}: {}",var1,var2,Lesser(var1,var2));
    AnyFunc();
}

// Datei math1.cpp
#include "bibl.h"
#include <print>
#include <cstdlib>

void AnyFunc()
{
    auto res = std::rand() %10;
    if (Lesser(res,5))
        std::println ("Zufallszahl ist kleiner 5");
    else
        std::println("Zufallszahl ist groesser 5");
}

Sowohl main.cpp wie auch math1.cpp binden die Header-Datei bibl.h ein. Dadurch, dass die Funktion Lesser() innerhalb der Header-Datei definiert ist, wird sich beim Zusammenbinden der Anwendung der Linker beschweren, dass Lesser() mehrfach definiert ist. Durch die Definition von Lesser() als inline-Funktion wird die Funktion nur einmal instanziiert und die Anwendung kann erstellt werden.

2. Wie bekannt, kann der Zugriff auf private-Eigenschaften einer Klasse nur über public-Methoden erfolgen. Bei sehr kleinen Methoden, die z.B. nur eine Eigenschaft setzen oder zurückliefern, kann aber mehr Zeit für den Aufruf der Methode benötigt werden als für die Bearbeitung der Eigenschaft.

inline-Funktionen

inline-Funktionen werden dadurch gekennzeichnet, dass vor dem Returntyp der Funktion das Schlüsselwort inline gestellt wird.

Wenn die Definition von Lesser() wie folgt angepasst wird, lässt sich die Anwendung nun ohne Fehler übersetzen.

// Datei bibl.h
// Kleine Bibliothekfunktionen

inline bool Lesser(int val1, int val2)
{
    return val1<val2;
}

10 kleiner 20: true
Zufallszahl ist kleiner 5

inline-Funktionen entsprechen von der Wirkungsweise her in etwa den veralteten Präprozessor-Makros (#define-Direktive). Der Hauptunterschied zu den Makros liegt darin, dass die Parameter bei inline-Funktionen typisiert sind und inline-Funktionen einen Rückgabewert haben können.

inline-Methoden

Werden Methoden innerhalb einer Klasse, die nicht in einem benannten Modul liegt, definiert, werden sie automatisch als inline-Methode behandelt.

#include <print>
#include <string>
#include <string_view>

class Window
{
    std::string title;
public:
    // ctor
    Window (std::string_view _title):
        title(_title)
    { }
    // GetTitle ist implizit inline-Methode
    const std::string& GetTitle()
    {
        return title;
    }
};

int main()
{
    Window win("Fenster1");
    std::println("Fenster: {}",win.GetTitle());
}

Fenster: Fenster1

Wird eine Methode innerhalb einer Klasse deklariert, kann sie bei ihrer Definition außerhalb der Klasse durch voranstellen des Schlüsselworts inline vor dem Returntyp ebenfalls als inline-Methode definiert werden.

#include <print>
#include <string>
#include <string_view>

class Window
{
    std::string title;
public:
    // ctor
    Window (std::string_view _title):
        title(_title)
    { }
    const std::string& GetTitle();
};
// GetTitle ist inline-Methode
inline const std::string& Window::GetTitle()
{
    return title;
}

int main()
{
    Window win("Fenster1");
    std::println("Fenster: {}",win.GetTitle());
}

Fenster: Fenster1

In Klassen in einem benannten Modul müssen inline-Methoden immer explizit als inline definiert werden, d.h. unabhängig davon, ob sie innerhalb oder außerhalb der Klasse definiert sind.

module;
#include <string>
#include <string_view>

export module Window;

export class Window
{
    std::string title;
public:
    // ctor
    Window (std::string_view _title):
        title(_title)
    { }
    // GetTitle ist muss im Modul explizit
    // als inline-Methode definiert werden
    inline const std::string& GetTitle()
    {
        return title;
    }
};

Es gibt auch inline-Eigenschaften. Diese spielen bei statischen Eigenschaften eine Rolle und werden deshalb im Kapitel Statische Member beschrieben.