C++提供的智能指针 unique_ptr、shared_ptr、weak_ptr
flyfish
C++提供的智能指针 unique_ptr、shared_ptr、weak_ptr
- C++提供的智能指针 unique_ptr、shared_ptr、weak_ptr
- 曾经的代码是这样写的
- 示例
- 1. `std::unique_ptr`
- 2. `std::shared_ptr`
- 3. `std::weak_ptr`
- 循环引用 (写一个错误的例子和正确的例子)
- 循环引用示例 错误的例子
- 循环引用示例 正确的例子
- 对于 `std::vector` 存储的原始指针,需要手动遍历并调用 `delete` 释放内存
- 示例
- 对于 `std::vector` 存储的智能指针,智能指针会自动管理对象的生命周期
- enable_shared_from_this 和 shared_from_this
- expired 的作用
- `std::shared_ptr` :引用计数是线程安全的,但对对象的访问和修改需要额外的同步
- `td::unique_ptr`:不是线程安全的,不能在多个线程之间共享
- `std::weak_ptr` :调用 `lock` 方法是线程安全的,但对对象的访问和修改需要额外的同步
曾经的代码是这样写的
delete
用于释放通过 new
分配的单个对象。
delete[]
用于释放通过 new[]
分配的数组。
单个对象的分配和释放 :
int* p = new int; // 分配单个int对象
delete p; // 释放单个int对象
数组的分配和释放 :
int* arr = new int[10]; // 分配包含10个int的数组
delete[] arr; // 释放数组
示例
#include <iostream>class MyClass {
public:MyClass() { std::cout << "MyClass created" << std::endl; }~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};int main() {// 分配和释放单个对象MyClass* obj = new MyClass;delete obj;// 分配和释放数组MyClass* arr = new MyClass[3];delete[] arr;return 0;
}
C++标准库提供了几种智能指针
-
std::unique_ptr
:独占所有权智能指针(Unique Ownership Smart Pointer) -
std::shared_ptr
:共享所有权智能指针(Shared Ownership Smart Pointer) -
std::weak_ptr
:弱引用智能指针(Weak Reference Smart Pointer)
1. std::unique_ptr
std::unique_ptr
是一种独占所有权的智能指针,意味着同一时间只有一个 std::unique_ptr
拥有某个对象的所有权。它在离开作用域时会自动释放所管理的对象。
使用场景 :
独占所有权:当一个对象只能有一个所有者时,使用 std::unique_ptr
。
高效转移所有权:通过 std::move
可以高效地转移 std::unique_ptr
的所有权。
示例代码 :
#include <memory>
#include <iostream>class MyClass {
public:MyClass() { std::cout << "MyClass created" << std::endl; }~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};int main() {std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();// std::unique_ptr<MyClass> ptr2 = ptr1; // 错误:无法复制std::unique_ptr<MyClass> ptr2 = std::move(ptr1); // 合法:转移所有权return 0;
}
2. std::shared_ptr
std::shared_ptr
是一种共享所有权的智能指针,意味着多个 std::shared_ptr
可以同时指向同一个对象。对象的生存期由引用计数(reference count)管理,当最后一个 std::shared_ptr
被销毁时,引用计数归零,对象也被销毁。
使用场景 :
共享所有权:当多个对象需要共享同一资源时,使用 std::shared_ptr
。
示例代码 :
#include <memory>
#include <iostream>class MyClass {
public:MyClass() { std::cout << "MyClass created" << std::endl; }~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};int main() {std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();std::shared_ptr<MyClass> ptr2 = ptr1; // 合法:共享所有权std::cout << "Reference count: " << ptr1.use_count() << std::endl; // 引用计数为2return 0;
}
3. std::weak_ptr
std::weak_ptr
是一种不控制对象生存期的智能指针,它指向一个由 std::shared_ptr
管理的对象,但不增加引用计数。std::weak_ptr
主要用于解决循环引用问题。
使用场景 :
弱引用:当需要访问一个由 std::shared_ptr
管理但不应该延长其生存期的对象时,使用 std::weak_ptr
。
防止循环引用:在某些数据结构(如双向链表、图)中使用,以避免循环引用导致的内存泄漏。
示例代码 :
#include <memory>
#include <iostream>class MyClass {
public:MyClass() { std::cout << "MyClass created" << std::endl; }~MyClass() { std::cout << "MyClass destroyed" << std::endl; }std::weak_ptr<MyClass> ptr; // 使用 weak_ptr 打破循环引用
};int main() {std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();std::shared_ptr<MyClass> ptr2 = std::make_shared<MyClass>();// 使用 lock() 方法来从 weak_ptr 获取 shared_ptrptr1->ptr = ptr2; // ptr1->ptr 仍然是 weak_ptr,但这里存储的是 ptr2 的 shared_ptrptr2->ptr = ptr1; // ptr2->ptr 也是 weak_ptr,但这里存储的是 ptr1 的 shared_ptr// 这里需要将 weak_ptr 转换成 shared_ptr,以便可以访问 MyClass 的成员if (auto lockedPtr1 = ptr1->ptr.lock()) {std::cout << "ptr1's ptr is locked and points to: " << lockedPtr1.get() << std::endl;} else {std::cout << "ptr1's ptr is expired." << std::endl;}if (auto lockedPtr2 = ptr2->ptr.lock()) {std::cout << "ptr2's ptr is locked and points to: " << lockedPtr2.get() << std::endl;} else {std::cout << "ptr2's ptr is expired." << std::endl;}return 0;
}
输出
MyClass created
MyClass created
ptr1's ptr is locked and points to: 000001E5FCA463B0
ptr2's ptr is locked and points to: 000001E5FCA467D0
MyClass destroyed
MyClass destroyed
循环引用 (写一个错误的例子和正确的例子)
循环引用(cyclic reference)发生在两个或多个对象互相持有对方的引用,导致这些对象无法被正确释放。这种情况通常会导致内存泄漏。使用 std::shared_ptr
管理对象时,容易出现循环引用问题。
循环引用示例 错误的例子
以下是一个简单的循环引用示例:
#include <iostream>
#include <memory>class B; // 前向声明class A {
public:std::shared_ptr<B> ptrB;~A() { std::cout << "A destroyed" << std::endl; }
};class B {
public:std::shared_ptr<A> ptrA;~B() { std::cout << "B destroyed" << std::endl; }
};int main() {std::shared_ptr<A> a = std::make_shared<A>();std::shared_ptr<B> b = std::make_shared<B>();a->ptrB = b;b->ptrA = a;return 0; // 循环引用导致 A 和 B 不会被正确释放
}
创建了两个类 A 和 B,并且它们之间存在循环引用。A 类包含一个指向 B 类的 std::shared_ptr,而 B 类也包含一个指向 A 类的 std::shared_ptr。这会导致循环引用问题,使得 A 和 B 的实例都无法被正确销毁,因为它们互相保持着对彼此的引用。,a
和 b
互相持有对方的 shared_ptr
,导致引用计数永远不会归零,从而导致内存泄漏。
循环引用示例 正确的例子
解决循环引用:使用 std::weak_ptr``std::weak_ptr
是一种不增加引用计数的智能指针,可以打破循环引用。以下是修正后的示例:
#include <iostream>
#include <memory>class B;class A {
public:std::shared_ptr<B> ptrB;~A() { std::cout << "A destroyed" << std::endl; }
};class B {
public:std::weak_ptr<A> ptrA; // 使用 weak_ptr 打破循环引用~B() { std::cout << "B destroyed" << std::endl; }
};int main() {std::shared_ptr<A> a = std::make_shared<A>();std::shared_ptr<B> b = std::make_shared<B>();a->ptrB = b;b->ptrA = a;return 0; // A 和 B 会被正确释放
}
输出
A destroyed
B destroyed
对于 std::vector
存储的原始指针,需要手动遍历并调用 delete
释放内存
如果 std::vector
存储的是通过 new
分配的原始指针,必须手动释放这些对象。可以通过循环遍历 vector
来删除所有指针指向的对象,然后清空 vector
。
示例
#include <vector>
#include <iostream>class MyClass {
public:MyClass() { std::cout << "MyClass created" << std::endl; }~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};int main() {std::vector<MyClass*> vec;vec.push_back(new MyClass());vec.push_back(new MyClass());// 释放内存for (MyClass* ptr : vec) {delete ptr;}vec.clear();return 0;
}
在这个例子中,手动遍历 vector
,对每个指针调用 delete
来释放内存,然后清空 vector
。std::vector
中装智能指针
对于 std::vector
存储的智能指针,智能指针会自动管理对象的生命周期
如果 std::vector
存储的是智能指针(如 std::unique_ptr
或 std::shared_ptr
),智能指针会自动管理对象的生命周期,当 vector
被销毁时,智能指针会自动释放所管理的对象,无需手动释放。
#include <vector>
#include <memory>
#include <iostream>class MyClass {
public:MyClass() { std::cout << "MyClass created" << std::endl; }~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};int main() {std::vector<std::unique_ptr<MyClass>> vec;vec.push_back(std::make_unique<MyClass>());vec.push_back(std::make_unique<MyClass>());// 当 vec 被销毁时,存储的 unique_ptr 会自动释放 MyClass 对象return 0;
}
输出
MyClass created
MyClass created
MyClass destroyed
MyClass destroyed
在这个例子中,std::unique_ptr
会在 vector
作用域结束时自动释放内存。使用 std::shared_ptr
#include <vector>
#include <memory>
#include <iostream>class MyClass {
public:MyClass() { std::cout << "MyClass created" << std::endl; }~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};int main() {std::vector<std::shared_ptr<MyClass>> vec;vec.push_back(std::make_shared<MyClass>());vec.push_back(std::make_shared<MyClass>());// 当 vec 被销毁时,存储的 shared_ptr 会自动管理 MyClass 对象的生命周期return 0;
}
输出
MyClass created
MyClass created
MyClass destroyed
MyClass destroyed
在这个例子中,std::shared_ptr
会在 vector
作用域结束时自动释放内存,只要没有其他 shared_ptr
仍然指向相同的对象。
enable_shared_from_this 和 shared_from_this
enable_shared_from_this 和 shared_from_this 提供了一种安全生成 shared_ptr 的方式
std::enable_shared_from_this 是一个帮助类,允许对象安全地生成指向自身的 std::shared_ptr。
安全地创建 shared_ptr:通过 enable_shared_from_this,可以确保在类成员函数中安全地生成指向当前对象的 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();}~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};int main() {std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();std::shared_ptr<MyClass> obj2 = obj->getSharedPtr();std::cout << "obj use count: " << obj.use_count() << std::endl; // 输出 2std::cout << "obj2 use count: " << obj2.use_count() << std::endl; // 输出 2return 0;
}
输出
obj use count: 2
obj2 use count: 2
MyClass destroyed
expired 的作用
expired 是 std::weak_ptr 类中的一个成员函数,用来检查 weak_ptr 指向的对象是否已经被销毁。std::weak_ptr 是一种不拥有对象的指针,它可以观察一个由 std::shared_ptr 管理的对象,但不会影响对象的生命周期。
expired 返回一个布尔值,如果 std::weak_ptr 指向的对象已经被销毁(引用计数为零),它返回 true;否则返回 false。
使用 expired 检查对象是否仍然存在
使用 expired 可以检查 std::weak_ptr 指向的对象是否仍然存在。如果对象已经被销毁,可以避免对一个无效的对象进行操作。
示例代码
以下是一个使用 std::weak_ptr 和 expired 的示例,展示了如何避免循环引用和检查对象的有效性
#include <iostream>
#include <memory>class MyClass {
public:MyClass() { std::cout << "MyClass created" << std::endl; }~MyClass() { std::cout << "MyClass destroyed" << std::endl; }std::weak_ptr<MyClass> ptr; // 使用 weak_ptr 打破循环引用
};int main() {{// 创建两个 shared_ptrauto ptr1 = std::make_shared<MyClass>();auto ptr2 = std::make_shared<MyClass>();// 互相引用对方的 shared_ptrptr1->ptr = ptr2;ptr2->ptr = ptr1;// 检查 ptr1 和 ptr2 指向的对象是否仍然存在if (ptr1->ptr.expired()) {std::cout << "ptr1's ptr is expired." << std::endl;} else {std::cout << "ptr1's ptr is still valid." << std::endl;}if (ptr2->ptr.expired()) {std::cout << "ptr2's ptr is expired." << std::endl;} else {std::cout << "ptr2's ptr is still valid." << std::endl;}} // 这里 ptr1 和 ptr2 超出作用域,被销毁// 此时 ptr1 和 ptr2 所指向的对象已经被销毁// 所有 MyClass 对象都已经被销毁,析构函数已经被调用return 0;
}
std::shared_ptr
:引用计数是线程安全的,但对对象的访问和修改需要额外的同步
当需要多个线程共享对象的所有权,确保对象在有线程使用时不会被销毁,不存在循环引用的风险,多线程里可以用std::shared_ptr。
例子
#include <iostream>
#include <memory>
#include <thread>
#include <vector>void threadFunction(std::shared_ptr<int> sharedPtr) {std::this_thread::sleep_for(std::chrono::milliseconds(100));std::cout << "Value: " << *sharedPtr << std::endl;
}int main() {std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);std::vector<std::thread> threads;for (int i = 0; i < 10; ++i) {threads.push_back(std::thread(threadFunction, sharedPtr));}for (auto& t : threads) {t.join();}return 0;
}
td::unique_ptr
:不是线程安全的,不能在多个线程之间共享
std::unique_ptr 不是线程安全的。因为 std::unique_ptr 不能被复制,只能被移动,这意味着同一时间只能有一个线程拥有该指针的所有权。如果需要在多个线程中共享所有权,应该使用 std::shared_ptr。
std::weak_ptr
:调用 lock
方法是线程安全的,但对对象的访问和修改需要额外的同步
当需要避免循环引用,线程只需要观察对象的生命周期,而不需要拥有对象,需要临时访问对象,而不需要延长对象的生命周期,多线程中用std::weak_ptr。
#include <iostream>
#include <memory>
#include <thread>
#include <vector>void threadFunction(std::weak_ptr<int> weakPtr) {std::this_thread::sleep_for(std::chrono::milliseconds(100));if (auto sharedPtr = weakPtr.lock()) {std::cout << "Value: " << *sharedPtr << std::endl;} else {std::cout << "Object has been destroyed." << std::endl;}
}int main() {std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);std::weak_ptr<int> weakPtr = sharedPtr;std::vector<std::thread> threads;for (int i = 0; i < 10; ++i) {threads.push_back(std::thread(threadFunction, weakPtr));}for (auto& t : threads) {t.join();}sharedPtr.reset(); // 销毁对象return 0;
}