<think>我们讨论的是`std::shared_
ptr`作为函数参数传递时的两种方式：值传递和引用传递（包括const引用）。这两种方式在性能、安全性和引用计数行为上有显著区别。
### 1. 值传递 (Pass by Value)
- **行为**：传递`std::shared_
ptr`时会复制指针，增加引用计数（原子操作）。
- **使用场景**：当函数需要共享对象的所有权（即函数内部需要延长对象的生命周期）时使用。
- **特点**：
- 安全：函数内持有对象的独立所有权，原始指针不会被意外释放。
- 开销：引用计数的增减涉及原子操作，有轻微性能开销。
- **示例**：
```cpp
void by_value(std::shared_
ptr<int>
ptr) {
// 引用计数+1（例如，从1变为2）
*
ptr = 20;
} // 函数结束，
ptr销毁，引用计数-1（恢复为1）
int main() {
auto p = std::make_shared<int>(10);
by_value(p); // 值传递
// 此处引用计数恢复为1
return 0;
}
```
### 2. 引用传递 (Pass by Reference)
- **行为**：传递`std::shared_
ptr`的引用（或const引用），不增加引用计数。
- **使用场景**：
- 只读访问：函数只需读取数据，不涉及所有权管理。
- 性能优化：避免不必要的引用计数操作（原子操作开销）。
- **特点**：
- 高效：无引用计数增减开销。
- 风险：若函数内部通过引用创建了新的`std::shared_
ptr`副本（例如赋值给全局变量），可能导致意外的所有权延长。
- **示例**：
```cpp
void by_ref(std::shared_
ptr<int>&
ptr) {
*
ptr = 30; // 修改数据，引用计数不变
}
void by_const_ref(const std::shared_
ptr<int>&
ptr) {
// 只读访问，引用计数不变
std::cout << *
ptr << std::endl;
}
int main() {
auto p = std::make_shared<int>(10);
by_ref(p); // 非常量引用传递
by_const_ref(p); // 常量引用传递
return 0;
}
```
---
### 实际场景对比示例
以下代码展示两种传递方式在引用计数和性能上的差异：
```cpp
#include <iostream>
#include <memory>
#include <vector>
// 值传递：增加引用计数
void process_by_value(std::shared_
ptr<std::vector<int>> data) {
data->push_back(42); // 修改数据
std::cout << "process_by_value: 引用计数 = " << data.use_count() << std::endl;
}
// 常量引用传递：不增加引用计数
void process_by_const_ref(const std::shared_
ptr<std::vector<int>>& data) {
data->push_back(100); // 修改数据（注意：const引用仍可修改对象本身，但不能修改
智能指针）
std::cout << "process_by_const_ref: 引用计数 = " << data.use_count() << std::endl;
}
int main() {
auto data = std::make_shared<std::vector<int>>();
// 值传递：引用计数从1变为2（函数内），函数结束后恢复为1
process_by_value(data);
std::cout << "main after by_value: 引用计数 = " << data.use_count() << std::endl;
// 常量引用传递：引用计数始终为1
process_by_const_ref(data);
std::cout << "main after by_const_ref: 引用计数 = " << data.use_count() << std::endl;
return 0;
}
```
#### 输出结果：
```
process_by_value: 引用计数 = 2
main after by_value: 引用计数 = 1
process_by_const_ref: 引用计数 = 1
main after by_const_ref: 引用计数 = 1
```
### 关键区别总结
| **特性** | **值传递** | **引用传递** |
|-------------------------|-------------------------------------|----------------------------------|
| **引用计数变化** | 增加（函数内+1，函数结束-1） | 不变 |
| **所有权共享** | 是（函数内独立所有权） | 否（依赖外部所有权） |
| **性能** | 有开销（原子操作） | 无额外开销 |
| **安全性** | 高（函数内对象不会被释放） | 低（需确保外部对象有效） |
| **适用场景** | 需延长对象生命周期的函数 | 只读访问或性能敏感场景 |
### 最佳实践建议
1. **优先使用const引用**：
- 若函数只需访问数据，不管理生命周期，使用`const std::shared_
ptr<T>&`传递。
- 避免意外复制所有权，同时减少性能开销[^2]。
2. **值传递用于所有权共享**：
- 当函数需要存储`std::shared_
ptr`（如存入全局容器、类成员变量）时，必须使用值传递以确保正确延长生命周期。
3. **避免非const引用**：
- 非const引用（`std::shared_
ptr<T>&`）可能被函数内部重置（`reset()`）或重新赋值，导致外部指针失效。除非明确需要修改
智能指针本身，否则慎用。
### 循环引用问题补充
若存在循环引用（如对象A持有`shared_
ptr<B>`，对象B持有`shared_
ptr<A>`），需将其中一方的指针改为`std::weak_
ptr`[^4]。例如：
```cpp
class B;
class A {
public:
std::shared_
ptr<B> b_
ptr;
};
class B {
public:
std::weak_
ptr<A> a_
ptr; // 使用weak_
ptr打破循环
};
int main() {
auto a = std::make_shared<A>();
auto b = std::make_shared<B>();
a->b_
ptr = b;
b->a_
ptr = a; // 不会增加A的引用计数
return 0;
} // 此处a和b能正常释放
```
---
§§相关问题§§
1. 在多线程环境下，`std::shared_
ptr`值传递的引用计数操作是否线程安全？
2. 如何用`std::weak_
ptr`安全地访问被管理的对象？
3. `std::make_shared`相比直接使用`new`创建`shared_
ptr`有何优势？
[^2]: `std::make_shared`通过单次内存分配同时存储对象和控制块，提升性能和内存利用率[^2]。
[^4]: 循环引用会导致内存泄漏，`std::weak_
ptr`通过不增加引用计数来打破循环[^4]。</think>### C++中`std::shared_
ptr`作为参数传递：值传递 vs 引用传递
在C++中，`std::shared_
ptr`作为函数参数传递时，选择值传递(pass by value)还是引用传递(pass by reference)会直接影响引用计数行为和性能。以下是两者的核心区别及实际示例：
---
#### 1. **值传递 (Pass by Value)**
- **行为**：创建
智能指针的副本，**增加引用计数**
- **适用场景**：函数需要延长对象生命周期（如存储到容器、异步任务）
- **特点**：
- 安全：函数内部持有独立所有权
- 开销：引用计数原子操作有轻微性能损失
- **示例**：
```cpp
#include <iostream>
#include <memory>
void process_value(std::shared_
ptr<int>
ptr) {
*
ptr += 10; // 修改值
std::cout << "值传递内部: " << *
ptr
<< " (引用计数: " <<
ptr.use_count() << ")\n";
} // 退出时引用计数-1
int main() {
auto p = std::make_shared<int>(5);
std::cout << "调用前: " << p.use_count() << "\n"; // 1
process_value(p); // 值传递，引用计数+1
std::cout << "调用后: " << *p // 15
<< " (引用计数: " << p.use_count() << ")\n"; // 1
}
```
**输出**：
```
调用前: 1
值传递内部: 15 (引用计数: 2)
调用后: 15 (引用计数: 1)
```
---
#### 2. **引用传递 (Pass by Reference)**
- **行为**：传递原始指针的引用，**不增加引用计数**
- **适用场景**：函数只需访问对象，不涉及所有权管理
- **特点**：
- 高效：无引用计数操作开销
- 风险：对象可能在函数执行期间被释放
- **示例**：
```cpp
#include <iostream>
#include <memory>
void process_ref(std::shared_
ptr<int>&
ptr) {
if (
ptr) { // 必须检查有效性
*
ptr *= 2;
std::cout << "引用传递内部: " << *
ptr
<< " (引用计数: " <<
ptr.use_count() << ")\n";
}
}
int main() {
auto p = std::make_shared<int>(10);
std::cout << "调用前: " << p.use_count() << "\n"; // 1
process_ref(p); // 引用传递，计数不变
std::cout << "调用后: " << *p // 20
<< " (引用计数: " << p.use_count() << ")\n"; // 1
}
```
**输出**：
```
调用前: 1
引用传递内部: 20 (引用计数: 1)
调用后: 20 (引用计数: 1)
```
---
#### 3. **常量引用传递 (Const Reference) - 推荐方式**
- **行为**：安全高效，避免意外修改所有权
- **最佳实践**：大多数只读访问场景
```cpp
void
safe_read(const std::shared_
ptr<int>&
ptr) {
if (
ptr) {
std::cout << "安全读取: " << *
ptr << "\n";
}
}
```
---
### 关键区别总结
| 特性 | 值传递 | 引用传递 | 常量引用传递 |
|--------------------|---------------------------|--------------------------|-------------------------|
| **引用计数变化** | 增加 (+1) | 不变 | 不变 |
| **所有权** | 函数获得独立所有权 | 共享外部所有权 | 共享外部所有权 |
| **性能** | 有原子操作开销 | 无额外开销 | 无额外开销 |
| **安全性** | 高（对象生命周期延长） | 中（需手动检查有效性） | 高（const保护） |
| **典型用例** | 存储到长期存在的容器 | 需要修改对象的场景 | 只读访问 |
---
### 实际应用场景
**值传递示例**：将资源交给工作线程
```cpp
void start_worker(std::shared_
ptr<Resource> res) {
std::thread([res] { // 线程持有独立所有权
res->process();
}).detach();
}
```
**常量引用传递示例**：数据读取函数
```cpp
void print_stats(const std::shared_
ptr<Data>& data) {
if (data) {
std::cout << "Data size: " << data->size() << "\n";
}
}
```
**引用传递示例**：重置资源（谨慎使用）
```cpp
void reset_resource(std::shared_
ptr<Resource>& res) {
res.reset(new Resource()); // 替换原始资源
}
```
---
### 最佳实践建议
1. **优先使用`const std::shared_
ptr<T>&`**
适用于大多数只读访问场景，兼顾效率和安全性[^3]。
2. **值传递用于所有权共享**
当函数需要延长对象生命周期时使用（如存储到全局容器）[^1]。
3. **避免非const引用传递**
除非明确需要修改
智能指针本身（如`reset()`），否则易导致意外行为。
4. **循环引用场景使用`std::weak_
ptr`**
当对象存在相互引用时，用`weak_
ptr`打破循环[^4]：
```cpp
class Node {
std::shared_
ptr<Node> next;
std::weak_
ptr<Node> prev; // 打破循环引用
};
```
---
扫一扫
468
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
