当前位置：首页 > news >正文

网站空间购买北京网络营销策划内容

news 2025/7/29 8:10:14

网站空间购买北京,网络营销策划内容,衡水外贸网站建设,学做衣服网站知乎目录一、智能指针 1. std::unique_ptr（独占所有权指针） 2. std::shared_ptr（共享所有权指针） 3. std::weak_ptr（弱引用指针） 关键区别总结最佳实践基本用法可封装的对象类型核心特性示例代码…

一、智能指针

1. std::unique_ptr（独占所有权指针）

2. std::shared_ptr（共享所有权指针）

3. std::weak_ptr（弱引用指针）

关键区别总结

最佳实践

基本用法

可封装的对象类型

核心特性

示例代码

1. 基本调用

2. 结合 Lambda 和参数传递

3. 作为回调函数

与模板的对比

使用场景

注意事项

总结

一、智能指针

shared_ptr和unique_ptr都支持的操作

shared_ptr<T> sp  空智能指针，可以指向类型为T的对象
unique_ptr<T> up  
p   将p用作一条判断，若p指向一个对象，则为true
*p  解引用p。获得它指向的对象
p->mem 等价于(*p).mem
p.get() 返回p中保存的指针。要小心使用，若智能指针释放了其对象，返回的指针所指向的对象也就消失了
swap(p,q) 交换p和q中的指针
p.swap(q)

share_ptr独有的操作

make_shared<T>(angs)        返回一个 shared_ptr，指向一个动态分配的类型为了的对象。使用args 初始化此对象
shared_ptr<T> p(q)          p是shared ptrq的拷贝:此操作会递增q中的计数器，g中的指针必须能转换为T*
p=q                         p和q都是shared_ptr，所保存的指针必须能相互转换。此操作会递减p的引用计数，递增q的引用计数;若p的引用计数变为0,则将其管理的原内存释放
p.unique()
p.use_count()                若p.use_count()为1，返true:否则返回false返回与p共享对象的智能指针数量;可能很慢，主要用于调试(参见4112节，第143页

1. `std::unique_ptr`（独占所有权指针）

特点：
- 独占资源的所有权，同一时间只能有一个 unique_ptr 指向某个对象。
- 不能拷贝构造或赋值，但可以通过 std::move 转移所有权。
- 生命周期结束时（超出作用域或被重置），自动释放管理的资源。
适用场景：
- 管理动态分配的资源，明确所有权单一的情况。
- 替代 C++98 的 auto_ptr（已弃用）。

示例：

#include <memory>void example_unique_ptr() {std::unique_ptr<int> ptr1(new int(42));  // 创建 unique_ptrstd::unique_ptr<int> ptr2 = std::move(ptr1); // 转移所有权if (ptr1) {// ptr1 不再拥有资源，不会执行此处}if (ptr2) {*ptr2 = 10; // 修改指向的值}
} // 自动释放 ptr2 的资源

2. `std::shared_ptr`（共享所有权指针）

特点：
- 通过引用计数（reference counting）管理资源，允许多个 shared_ptr 共享同一对象。
- 当最后一个 shared_ptr 被销毁或重置时，资源被释放。
- 可以通过 std::make_shared 高效创建（减少内存分配次数）。
适用场景：
- 需要多个指针共享同一资源的场景。
- 需要传递资源所有权但不确定何时释放的情况。

示例：

#include <memory>void example_shared_ptr() {std::shared_ptr<int> ptr1 = std::make_shared<int>(42); // 推荐使用 make_sharedstd::shared_ptr<int> ptr2 = ptr1; // 引用计数 +1std::cout << ptr1.use_count() << std::endl; // 输出 2
} // ptr1 和 ptr2 销毁，引用计数归零，资源释放

3. `std::weak_ptr`（弱引用指针）

特点：
- 指向 shared_ptr 管理的资源，但不增加引用计数。
- 用于解决 shared_ptr 的循环引用问题（如两个对象相互持有对方的 shared_ptr）。
- 需要通过 lock() 方法获取临时的 shared_ptr 来访问资源。
适用场景：
- 需要观察 shared_ptr 资源但不影响其生命周期。
- 打破循环引用。

示例：

#include <memory>void example_weak_ptr() {std::shared_ptr<int> shared = std::make_shared<int>(42);std::weak_ptr<int> weak = shared;if (auto temp = weak.lock()) { // 转换为 shared_ptrstd::cout << *temp << std::endl; // 输出 42}shared.reset(); // 释放资源if (weak.expired()) { // 检查资源是否已被释放std::cout << "Resource is gone." << std::endl;}
}

关键区别总结

智能指针	所有权	拷贝/赋值	性能开销	适用场景
`unique_ptr`	独占	只能移动	无	单一所有权，明确生命周期
`shared_ptr`	共享	允许拷贝	引用计数	共享所有权，不确定生命周期
`weak_ptr`	无（仅观察）	允许拷贝	无计数	解决循环引用，观察资源

最佳实践

优先使用 unique_ptr：默认情况下使用 unique_ptr，仅在需要共享时使用 shared_ptr。
避免裸指针与智能指针混用：不要将智能指针管理的资源通过裸指针传递。

使用 make_shared 和 make_unique（C++14+）：

cpp

复制

auto ptr = std::make_unique<int>(42);  // C++14 支持
auto ptr2 = std::make_shared<int>(42); // 减少内存分配次数

注意循环引用：如果两个对象互相持有 shared_ptr，使用 weak_ptr 打破循环。

基本用法

头文件：
```
#include <functional>
```

定义：

std::function<返回值类型(参数类型列表)> func;

例如：

std::function<int(int, int)> func; // 封装一个接受两个 int、返回 int 的可调用对象

可封装的对象类型

std::function 可以封装以下类型的可调用对象：

普通函数：

int add(int a, int b) { return a + b; }
std::function<int(int, int)> func = add;

Lambda 表达式：

std::function<int(int, int)> func = [](int a, int b) { return a * b; };

函数对象（仿函数）：

struct Multiply {int operator()(int a, int b) { return a * b; }
};
Multiply mul;
std::function<int(int, int)> func = mul;

类的成员函数（需结合 std::bind）：

class Calculator {
public:int subtract(int a, int b) { return a - b; }
};Calculator calc;
auto bound_func = std::bind(&Calculator::subtract, &calc, std::placeholders::_1, std::placeholders::_2);
std::function<int(int, int)> func = bound_func;

静态成员函数（直接赋值）：

class Math {
public:static int divide(int a, int b) { return a / b; }
};
std::function<int(int, int)> func = Math::divide;

核心特性

类型擦除：
- std::function 隐藏了底层可调用对象的具体类型，通过统一的接口调用。
- 例如，无论是 Lambda 还是函数指针，都可以被同一个 std::function 类型包装。
运行时多态：
- 可以在运行时动态绑定不同的函数或对象，适用于回调机制和事件驱动编程。
空状态检查：
- 默认初始化的 std::function 为空，调用空 function 会抛出 std::bad_function_call 异常。
- 使用 operator bool() 检查是否可调用：
```
if (func) {func(2, 3); // 安全调用
}
```

示例代码

1. 基本调用

#include <iostream>
#include <functional>void hello() {std::cout << "Hello, World!" << std::endl;
}int main() {std::function<void()> func = hello;func(); // 输出 "Hello, World!"return 0;
}

2. 结合 Lambda 和参数传递

#include <functional>int main() {std::function<int(int, int)> operation;// 动态绑定加法operation = [](int a, int b) { return a + b; };std::cout << operation(3, 4) << std::endl; // 输出 7// 动态绑定乘法operation = [](int a, int b) { return a * b; };std::cout << operation(3, 4) << std::endl; // 输出 12return 0;
}

3. 作为回调函数

#include <functional>
#include <vector>class Button {
public:using Callback = std::function<void()>;void setOnClick(Callback callback) {onClick = callback;}void click() {if (onClick) onClick();}private:Callback onClick;
};int main() {Button btn;btn.setOnClick([]() { std::cout << "Button clicked!" << std::endl; });btn.click(); // 输出 "Button clicked!"return 0;
}