C++_ 模板学习七-Aet

Bingliaolong 2026-08-09 23:54 Aet | 隐藏边栏 | 抢沙发 | 4 0

文章评分 2 次，平均分 5.0 ：

`Typelist`——编译期类型容器

概述

普通容器保存运行期对象

1 2	std::vector<int> std::list<std::string>

Typelist 保存的是一组类型
1. 它没有运行期元素，也不负责构造对象
2. 所有内容都编码在模板参数包中

1	TypeList<int, double, std::string>

C++ 标准库没有名为 std::typelist 的类型，但：
1. std::tuple<Ts...> 保存一组不同类型的对象
2. std::variant<Ts...> 保存其中一种类型的对象
3. std::integer_sequence<T, Values...> 保存一组编译期数值
4. 大型项目经常定义自己的 TypeList
5. Boost.MP11 等库提供了成熟的类型列表算法

最小`TypeList`

template<class... Types>

struct TypeList

{

};

使用

using Empty = TypeList<>;

using NumericTypes =

TypeList<int, long, float, double>;

Typelist 本身通常是空类
1. 这个对象不包含 int、long、float、double 对象

NumericTypes list;

// 类型信息存在于：

TypeList<int, long, float, double>

// 这个类型的模板实参中

`Typelist`是不可变的

向列表添加类型不会修改原列表，而是生成一个新类型

using L1 = TypeList<int, double>;

using L2 = PushFrontT<L1, bool>;

1 2	L1 == TypeList<int, double> L2 == TypeList<bool, int, double>

实现`Size`

#include <cstddef>

#include <type_traits>

template<class List>

struct Size;

template<class... Types>

struct Size<TypeList<Types...>>

: std::integral_constant<

std::size_t,

sizeof...(Types)

{

};

using List = TypeList<int, double, char>;

static_assert(Size<List>::value == 3);

static_assert(Size<TypeList<>>::value == 0);

也可以提供变量模板

template<class List>

inline constexpr std::size_t SizeV =

Size<List>::value;

1	static_assert(SizeV<List> == 3);

实现`Front`

Front 返回第一个类型

template<class List>

struct Front;

template<class Head, class... Tail>

struct Front<TypeList<Head, Tail...>>

{

using type = Head;

};

template<class List>

using FrontT = typename Front<List>::type;

using List = TypeList<int, double, char>;

static_assert(

std::is_same_v<

FrontT<List>,

int

);

// 拆包过程

TypeList<int, double, char>

Head = int

Tail... = double, char

// 因此

type = Head = int

对于空列表
1. 没有对应偏特化，因此不合法
2. 这表示 Front 的前置条件是列表非空

1	FrontT<TypeList<>>

实现`PopFront`

PopFront 删除第一个类型，并生成新列表

template<class List>

struct PopFront;

template<class Head, class... Tail>

struct PopFront<TypeList<Head, Tail...>>

{

using type = TypeList<Tail...>;

};

template<class List>

using PopFrontT =

typename PopFront<List>::type;

template<class List>

struct PopFront;

template<class Head, class... Tail>

struct PopFront<TypeList<Head, Tail...>>

{

using type = TypeList<Tail...>;

};

template<class List>

using PopFrontT =

typename PopFront<List>::type;

这里不是删除运行期对象，而是重新构造一个模板特化

1	TypeList<Tail...>

实现`PushFront`

template<class List, class NewType>

struct PushFront;

template<class... Types, class NewType>

struct PushFront<

TypeList<Types...>,

NewType

{

using type =

TypeList<NewType, Types...>;

};

template<class List, class NewType>

using PushFrontT =

typename PushFront<List, NewType>::type;

using List = TypeList<int, double>;

using Result =

PushFrontT<List, bool>;

static_assert(

std::is_same_v<

Result,

TypeList<bool, int, double>

);

实现`PushBack`

对于参数包形式的 TypeList，可以直接展开

template<class List, class NewType>

struct PushBack;

template<class... Types, class NewType>

struct PushBack<

TypeList<Types...>,

NewType

{

using type =

TypeList<Types..., NewType>;

};

template<class List, class NewType>

using PushBackT =

typename PushBack<List, NewType>::type;

using List = TypeList<int, double>;

static_assert(

std::is_same_v<

PushBackT<List, bool>,

TypeList<int, double, bool>

);

基础操作完整程序

100

101

102

103

104

105

106

107

108

#include <cstddef>

#include <type_traits>

template<class... Types>

struct TypeList

{

};

template<class List>

struct Size;

template<class... Types>

struct Size<TypeList<Types...>>

: std::integral_constant<

std::size_t,

sizeof...(Types)

{

};

template<class List>

struct Front;

template<class Head, class... Tail>

struct Front<TypeList<Head, Tail...>>

{

using type = Head;

};

template<class List>

using FrontT = typename Front<List>::type;

template<class List>

struct PopFront;

template<class Head, class... Tail>

struct PopFront<TypeList<Head, Tail...>>

{

using type = TypeList<Tail...>;

};

template<class List>

using PopFrontT =

typename PopFront<List>::type;

template<class List, class NewType>

struct PushFront;

template<class... Types, class NewType>

struct PushFront<TypeList<Types...>, NewType>

{

using type =

TypeList<NewType, Types...>;

};

template<class List, class NewType>

using PushFrontT =

typename PushFront<List, NewType>::type;

template<class List, class NewType>

struct PushBack;

template<class... Types, class NewType>

struct PushBack<TypeList<Types...>, NewType>

{

using type =

TypeList<Types..., NewType>;

};

template<class List, class NewType>

using PushBackT =

typename PushBack<List, NewType>::type;

int main()

{

using Types =

TypeList<int, double, char>;

static_assert(Size<Types>::value == 3);

static_assert(

std::is_same_v<

FrontT<Types>,

int

);

static_assert(

std::is_same_v<

PopFrontT<Types>,

TypeList<double, char>

);

static_assert(

std::is_same_v<

PushFrontT<Types, bool>,

TypeList<bool, int, double, char>

);

static_assert(

std::is_same_v<

PushBackT<Types, bool>,

TypeList<int, double, char, bool>

);

}

实现 `At`：按索引取类型

template<class List, std::size_t Index>

struct At;

template<class Head, class... Tail>

struct At<TypeList<Head, Tail...>, 0>

{

using type = Head;

};

template<

std::size_t Index,

class Head,

class... Tail

struct At<

TypeList<Head, Tail...>,

Index

> : At<TypeList<Tail...>, Index - 1>

{

};

template<class List, std::size_t Index>

using AtT =

typename At<List, Index>::type;

using Types =

TypeList<int, double, char>;

static_assert(

std::is_same_v<

AtT<Types, 0>,

int

);

static_assert(

std::is_same_v<

AtT<Types, 1>,

double

);

static_assert(

std::is_same_v<

AtT<Types, 2>,

char

);

At<TypeList<int, double, char>, 2>

→ At<TypeList<double, char>, 1>

→ At<TypeList<char>, 0>

→ char

如果索引越界，递归最终作用于空列表，编译失败
标准库对于元组有相似操作

1	std::tuple_element_t<Index, Tuple>

`Transform`：转换每个类型

目标

1	TypeList<int, double, char>

// 经过 std::add_pointer 转换成

TypeList<int*, double*, char*>

实现

template<

class List,

template<class> class MetaFunction

struct Transform;

template<

template<class> class MetaFunction,

class... Types

struct Transform<

TypeList<Types...>,

MetaFunction

{

using type = TypeList<

typename MetaFunction<Types>::type...

};

template<

class List,

template<class> class MetaFunction

using TransformT =

typename Transform<

List,

MetaFunction

>::type;

using Types =

TypeList<int, double, char>;

using PointerTypes =

TransformT<

Types,

std::add_pointer

static_assert(

std::is_same_v<

PointerTypes,

TypeList<int*, double*, char*>

);

核心展开

1	typename MetaFunction<Types>::type...

typename MetaFunction<int>::type,

typename MetaFunction<double>::type,

typename MetaFunction<char>::type

我们的 Transform 要求元函数遵循 trait 接口

template<class T>

struct MetaFunction

{

using type = ...;

};

`Transform`可能提前失败

下面会失败

using Types =

TypeList<int, double>;

using UnsignedTypes =

TransformT<

Types,

std::make_unsigned

1	// 因为 std::make_unsigned<double> 不合法

Transform 会对列表中的每个元素实例化元函数
1. 它不会自动跳过不适用的类型
正确流程通常是

1 2	先 Filter 筛出合法类型再 Transform 执行转换

`Filter`：过滤类型

目标

1	TypeList<int, double, char, std::string>

// 保留满足

std::is_integral<T>::value

// 的类型

// 得到

TypeList<int, char>

实现

template<

class List,

template<class> class Predicate

struct Filter;

template<template<class> class Predicate>

struct Filter<TypeList<>, Predicate>

{

using type = TypeList<>;

};

template<

template<class> class Predicate,

class Head,

class... Tail

struct Filter<

TypeList<Head, Tail...>,

Predicate

{

private:

using FilteredTail =

typename Filter<

TypeList<Tail...>,

Predicate

>::type;

public:

using type =

std::conditional_t<

Predicate<Head>::value,

PushFrontT<

FilteredTail,

Head

FilteredTail

};

template<

class List,

template<class> class Predicate

using FilterT =

typename Filter<List, Predicate>::type;

#include <string>

using Types =

TypeList<

int,

double,

char,

std::string

using IntegralTypes =

FilterT<

Types,

std::is_integral

static_assert(

std::is_same_v<

IntegralTypes,

TypeList<int, char>

);

`Filter`如何保持顺序

输入

1	TypeList<int, double, char>

// 递归先处理尾部

TypeList<double, char>

// 得到

TypeList<char>

// 然后处理头部 int

std::is_integral_v<int> == true

// 将 int 添加到已过滤尾部的前面

PushFront<TypeList<char>, int>

// 得到

TypeList<int, char>

所以原有相对顺序得到保留

自定义`Predicate`

Predicate 是输入类型、输出布尔值的元函数

template<class T>

struct IsSmall

: std::bool_constant<

(sizeof(T) <= 8)

{

};

1 2	using SmallTypes = FilterT<Types, IsSmall>;

注意 sizeof(T) 不等于复制成本，也不能完整描述：
1. 构造是否昂贵
2. 是否动态分配内存
3. 是否可平凡复制
4. 是否适合按值传递

组合`Transform`和`Filter`

假设输入

using RawTypes =

TypeList<

const int&,

double&&,

const char,

std::string&

先删除 cv/ref

using CleanTypes =

TransformT<

RawTypes,

std::remove_cvref

// C++20 结果

TypeList<

int,

double,

char,

std::string

再过滤整数

using IntegralTypes =

FilterT<

CleanTypes,

std::is_integral

// 结果

TypeList<int, char>

// 如果先过滤 FilterT<RawTypes, std::is_integral>

// const int& 不是整数类型本身，而是引用类型，因此不会满足 is_integral

把`TypeList`转成`tuple`或`variant`

Typelist 只描述类型
1. 最终通常需要把它应用到实际类模板上
实现 Rename

template<

class List,

template<class...> class Target

struct Rename;

template<

template<class...> class Target,

class... Types

struct Rename<

TypeList<Types...>,

Target

{

using type = Target<Types...>;

};

template<

class List,

template<class...> class Target

using RenameT =

typename Rename<List, Target>::type;

#include <tuple>

#include <variant>

using Types =

TypeList<int, double, char>;

using Tuple =

RenameT<Types, std::tuple>;

using Variant =

RenameT<Types, std::variant>;

static_assert(

std::is_same_v<

Tuple,

std::tuple<int, double, char>

);

static_assert(

std::is_same_v<

Variant,

std::variant<int, double, char>

);

这种操作在不同库中可能叫
1. Rename
2. Rebind
3. Apply
4. Instantiate
5. Wrap
可以理解为
1. 把类型列表中的参数包重新传给另一个类模板

`TypeList`、`Tuple`和`Variant`的区别


类型	是否保存对象	运行期含义
`TypeList<Ts...>`	否	纯编译期类型集合
`std::tuple<Ts...>`	是	同时保存每种类型的一个对象
`std::variant<Ts...>`	是	任意时刻保存其中一种类型
`std::integer_sequence<T, Vs...>`	否	编译期数值序列

例如

// 不会构造任何对象

TypeList<int, std::string>

// 会同时包含一个 int 和一个 std::string

std::tuple<int, std::string>

// 只保存一个当前活动值

std::variant<int, std::string>

另外，std::variant 的备选类型不能是：
1. void
2. 引用类型
3. 数组类型
4. 如果 TypeList 经过转换后要生成 variant，必须保证结果满足这些要求

把类型列表展开为代码

可以将每个类型包装成 tag，再执行参数包展开

template<class T>

struct TypeTag

{

using type = T;

};

template<class... Types, class Function>

constexpr void for_each_type(

TypeList<Types...>,

Function&& function)

{

(

function(TypeTag<Types>{}),

...

);

}

#include <iostream>

using Types =

TypeList<int, double, char>;

for_each_type(

Types{},

[](auto tag) {

using T =

typename decltype(tag)::type;

std::cout << sizeof(T) << '\n';

}

);

这里没有创建 T 对象，只构造了

1	TypeTag<T>

C++20 也可以使用

1	std::type_identity<T>{}

这种技术可以用于
1. 为一组消息类型生成处理器
2. 为一组测试类型生成测试用例
3. 为所有协议类型生成序列化函数表
4. 对一组组件类型执行静态注册

网络消息中的实际应用

struct Login {};

struct Logout {};

struct Heartbeat {};

struct DebugMessage {};

using AllMessages =

TypeList<

Logout,

Heartbeat,

DebugMessage

定义 trait

template<class Message>

struct MessageTraits;

template<>

struct MessageTraits<Login>

{

static constexpr bool wire_enabled = true;

};

template<>

struct MessageTraits<Logout>

{

static constexpr bool wire_enabled = true;

};

template<>

struct MessageTraits<Heartbeat>

{

static constexpr bool wire_enabled = true;

};

template<>

struct MessageTraits<DebugMessage>

{

static constexpr bool wire_enabled = false;

};

定义 Predicate

template<class Message>

struct IsWireMessage

: std::bool_constant<

MessageTraits<Message>::wire_enabled

{

};

过滤

using WireMessages =

FilterT<

AllMessages,

IsWireMessage

// 结果

TypeList<

Logout,

Heartbeat

生成 variant

using MessageVariant =

RenameT<

WireMessages,

std::variant

using MessageVariant =

std::variant<

Logout,

Heartbeat

// 可以使用

std::visit(

[](const auto& message) {

handle(message);

message_variant

);

编译成本与现代化建议

对于具体的参数包 TypeList
1. Size：直接 sizeof...
2. `Front：一次偏特化
3. PopFront：一次偏特化
4. PushFront、PushBack：一次参数包展开
5. Transform：每个类型实例化一次元函数
6. Filter：线性递归，约为 O(N) 层实例化
7. At<N>：线性递归，约为 O(N)
大型列表的递归算法可能导致
1. 编译时间增加
2. 模板实例化深度过大
3. 错误信息冗长
4. 编译器内存消耗增加

`std::tuple`与异质存储

概述

std::tuple<Ts...> 在一个对象中，分别保存参数包 Ts... 中的每一种对象
它与之前的类型列表有本质区别

1 2	TypeList<int, std::string, double> // 只有类型信息，不保存对象 std::tuple<int, std::string, double> // 实际保存三个对象

`std::tuple`的基本使用

message 中三个元素的类型完全不同

#include <iostream>

#include <string>

#include <tuple>

int main()

{

std::tuple<int, std::string, double> message{

42, "login", 3.5

};

std::cout << std::get<0>(message) << '\n';

std::cout << std::get<1>(message) << '\n';

std::cout << std::get<2>(message) << '\n';

}

这里的 0 是模板实参，必须在编译期确定

std::get<0>(message);

// 下面这样不行

std::size_t index = 1;

std::get<index>(message); // 错误

// 原因是返回类型依赖索引

get<0> -> int&

get<1> -> std::string&

get<2> -> double&

// 如果索引运行时才知道，那么函数的返回类型也无法在编译期确定

从零实现一个递归`TinyTuple`

#include <utility>

template<class... Types>

class TinyTuple;

// 递归终点

template<>

class TinyTuple<>

{

};

// 至少包含一个元素

template<class Head, class... Tail>

class TinyTuple<Head, Tail...>

{

private:

Head head_;

TinyTuple<Tail...> tail_;

public:

TinyTuple(Head head, Tail... tail)

: head_(std::move(head)),

tail_(std::move(tail)...)

{

}

Head& head() noexcept

{

return head_;

}

const Head& head() const noexcept

{

return head_;

}

TinyTuple<Tail...>& tail() noexcept

{

return tail_;

}

const TinyTuple<Tail...>& tail() const noexcept

{

return tail_;

}

};

TinyTuple<int, std::string, double> t{

42, "login", 3.5

};

TinyTuple<int, std::string, double>

// 近似展开

class Tuple0 {

int head_;

class Tuple1 {

std::string head_;

class Tuple2 {

double head_;

TinyTuple<> tail_;

} tail_;

};

实现`get`

可以利用 if constexpr 递归查找第 I 个元素

#include <cstddef>

template<std::size_t I, class Head, class... Tail>

decltype(auto) tiny_get(TinyTuple<Head, Tail...>& tuple)

{

static_assert(I < 1 + sizeof...(Tail),

"tuple index out of range");

if constexpr (I == 0) {

return tuple.head();

} else {

return tiny_get(tuple.tail());

}

template<std::size_t I, class Head, class... Tail>

decltype(auto) tiny_get(const TinyTuple<Head, Tail...>& tuple)

{

static_assert(I < 1 + sizeof...(Tail),

"tuple index out of range");

if constexpr (I == 0) {

return tuple.head();

} else {

return tiny_get(tuple.tail());

}

TinyTuple<int, std::string, double> t{

42, "login", 3.5

};

tiny_get<0>(t) = 100;

tiny_get<1>(t) += "_request";

std::cout << tiny_get<0>(t) << '\n';

std::cout << tiny_get<1>(t) << '\n';

// 对于 tiny_get<2>(t)

// 编译器进行的逻辑递归是

tiny_get<2>(TinyTuple<int, string, double>)

tiny_get<1>(TinyTuple<string, double>)

tiny_get<0>(TinyTuple<double>)

return double&

因为 if constexpr 不会实例化未选择的分支，所以递归能在 I == 0 时停止

为什么返回 `decltype(auto)`

假设错误地写成

1 2	template<std::size_t I, class... Types> auto tiny_get(TinyTuple<Types...>& tuple);

即使内部返回的是引用
1. 普通 auto 也会像变量类型推导一样丢掉引用，结果可能成为值类型

1	return tuple.head();

而decltype(auto)
1. 使用 decltype 规则推导，可以保留返回表达式的引用性质
标准库 std::get 大致要保留这些类型


`tuple`表达式	普通元素对应的返回类型
`tuple&`	`T&`
`const tuple&`	`const T&`
`tuple&&`	`T&&`
`const tuple&&`	`const T&&`

std::tuple<std::string> t{"hello"};

static_assert(std::is_same_v<

decltype(std::get<0>(t)),

std::string&

>);

static_assert(std::is_same_v<

decltype(std::get<0>(std::move(t))),

std::string&&

>);

// 因此，真正的 get 实现还需要处理右值和完美转发

按类型访问：`std::get<T>`

除了索引，标准库还支持

std::tuple<int, std::string, double> t{

42, "login", 3.5

};

std::string& name = std::get<std::string>(t);

但前提是目标类型在 tuple 中恰好出现一次

std::tuple<int, int> t{1, 2};

std::get<0>(t); // 正确

std::get<1>(t); // 正确

std::get<int>(t); // 错误：int 出现了两次

如果一个返回值具有稳定的业务含义，工程中经常应该考虑使用结构体：
1. tuple 更适合局部组合、泛型工具和临时返回值，不适合代替所有业务结构体

struct DecodeResult {

std::uint16_t command;

std::uint32_t payload_size;

};

// 它通常比下面更清楚

using DecodeResult =

std::tuple<std::uint16_t, std::uint32_t>;

简单递归实现的空间问题

template<class Head, class... Tail>

class TinyTuple<Head, Tail...>

{

Head head_;

TinyTuple<Tail...> tail_;

};

递归终点
1. 是一个空类型

1	TinyTuple<>

但一个独立的空对象通常不能完全没有大小
1. 这是因为两个不同对象通常需要能拥有不同地址

struct Empty {};

static_assert(sizeof(Empty) >= 1);

因此
1. empty 可能占用额外空间或引起对齐填充

struct Data {

int value;

Empty empty;

};

TinyTuple 最深处也包含一个空的 TinyTuple<> 成员，因而可能造成空间浪费

`EBO`：空基类优化

如果空类型作为基类存在，编译器通常可以不给它分配额外空间
1. Empty Base Optimization，空基类优化，简称 EBO 或 EBCO

struct Empty {};

struct MemberStorage {

Empty empty;

int value;

};

struct BaseStorage : private Empty {

int value;

};

// 在常见实现中

sizeof(BaseStorage)

// 可能等于一个 int 的大小，而 MemberStorage 可能更大

但不要写这样的可移植断言
1. EBO 是否发生以及具体布局仍然与编译器、ABI和类型关系有关

1	static_assert(sizeof(BaseStorage) == sizeof(int)); // 不保证

让递归 `tuple` 继承 `tail`

class Tuple<Head, Tail...> {

Head head_;

Tuple<Tail...> tail_;

};

可以改为

template<class... Types>

class CompressedTuple;

template<>

class CompressedTuple<>

{

};

template<class Head, class... Tail>

class CompressedTuple<Head, Tail...>

: private CompressedTuple<Tail...>

{

private:

using Base = CompressedTuple<Tail...>;

Head head_;

public:

Head& head() noexcept

{

return head_;

}

Base& tail() noexcept

{

return *this;

}

};

递归终点 CompressedTuple<> 现在成为空基类，而不是空成员
1. 编译器可以对它应用 EBO
但是这仍然只优化了空的递归尾节点，没有完整解决空元素的问题
1. 如果 Empty 仍以普通成员保存，它仍然可能占空间

1	std::tuple<Empty, int>

标准库风格：带索引的存储叶子

一种更接近工业实现的模型是

template<std::size_t I, class T>

class TupleLeaf

{

private:

T value_;

};

然后让 tuple 同时继承所有叶子

TupleImpl<0, int>

TupleImpl<1, std::string>

TupleImpl<2, double>

#include <cstddef>

#include <utility>

template<std::size_t I, class T>

struct TupleLeaf

{

T value;

};

template<class IndexSequence, class... Types>

struct TupleImpl;

template<std::size_t... I, class... Types>

struct TupleImpl<std::index_sequence<I...>, Types...>

: TupleLeaf<I, Types>...

{

};

template<class... Types>

struct FlatTuple

: TupleImpl<std::index_sequence_for<Types...>, Types...>

{

};

FlatTuple<int, std::string, double>

// 相当于

TupleLeaf<0, int>

TupleLeaf<1, std::string>

TupleLeaf<2, double>

考虑

FlatTuple<int, int>

// 它需要两个不同基类

TupleLeaf<0, int>

TupleLeaf<1, int>

// 如果没有索引

TupleLeaf<int>

// 就会重复继承完全相同的基类，访问和对象模型都会出现问题

所以大型模板实现中的索引经常不仅用于查找，还用于：
1. 给相同类型的不同位置创建唯一身份

对空元素应用 `EBO`

在 C++20 之前，常见做法是根据类型是否为空，选择成员存储或继承存储

#include <type_traits>

template<

std::size_t I,

class T,

bool UseEbo =

std::is_empty_v<T> &&

!std::is_final_v<T>

class TupleLeaf;

template<std::size_t I, class T>

class TupleLeaf<I, T, false>

{

private:

T value_;

};

template<std::size_t I, class T>

class TupleLeaf<I, T, true>

: private T

{

};

为什么要检查 !std::is_final_v<T>
1. 因为 final 类型不能被继承
2. 因此，即使它是空类型，也只能采用成员存储
真实标准库实现还要处理
1. 构造函数和约束
2. 引用类型
3. const 和右值
4. 异常规范
5. allocator-aware construction
6. 不同类型之间的转换构造
7. 比较运算
8. ABI兼容性

`C++20：[[no_unique_address]]`

C++20 提供了更直接的成员级空间优化机制

template<std::size_t I, class T>

struct TupleLeaf

{

[[no_unique_address]] T value;

};

它告诉编译器
1. 如果对象模型允许，该成员不必拥有独占的存储地址

// 空 allocator 可能不会增加 Buffer 的大小

struct EmptyAllocator {};

struct Buffer {

[[no_unique_address]] EmptyAllocator allocator;

char* data;

std::size_t size;

};

这项特性在以下场景很常见
1. allocator
2. deleter
3. policy object
4. comparator
5. hash functor
6. stateless callback
7. tuple-like storage
但需要注意
1. 它是允许优化，不是保证特定大小
2. 对齐和 ABI 仍可能影响结果
3. 重复的相同空类型不一定都能重叠
4. 不应该根据这种对象布局设计网络协议或磁盘格式

递归 `tuple` 与索引叶子 `tuple`


特性	递归	索引叶子继承
理解难度	低	较高
`get<I>`	递归进入 `tail`	定位唯一叶子
重复类型	可以保存	通过索引获得唯一身份
空类型优化	需要额外处理	容易按叶子应用 `EBO`
模板实例化深度	随索引递归	通常更扁平
工业实现价值	教学为主	更接近标准库实现

不同标准库的真实实现并不要求采用完全相同的内部结构。不能依赖：
1. sizeof(std::tuple<...>)
2. 或元素在内存中的排列顺序

`make_tuple`、`tie` 与 `forward_as_tuple`

std::make_tuple
1. std::make_tuple 对 std::reference_wrapper<T> 有特殊处理，结果元素会成为 T&

int id = 42;

std::string name = "login";

auto t = std::make_tuple(id, name);

std::tuple<int, std::string>

// 它通常保存衰变后的值，相当于对参数应用类似 std::decay 的处理

// 去除引用

// 去除顶层 const、volatile

// 数组退化为指针

// 函数退化为函数指针

// 因此，修改 tuple 中的元素通常不会修改原变量

std::get<0>(t) = 100;

std::cout << id; // 仍然是 42

// 如果确实需要引用，可以使用

auto t = std::make_tuple<std::ref(id));

std::get<0>(t) = 100;

// id现在是100

std::tie
1. std::tie 创建左值引用的 tuple
2. tie 不拥有对象。被引用对象必须继续存活

int id;

std::string name;

auto refs = std::tie(id, name);

// 类型大概为

std::tuple<int&, std::string&>

// 它常用于解包

std::tie(id, name) = std::make_tuple(43, std::string{"login"});

// 还可以忽略某个元素

int id;

double cost;

std::tie(id, std::ignore, cost) =

std::make_tuple(42, std::string{"login"}, 3.5);

std::forward_as_tuple
1. 它创建由万能引用组成的 tuple
2. 它的用途是暂时保存参数的值类别，以便稍后继续完美转发
3. forward_as_tuple 适合在同一个完整表达式或严格受控的同步调用链中转发，不适合保存到异步任务、容器或成员变量中

template<class... Args>

void dispatch(Args&&... args)

{

auto forwarded =

std::forward_as_tuple(std::forward<Args>(args)...);

}

// 但它不延长临时对象生命周期

auto t = std::forward_as_tuple(std::string{"temporary"});

// 语句结束后，临时 std::string 已经销毁，而 t 中仍然保存着指向它的右值引用

// 后续 std::get<0>(t)

// 将产生悬空引用和未定义行为

三者的选择表


工具	保存内容	拥有对象吗	典型用途
`make_tuple(args...)`	衰变后的值	是	打包并保存参数
`tie(args...)`	左值引用	否	解包、引用已有变量
`forward_as_tuple(args...)`	万能引用	否	临时保留值类别并继续转发
`tuple{args...}`	`CTAD`推导出的元素	通常是值	直接构造 `tuple`

结构化绑定

C++17 可以使用结构化绑定

std::tuple<int, std::string> result{

42, "login"

};

auto [id, name] = result;

这里的 auto 会创建一个隐藏的 tuple 副本，id、name 对应这个副本的元素

// 修改它们不会修改原 tuple

id = 100;

std::cout << std::get<0>(result); // 42

如果希望绑定原对象

auto& [id, name] = result;

id = 100;

// result 的第 0 个元素也变成 100

常见形式

auto [a, b] = t; // 对隐藏对象进行值初始化，通常发生复制

auto& [a, b] = t; // 左值引用

const auto& [a, b] = t; // const 左值引用

auto&& [a, b] = expr; // 根据 expr 保留值类别

`std::apply` 的原理

假设有：

void handle(int id,

const std::string& command,

double cost);

参数保存在 tuple 中

auto args = std::make_tuple(

42,

std::string{"login"},

3.5

);

使用

std::apply(handle, args);

// 相当于

handle(

std::get<0>(args),

std::get<1>(args),

std::get<2>(args)

);

简化版 `apply`

#include <functional>

#include <tuple>

#include <type_traits>

#include <utility>

template<class F, class Tuple, std::size_t... I>

constexpr decltype(auto)

tiny_apply_impl(F&& function,

Tuple&& tuple,

std::index_sequence<I...>)

{

return std::invoke(

std::forward<F>(function),

std::get(std::forward<Tuple>(tuple))...

);

}

template<class F, class Tuple>

constexpr decltype(auto)

tiny_apply(F&& function, Tuple&& tuple)

{

using TupleType = std::remove_reference_t<Tuple>;

constexpr std::size_t size =

std::tuple_size_v<TupleType>;

return tiny_apply_impl(

std::forward<F>(function),

std::forward<Tuple>(tuple),

std::make_index_sequence<size>{}

);

}

// 如果 tuple 有三个元素

std::make_index_sequence<3>

// 产生的类型是

std::index_sequence<0, 1, 2>

// 于是

std::get(tuple)...

// 展开成

std::get<0>(tuple),

std::get<1>(tuple),

std::get<2>(tuple)

// 完整调用最终变成

std::invoke(

function,

std::get<0>(tuple),

std::get<1>(tuple),

std::get<2>(tuple)

);

为什么使用 `std::invoke`

如果只写
1. 普通函数、lambda 和函数对象通常可以工作
2. 但成员函数指针需要特殊语法

1	funtion(args...);

std::invoke 统一支持
1. 普通函数
2. lambda
3. 函数对象
4. 成员函数指针
5. 数据成员指针
6. std::reference_wrapper

struct Connection {

void send(int type, std::string payload)

{

}

};

Connection connection;

auto args =

std::make_tuple(1, std::string{"hello"});

std::apply(

[&](int type, const std::string& payload) {

connection.send(type, payload);

args

);

// 或者直接处理成员函数指针以及对象参数

auto call_args =

std::make_tuple(&connection, 1, std::string{"hello"});

std::apply(&Connection::send, call_args);

`std::apply` 的值类别传播

观察

1	std::get<I>(std::forward<Tuple>(tuple))

如果传给 apply 的 tuple 是左值，元素通常作为左值传递

1	std::apply(function, tuple);

如果 tuple 是右值
1. 元素可以作为右值继续传递

1	std::apply(function, std::move(tuple));

auto consume = [](std::string value) {

// 获取 string 所有权

};

std::tuple<std::string> t{"payload"};

// 这里可以将 t 中的字符串移动给 consume

std::apply(consume, std::move(t));

网络项目中的例子

假设解析网络包头后得到两个字段

using HeaderResult =

std::tuple<std::uint16_t, std::uint32_t>;

HeaderResult decode_header(/* bytes */)

{

std::uint16_t command = 10;

std::uint32_t payload_size = 1024;

return {command, payload_size};

}

// 调用方可以写

auto [command, payload_size] = decode_header();

// 这种局部、简单的返回值使用 tuple 是合理的

// 但不能这样做

HeaderResult header;

// 错误思想：把 tuple 的内存直接发送出去

send(socket, &header, sizeof(header), 0);

原因包括：
1. tuple 的内存布局没有协议保证
2. 元素顺序不等于物理内存顺序
3. 可能存在对齐和填充
4. 不同标准库实现可能不同
5. 不同编译器、ABI和版本可能不同
6. 整数还有网络字节序问题

异步代码中的危险 `tuple`

下面这种 tuple 本身不拥有底层对象

1	std::tuple<Socket&, std::span<const std::byte>> task;

如果保存到异步队列，必须确认
1. ocket 在任务执行前不会销毁
2. span 指向的缓冲区仍然存活
3. 缓冲区不会被并发修改
4. socket 的关闭与任务取消有同步保证
问题不在 tuple 本身，而在于 tuple 很容易把多个非拥有引用打包起来，让生命周期关系变得不明显
工程上常用的判断方法是
1. 这个 tuple 被保存后，其中每一个元素究竟拥有资源，还是仅仅借用资源

// 如果任务跨线程、跨事件循环或延迟执行，通常优先保存拥有所有权的类型

std::tuple<

std::shared_ptr<Connection>,

std::vector<std::byte>

其他

阅读模板的翻译方法

下面模板通常意味着：
1. 给参数包中的每个元素编号
2. 支持重复类型
3. 根据索引选择某个元素
4. 可能进行 EBO 或 [[no_unique_address]] 优化

1 2	template<std::size_t I, class T> struct Leaf;

下面模板通常意味着：
1. 将 tuple、数组或参数包按索引展开
2. 生成 get(...)...
3. 并行处理两个或多个参数包
4. 将运行形式转换成编译期展开形式

1	std::index_sequence<I...>

下面模板通常意味着：
1. 代码准备处理 tuple-like 对象
2. 后面很可能会构造 make_index_sequence
3. 随后用 get 展开元素

1	std::tuple_size_v<std::remove_reference_t<T>>

对下面，要检查：
1. 元素是否应该被移动
2. tuple 后续是否还会使用
3. 元素中是否含有引用
4. f 的参数是按值还是按引用接收

1	std::apply(f, std::move(tuple))

对下面，第一反应应该是检查临时对象和异步生命周期

1	std::forward_as_tuple(...)

Typelist——编译期类型容器
概述
最小TypeList
Typelist是不可变的
实现Size
实现Front
实现PopFront
实现PushFront
实现PushBack
基础操作完整程序
实现 At：按索引取类型
Transform：转换每个类型
Transform可能提前失败
Filter：过滤类型
Filter如何保持顺序
自定义Predicate
组合Transform和Filter
把TypeList转成tuple或variant
TypeList、Tuple和Variant的区别
把类型列表展开为代码
网络消息中的实际应用
编译成本与现代化建议
std::tuple与异质存储
概述
std::tuple的基本使用
从零实现一个递归TinyTuple
实现get
为什么返回 decltype(auto)
按类型访问：std::get<T>
简单递归实现的空间问题
EBO：空基类优化
让递归 tuple 继承 tail
标准库风格：带索引的存储叶子
对空元素应用 EBO
C++20：[[no_unique_address]]
递归 tuple 与索引叶子 tuple
make_tuple、tie 与 forward_as_tuple
三者的选择表
结构化绑定
std::apply 的原理
简化版 apply
为什么使用 std::invoke
std::apply 的值类别传播
网络项目中的例子
异步代码中的危险 tuple
其他
阅读模板的翻译方法

声明：本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0 最后编辑于：2026-08-10

Everything will be better.

一	二	三	四	五	六	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31

C++_ 模板学习七

Typelist——编译期类型容器

概述

最小TypeList

Typelist是不可变的

实现Size

实现Front

实现PopFront

实现PushFront

实现PushBack

基础操作完整程序

实现 At：按索引取类型

Transform：转换每个类型

Transform可能提前失败

Filter：过滤类型

Filter如何保持顺序

自定义Predicate

组合Transform和Filter

把TypeList转成tuple或variant

TypeList、Tuple和Variant的区别

把类型列表展开为代码

网络消息中的实际应用

编译成本与现代化建议

std::tuple与异质存储

概述

std::tuple的基本使用

从零实现一个递归TinyTuple

实现get<I>

为什么返回 decltype(auto)

按类型访问：std::get<T>

简单递归实现的空间问题

EBO：空基类优化

让递归 tuple 继承 tail

标准库风格：带索引的存储叶子

对空元素应用 EBO

C++20：[[no_unique_address]]

递归 tuple 与索引叶子 tuple

make_tuple、tie 与 forward_as_tuple

三者的选择表

结构化绑定

std::apply 的原理

简化版 apply

为什么使用 std::invoke

std::apply 的值类别传播

网络项目中的例子

异步代码中的危险 tuple

其他

阅读模板的翻译方法

你可能也喜欢

热评文章

发表评论

标签云集

`Typelist`——编译期类型容器

最小`TypeList`

`Typelist`是不可变的

实现`Size`

实现`Front`

实现`PopFront`

实现`PushFront`

实现`PushBack`

实现 `At`：按索引取类型

`Transform`：转换每个类型

`Transform`可能提前失败

`Filter`：过滤类型

`Filter`如何保持顺序

自定义`Predicate`

组合`Transform`和`Filter`

把`TypeList`转成`tuple`或`variant`

`TypeList`、`Tuple`和`Variant`的区别

`std::tuple`与异质存储

`std::tuple`的基本使用

从零实现一个递归`TinyTuple`

实现`get<I>`

为什么返回 `decltype(auto)`

按类型访问：`std::get<T>`

`EBO`：空基类优化

让递归 `tuple` 继承 `tail`

对空元素应用 `EBO`

`C++20：[[no_unique_address]]`

递归 `tuple` 与索引叶子 `tuple`

`make_tuple`、`tie` 与 `forward_as_tuple`

`std::apply` 的原理

简化版 `apply`

为什么使用 `std::invoke`

`std::apply` 的值类别传播

异步代码中的危险 `tuple`