在C++项目开发中，算法效率是决定程序整体性能的核心因素之一，很多看似功能正常的算法，在大数据量场景下会出现运行缓慢、资源占用过高的问题，掌握实用的效率提升技巧能有效解决这类问题。
选择合适的数据结构
数据结构的特性直接影响算法的时间复杂度，需要根据操作场景选择最匹配的结构。比如频繁插入删除的场景优先使用std::list或std::forward_list，频繁随机访问的场景使用std::vector，需要快速查找的场景使用std::unordered_map而非std::map。
以下是一个简单的查找场景对比示例，使用哈希表比有序映射的查找效率更高：
#include <iostream>
#include <map>
#include <unordered_map>
#include <chrono>
int main() {
// 有序映射存储数据
std::map<int, int> ordered_map;
// 哈希表存储数据
std::unordered_map<int, int> hash_map;
// 插入100000条数据
for (int i = 0; i < 100000; ++i) {
ordered_map[i] = i * 2;
hash_map[i] = i * 2;
}
auto start = std::chrono::high_resolution_clock::now();
// 有序映射查找
for (int i = 0; i < 100000; ++i) {
auto it = ordered_map.find(i);
}
auto end = std::chrono::high_resolution_clock::now();
auto ordered_time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
start = std::chrono::high_resolution_clock::now();
// 哈希表查找
for (int i = 0; i < 100000; ++i) {
auto it = hash_map.find(i);
}
end = std::chrono::high_resolution_clock::now();
auto hash_time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
std::cout << "有序映射查找耗时: " << ordered_time.count() << "ms" << std::endl;
std::cout << "哈希表查找耗时: " << hash_time.count() << "ms" << std::endl;
return 0;
}
循环优化技巧
循环是算法中执行频率最高的部分，优化循环能带来显著的性能提升。
减少循环内重复计算
将循环内不随迭代变化的计算移到循环外部，避免每次迭代都重复执行。比如获取容器大小的操作，如果在循环中不会修改容器，就提前保存大小值。
#include <vector>
#include <iostream>
int main() {
std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = 0;
// 优化前：每次循环都调用size()
for (int i = 0; i < nums.size(); ++i) {
sum += nums[i];
}
sum = 0;
// 优化后：提前保存size()
int size = nums.size();
for (int i = 0; i < size; ++i) {
sum += nums[i];
}
return 0;
}
循环展开
对于简单的循环逻辑，可以适当展开循环减少迭代次数，降低循环控制的开销。不过现代编译器开启优化后可能会自动处理，手动展开适合对性能要求极高的场景。
#include <vector>
int main() {
std::vector<int> nums(1000, 1);
int sum = 0;
// 普通循环
for (int i = 0; i < 1000; ++i) {
sum += nums[i];
}
sum = 0;
// 循环展开，每次处理4个元素
for (int i = 0; i < 1000; i += 4) {
sum += nums[i];
sum += nums[i + 1];
sum += nums[i + 2];
sum += nums[i + 3];
}
return 0;
}
内存访问优化
C++中内存访问的效率差异很大，连续内存的访问速度远快于离散内存。
优先使用连续内存容器
比如std::vector的内存是连续的，遍历速度比std::list快很多，因为std::list的每个节点是离散分配的，缓存命中率低。如果只是需要顺序遍历，优先选择std::vector。
避免频繁的动态内存分配
动态内存分配（比如new操作）的开销比较大，频繁分配释放会导致性能下降。可以提前预留容器空间，比如使用std::vector的reserve方法，避免插入元素时频繁重新分配内存。
#include <vector>
int main() {
std::vector<int> v1;
// 未预留空间，插入元素时会多次重新分配内存
for (int i = 0; i < 10000; ++i) {
v1.push_back(i);
}
std::vector<int> v2;
// 提前预留空间，减少内存分配次数
v2.reserve(10000);
for (int i = 0; i < 10000; ++i) {
v2.push_back(i);
}
return 0;
}
利用编译器优化特性
现代C++编译器提供了很多优化选项，合理使用能提升算法效率。
开启合适的优化等级
在编译时开启-O2或-O3优化等级，编译器会自动进行循环优化、内联函数展开、常量折叠等优化操作。比如GCC编译时添加-O2参数：g++ -O2 main.cpp -o main。
使用内联函数
对于频繁调用的小函数，可以使用inline关键字建议编译器将其内联展开，减少函数调用的开销。不过现代编译器会自动判断是否需要内联，手动添加inline只是建议。
#include <iostream>
// 内联函数，计算平方
inline int square(int x) {
return x * x;
}
int main() {
int a = 5;
// 调用内联函数，编译器可能会直接展开为 a * a
int result = square(a);
std::cout << result << std::endl;
return 0;
}
避免不必要的拷贝
对象拷贝会带来额外的性能开销，尤其是在处理大对象时。可以使用引用、移动语义来减少拷贝。
比如函数参数使用const引用传递大对象，避免值传递的拷贝；使用std::move转移对象所有权，避免临时对象的拷贝。
#include <vector>
#include <iostream>
// 使用const引用传递，避免拷贝大vector
void process_vector(const std::vector<int>& vec) {
for (int num : vec) {
// 处理逻辑
}
}
int main() {
std::vector<int> large_vec(100000, 1);
// 传递引用，无拷贝开销
process_vector(large_vec);
std::vector<int> vec1 = {1, 2, 3};
// 使用移动语义，转移所有权，避免拷贝
std::vector<int> vec2 = std::move(vec1);
return 0;
}