Warum ist der virtuelle + indirekte Funktionsaufruf schneller als ein virtueller oder ein indirekter Funktionsaufruf? ⇐ C++

[Anonymous]

Ich habe versucht, die Kosten einer Indirektion zu messen, da das Stapeln von Indirektionen übereinander die Leistung speziell abbauen sollte. /> Virtuelle Funktionsaufruf. Code < /p>

Code: Select all

#include 
#include 
#include 
#include 
#include 

static int foo(int a, std::vector& v) {
v.push_back(a);
if (v.size() > 2)
{
v.clear();
}
return a;
}

struct IFooable
{
virtual int foo(int a) = 0;
};

__declspec(dllimport) int foo2(int a, std::vector& v);

__declspec(dllimport) int direct_version(std::vector& v);

__declspec(dllimport) int indirect_version(int (*fn)(int, void*), void* p);

__declspec(dllimport) int indirect_Interface(IFooable& f);

struct MyFoo final: public IFooable
{
int foo(int a) override
{
return ::foo(a, v);
}
MyFoo(std::vector& v) : v{ v } {}
std::vector& v;
};

struct MyFoo2 final : public IFooable
{
using functype = int (*)(int, std::vector&);
int foo(int a) override
{
return f(a, v);
}
MyFoo2(std::vector& v, functype f) : v{ v }, f{ f } {}
std::vector& v;
functype f;
};

int main(int argc, char* argv[]) {
std::vector v;
for (int i = 0; i < 20; i++)
{
foo(i, v);
}

std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();

direct_version(v);
std::chrono::steady_clock::time_point end1 = std::chrono::steady_clock::now();

indirect_version([](int a, void* p) {return foo(a, *reinterpret_cast(p)); }, reinterpret_cast(&v));
std::chrono::steady_clock::time_point end2 = std::chrono::steady_clock::now();

MyFoo ff{ v };
indirect_Interface(ff);
std::chrono::steady_clock::time_point end3 = std::chrono::steady_clock::now();
MyFoo2 ff2{ v, foo2 };
indirect_Interface(ff2);
std::chrono::steady_clock::time_point end4 = std::chrono::steady_clock::now();

std::cout