C++11&QT复习 （十五）

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()的类都可以放进容器，包括lambda
  std::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代替指针
  // 碰到问题先去找标准库的解决方案，不要自己（瞎）实现
}

四、总结

实践建议

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