C++
optimalisatie

Invoering

Inline uitbreiding / inline

Inline-uitbreiding (ook bekend als inlining) is compileroptimalisatie die een aanroep van een functie vervangt door de hoofdtekst van die functie. Dit bespaart de functieoproep overhead, maar ten koste van de ruimte, omdat de functie meerdere keren kan worden gedupliceerd.

// source:

int process(int value)
{
    return 2 * value;
}

int foo(int a)
{
    return process(a);
}

// program, after inlining:

int foo(int a)
{
    return 2 * a; // the body of process() is copied into foo()
}

Inlining wordt meestal gedaan voor kleine functies, waarbij de functieoproep overhead aanzienlijk is in vergelijking met de grootte van de functie.

Optimalisatie van lege basis

De grootte van elk object of lidsubobject moet minimaal 1 zijn, zelfs als het type een leeg class is (dat wil zeggen, een class of struct die geen niet-statische gegevensleden heeft), om te kunnen garanderen dat de adressen van afzonderlijke objecten van hetzelfde type zijn altijd verschillend.

Echter, base class zijn subobjecten niet zo beperkt, en kan volledig worden geoptimaliseerd uit het object lay-out:

#include <cassert>

struct Base {}; // empty class

struct Derived1 : Base {
    int i;
};

int main() {
    // the size of any object of empty class type is at least 1
    assert(sizeof(Base) == 1);

    // empty base optimization applies
    assert(sizeof(Derived1) == sizeof(int));
}

Optimalisatie van lege basissen wordt gewoonlijk gebruikt door allocator-bewuste standaardbibliotheekklassen ( std::vector , std::function , std::shared_ptr , enz.) Om te voorkomen dat er extra opslagruimte voor het allocatorlid wordt std::shared_ptr als de allocator stateloos is. Dit wordt bereikt door een van de vereiste gegevensleden op te slaan (bijv. begin , end of capacity voor de vector ).

Referentie: cppreference