C++模板元模板（异类词典与policy模板）- - - 前篇

本文主要是介绍C++模板元模板（异类词典与policy模板）- - - 前篇，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

前言

一、具名参数简介？

二、异类词典

2.1 模块的使用方式

2.2 什么是闭包？

2.3 使用别名替代继承的本质区别

---

一、具名参数简介？

具名参数（named parameters）是一种在函数调用时使用参数名称来明确指定参数值的方法。通常，函数调用时参数是按照参数定义的顺序传递的，而具名参数则允许根据参数名称来指定参数值，而不必遵循固定的顺序。

使用具名参数的好处有：

1. 可读性更强：通过在函数调用中使用参数名称来指定参数值，代码的可读性更高，不再受限于参数的顺序。

2. 减少错误：使用具名参数可以避免由于参数顺序错误而导致的错误。

3. 选填参数和默认参数：具名参数也常用于具有选填参数和默认参数的函数，可以明确指定你感兴趣的参数，而省略其他参数。这使得使用具有大量可选参数的函数时更加便捷。

Python代码示例：

def print_info(name, age, address):print(f"Name: {name}")print(f"Age: {age}")print(f"Address: {address}")# 按照顺序传递参数
print_info("Alice", 25, "123 Main St")# 使用具名参数
print_info(age=30, name="Bob", address="456 Maple Ave")# 使用混合方式传递参数
print_info("Charlie", address="789 Oak Ln", age=35)

以上就是python使用的方式，但是C++语言本身并不支持函数的具名调用，以下看一种在C++中使用具名函数的方式是通过类似 std::map 这样的映射结构:

float fun(const std::map<std::string, float>& params) {auto a_it = params.find("a");auto b_it = params.find("b");auto weight_it = params.find("weight");return (a_it->second) * (weight_it->second) + (b_it->seconde * (1 - (weight_it->second));}int main(){std::map<std::string, float> params;params["a"] = 1.3f; params["b"] = 2.4f;params["weight"] = 0.1f;std::cerr << fun(params);    // 调用
}

代码讲解：

1. `float fun(const std::map<std::string, float>& params) {`声明一个名为`fun`的函数，它接受一个`std::map<std::string, float>`类型的参数`params`，并返回一个`float`类型的值。2. `auto a_it = params.find("a");`使用`find`函数在`params`中查找键为"a"的元素，将返回的迭代器保存在`a_it`变量中。如果找到了相应的键，`a_it`将指向该键值对，否则指向`params`中的末尾。3. `auto b_it = params.find("b");`同样使用`find`函数在`params`中查找键为"b"的元素，将返回的迭代器保存在`b_it`变量中。4. `auto weight_it = params.find("weight");`同样使用`find`函数在`params`中查找键为"weight"的元素，将返回的迭代器保存在`weight_it`变量中。5. `return (a_it->second) * (weight_it->second) + (b_it->seconde * (1 - (weight_it->second));`这一行是返回计算结果的表达式。它通过使用迭代器对应的`second`成员来获取`map`中键值对的值。具体来说，`a_it->second`表示`params`中键为"a"的值，`weight_it->second`表示`params`中键为"weight"的值，`b_it->second`表示`params`中键为"b"的值。表达式计算了`(a_it->second) * (weight_it->second)`和`(b_it->seconde * (1 - (weight_it->second))`两部分，并将它们相加作为计算结果返回。6. `int main(){`此处是`main`函数的开始。7. `std::map<std::string, float> params;`声明了一个名为`params`的`std::map<std::string, float>`类型变量。8. `params["a"] = 1.3f; params["b"] = 2.4f;`将键值对"a"和"b"分别设置为1.3和2.4，并存储在`params`中。9. `params["weight"] = 0.1f;`将键为"weight"设置为0.1，并存储在`params`中。10. `std::cerr << fun(params);`调用函数`fun`，并将返回的结果输出到标准错误流`std::cerr`中。11. `}``main`函数的结束。

二、异类词典

异类词典（Heterogeneous Dictionary）是指在一个字典（或者键值对的集合）中，可以存储不同类型的值。它允许将不同的数据类型关联到特定的键上，从而实现对异类数据的统一管理和访问。

在许多编程语言中，字典（或称为映射、关联数组等）都是以键值对的方式存储数据。通常情况下，字典中的值都是相同类型的，例如整数、字符串或者其他固定类型。

而异类词典则允许在同一个字典中存储不同类型的值。例如，可以将整数、字符串、浮点数等不同类型的数据关联到字典的不同键上。这样的设计有助于在一个数据结构中有效地组织和访问异构数据，避免了创建多个独立的字典或数据结构的需要。

VarTypeDict（Variable Type Dictionary）是一个可能用于实现异类词典的概念。它是指一个具有灵活类型的字典结构，其中的值可以是不同类型的变量。通过使用VarTypeDict，可以将不同类型的数据按照键值对的形式存储在一个数据结构中，并可以方便地检索和操作这些数据。

VarTypeDict可以更好地处理多样化的数据需求，提供了更大的灵活性和可扩展性。它能够有效地组织和管理异类数据，并通过键来标识和访问这些数据，让程序更加可读、易于理解和维护。

2.1 模块的使用方式

书中示例代码

// 声明一个异类词典 FParams
struct FParams: public VarTypeDict<A, B, Weight> {};template <typename TIn>
float fun(const TIn& in) {auto a = in.template Get<A>();auto b = in.template Get<B>();auto weight = in.template Get<Weight>();return a * weight + b * (1 - weight);
}int main()
{std::cerr << fun (Fparms::Create().Set<A>(1.3f).Set<B>(2.4f).Set<Weight>(0.1f));
}

代码讲解：

// 声明一个异类词典 FParams
struct FParams : public VarTypeDict<A, B, Weight> {};

这行代码定义了一个名为 `FParams` 的结构体，它继承自 `VarTypeDict` 异类词典模板，并指定了键类型为 `A`、`B` 和 `Weight`。它将被用作参数传递的封装。

template <typename TIn>
float fun(const TIn& in) {

这行代码定义了一个模板函数 `fun`，它有一个模板参数 `TIn`，表示接受的输入参数类型。函数返回值为浮点数类型 `float`。

auto a = in.template Get<A>();
auto b = in.template Get<B>();
auto weight = in.template Get<Weight>();

这里使用 `in.template Get<>()` 语法从输入参数 `in` 中获取键对应的值，并将其保存到变量 `a`、`b` 和 `weight` 中。`template` 关键字用于指示获取异类词典中的值时使用模板实例化。

return a * weight + b * (1 - weight);

这行代码使用获取到的异类词典中的值 `a`、`b` 和 `weight` 进行计算，并返回计算结果。

std::cerr << fun(Fparams::Create().Set<A>(1.3f).Set<B>(2.4f).Set<Weight>(0.1f));

这里，FParams::Create() 返回一个临时对象，并通过链式调用 .Set<>() 设置了异类词典中的键值对。每次 .Set<>() 被调用时，都会返回一个新的异类词典对象，可以继续进行下一个键值对的设置。这种方式利用了闭包的特性，允许在连续调用的过程中共享状态，方便地设置异类词典的键值。

之后，这个异类词典实例作为参数传递给了 fun 函数，并进行计算。

这段代码中使用了闭包的概念，通过链式调用和共享状态，方便地设置异类词典的键值对。

接着，调用了 `fun` 函数将 `FParams` 类型的实例作为参数进行计算，并将结果输出到标准错误流 `std::cerr`。

代码通过使用异类词典实现了参数传递和计算的功能，将不同类型的参数封装到一个数据结构中，并可以通过键方便地获取和操作这些参数。

作者示例代码

#include <iostream>
#include <unordered_map>
#include <variant>typedef std::unordered_map<std::string, std::variant<int, bool, std::string>> VarTypeDict;int main() {VarTypeDict varDict;// 向异类词典中添加键值对varDict["age"] = 25;varDict["isStudent"] = true;varDict["name"] = "John Doe";// 从异类词典中获取数据并输出int age = std::get<int>(varDict["age"]);bool isStudent = std::get<bool>(varDict["isStudent"]);std::string name = std::get<std::string>(varDict["name"]);std::cout << "Age: " << age << std::endl;std::cout << "Is Student: " << std::boolalpha << isStudent << std::endl;std::cout << "Name: " << name << std::endl;return 0;
}

代码讲解：

示例中，我们使用了 std::unordered_map 来实现异类词典，其中的值类型被定义为 std::variant<int, bool, std::string>，即可以存储整数、布尔值和字符串类型。代码首先创建了一个名为 varDict 的异类词典。

然后，我们向 varDict 中添加了三个键值对："age"、"isStudent" 和 "name"，对应的值是一个整数、一个布尔值和一个字符串。

随后，我们通过使用 std::get 函数来从异类词典中获取相应的值，并将它们赋给不同的变量。最后，使用 std::cout 将这些值输出到控制台。

2.2 什么是闭包？

闭包（Closure）是一种将函数与其相关的引用环境捆绑在一起的概念。它允许函数访问并操作其定义时的非局部变量，即使在函数定义所在的作用域以外调用函数时，也能够访问这些变量。

代码示例：

#include <iostream>
#include <functional>std::function<int()> createClosure(int x) {return [=]() {return x * 2;};
}int main() {int x = 5;auto closure = createClosure(x);std::cout << closure() << std::endl; // 输出：10return 0;
}

在这段代码中，函数 `createClosure` 接受一个 `int` 类型的参数 `x`。它返回一个 `std::function` 类型的闭包，该闭包将输入参数 `x` 与其内部的匿名函数捆绑在一起。

在匿名函数内部，我们使用了捕获列表 `[=]` 来捕获外部的变量 `x`。捕获列表 `[=]` 表示以值的方式捕获所有外部变量。

然后，闭包使用一个匿名函数作为返回结果，并返回 `x * 2` 的计算结果。

在 `main` 函数中，我们定义了一个变量 `x` 并赋值为 `5`。然后，我们调用 `createClosure` 函数，并将 `x` 作为参数传递给它。这将返回一个闭包，并将其赋值给变量 `closure`。

最后，我们通过调用 `closure()` 来执行闭包的函数体，并输出结果 `10`。这是因为闭包中的函数可以访问并操作定义时的非局部变量 `x`。

总而言之，闭包是一个捆绑了函数和与之相关的引用环境的结构。它允许函数访问并操作函数定义所在作用域以外的变量。通过使用闭包，可以将函数和其上下文封装起来，便于在需要时再次调用。

2.3 使用别名替代继承的本质区别

将 `struct FParams: public VarTypeDict<A, B, Weight> {};` 改成 `using FParams = VarTypeDict<A, B, Weight>;` 的本质区别在于继承和类型别名之间的差异。

在原始的代码中，通过 `struct` 关键字声明了一个名为 `FParams` 的结构体，它继承自 `VarTypeDict` 模板，并指定了键类型为 `A`、`B` 和 `Weight`。这意味着 `FParams` 结构体将拥有 `VarTypeDict` 中的成员变量和成员函数。

而将其改成 `using FParams = VarTypeDict<A, B, Weight>;` 后，则使用 `using` 关键字进行类型别名。这意味着 `FParams` 现在只是 `VarTypeDict<A, B, Weight>` 的别名，没有继承 `VarTypeDict` 中的任何成员。

本质上的区别在于，继承将使得 `FParams` 结构体继承了 `VarTypeDict` 的数据成员和成员函数，继承关系会在编译时体现在类型之间。而类型别名只是起了一个别名，不会生成新的派生类型，类型判断和类型转换时仍然将被视为 `VarTypeDict<A, B, Weight>` 类型。

在这个具体的代码示例中，由于 `FParams` 结构体并没有使用 `VarTypeDict` 的任何成员，所以改变这两种方式的本质区别不会在代码的行为上产生明显的影响。但是如果 `FParams` 结构体需要使用 `VarTypeDict` 中的成员变量和成员函数，则必须使用继承而不是类型别名。

这篇关于C++模板元模板（异类词典与policy模板）- - - 前篇的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---