C++ 函数语义学——函数调用与继承关系性能-CSDN博客

本文链接：https://blog.csdn.net/qq_68194402/article/details/141113950

函数调用与继承关系性能

- 函数调用与继承关系性能

1. 函数调用中编译器的循环代码优化

在函数调用中，编译器可以通过多种优化技术来提高代码的执行效率，特别是在循环中。以下是一些常见的优化技术：

循环展开：通过减少循环控制变量的更新次数来减少循环的开销。例如，将一个循环展开成多个循环体的重复，以减少循环控制的开销。

// 原始代码
for (int i = 0; i < 100; ++i) {
    a[i] = b[i] + c[i];
}

// 循环展开后的代码
for (int i = 0; i < 100; i += 4) {
    a[i] = b[i] + c[i];
    a[i+1] = b[i+1] + c[i+1];
    a[i+2] = b[i+2] + c[i+2];
    a[i+3] = b[i+3] + c[i+3];
}

循环合并：将多个循环合并为一个循环，以减少循环控制的开销。

// 原始代码
for (int i = 0; i < 100; ++i) {
    a[i] = b[i] + c[i];
}
for (int i = 0; i < 100; ++i) {
    d[i] = e[i] + f[i];
}

// 循环合并后的代码
for (int i = 0; i < 100; ++i) {
    a[i] = b[i] + c[i];
    d[i] = e[i] + f[i];
}

循环分裂：将一个复杂的循环分裂为多个简单的循环，以提高缓存命中率和并行执行的可能性。

// 原始代码
for (int i = 0; i < 100; ++i) {
    a[i] = b[i] + c[i];
    d[i] = e[i] + f[i];
}

// 循环分裂后的代码
for (int i = 0; i < 100; ++i) {
    a[i] = b[i] + c[i];
}
for (int i = 0; i < 100; ++i) {
    d[i] = e[i] + f[i];
}

2. 继承关系深度增加，开销也增加

在面向对象编程中，继承关系的深度会影响程序的性能。继承关系越深，类的层次结构越复杂，以下是一些可能的性能开销：

对象构造和析构：每个类的构造函数和析构函数都会被调用，继承关系越深，调用的次数越多。

class A {
public:
    A() { std::cout << "A constructor" << std::endl; }
    virtual ~A() { std::cout << "A destructor" << std::endl; }
};

class B : public A {
public:
    B() { std::cout << "B constructor" << std::endl; }
    ~B() { std::cout << "B destructor" << std::endl; }
};

class C : public B {
public:
    C() { std::cout << "C constructor" << std::endl; }
    ~C() { std::cout << "C destructor" << std::endl; }
};

int main() {
    C c;
    return 0;
}

输出结果：

A constructor
B constructor
C constructor
C destructor
B destructor
A destructor

成员变量的初始化：每个类的成员变量都需要初始化，继承关系越深，初始化的成员变量越多。

class A {
public:
    A() : a(0) { }
private:
    int a;
};

class B : public A {
public:
    B() : b(0) { }
private:
    int b;
};

class C : public B {
public:
    C() : c(0) { }
private:
    int c;
};

函数调用开销：在多层继承中，函数调用可能需要经过多个中间类的转发，增加了调用的开销。

class A {
public:
    virtual void func() { std::cout << "A::func" << std::endl; }
};

class B : public A {
public:
    void func() override { std::cout << "B::func" << std::endl; }
};

class C : public B {
public:
    void func() override { std::cout << "C::func" << std::endl; }
};

int main() {
    C c;
    A* a = &c;
    a->func(); // 调用 C::func
    return 0;
}

3. 继承关系深度增加，虚函数导致的开销增加

虚函数是实现多态性的重要机制，但它也会带来一定的性能开销，特别是在继承关系深度增加时：

虚函数表查找：每次调用虚函数时，程序需要通过虚指针（vptr）查找虚函数表（vtable），继承关系越深，查找的开销越大。

class A {
public:
    virtual void func() { std::cout << "A::func" << std::endl; }
};

class B : public A {
public:
    void func() override { std::cout << "B::func" << std::endl; }
};

class C : public B {
public:
    void func() override { std::cout << "C::func" << std::endl; }
};

int main() {
    C c;
    A* a = &c;
    a->func(); // 调用 C::func
    return 0;
}

缓存命中率降低：复杂的继承关系和频繁的虚函数调用可能导致缓存命中率降低，从而影响性能。

内存占用增加：每个多态类对象都需要存储一个虚指针（vptr），继承关系越深，虚指针的数量越多，内存占用也会增加。

class A {
public:
    virtual void func() { }
private:
    int a;
};

class B : public A {
public:
    void func() override { }
private:
    int b;
};

class C : public B {
public:
    void func() override { }
private:
    int c;
};