C++内联函数性能分析

C++内联函数性能分析

内联函数通过在调用点展开函数体来消除函数调用开销。理解内联机制和使用场景对于编写高性能代码至关重要。

inline关键字建议编译器内联函数。

#include
#include

inline int add(int a, int b) {
return a + b;
}

inline int multiply(int a, int b) {
return a * b;
}

void inline_basic() {
int result1 = add(10, 20);
int result2 = multiply(5, 6);
std::cout << "Results: " << result1 << ", " << result2 << "\n";
}

类内定义的成员函数自动成为内联函数。

class Point {
int x_, y_;

public:
Point(int x, int y) : x_(x), y_(y) {}

int x() const { return x_; }
int y() const { return y_; }

int distance_squared() const {
return x_ * x_ + y_ * y_;
}
};

void implicit_inline() {
Point p(3, 4);
std::cout << "Distance squared: " << p.distance_squared() << "\n";
}

constexpr函数隐式内联。

constexpr int factorial(int n) {
return n <= 1 ? 1 : n * factorial(n - 1);
}

void constexpr_inline() {
constexpr int result = factorial(5);
std::cout << "Factorial: " << result << "\n";
}

内联函数可以减少函数调用开销。

int regular_function(int x) {
return x * x;
}

inline int inline_function(int x) {
return x * x;
}

void performance_comparison() {
const int iterations = 10000000;

auto start = std::chrono::high_resolution_clock::now();
volatile int result = 0;
for (int i = 0; i < iterations; ++i) {
result = regular_function(i);
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast(end - start);
std::cout << "Regular function: " << duration.count() << " ms\n";

start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < iterations; ++i) {
result = inline_function(i);
}
end = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast(end - start);
std::cout << "Inline function: " << duration.count() << " ms\n";
}

过度内联会增加代码大小。

inline void large_function() {
for (int i = 0; i < 100; ++i) {
std::cout << i << " ";
}
std::cout << "\n";
}

编译器可以忽略inline建议。

inline void complex_function(int n) {
if (n > 0) {
complex_function(n - 1);
}
}

__attribute__((always_inline))强制内联。

__attribute__((always_inline)) inline int force_inline(int x) {
return x * x;
}

__attribute__((noinline))禁止内联。

__attribute__((noinline)) int no_inline(int x) {
return x * x;
}

内联函数必须在头文件中定义。

template
inline T max_value(T a, T b) {
return a > b ? a : b;
}

内联是优化的重要手段，但应该根据函数大小和调用频率合理使用。