文章目录
- 1、智能指针简介
- 1.1 原始指针（raw pointer）的⼀些问题
- 1.2 智能指针（smart pointers）
- 2、智能指针（smart pointers）——unique_ptr
- 2.1 unique_ptr 的声明
- 2.2 unique_ptr 的函数
- 2.3 ⾃定义类型使⽤ unique_ptr
- 2.4 unique_ptr 不⽀持拷⻉、赋值
- 2.5 使⽤make_unique初始化（C++14标准）
- 代码：
- 3、智能指针（smart pointers）——shared_ptr
- 3.1 shared_ptr的声明
- 3.2 shared_ptr的函数
- 3.3 ⾃定义类型使⽤shared_ptr
- 3.4 vector和复制操作
- 3.5 使⽤make_shared初始化（C++11标注）
- 代码：
1、智能指针简介
1.1 原始指针（raw pointer）的⼀些问题
• C++ 提供了内存管理的绝对⾃由度
------->• 分配
------->• 释放
------->• 声明周期管理
•⼀些潜在严重问题
------->• 未初始化的指针（wild pointer），也就是野指针，可指向内存的任何位置
------->• 内存泄漏（memory leak），可能因为没有及时释放分配的内存空间
------->• 悬空指针（dangling pointer）：指针指向已经释放的对象
• 所有权（ownership），引入智能指针
------->• 谁拥有指针？
------->• 何时可以删除指针？
1.2 智能指针（smart pointers）
• 也是对象
• 只能指向堆上分配的内存
• ⽤完后会⾃动删除
• 遵循RAII（资源获取即初始化）原则，对资源的申请释放，是一种成对操作的封装
• 几种C++ 智能指针：
------->• Unique pointers (unique_ptr)
------->• Shared pointers (shared_ptr)
------->• Weak pointers (weak_ptr)
------->• Auto pointers (auto_ptr) （已弃⽤）
- 导入 #include <memory>
- 在类模板（class templates）中定义
- 对原始指针做了封装
- 重载的操作符
- 解引⽤（*）
- 成员选择（->）
- 不⽀持算数操作符（++, — —等）
创建智能指针的具体实例如下，smart_pointer 可以换成上面提到的 unique_ptr，shared_ptr，weak_ptr，ptr 是指向 Type 类别的智能指针，当运行完 {} 里面的程序时，会自动调用析构函数，会帮助我们处理堆上分配的内存空间，
2、智能指针（smart pointers）——unique_ptr
- unique_ptr<T> ptr_name
- 指向heap堆上类型 T 的对象
- 唯⼀（unique），多个 unique_ptr 不可以指向同⼀个对象
- 拥有指向对象的唯⼀所有权
- 不可以复制或赋值，但可以移动
- 指针使⽤完毕，被指向的对象会⾃动释放销毁
2.1 unique_ptr 的声明
2.2 unique_ptr 的函数
2.3 ⾃定义类型使⽤ unique_ptr
2.4 unique_ptr 不⽀持拷⻉、赋值
std::move(p1)：转移p1拥有的所有权，容器 vec 拥有堆上面对象的所有权，p1 会设置为空指针，
2.5 使⽤make_unique初始化（C++14标准）
make_unique 的作用也是在堆上创建的内存空间，
auto 关键字是编译器根据 make_unique 的返回值自动帮我们判断数据类型，
代码：
#include <iostream>
#include <vector>
#include <string>
#include <memory>
using namespace std;
class Account
{
private:
string name {"account"};
double balance {0.0};
public:
Account(string name = "none", double balance = 0.0);
~Account();
bool deposit(double amount);
void printInfo() const;
double getBalance();
};
Account::Account(string name, double balance)
:name {name}, balance {balance}
{
cout << "构造函数，name: " << name << endl;
}
Account::~Account()
{
cout << "析构函数，name: " << name << endl;
}
bool Account::deposit(double amount)
{
balance += amount;
return true;
}
void Account::printInfo() const
{
cout << "name: " << name << ", balance: " << balance << endl;
}
double Account::getBalance()
{
return balance;
}
int main()
{
// Account alice_account {"Alice", 1000.0}; // 构造函数和析构函数都会被调用
// Account * bob_account = new Account {"Bob", 2000.0}; // 只有构造函数被调用
// delete bob_account; // 析构函数被调用
// unique_ptr<Account> p1 {new Account {"jams", 1000.0}}; // 构造函数和析构函数都会被调用
// auto p2 = make_unique<Account>("mike", 2000.0); // 构造函数和析构函数都会被调用
// unique_ptr<Account> p3;
// // p3 = p2; // 报错，因为unique_ptr不允许拷贝，只能移动
// p3 = move(p2); // p2 会被置为null，即空指针
// if (! p2)
// cout << "p2 is null" << endl;
// auto p4 = make_unique<Account>("Helen", 3000.0);
// p4->deposit(1000.0);
// p4->printInfo(); // 调用成员函数
vector<unique_ptr<Account>> accounts;
accounts.push_back( make_unique<Account>("alice",1000));
accounts.push_back( make_unique<Account>("bob",500));
accounts.push_back( make_unique<Account>("mike",1000));
for (const auto &acc: accounts)
cout << acc->getBalance() << endl;
return 0;
}
3、智能指针（smart pointers）——shared_ptr
- shared_ptr<T> ptr_name
- 指向heap堆上类型为 T 的对象
- 不唯⼀，多个shared_ptr可以指向同⼀个对象
- 被管理对象的所有权在多个shared_ptr中共享
- 可以复制或赋值
- 可以移动
- 引⽤计数（reference count）为0，被指向的对象会⾃动释放销毁
3.1 shared_ptr的声明
当超出 {} 的作用域后，堆上的对象也会自动销毁，
3.2 shared_ptr的函数
use_count()：返回引用计数的值，也就是当前堆上的对象被多少 shared_ptr 管理，
p1.reset() 并没有释放 p1 所指向的对象，因为 p2 还在指向这个对象，
3.3 ⾃定义类型使⽤shared_ptr
3.4 vector和复制操作
3.5 使⽤make_shared初始化（C++11标注）
不再使用关键字 new，编译器也可以生成更高效的执行代码，
代码：
#include <iostream>
#include <vector>
#include <string>
#include <memory>
using namespace std;
class Account
{
private:
string name {"account"};
double balance {0.0};
public:
Account(string name = "none", double balance = 0.0);
~Account();
void print() const;
};
Account::Account(string name, double balance)
:name {name}, balance {balance}
{
cout << "构造函数，name: " << name << endl;
}
Account::~Account()
{
cout << "析构函数，name: " << name << endl;
}
void Account::print() const
{
cout << "name: " << name << ", balance: " << balance << endl;
}
void test_func(shared_ptr<Account> p)
{
cout << "p.use_count(): " << p.use_count() << endl; // 2
}
int main()
{
// cout << "=====================" << endl;
// shared_ptr<int> p1 {new int {100}};
// cout << "p1.use_count(): " << p1.use_count() << endl; // 1
// shared_ptr<int> p2 {p1}; // 共享所有权
// cout << "p1.use_count(): " << p1.use_count() << endl; // 2
// p1.reset(); // 释放所有权，但是不会销毁对象，因为p2还在使用
// cout << "p1.use_count(): " << p1.use_count() << endl; // 0
// cout << "p2.use_count(): " << p2.use_count() << endl; // 1
// cout << "=====================" << endl;
// shared_ptr<Account> p1 = make_shared<Account>("Alice", 1000.0);
// test_func(p1);
// cout << "p1.use_count(): " << p1.use_count() << endl; // 2
// {
// shared_ptr<Account> p2 = p1;
// cout << "p2.use_count(): " << p2.use_count() << endl; // 3
// {
// shared_ptr<Account> p3 = p1;
// cout << "p3.use_count(): " << p3.use_count() << endl; // 4
// p1.reset();
// }
// cout << "p1.use_count(): " << p1.use_count() << endl; // 2
// cout << "p2.use_count(): " << p2.use_count() << endl; // 2
// }
// cout << "p1.use_count(): " << p1.use_count() << endl; // 1
cout << "=====================" << endl;
shared_ptr<Account> p1 = make_shared<Account>("Alice", 1000.0);
shared_ptr<Account> p2 = make_shared<Account>("Bob", 2000.0);
shared_ptr<Account> p3 = make_shared<Account>("Charlie", 3000.0);
vector<shared_ptr<Account>> accounts;
accounts.push_back(p1);
accounts.push_back(p2);
accounts.push_back(p3);
for (const auto &p: accounts)
{
p->print();
cout << "p.use_count(): " << p.use_count() << endl; // 1
}
return 0;
}
