新发布手机万秀服务不错的seo推广

Day10 标准模板库学习笔记（2025.04.02）

一、函数和数组能否放入 STL 容器？

1. 引用不能直接作为容器元素类型

C++ 的容器如 std::vector 不支持存储引用类型（例如 int&），因为引用并非对象本身，不能被复制或赋值。

std::vector<int&> rv; // ❌ 编译失败

✅ 推荐做法：使用 std::reference_wrapper<T>

标准库提供了 std::reference_wrapper 类模板，它可以将引用包装为对象，从而实现“间接”存储引用。

#include <functional>
std::vector<std::reference_wrapper<int>> rv1;
rv1.push_back(i); // i 是 int 类型变量

你也可以自定义类似的封装类，但通常没必要：

template <typename T>
class my_reference_wrapper {T& r;
public:my_reference_wrapper(T& i) : r(i) {}
};

2. 函数不能直接作为容器元素类型

函数名本身不是对象，而是函数类型，不能直接作为 std::vector 的元素类型。

std::vector<decltype(add)> fv; // ❌ 编译失败

✅ 推荐做法一：使用函数指针类型

函数名在赋值或传参时会自动“衰变”（decay）为函数指针。

auto f = add;  // 类型为 void(*)()
using func_ptr = decltype(f);std::vector<func_ptr> fv1;
fv1.push_back(add);
fv1.push_back(minus);

✅ 推荐做法二：使用 std::function

std::function 是更通用、灵活的可调用对象封装器，可以容纳函数、函数指针、Lambda 表达式、函数对象等。

std::vector<std::function<void()>> fv2;
fv2.push_back(add);
fv2.push_back(minus);
fv2.push_back([](){});
fv2.push_back(Callable{}); // 假设 Callable 重载了 operator()

补充知识：函数和数组的“衰变”行为

C++ 中，数组和函数在很多场景下都会自动转换为指针类型，这种现象称为“衰变”（decay）。

int array[10];
auto p1 = array;     // int*
auto&& r1 = array;   // 引用仍保留 int[10] 类型

衰变行为可以用 <type_traits> 里的 std::decay_t<T> 模拟：

static_assert(std::is_same_v<decltype(array), std::remove_reference_t<decltype(r1)>>);
static_assert(std::is_same_v<decltype(p1), std::decay_t<decltype(array)>>);

函数也会衰变为函数指针：

static_assert(std::is_same_v<decltype(add), std::remove_reference_t<decltype(function_ref)>>);

---

二、数组能否放入容器？

❌ 直接存放原生数组类型 T[N] 不被支持

std::vector<int[10]> v;  // 编译失败

因为数组不能被拷贝或赋值。

✅ 推荐做法一：使用数组指针

std::vector<int*> v1;
v1.push_back(array);  // array 是 int[10]

但这种方式存在数组退化为指针的问题，可能引发不安全行为。

✅ 推荐做法二（更推荐）：使用 std::array

std::array 是标准库提供的定长数组类型，兼具 C 数组的性能与 STL 容器的接口。

std::vector<std::array<int, 10>> v2;
v2.push_back(std::to_array(array)); // C++20 提供的安全转换

---

三、测试代码

#include <type_traits>
#include <functional>
#include <vector>
#include <algorithm>
#include <iostream>
#include <array>void add()
{std::cout << "add" << std::endl;
}void minus()
{std::cout << "minus" << std::endl;
}// 普通类定义可以写在函数里，模板类不行
template <typename T>
class my_reference_wrapper
{T& r;
public:my_reference_wrapper(T& i) : r(i) {}
};/*
容器无法容纳引用和函数？
*/
void container_can_not_contain_reference_and_function()
{int i = 1;int& ri = i;int& ri1 = i;// 想把这两个引用放到容器里// 想把上面两个函数 add 和 minus 放到容器里//std::vector<int&> rv; // 编译出错//std::vector<decltype(add)> fv; // 编译出错// 怎么办...// 对于引用，标准库提供了个包装类，把引用藏到自定义类型里std::vector<std::reference_wrapper<int>> rv1;rv1.push_back(ri);rv1.push_back(ri1);// 自己写也可以std::vector<my_reference_wrapper<int>> rv2;rv2.push_back(ri);rv2.push_back(ri1);// 你永远也不需要这么做...// 要么把对象拷贝进容器，要么移动进容器，把引用放进去是做什么？？？// 但是函数对象是确实有放到容器里的需求// 这里只是没写对元素的类型，试着拷贝函数给一个变量，看看变量的类型auto f = add; // f 是个函数指针using func_pointer = decltype(f);// 所以元素可以用函数指针类型std::vector<func_pointer> fv1;fv1.push_back(add);fv1.push_back(minus);// 标准库提供了更好的方案 std::function// 首先指定的还是函数类型，而不是函数指针类型// 其次接收可调用对象，即函数和重载了operator()的类都可以放进容器，包括lambdastd::vector<std::function<decltype(add)>> fv2;fv2.push_back(add);fv2.push_back(minus);class Callable{public:void operator()() {}};fv2.push_back(Callable());fv2.push_back([]() {});// 发生了什么？为什么函数赋值后成了函数指针？// 这里涉及C++比较麻烦的地方，为了保持和C语言的兼容性// 所谓 decay 衰变// C语言有数组和函数，数组和函数在赋值/传参时会自动衰变为指针// 这是C编译器的行为，C++编译器为了兼容C，无奈照搬了，这也导致了C++的类型系统有瑕疵// 模板专家很多时候就是在处理这种奇怪的兼容性问题// 这也是为什么数组名是个指针，而函数自动会转为函数指针的原因int array[10];auto array_decay = array; // 类型衰变为 int*auto&& array_ref = array; // 万能引用可以看到精确类型，其实任何引用都可以auto function_decay = add; // 类型衰变为 void(*)()auto&& function_ref = add; // 万能引用可以看到精确类型，其实任何引用都可以static_assert(std::is_same_v<decltype(array_decay),std::decay_t<decltype(array)>>); // 自动decay和手动调用decay得到一样的类型static_assert(std::is_same_v<decltype(function_decay),std::decay_t<decltype(add)>>); // 自动decay和手动调用decay得到一样的类型static_assert(std::is_same_v<decltype(array),std::remove_reference_t<decltype(array_ref)>>); // 把引用移除就得到原来的类型static_assert(std::is_same_v<decltype(add),std::remove_reference_t<decltype(function_ref)>>); // 把引用移除就得到原来的类型// C数组会衰变，还允许做元素，C++这帮人...std::vector<int[10]> array_array;// 但，怎么塞元素...//array_array.push_back(array); // 编译出错// 完蛋，没法塞进去...// 都不让塞为什么允许C数组做元素啊...// 要么妥协，使用衰变类型，即指针std::vector<int*> array_array1;array_array1.push_back(array);// 要么改成标准库的定长数组std::array，推荐做法std::vector<std::array<int, 10>> array_array2;// 使用 std::to_array 从C数组构造标准库数组array_array2.push_back(std::to_array(array));// 记住// 永远不需要把引用放进容器// 函数放进容器是有需求的，推荐用std::function代替函数指针// 数组放进容器也有需求，推荐用std::array代替指针// 碰到问题先去找标准库的解决方案，不要自己（瞎）实现
}

四、总结

数据类型	是否能放入 STL 容器	推荐做法
引用 T&	❌	使用 std::reference_wrapper<T>
函数 void()	❌	使用 std::function<void()> 或函数指针
数组 T[N]	❌	使用 std::array<T, N> 或 T*

实践建议

• 遇到“不能放入容器”的情况，优先查标准库是否已有合适的封装工具。
• 避免自己写低质量、重复的封装类，标准库几乎总有更好的方案。
• 多理解“类型衰变”在函数和数组上的行为，有助于掌握模板编程细节。