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

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)

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`函数的结束。

// 声明一个异类词典 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> {};

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>();

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

#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;
}

#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; // 输出：10
    return 0;
}