泛型 Lambda，如此强大！

最近发现泛型编程有了另一利器——泛型 Lambda，比想象当中要强大许多，威力不小，和大家分享一下。

本篇内容需要对泛型编程有所了解，若是读过之前更新的相关文章，食用更佳。

泛型编程

开始之前，先来简单回顾一下泛型编程的内容。

泛型编程的目的是将「数据和方法」进行分离，将数据高度抽象，于是可以表示同类问题的「最小通解」。

C++ 通过模板来实现泛型编程，模板又分为变量模板、函数模板和类模板。这些模板始终围绕着「数据和方法」。变量模板属于对数据类型的抽象，函数模板属于对方法的抽象，而类模板，则二者兼有，因为类本身的目的就是将数据和方法进行结合。因此为什么说函数模板处理的是数值，而类模板处理的是类型呢？就是由于函数只具有方法，而在C++中方法是不支持偏特化的，所以它无法处理类型。

至 C++14，Lambda 也迎来了泛化能力，称为 Generic Lambda。不过此时的泛化能力只是由 auto 带来的，威力略弱。随后又经过多年的发展，Lambda 的能力越来越强。C++20 加入了 Template Lambda，这让 Lambda 也可以指定模板参数，使其泛化能力更加完善。

至此，C++ 的泛型编程多了一个新的主角——泛型 Lambda。

泛型 Lambda

为何泛型Lambda值得单独拿出来说呢？

一是因其特殊性，在一些情境使用它来封装变化，会让事情简单许多；二是由其新颖性，它的许多特性和用处尚处探索期，值得讨论。

首先来说其特殊性。Lambda 函数其实就是一个匿名的函数对象，它实际上也是一个“类”。不同的是，它唯一的方法就是 operator()，也就是 Lambda 体，而数据则是 [] 中捕获的参数，这些参数就是“类”中定义的成员变量。因此，Lambda 函数既具有函数的部分特征，又具有类的部分特征。也因如此，事情变得有趣起来。Lambda 具有的函数部分特征，让它具备了函数模板的能力；类部分特征，让它具备了类模板的继承能力。此外，由于 Lambda 的类型是一个 closure type（闭包类型），所以它还可以定义在函数内部，也可以当作回调函数使用。

如此这些，再加上泛型，使得泛型 Lambda 极具威力。

继而来看其新颖性。

当下大多数 C++ 开发者对于 Lambda 的使用，还只是停留在函数部分，相当于只发挥了 Lambda 的基本能力。

实际上，Lambda 的能力要比想象之中强大许多，在基本能力之上，还有些令人兴奋的能力。

这也是值得探索的地方。

以继承封装「变化」

不论写库或框架，都是在提炼「不变」的逻辑，将「变化」的逻辑交给用户配置。

可以是预留接口，让用户覆写接口；也可以是采用回调，让用户提供处理逻辑；抑或是提供配置文件，让用户填写变化的信息，再通过配置文件自动生成相应处理逻辑。

应对「变化」的方式很多，对于一些逻辑不甚复杂的变化，完全可以借助 Lambda 来实现。

Lambda 天生可以在函数内部构建，自带一个 operator ()，这就相当于一个表示变化的接口，也就是用户可以手动配置的地方。有了表示变化的地方，你再将不变的逻辑封装到一个类中，让该类继承自此 Lambda。于是，你便可以在不变之中使用变化的逻辑。

Lambda 重载

既然泛型 Lambda 具备函数模板的特性，那么它是否也可以重载呢？

回答是 No。前文提到，Lambda 是函数对象，它只有唯一的一个方法 operator()，也就是 Lambda 体，Lambda 体只有一个，你又如何能写多个呢？

但是，可以提供多个 Lambda，也就是造就多个函数对象，让它们参数不同，再借助某种技巧，便可以从「视觉层面」实现 Lambda 重载。说是「视觉层面」，意思是说它本质上不是函数意义上的那种重载，只是使用起来像是函数重载一样。

这个技巧就是 overload pattern。

其实早在 C++ DP.13-2 泛化实现Cyclic Visitor与强大的C++17 std::visit 这篇文章中，就已经提到并使用了这个技巧。这里再次拿出一节来介绍它，是因为我发现它比想象之中更加强大，可以说是泛型 Lambda 编程的一个核心技术。它的实作很简单，只有两行代码:

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

各位知道，C++ 中代码越少往往并不意味着它有多简单，而是说明其「信息密度」较大。此处，第一行首先使用了可变参数模板，使得 overloaded 可以继承自多个 Lambda。其次使用了 Using-declaration，以防止重载之时产生歧义。

第二行则使用了 C++17 的 CTAD(Class Template Argument Deduction)，以推导出 overloaded 的类型。有何必要呢？这是因为你无法创建一个 overloaded 类型的对象，因为 Lambda 的类型不可知，你无法填写模板参数类型。借由 CTAD，便可以为 overloaded 添加一个用户自定义的类型推导指引，这样编译器才能够推导出其类型。

现在，就可以使用「视觉层面」的 Lambda 重载了：

const auto func = overloaded {
    [](const int& n) { std::cout << "int:" << n << '\n'; },\
    [](const std::string& s) { std::cout << "string:" << s << '\n'; }
};

func(2);
func("im the lambda with parameter std::string");

这里又使用了「聚合初始化」，通过它可以直接调用基类中 Lambda 的构造器，从而避免为 overloaded 显式编写构造函数向基类传递参数。

总之，通过 Lambda 重载，便可以将许多相似的「变化逻辑」聚到一起，再以不同的参数访问这些不同的逻辑，从而以一种崭新的形式封装变化。

泛型 Lambda 实现对象工厂

通过泛型 Lambda，我们拥有了一种新的实现对象工厂的策略，简单而威力巨大。

代码如下：

template<class... Ts> struct Fruit : Ts... { using Ts::operator()...; };
template<class... Ts> Fruit(Ts...) -> Fruit<Ts...>;

是的，就是使用了 Lambda 重载来实现 Fruit。然后再通过以下形式定义对象工厂：

struct Apple { void print() { std::cout << "apple print\n"; } };
struct Pineapplce {void print() { std::cout << "pineapple print\n"; } };

// 定义对象工厂
static constexpr auto FruitFactory = Fruit {
    []<typename T>(const T& apple) { return new T; }
};

// 从工厂创建产品
auto apple = FruitFactory(Apple{});
apple->print();

此处第 6 行代码便使用了 C++20 的 Template Lambda，由此可以创建任意类型的对象。

如此少的代码，实现的对象工厂可并不弱，而且这种实现方法更加轻便，除了无法动态产生，已经相当不错了。

泛型 Lambda 实现抽象工厂

根据泛型 Lambda，实现抽象工厂也有了一种新的形式。并且这种形式使用起来更加轻便，我已经决定使用这种方式替换 okdp 库的实现。

可以通过 Lambda 重载来定义抽象工厂：

template<class... Ts> struct AbstractAIFactory : Ts... { using Ts::operator()...; };
template<class... Ts> AbstractAIFactory(Ts...) -> AbstractAIFactory<Ts...>;

具体工厂的定义则更具有技巧性，实现如下：

template<class T, class U>
concept IsAbstractAI = std::same_as<T, U>;

template<class T>
static constexpr auto AIFactory = AbstractAIFactory {
    []() requires IsAbstractAI<T, Lux> { return new LuxEasy; },
    []() requires IsAbstractAI<T, Ziggs> { return new ZiggsEasy; },
    []() requires IsAbstractAI<T, Teemo> { return new TeemoEasy; }
};

auto lux = AIFactory<Ziggs>();
lux->print();

你是否已经意识到了这种实现形式的强大之处？

这里用到的技术就更加多了，除了前面介绍的「聚合初始化」，还使用到了 C++20 的Concepts，这点已经写过相关文章了，相信大家不会太陌生。

此外，这里还用到了变量模板，想想前面几节的内容，提到过范型 Lambda 虽然具有函数模板和类模板的部分特征，但它的「数据」部分只能通过捕获参数。因此其实无法真正像类那样使用，而抽象工厂的抽象类又无法实例化，所以我们也无法像对象工厂那样使用。于是，为了为它添上「类型的能力」，这里借助了变量模板。正因如此，你才能像类一样使用 AIFactory。

不过，事情尚未结束，此时「抽象工厂」就是 AbstractAIFactory，通过 Lambda 重载完成的不错。「具体工厂」属于变化的部分，就相当于 Lambda 体，也就是这里为每个类型实现的 Lambda 函数。问题在哪呢？巨大的重复！

消除这种类型的重复比较好的方法是借助「泛型宏」，这点在对象工厂那篇文章中介绍并使用过。泛型编程是理念，模板是手段，宏同样是一种手段，需要根据具体情形具体分析，从而合理地进行选择。

不过此处的情形有些复杂，泛型宏的确可以很好的完成任务，但是工作比较复杂，已经涉及到泛型宏深入层次的技术了。因此由于本篇主题不是泛型宏，篇幅有限，此处只展示下代码，不做进一步解释，大家可以自己看看。代码如下：

#define _GET_OVERRIDE(_1, _2, _3, _4, _5, _6, NAME, ...) NAME

#define _CONCRETE_AI_FACTORY_BODY_0(LAM, AIType, LEvel)
#define _CONCRETE_AI_FACTORY_BODY_1(LAM, AIType, Level, AIName) LAM(AIType, Level, AIName)
#define _CONCRETE_AI_FACTORY_BODY_2(LAM, AIType, Level, AIName, ...) LAM(AIType, Level, AIName) _CONCRETE_AI_FACTORY_BODY_1(LAM, AIType, Level, __VA_ARGS__)
#define _CONCRETE_AI_FACTORY_BODY_3(LAM, AIType, Level, AIName, ...) LAM(AIType, Level, AIName) _CONCRETE_AI_FACTORY_BODY_2(LAM, AIType, Level, __VA_ARGS__)
#define _CONCRETE_AI_FACTORY_BODY_4(LAM, AIType, Level, AIName, ...) LAM(AIType, Level, AIName) _CONCRETE_AI_FACTORY_BODY_3(LAM, AIType, Level, __VA_ARGS__)
#define _CONCRETE_AI_FACTORY_BODY_5(LAM, AIType, Level, AIName, ...) LAM(AIType, Level, AIName) _CONCRETE_AI_FACTORY_BODY_4(LAM, AIType, Level, __VA_ARGS__)

#define _GENERATE_AI_LAMBDA(AIType, Level, AIName) []() requires IsAbstractAI<AIType, AIName> { return new AIName##Level; },

#define CONCRETE_AI_FACTORY(AIType, Level, ...) \
    _GET_OVERRIDE("ignored", ##__VA_ARGS__, \
    _CONCRETE_AI_FACTORY_BODY_5, _CONCRETE_AI_FACTORY_BODY_4, \
    _CONCRETE_AI_FACTORY_BODY_3, _CONCRETE_AI_FACTORY_BODY_2, \
    _CONCRETE_AI_FACTORY_BODY_1, _CONCRETE_AI_FACTORY_BODY_0) \
    (_GENERATE_AI_LAMBDA, AIType, Level, ##__VA_ARGS__)

泛型宏的实现复杂是针对开发者来说的，对于使用者来说却是极为简单。现在你可以非常简单地使用宏实现的「具体工厂」来替换前面的写法：

template<class T>
static constexpr auto AIFactory = AbstractAIFactory {
    // []() requires IsAbstractAI<T, Lux> { return new LuxEasy; },
    // []() requires IsAbstractAI<T, Ziggs> { return new ZiggsEasy; },
    // []() requires IsAbstractAI<T, Teemo> { return new TeemoEasy; }
    CONCRETE_AI_FACTORY(T, Easy, Lux, Ziggs, Teemo)
};

不论你有多少产品，都可以由该具体工厂轻松实现，是不是很强大！

总结

本篇内容应该是我写的涉及内容最广的文章之一了，光之前写过的文章就引用了多篇，是以对大家的要求也会有点高，可以多看几遍。

另外这篇的内容其实很“新”，首先组合使用了许多 C++20 特性，其次涉及了大量泛型编程技术，文章介绍的泛型 Lambda 技术现在还不是很流行，使用场景也是慢慢摸索出来的，比较成熟的想法都写在了本文之中。但它的用处我感觉还有很多，还在研究中，后续再和大家分享。