一、范围 for 循环的实战应用
1.1 范围 for 的语法结构（for (auto &elem : container)）
C++11 引入的范围 for 循环，为我们遍历容器和序列提供了一种简洁且高效的方式。其基本语法结构为for (auto &elem : container)，其中auto &elem表示声明一个变量elem，它的类型会根据container中元素的类型自动推导，&符号表示以引用的方式来访问元素，这样可以避免不必要的拷贝，提高效率；container则是需要遍历的容器或者序列，比如常见的std::vector、std::array、std::list等 STL 容器，甚至是普通的 C 风格数组。
下面通过一个简单的示例来展示其语法：
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (auto &num : numbers) {
num *= 2; // 直接修改容器中的元素
std::cout << num << " ";
}
return 0;
}在这个例子中，num以引用的方式遍历numbers容器中的每一个元素，对每个元素进行乘以 2 的操作，最后输出修改后的元素。如果不使用引用，只是for (auto num : numbers)，那么num只是容器中元素的一个拷贝，修改num并不会影响到容器中的实际元素。
再看一个遍历数组的例子：
#include <iostream>
int main() {
int arr[] = {10, 20, 30, 40, 50};
for (auto &value : arr) {
value += 10;
std::cout << value << " ";
}
return 0;
}这里通过范围 for 循环遍历了整数数组arr，对每个元素增加 10 并输出。可以看到，无论是 STL 容器还是普通数组，范围 for 循环的语法都非常简洁直观。
1.2 范围 for 的适用场景（遍历容器、数组、自定义序列）
- 遍历 STL 容器：在 STL 库中，范围 for 循环可以轻松遍历各种容器。例如，在std::map中查找特定键值对并处理对应的值：
#include <iostream>
#include <map>
#include <string>
int main() {
std::map<std::string, int> ageMap = {{"Alice", 30}, {"Bob", 25}, {"Charlie", 35}};
for (auto &pair : ageMap) {
if (pair.first == "Bob") {
pair.second += 1; // Bob年龄加1
std::cout << "Bob's new age: " << pair.second << std::endl;
}
}
return 0;
}- 遍历数组：对于 C 风格数组，范围 for 循环同样适用。比如统计数组中所有元素的和：
#include <iostream>
int main() {
int numbers[] = {1, 3, 5, 7, 9};
int sum = 0;
for (auto num : numbers) {
sum += num;
}
std::cout << "Sum of array elements: " << sum << std::endl;
return 0;
}- 遍历自定义序列：只要自定义类型定义了合适的begin()和end()函数，就可以使用范围 for 循环。例如，自定义一个简单的整数序列类：
#include <iostream>
#include <vector>
class MySequence {
private:
std::vector<int> data;
public:
MySequence() {
data = {100, 200, 300, 400, 500};
}
auto begin() {
return data.begin();
}
auto end() {
return data.end();
}
};
int main() {
MySequence seq;
for (auto value : seq) {
std::cout << value << " ";
}
return 0;
}在这些场景中，范围 for 循环大大简化了代码的编写，提高了代码的可读性，让开发者更专注于业务逻辑，而不是繁琐的迭代器操作。
1.3 范围 for 的使用限制（不能修改容器大小、不能获取迭代器）
- 不能修改容器大小：在范围 for 循环中，不允许修改正在遍历的容器大小。这是因为范围 for 循环是基于迭代器实现的，当容器大小改变时，迭代器可能会失效，从而导致未定义行为。例如：
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
// 错误示范，在范围for循环中修改容器大小
for (auto num : numbers) {
numbers.push_back(num * 2); // 试图向容器中添加元素
}
return 0;
}上述代码在编译时虽然可能不会报错，但运行时会出现未定义行为，因为在循环过程中向numbers容器添加元素，导致迭代器失效。
- 不能获取迭代器：范围 for 循环隐藏了迭代器的细节，在循环体内部无法直接获取当前元素的迭代器。如果需要使用迭代器进行一些特殊操作，比如删除当前元素并继续遍历，就无法直接使用范围 for 循环。例如，要删除std::vector中的所有偶数元素：
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
// 范围for循环无法直接实现删除操作
for (auto num : numbers) {
if (num % 2 == 0) {
// 这里无法获取迭代器来删除当前元素
}
}
return 0;
}在这种情况下，需要使用传统的基于迭代器的 for 循环来实现：
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (auto it = numbers.begin(); it != numbers.end(); ) {
if (*it % 2 == 0) {
it = numbers.erase(it); // 删除当前元素，并更新迭代器
} else {
++it;
}
}
for (auto num : numbers) {
std::cout << num << " ";
}
return 0;
}所以，在使用范围 for 循环时，需要清楚其局限性，根据具体需求选择合适的遍历方式。
二、C++11 智能指针增强
2.1 unique_ptr 的增强（移动语义支持、自定义删除器优化）
在 C++11 之前，指针的所有权转移往往需要手动处理，容易出错且繁琐。C++11 引入的unique_ptr很好地解决了这个问题，它支持移动语义，使得指针所有权的转移更加安全和高效。移动语义允许unique_ptr在不进行拷贝的情况下将资源的所有权从一个对象转移到另一个对象。例如：
#include <iostream>
#include <memory>
int main() {
std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
std::unique_ptr<int> ptr2;
ptr2 = std::move(ptr1); // 将ptr1的所有权转移给ptr2
if (!ptr1) {
std::cout << "ptr1 is null after move" << std::endl;
}
if (ptr2) {
std::cout << "ptr2 owns the resource: " << *ptr2 << std::endl;
}
return 0;
}在这个例子中，std::move(ptr1)将ptr1的所有权转移给ptr2，ptr1被置为空。这样，资源的所有权得到了安全转移，并且避免了不必要的拷贝操作，提高了效率。
unique_ptr还支持自定义删除器，这在管理一些非内存资源（如文件句柄、网络连接等）时非常有用。通过自定义删除器，可以指定当unique_ptr销毁时如何释放资源。例如，管理一个文件句柄：
#include <iostream>
#include <memory>
#include <fstream>
// 自定义删除器
void closeFile(std::ifstream* file) {
if (file->is_open()) {
file->close();
}
delete file;
}
int main() {
std::unique_ptr<std::ifstream, decltype(&closeFile)> filePtr(new std::ifstream("test.txt"), &closeFile);
if (filePtr) {
std::string line;
while (std::getline(*filePtr, line)) {
std::cout << line << std::endl;
}
}
return 0;
}在这个例子中，unique_ptr使用closeFile函数作为自定义删除器来关闭和释放文件句柄，确保文件在不再需要时被正确关闭，避免了资源泄漏。
2.2 shared_ptr 的增强（make_shared 函数、与 std::enable_shared_from_this）
make_shared函数是 C++11 为shared_ptr引入的一个重要增强。在传统方式中，创建一个shared_ptr需要先使用new分配内存，然后再将其传递给shared_ptr的构造函数，这涉及到两次内存分配（一次为对象本身，一次为控制块）。而make_shared函数则在一次内存分配中完成对象的创建和控制块的分配，减少了内存分配次数，提高了效率。例如：
#include <iostream>
#include <memory>
int main() {
// 传统方式创建shared_ptr
std::shared_ptr<int> ptr1(new int(10));
// 使用make_shared创建shared_ptr
std::shared_ptr<int> ptr2 = std::make_shared<int>(20);
return 0;
}在这个例子中，ptr2通过make_shared创建，相比ptr1的传统创建方式，减少了一次内存分配操作，在性能上更有优势。
std::enable_shared_from_this是一个模板类，它为shared_ptr管理的对象提供了一种安全的方式来获取指向自身的shared_ptr。当一个类继承自std::enable_shared_from_this时，它可以使用shared_from_this成员函数来返回一个指向自身的shared_ptr，这个shared_ptr与当前对象被管理的shared_ptr共享引用计数。例如：
#include <iostream>
#include <memory>
class MyClass : public std::enable_shared_from_this<MyClass> {
public:
std::shared_ptr<MyClass> getSharedPtr() {
return shared_from_this();
}
};
int main() {
std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();
std::shared_ptr<MyClass> anotherPtr = obj->getSharedPtr();
return 0;
}在这个例子中，如果MyClass不继承自std::enable_shared_from_this，直接在getSharedPtr函数中使用std::shared_ptr<MyClass>(this)返回指针，会导致创建一个新的独立的shared_ptr，与原来管理obj的shared_ptr没有共享引用计数，从而可能引发内存的重复释放等问题。而通过继承std::enable_shared_from_this并使用shared_from_this函数，可以安全地返回与外部shared_ptr共享引用计数的指针，确保对象生命周期的正确管理。
2.3 weak_ptr 的实际应用（解决循环引用、观察 shared_ptr）
在使用shared_ptr时，循环引用是一个常见的问题。当两个或多个对象通过shared_ptr相互引用时，会导致它们的引用计数永远不会降至零，从而造成内存泄漏。例如，在双向链表节点类中，如果两个节点都使用shared_ptr相互指向对方：
#include <iostream>
#include <memory>
class Node {
public:
std::shared_ptr<Node> next;
std::shared_ptr<Node> prev;
~Node() {
std::cout << "Node destroyed" << std::endl;
}
};
int main() {
std::shared_ptr<Node> node1 = std::make_shared<Node>();
std::shared_ptr<Node> node2 = std::make_shared<Node>();
node1->next = node2;
node2->prev = node1;
return 0;
}在上述代码中，node1和node2相互引用，当main函数结束时，node1和node2的引用计数都不会变为零，导致内存泄漏。
而weak_ptr可以解决这个问题。weak_ptr是一种弱引用，它不会增加对象的引用计数，主要用于观察shared_ptr所管理的对象。将其中一个引用改为weak_ptr，就可以打破循环引用：
#include <iostream>
#include <memory>
class Node {
public:
std::shared_ptr<Node> next;
std::weak_ptr<Node> prev;
~Node() {
std::cout << "Node destroyed" << std::endl;
}
};
int main() {
std::shared_ptr<Node> node1 = std::make_shared<Node>();
std::shared_ptr<Node> node2 = std::make_shared<Node>();
node1->next = node2;
node2->prev = node1;
return 0;
}在这个改进后的代码中，node2对node1的引用是weak_ptr，当main函数结束时，node1和node2的引用计数能够正确归零，对象被正常销毁，避免了内存泄漏。
weak_ptr还可以用于观察shared_ptr管理的资源。通过lock函数，weak_ptr可以尝试获取一个指向资源的shared_ptr，如果资源已经被释放，lock函数将返回一个空的shared_ptr。例如：
#include <iostream>
#include <memory>
int main() {
std::shared_ptr<int> sharedPtr = std::make_shared<int>(10);
std::weak_ptr<int> weakPtr = sharedPtr;
auto tempPtr = weakPtr.lock();
if (tempPtr) {
std::cout << "Resource is still valid: " << *tempPtr << std::endl;
} else {
std::cout << "Resource has been released" << std::endl;
}
sharedPtr.reset();
tempPtr = weakPtr.lock();
if (tempPtr) {
std::cout << "Resource is still valid: " << *tempPtr << std::endl;
} else {
std::cout << "Resource has been released" << std::endl;
}
return 0;
}在这个例子中，首先创建了一个shared_ptr和一个指向相同资源的weak_ptr，通过weak_ptr的lock函数获取shared_ptr并检查资源是否有效。当sharedPtr被重置后，再次调用lock函数，此时返回的shared_ptr为空，表明资源已被释放。这样，weak_ptr就可以在不影响资源生命周期的情况下，对shared_ptr管理的资源进行观察。
三、范围 for 与智能指针的实战技巧
3.1 范围 for 与 const 的结合（遍历不可修改元素）
在一些场景中，我们可能只需要遍历容器中的元素，而不希望对其进行修改，这时可以在范围 for 循环中使用const修饰变量。通过这种方式，我们可以确保在遍历过程中不会意外修改容器中的元素，提高代码的安全性和可读性。例如，遍历一个包含字符串的std::vector，并输出每个字符串：
#include <iostream>
#include <vector>
#include <string>
int main() {
std::vector<std::string> words = {"apple", "banana", "cherry"};
for (const auto &word : words) {
std::cout << word << " ";
}
return 0;
}在这个例子中，const auto &word表示word是一个常量引用，指向words容器中的每个元素。这样，在循环体中就无法对word进行修改，只能读取其值。如果尝试在循环体中修改word，比如word = “new_word”;，编译器会报错，提示不能对常量进行赋值操作。这种写法不仅可以保护容器中的数据不被意外修改，还能避免因不必要的拷贝而带来的性能开销，因为const引用可以直接访问容器中的元素，而无需进行拷贝。
3.2 智能指针在容器中的使用（避免内存泄漏）
将智能指针放入容器中是一种非常有效的避免内存泄漏的方法。在传统的 C++ 编程中，如果在容器中存放裸指针，当容器销毁或者元素被移除时，开发者需要手动释放指针所指向的内存，否则就会导致内存泄漏。而智能指针利用 RAII（Resource Acquisition Is Initialization）机制，在其生命周期结束时会自动释放所指向的内存，大大简化了内存管理。
例如，创建一个存放std::unique_ptr<int>的std::vector：
#include <iostream>
#include <memory>
#include <vector>
int main() {
std::vector<std::unique_ptr<int>> numbers;
numbers.push_back(std::make_unique<int>(10));
numbers.push_back(std::make_unique<int>(20));
numbers.push_back(std::make_unique<int>(30));
// 这里无需手动释放内存
return 0;
}在这个例子中，numbers容器中的每个元素都是std::unique_ptr<int>，当numbers容器销毁时，其中的std::unique_ptr<int>对象也会随之销毁，它们所指向的内存会被自动释放。即使在容器的生命周期内，某个元素被移除（例如通过erase操作），对应的std::unique_ptr<int>也会释放其指向的内存，确保不会发生内存泄漏。
同样，对于std::shared_ptr，多个std::shared_ptr可以共享同一个对象，并且只有当最后一个指向该对象的std::shared_ptr被销毁时，对象才会被释放。例如，创建一个存放std::shared_ptr<std::string>的std::list：
#include <iostream>
#include <memory>
#include <list>
#include <string>
int main() {
std::list<std::shared_ptr<std::string>> names;
names.push_back(std::make_shared<std::string>("Alice"));
names.push_back(std::make_shared<std::string>("Bob"));
names.push_back(std::make_shared<std::string>("Charlie"));
// 这里无需手动释放内存
return 0;
}在这个例子中，names容器中的每个元素都是std::shared_ptr<std::string>，当names容器销毁时，其中的std::shared_ptr<std::string>对象的引用计数会减少，当引用计数变为 0 时，对应的std::string对象会被自动释放，有效地避免了内存泄漏。
3.3 范围 for 与智能指针的结合（遍历智能指针容器）
当容器中存放智能指针时，我们可以使用范围 for 循环来遍历这个容器，同时方便地访问智能指针所指向的对象。例如，假设有一个类MyClass，创建一个存放std::shared_ptr<MyClass>的std::vector，并使用范围 for 循环遍历：
#include <iostream>
#include <memory>
#include <vector>
class MyClass {
public:
MyClass(int value) : data(value) {}
void printData() const {
std::cout << "Data: " << data << std::endl;
}
private:
int data;
};
int main() {
std::vector<std::shared_ptr<MyClass>> objects;
objects.push_back(std::make_shared<MyClass>(1));
objects.push_back(std::make_shared<MyClass>(2));
objects.push_back(std::make_shared<MyClass>(3));
for (const auto &ptr : objects) {
ptr->printData();
}
return 0;
}在这个例子中，objects是一个存放std::shared_ptr<MyClass>的std::vector。在范围 for 循环中，auto &ptr表示ptr是objects中每个std::shared_ptr<MyClass>的引用。通过ptr->printData()，我们可以方便地调用MyClass对象的成员函数，访问其成员变量。这种方式不仅简洁明了，而且充分利用了智能指针的自动内存管理机制和范围 for 循环的简洁性，使代码更加易读和健壮。如果MyClass对象在遍历过程中需要被修改，可以去掉const修饰，直接在循环体中通过ptr来修改对象的状态。
四、实战项目：智能指针管理的对象集合
4.1 项目需求（动态创建对象、用智能指针存储、范围 for 遍历）
假设我们正在开发一个简单的游戏对象管理系统，需要动态创建各种游戏对象，如角色、道具等。为了确保内存的安全管理，我们决定使用智能指针来存储这些对象。同时，为了方便遍历和操作这些游戏对象，我们将使用范围 for 循环。具体需求如下：
- 动态创建对象：根据游戏的逻辑和玩家的操作，在运行时动态创建不同类型的游戏对象。例如，当玩家进入新的场景时，创建新的角色和道具对象。
- 用智能指针存储：使用std::shared_ptr来存储游戏对象，因为多个部分的游戏逻辑可能需要访问和操作同一个对象，std::shared_ptr可以方便地实现对象的共享所有权。
- 范围 for 遍历：在游戏的更新循环中，需要遍历所有的游戏对象，对它们进行状态更新、绘制等操作。使用范围 for 循环可以简洁地实现这一功能，提高代码的可读性和可维护性。
4.2 智能指针容器与范围 for 实现对象管理
首先，定义一个基类GameObject，作为所有游戏对象的基类，然后派生出具体的游戏对象类，如Character和Item。使用std::vector<std::shared_ptr<GameObject>>来存储这些游戏对象，并通过范围 for 循环实现对象的创建、管理和遍历。
#include <iostream>
#include <memory>
#include <vector>
// 游戏对象基类
class GameObject {
public:
virtual void update() = 0;
virtual void draw() = 0;
virtual ~GameObject() = default;
};
// 角色类
class Character : public GameObject {
public:
Character(const std::string& name) : m_name(name) {}
void update() override {
std::cout << m_name << " is updating." << std::endl;
}
void draw() override {
std::cout << m_name << " is drawing." << std::endl;
}
private:
std::string m_name;
};
// 道具类
class Item : public GameObject {
public:
Item(const std::string& name) : m_name(name) {}
void update() override {
std::cout << m_name << " item is updating." << std::endl;
}
void draw() override {
std::cout << m_name << " item is drawing." << std::endl;
}
private:
std::string m_name;
};
int main() {
// 使用智能指针容器存储游戏对象
std::vector<std::shared_ptr<GameObject>> gameObjects;
// 动态创建角色对象
gameObjects.push_back(std::make_shared<Character>("Warrior"));
gameObjects.push_back(std::make_shared<Character>("Mage"));
// 动态创建道具对象
gameObjects.push_back(std::make_shared<Item>("Health Potion"));
gameObjects.push_back(std::make_shared<Item>("Magic Scroll"));
// 使用范围for循环遍历并更新游戏对象
for (const auto& obj : gameObjects) {
obj->update();
}
// 使用范围for循环遍历并绘制游戏对象
for (const auto& obj : gameObjects) {
obj->draw();
}
return 0;
}在上述代码中，gameObjects是一个std::vector<std::shared_ptr<GameObject>>类型的容器，用于存储各种游戏对象的智能指针。通过std::make_shared动态创建Character和Item对象，并将它们添加到容器中。在更新和绘制阶段，使用范围 for 循环遍历容器，调用每个游戏对象的update和draw方法，实现了对游戏对象的有效管理和操作。
4.3 内存泄漏检测与遍历效率测试
为了确保项目中没有内存泄漏，我们可以使用工具如Valgrind（在 Linux 平台）或Visual Leak Detector（在 Windows 平台）。以Valgrind为例，使用以下步骤进行内存泄漏检测：
- 安装 Valgrind：在 Linux 系统中，可以使用包管理器进行安装，如sudo apt-get install valgrind（对于基于 Debian 或 Ubuntu 的系统）。
- 编译项目：在编译项目时，需要添加调试信息，以便Valgrind能够更准确地报告内存泄漏的位置。例如，使用g++ -g -O0 -o game game.cpp进行编译，其中-g表示生成调试信息，-O0表示不进行优化。
- 运行检测：运行Valgrind对编译后的可执行文件进行检测，命令为valgrind --leak-check=full./game。–leak-check=full表示进行全面的内存泄漏检测。
在效率测试方面，我们可以对比范围 for 循环和传统的基于迭代器的 for 循环遍历智能指针容器的效率。通过多次运行测试代码，记录每种遍历方式的执行时间，分析测试结果。以下是一个简单的效率测试示例代码：
#include <iostream>
#include <memory>
#include <vector>
#include <chrono>
class DummyObject {
public:
DummyObject() = default;
~DummyObject() = default;
};
void testRangeForLoop(const std::vector<std::shared_ptr<DummyObject>>& objects) {
auto start = std::chrono::high_resolution_clock::now();
for (const auto& obj : objects) {
// 模拟一些操作
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
std::cout << "Range for loop duration: " << duration << " microseconds" << std::endl;
}
void testIteratorForLoop(const std::vector<std::shared_ptr<DummyObject>>& objects) {
auto start = std::chrono::high_resolution_clock::now();
for (auto it = objects.begin(); it != objects.end(); ++it) {
// 模拟一些操作
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
std::cout << "Iterator for loop duration: " << duration << " microseconds" << std::endl;
}
int main() {
std::vector<std::shared_ptr<DummyObject>> testObjects;
for (int i = 0; i < 1000000; ++i) {
testObjects.push_back(std::make_shared<DummyObject>());
}
testRangeForLoop(testObjects);
testIteratorForLoop(testObjects);
return 0;
}通过运行上述测试代码，可以得到范围 for 循环和传统迭代器 for 循环遍历相同数量智能指针的时间消耗。通常情况下，范围 for 循环由于其简洁的语法和编译器的优化，在遍历效率上与传统迭代器 for 循环相当，甚至在某些情况下略胜一筹，特别是在代码可读性和编写便利性方面具有明显优势。通过内存泄漏检测和遍历效率测试，可以确保项目在内存管理和性能方面都能满足要求。
浙公网安备 33010602011771号