CppCon 2018 学习:A New Take on Polymorphism

你这段内容介绍了 C++ 中的多态性（Polymorphism），特别是 静态多态（Static Polymorphism） 的概念与示例。下面我来详细解释每个部分的含义和代码背后的机制。

什么是 Polymorphism（多态）？

Polymorphism = “many forms”（多种形式）

多态性是一种程序设计特性，使得同样的操作符或函数调用可以根据类型的不同执行不同的行为。

静态多态（Static Polymorphism）

多态行为在 编译时（而非运行时）就确定了

也叫 编译时多态，通过 函数重载（overloading）、模板（templates）、运算符重载（operator overloading） 等机制实现。

示例分析

abs(5);    // 调用 int 版本
abs(5.);   // 调用 double 版本

这是函数重载的例子。abs 是重载函数，针对不同类型（int、double）编译器选择不同的函数版本，运行时无需判断类型，效率高。

模板函数示例：dot_product

template <typename Vector>
auto dot_product(const Vector& a, const Vector& b) {
    assert(a.size() == b.size());
    typename Vector::value_type sum = 0;
    for (size_t i = 0; i < a.size(); ++i) {
        sum += a[i] * b[i]; // 运算符重载
    }
    return sum;
}

逐行解释：

• template <typename Vector>
  → 定义一个泛型函数，参数可以是任何“容器类”类型，比如 std::vector<int>、std::array<double, N> 等。
• assert(a.size() == b.size());
  → 断言两个向量大小一致。
• typename Vector::value_type sum = 0;
  → 获取容器元素类型，如 int、float，用于累加。
• a[i] * b[i]
  → 使用 运算符重载（operator overloading），该语句本质上调用 operator*，可被用户自定义重载。

总结：

这是典型的 静态多态 实例，dot_product 不依赖运行时类型信息，而是在编译期根据传入的容器类型实例化出具体版本的函数代码。性能好，无运行时开销。

动态 vs 静态 多态

未来指向：DynaMix

标题提到了 DynaMix，它是一个现代 C++ 库，用来以更灵活的方式实现多态（组件组合而不是类继承）。它允许你在运行时改变对象的行为和能力，解决传统动态多态扩展困难的问题。

可理解为“运行时 mixin 机制” + 动态组合组件接口，更多基于 composition 而不是 inheritance。

C++ 中的 动态多态性（dynamic polymorphism），以及它在现代 C++ 和面向对象编程（OOP）中的地位、优缺点与争议。以下是对整段内容的详细逐条解释与理解。

Dynamic Polymorphism（动态多态性）

定义：

动态多态性指的是：

函数调用在编译期是已知的，但实际调用的函数体在运行期才能确定。

例如：

• 函数指针
• std::function
• 虚函数（virtual functions）

举例：

struct Drawable {
  virtual void draw(std::ostream& out) const = 0;
};

这里 draw() 是一个虚函数，编译器不知道你到底是要调用 Square::draw 还是 Circle::draw，直到运行时。

特点和争议：

• 慢：虚函数需要虚表指针（vtable lookup），不能内联，增加了运行时开销。
• 不友好的编译器错误：出错位置往往在运行时才暴露。
• 与现代 C++ 哲学相悖：现代 C++ 倾向使用 编译期多态（templates、concepts）和 值语义（value semantics），而不是传统的类层次结构和虚函数。

OOP 的现状（State of OOP）

OOP has been criticized a lot.

面向对象编程受到了越来越多的质疑，尤其在现代 C++ 社区。原因包括：

• 模式（patterns）往往弥补语言表达力不足
• 虚继承复杂、封装差、扩展性差
• 动态多态相比泛型性能差，调试难
  但也不能完全否定：

“OOP can be useful for business logic (gameplay)”

在一些 业务逻辑（如游戏玩法、UI 控制、事件系统）中，OOP 的模型依然是直观的、实用的。

C++ 的 OOP 支持

C++ 本身就是一门 OOP 语言，但原生只提供：

• 类（class/struct）
• 继承（inheritance）
• 虚函数（virtual functions）
  示例代码：

struct Drawable {
  virtual void draw(std::ostream& out) const = 0;
};
struct Square : Drawable {
  void draw(std::ostream& out) const override { out << "■"; }
};
struct Circle : Drawable {
  void draw(std::ostream& out) const override { out << "◯"; }
};
void f(const Drawable& d) {
  d.draw(std::cout);
}
int main() {
  f(Square{});
  f(Circle{});
}

这个设计很好地展示了传统 C++ 动态多态。

C++ vs. 脚本语言：业务逻辑中的选择

问题：

Is C++ a bad choice for business logic?

很多团队选择了其他语言（Lua, Python, JS, Ruby）来处理业务逻辑，原因包括：

脚本语言的优势：

• 热重载（hotswap）：运行时可以加载/修改脚本
• 更好地支持非程序员：比如策划可以写 Lua 脚本
• 开发快速，语法简单

但也有缺点：

• 速度慢
• 绑定层（C++ <=> 脚本）增加复杂性
• 功能重复、可能带来重复的 bug
  所以脚本语言适合快速开发、业务逻辑，但 核心性能敏感的模块仍需 C++ 编写。

小结：C++ 与多态性

现代 C++ 中多态性（Polymorphism in Modern C++） 的多种形式，特别是围绕 类型擦除（type erasure）、信号/槽机制（signals/slots）、多重分发（multiple dispatch） 等现代方法，作为传统虚函数的替代方案。

回顾：传统的动态多态（Virtual Functions）

传统 C++ 中的多态实现通常如下：

struct Drawable {
  virtual void draw(std::ostream&) const = 0;
  virtual ~Drawable() = default;
};
void f(const Drawable& d) { d.draw(std::cout); }

这个方式 侵入性强（必须继承抽象类），并存在性能与灵活性的问题。

Modern C++：类型擦除多态（Polymorphic Type-Erasure Wrappers）

类型擦除是一种 更灵活、更现代 的多态性实现方式，允许你使用不相关的类型，只要它们满足某种接口。

示例伪代码（类似用法）：

// 宏/库魔法：生成 Drawable 类型（满足 .draw(std::ostream&)）
using Drawable = Library_Magic(void, draw, (std::ostream&));
// 接口函数
void f(const Drawable& d) {
  d.draw(std::cout);
}
// 实际类型
struct Square {
  void draw(std::ostream& out) const { out << "Square\n"; }
};
struct Circle {
  void draw(std::ostream& out) const { out << "Circle\n"; }
};
int main() {
  f(Square{});
  f(Circle{});
}

典型库：

类型擦除相比虚函数的优势

结论：

类型擦除本质是 “改进过的虚函数”，更现代、灵活，但还不够强大到完全替代其他语言（如 Lua/Python）用于脚本逻辑。

其他现代 C++ 多态机制

1. 信号/槽（Signals/Slots）

一种发布/订阅的模式，广泛用于 GUI 编程中

• 最著名：Qt 的信号与槽机制
• C++ 中的实现包括：
  • Boost.Signals2
  • FastDelegate
  • nano-signal-slot（轻量）
• 非常适合事件驱动系统（UI、游戏）

// 简化示例
Signal<void()> onClick;
onClick.connect([] { std::cout << "Clicked!\n"; });
onClick();  // 会触发连接的回调

2. 多重分发（Multiple Dispatch）

根据 多个参数的类型 同时决定调用哪个函数

collide(obj1, obj2);  // 根据 obj1 和 obj2 的实际类型选择重载

传统 C++ 虚函数只支持单分发（this 指针），多分发则更复杂，但可以通过技巧模拟：

• 模拟方式：
  • 双重虚函数调度（double dispatch）
  • 类型标签（type tag + switch）
  • 动态类型映射表
• 库支持：
  • Folly.Poly
  • yomm2（You Only Multiply Methods）——真正支持多重分发的库

Functional 风格

一些 函数式编程库 也能实现多态行为，比如通过：

• 高阶函数（higher-order function）
• std::function
• 可组合组件
• monad（比如 std::optional, expected）
  这些更偏向于 组合式、声明式 编程风格，和 OOP 的层次继承形成鲜明对比。

总结

内容介绍了 DynaMix —— 一种“动态混入（dynamic mixins）”机制，目标是在 C++ 中实现类似 Ruby 的运行时多态性组合。下面是对它的逐步详细解析：

什么是 DynaMix？

DynaMix 是一种支持在运行时（而非编译时）组合和修改多态对象行为的机制。

• 它不是物理库、也不是游戏库。
• 它是对 C++ 中传统多态编程方式的革新。
• 名字来自 Dynamic + Mixins。

为什么需要 DynaMix？

C++ 传统的多态依赖虚函数和继承：

struct Animal {
    virtual void speak() = 0;
};

这种方式的问题：

• 侵入性强：类必须提前设计好虚函数接口。
• 编译时确定：对象的行为在编译期就被固定。
• 缺乏灵活组合：不能动态添加“能力”。
  而 Ruby、Python 等语言支持运行时修改对象的行为 —— 这就是 DynaMix 的灵感来源。

Ruby 示例解释（灵感来源）

Ruby 支持 动态混入模块（Mixin）：

module FlyingCreature
  def move_to(target)
    puts can_move_to?(target) ? "flying to #{target}" : "can't fly to #{target}"
  end
  def can_move_to?(target)
    true  # 飞行生物不关心目标
  end
end
module AfraidOfEvens
  def can_move_to?(target)
    target % 2 != 0  # 害怕偶数的生物只能移动到奇数位置
  end
end
a = Object.new
a.extend(FlyingCreature)      # 给对象 a 添加 FlyingCreature 的能力
a.move_to(10)                 # => flying to 10
a.extend(AfraidOfEvens)       # 给同一个对象添加新的能力，覆盖旧行为
a.move_to(10)                 # => can't fly to 10

关键特性：

• 对象在运行时组合“行为模块”。
• AfraidOfEvens 覆盖了 FlyingCreature 中的 can_move_to?。
• 完全运行时多态，无继承、无预先定义的抽象接口。

DynaMix 在 C++ 中做了什么？

它尝试在 C++ 中提供类似能力：

• 可以在 运行时向对象添加或移除“行为（mixin）”。
• 可以根据对象“当前状态”决定它有哪些接口和能力。
• 行为之间可以 组合、协作、甚至互相覆盖。

举个 DynaMix 在 C++ 中的简单类比

假设你有一个游戏角色系统，你可以写：

object.add<Renderable>();
object.add<Physics>();
object.remove<Physics>();

你可以通过 .get<Renderable>().draw(); 来访问接口。
背后是 DynaMix 实现的：

• 类型擦除
• 动态调度
• RTTI 或自定义类型信息
• 分层组件映射机制

对比：传统多态 vs DynaMix

总结

DynaMix 是 C++ 对动态行为组合的尝试，结合类型擦除与组件思想，允许你：

• 把对象看作一组“能力”的组合。
• 不再用深层继承，而是用行为模块（mixins）动态组合。
• 运行时修改对象行为。
• 接近脚本语言的灵活性，但保留 C++ 的性能和类型安全。
  它是给 C++ 带来更多 灵活性与表达能力 的一次有趣探索。

C++ 代码展示了 静态多态性（Static Polymorphism）的一种形式：CRTP Mixins（Curiously Recurring Template Pattern）。

总体概念

这段代码的核心思想是通过 CRTP + mixins 机制，把“能力”像乐高一样组合到类上，而不用写大量重复的派生类或使用虚函数。

代码结构详解

我们逐段解析它的意义：

1⃣ cd_reader：一个基础功能类

struct cd_reader {
    string get_sound() const {
        return cd.empty() ? "silence" : ("cd: " + cd);
    }
    string cd;
};

• 有一个成员变量 cd，代表正在播放的 CD。
• 提供接口 get_sound() 返回声音信息（或者 “silence”）。

2⃣ headphones<Self>：一个 mixin 模板类

template <typename Self>
struct headphones {
    const Self* self() const {
        return static_cast<const Self*>(this);
    }
    void play() {
        cout << "Playing " << self()->get_sound()
             << " through headphones\n";
    }
};

这是一个典型的 CRTP 模板 mixin。

• 通过 static_cast<const Self*>(this) 获取派生类指针（类似 this）。
• 通过 self()->get_sound() 调用派生类的函数。
• play() 表示把声音通过耳机播放。
  Self 是派生类类型，通过 CRTP 传入。

3⃣ diskman：组合行为的具体类型

struct diskman : public cd_reader, public headphones<diskman> {};

表示“磁带随身听”，它具有：

• cd_reader 功能（可以获取 CD 声音）
• headphones 功能（可以播放声音到耳机）
  它可以直接调用：

diskman d;
d.cd = "Jazz";
d.play();  // 输出：Playing cd: Jazz through headphones

4⃣ 类似的其他组合：

struct boombox : public cd_reader, public speakers<boombox> {};
struct ipod : public mp3_reader, public headphones<ipod> {};

假设：

• speakers<Self> 是另一个 mixin，提供 play()，但输出到扬声器。
• mp3_reader 是类似 cd_reader 的功能类，但读取 MP3。
  这表明可以通过不同组合产生不同类型的设备（boombox、ipod），都共享通用行为组件。

CRTP Mixins 的优点

CRTP Mixins 的缺点

总结

这段代码使用 CRTP Mixins 技术实现了静态组合多态行为：

• 用 headphones<Self> 封装“耳机播放”逻辑；
• 用 cd_reader/mp3_reader 提供声音源；
• 用继承将它们组合成 diskman / ipod 等不同设备；
• 整个系统没有使用任何虚函数，但依然实现了“多态行为”。
  它是一种 编译时多态替代方案，适用于 性能要求高、行为固定 的系统设计场景（如嵌入式、音频播放模拟器等）。

静态（CRTP）Mixins 的一种典型用法，它结合了 CRTP（奇异递归模板模式） 与 组件式编程思想（Mixins） 来实现零运行时开销的多态组合行为。

下面我们逐段详细分析：

代码结构概述

struct cd_reader {
    string get_sound() const {
        return cd.empty() ? "silence" : ("cd: " + cd);
    }
    string cd;
};

cd_reader 是一个“能力组件”

• 提供了一个 get_sound() 方法，用来返回正在播放的 CD。
• 如果 cd 是空的，就返回 "silence"。
• 它并不定义如何“播放”，只负责提供声音源。

template <typename Self>
struct headphones {
    const Self* self() const {
        return static_cast<const Self*>(this);
    }
    void play() {
        cout << "Playing " << self()->get_sound()
             << " through headphones\n";
    }
};

headphones<Self> 是一个 Mixin 模板类

• 使用了 CRTP（Curiously Recurring Template Pattern）。
• 通过 static_cast 获取派生类的指针，从而调用 self()->get_sound()。
• 实现了播放行为 —— 输出音频到耳机。
• 它假设派生类拥有 get_sound() 方法，但不关心细节。

struct diskman : public cd_reader, public headphones<diskman> {};

diskman 是实际对象类型

• 它组合了 cd_reader（声音源）和 headphones<diskman>（播放行为）。
• 现在你可以创建对象如下：

diskman d;
d.cd = "Rock";
d.play();  // 输出：Playing cd: Rock through headphones

struct boombox : public cd_reader, public speakers<boombox> {};

boombox 说明（假设）

虽然 speakers<boombox> 没有在你提供的代码中定义，但可以推测它是另一个 mixin，用来将声音通过扬声器播放：

template <typename Self>
struct speakers {
    const Self* self() const {
        return static_cast<const Self*>(this);
    }
    void play() {
        cout << "Playing " << self()->get_sound()
             << " through speakers\n";
    }
};

struct ipod : public mp3_reader, public headphones<ipod> {};

mp3_reader 说明（假设）

同样，mp3_reader 类应该是和 cd_reader 类似的声音源组件，例如：

struct mp3_reader {
    string song;
    string get_sound() const {
        return song.empty() ? "silence" : ("mp3: " + song);
    }
};

CRTP (Curiously Recurring Template Pattern)

这段代码的关键是 CRTP：

template <typename Self>
struct headphones {
    const Self* self() const {
        return static_cast<const Self*>(this);  // 把自己转换为派生类
    }
    void play() {
        cout << "Playing " << self()->get_sound() << " through headphones\n";
    }
};

通过 CRTP：

• mixin 类 headphones<Self> 可以在不依赖虚函数的情况下访问派生类方法。
• 避免了运行时多态（virtual），实现了 零开销 的编译期多态。

总结：这段代码的意义

现实意义 / 使用场景

这种设计非常适用于：

• 嵌入式系统（无需虚函数机制）
• 游戏引擎中组件化设计（ECS 架构的一部分）
• 高性能系统（如数值计算、图像处理等）

以下是你所提供的 Static (CRTP) Mixins 示例的完整代码，包括推测的缺失部分（如 speakers 和 mp3_reader）。这个示例展示了如何使用 CRTP 和 Mixin 组件组合不同的功能模块。

完整示例代码（C++17 起）

#include <iostream>
#include <string>
using namespace std;
// 声音源：CD 播放器
struct cd_reader {
    string cd;
    string get_sound() const {
        return cd.empty() ? "silence" : ("cd: " + cd);
    }
};
// 声音源：MP3 播放器
struct mp3_reader {
    string song;
    string get_sound() const {
        return song.empty() ? "silence" : ("mp3: " + song);
    }
};
// Mixin：通过耳机播放
template <typename Self>
struct headphones {
    const Self* self() const {
        return static_cast<const Self*>(this);
    }
    void play() const {
        cout << "Playing " << self()->get_sound()
             << " through headphones\n";
    }
};
// Mixin：通过扬声器播放
template <typename Self>
struct speakers {
    const Self* self() const {
        return static_cast<const Self*>(this);
    }
    void play() const {
        cout << "Playing " << self()->get_sound()
             << " through speakers\n";
    }
};
// 设备：磁带机（使用 CD 和耳机）
struct diskman : public cd_reader, public headphones<diskman> {};
// 设备：收音机（使用 CD 和扬声器）
struct boombox : public cd_reader, public speakers<boombox> {};
// 设备：iPod（使用 MP3 和耳机）
struct ipod : public mp3_reader, public headphones<ipod> {};
int main() {
    diskman d;
    d.cd = "Linkin Park - Hybrid Theory";
    d.play();
    boombox b;
    b.cd = "Queen - Greatest Hits";
    b.play();
    ipod i;
    i.song = "Daft Punk - One More Time";
    i.play();
    return 0;
}

输出示例：

Playing cd: Linkin Park - Hybrid Theory through headphones
Playing cd: Queen - Greatest Hits through speakers
Playing mp3: Daft Punk - One More Time through headphones

说明：

给出的代码是用 CRTP (Curiously Recurring Template Pattern) 实现的静态 mixin 模式，目的是通过模板静态多态组合不同功能。

不过你这段代码里 speakers 和 mp3_reader 没给出定义，所以不完整。完整示例如下（补全了缺失部分）：

#include <iostream>
#include <string>
using namespace std;
struct cd_reader {
    string cd;
    string get_sound() const {
        return cd.empty() ? "silence" : ("cd: " + cd);
    }
};
struct mp3_reader {
    string song;
    string get_sound() const {
        return song.empty() ? "silence" : ("mp3: " + song);
    }
};
template <typename Self>
struct headphones {
    const Self* self() const {
        return static_cast<const Self*>(this);
    }
    void play() const {
        cout << "Playing " << self()->get_sound()
             << " through headphones\n";
    }
};
template <typename Self>
struct speakers {
    const Self* self() const {
        return static_cast<const Self*>(this);
    }
    void play() const {
        cout << "Playing " << self()->get_sound()
             << " through speakers\n";
    }
};
struct diskman : cd_reader, headphones<diskman> {};
struct boombox : cd_reader, speakers<boombox> {};
struct ipod : mp3_reader, headphones<ipod> {};
int main() {
    diskman d;
    d.cd = "The Beatles";
    d.play();
    boombox b;
    b.cd = "Led Zeppelin";
    b.play();
    ipod i;
    i.song = "Daft Punk";
    i.play();
    return 0;
}

输出：

Playing cd: The Beatles through headphones
Playing cd: Led Zeppelin through speakers
Playing mp3: Daft Punk through headphones

这就是典型的 CRTP 静态 mixin 用法，把不同功能（播放方式、声音源）以模板静态组合形式混入设备类，编译时解析多态，零开销。

写一个完整的示例代码，包含你给出的静态多态（CRTP mixins）模式，并在代码里添加详细注释帮助理解。

#include <iostream>
#include <string>
using namespace std;
// 这是一个简单的“cd_reader”类，提供获取声音的方法
struct cd_reader {
    string cd; // 存放cd名称或内容
    // 获取声音内容
    string get_sound() const {
        // 如果cd为空，则返回"silence"，否则返回"cd: "加cd内容
        return cd.empty() ? "silence" : ("cd: " + cd);
    }
};
// 这是mp3_reader类，类似cd_reader，只不过管理的是mp3
struct mp3_reader {
    string mp3; // 存放mp3文件名
    string get_sound() const {
        // mp3为空时返回“silence”，否则返回mp3文件名
        return mp3.empty() ? "silence" : mp3;
    }
};
// 这是一个模板类 headphones，使用CRTP模式
// 通过传入子类Self，实现静态多态
template <typename Self>
struct headphones {
    // 获取指向子类的指针
    const Self* self() const {
        return static_cast<const Self*>(this);
    }
    // 播放方法，调用子类的 get_sound()
    void play() {
        cout << "Playing " << self()->get_sound() << " through headphones\n";
    }
};
// 这里模拟一个 speakers mixin，给 boombox 使用
template <typename Self>
struct speakers {
    const Self* self() const {
        return static_cast<const Self*>(this);
    }
    void play() {
        cout << "Playing " << self()->get_sound() << " through speakers\n";
    }
};
// 具体设备类 diskman，继承cd_reader和headphones（传入自己类型diskman）
struct diskman : public cd_reader, public headphones<diskman> {};
// 具体设备类 boombox，继承cd_reader和speakers
struct boombox : public cd_reader, public speakers<boombox> {};
// 具体设备类 ipod，继承mp3_reader和headphones
struct ipod : public mp3_reader, public headphones<ipod> {};
// 模板函数，使用任何实现了play()的播放设备
template <typename SoundPlayer>
void use_player(SoundPlayer& player) {
    player.play();
}
int main() {
    diskman dm;
    dm.cd = "Led Zeppelin IV (1971)";
    use_player(dm); // 输出: Playing cd: Led Zeppelin IV (1971) through headphones
    ipod ip;
    ip.mp3 = "Led Zeppelin - Black Dog.mp3";
    use_player(ip); // 输出: Playing Led Zeppelin - Black Dog.mp3 through headphones
    boombox bb;
    bb.cd = "Queen - Bohemian Rhapsody";
    use_player(bb); // 输出: Playing cd: Queen - Bohemian Rhapsody through speakers
    return 0;
}

代码解析

• cd_reader 和 mp3_reader 提供不同类型的声音源读取接口。
• headphones 和 speakers 是模板 mixin，利用 CRTP 模式，静态地绑定子类实现的接口。
• 每个具体设备类（diskman, boombox, ipod）都组合了对应的声音源和播放方式。
• use_player 是一个模板函数，能接受任何有 play() 的对象，实现了静态多态。
• 由于静态多态，编译器能在编译期解析函数调用，避免运行时开销。

这段内容是介绍 C++ 中一个非常有趣的库 DynaMix 的核心思想。它是一个实现 运行时可组合多态（runtime composable polymorphism） 的库——是一种比传统面向对象更加灵活的多态方案。

我们来详细逐段解析你贴的内容：

什么是 DynaMix？

DynaMix = Dynamic + Mixins

DynaMix 是一种 动态组合 mixins（混入类） 的系统，允许你在运行时对对象的能力进行增删改——而不仅仅是在编译期定义好。

核心构建块（Building Blocks）

dynamix::object

这是 DynaMix 提供的最核心类，相当于一个空的壳子对象，初始什么功能都没有。

Mixins

用户定义的类，它们提供具体的功能。例如 cd_reader, headphones_output, speakers_output 等。

Messages

这些是 DynaMix 中的“虚函数接口”——一种发送行为的方式，不是成员函数，而是通过 DynaMix 注册并调用的自由函数。例如：play()。

使用流程（Usage）

Mutation（变异）

这是 DynaMix 的关键操作：你可以给对象动态添加或移除 mixin。
比如：

dynamix::mutate(obj)
    .add<cd_reader>()
    .add<headphones_output>();

Message 调用

不能通过成员函数 obj.play() 来调用，而是通过 play(obj) 这样的全局函数来调用：

play(sound_player);

DynaMix 根据当前对象的 mixin 组合决定哪个 play() 实现生效。

示例代码详解：DynaMix Sound Player

dynamix::object sound_player; // 创建一个空对象

第一步：添加功能模块（mixins）

dynamix::mutate(sound_player)
    .add<cd_reader>()
    .add<headphones_output>();

此时 sound_player 拥有了两个功能：

• 可以读取 CD（cd_reader）
• 可以输出到耳机（headphones_output）

第二步：使用功能

sound_player.get<cd_reader>()->insert("Led Zeppelin IV (1971)");
play(sound_player); 

• 你调用 cd_reader 的 insert() 方法，插入一张 CD。
• 然后通过 message play() 来播放。此时是通过 headphones 输出的。
  输出：

-> Playing CD "Led Zeppelin IV (1971)" through headphones

第三步：切换输出方式

dynamix::mutate(sound_player)
    .remove<headphones_output>()
    .add<speakers_output>();
play(sound_player);

你移除了耳机功能，添加了扬声器输出功能。再次调用 play()：
输出：

-> Playing CD "Led Zeppelin IV (1971)" THROUGH SPEAKERS

注意

DynaMix 的对象不能通过 sound_player.play() 来调用 play()，因为 play() 是一个被 DynaMix message 系统接管的自由函数，而不是类的成员函数。

总结：DynaMix 特性对比传统多态

示例：使用 DynaMix 实现可动态改变行为的播放器

#include <dynamix/object.hpp>
#include <dynamix/mutate.hpp>
#include <iostream>
#include <string>
using namespace std;
using namespace dynamix;
// 假设存在以下 mixin 和 message 定义（这里只是说明性质）
// mixin: 提供播放音频的能力的消息
DYNAMIX_MESSAGE(void, play, (object& obj)); // message 声明
// mixin: 读取 CD 的能力
struct cd_reader {
    void insert(const string& cd_name) {
        cd = cd_name;
    }
    string get_sound() const {
        return cd.empty() ? "silence" : "CD: " + cd;
    }
private:
    string cd;
};
// mixin: 使用耳机播放音频
struct headphones_output {
    void play(object& obj) const {
        auto reader = obj.get<cd_reader>();
        if (reader)
            cout << "Playing " << reader->get_sound() << " through headphones" << endl;
    }
};
// mixin: 使用扬声器播放音频
struct speakers_output {
    void play(object& obj) const {
        auto reader = obj.get<cd_reader>();
        if (reader)
            cout << "Playing " << reader->get_sound() << " THROUGH SPEAKERS" << endl;
    }
};
// 将 play 函数注册为一个消息（message）
DYNAMIX_DEFINE_MESSAGE(play);
int main() {
    // 创建一个空的动态对象，初始时没有任何功能
    object sound_player;
    // 向对象中添加 cd_reader 和 headphones_output 两个 mixin（功能模块）
    mutate(sound_player)
        .add<cd_reader>()
        .add<headphones_output>();
    // 使用 cd_reader 功能插入一张 CD
    sound_player.get<cd_reader>()->insert("Led Zeppelin IV (1971)");
    // 调用消息 play（此时 headphones_output 中的 play 实现会被调用）
    play(sound_player);
    // 输出: Playing CD: Led Zeppelin IV (1971) through headphones
    // 将耳机输出移除，添加扬声器输出
    mutate(sound_player)
        .remove<headphones_output>()
        .add<speakers_output>();
    // 再次播放（现在是扬声器版本）
    play(sound_player);
    // 输出: Playing CD: Led Zeppelin IV (1971) THROUGH SPEAKERS
}

要点总结

应用场景示例

• 游戏开发：动态添加/删除角色能力（飞行、隐身、攻击等）
• 插件系统：运行时加载功能模块，无需重启程序
• 模拟多重继承：比传统虚函数更加灵活

DynaMix —— 一种为 C++ 提供运行时可组合多态（runtime composable polymorphism）的库。它通过“mixin + 消息”的机制来替代传统的虚函数继承体系，旨在更灵活、动态地构建对象行为。

下面是逐段详细理解与注释解释：

Inevitable Boilerplate（不可避免的样板代码）

DynaMix 使用宏来声明和定义“消息”（类似虚函数，但与类解耦）：

// 声明三个消息（message）接口，参数分别为 0 个和 2 个：
DYNAMIX_MESSAGE_0(string, get_sound);           // 返回 string，无参数
DYNAMIX_MESSAGE_0(void, play);                  // 返回 void，无参数
DYNAMIX_MESSAGE_2(int, foo, float, arg1, string, arg2); // 返回 int，有两个参数
// 定义（注册）这些消息
DYNAMIX_DEFINE_MESSAGE(get_sound);
DYNAMIX_DEFINE_MESSAGE(play);
DYNAMIX_DEFINE_MESSAGE(foo);

本质： MESSAGE 声明的是接口，DEFINE 注册的是实现跳转机制（类似虚表注册）。

Message vs Method

这段区分了 DynaMix 的消息和传统 C++ 的方法（member function）：

struct Foo {
    void bar();
};
Foo foo;
foo.bar();        // 方法调用
void Foo::bar() {} // 方法定义

而在 DynaMix 中，“消息”不是绑定在类上的，而是通过全局函数 + mixin 实现的。类似 Smalltalk 的消息机制：

play(myObject); // 消息：运行时查找 play 实现并调用

Boilerplate Continued：声明 mixin

DYNAMIX_DECLARE_MIXIN(cd_reader);
DYNAMIX_DECLARE_MIXIN(headphones_output);

作用： 声明 cd_reader、headphones_output 是 DynaMix 的 mixin，参与对象组合。

然后是 mixin 的定义：

class cd_reader {
public:
    string get_sound() {
        return _cd.empty() ? "silence" : ("CD " + _cd);
    }
    void insert(const string& cd) {
        _cd = cd;
    }
private:
    string _cd;
};
// 把 get_sound 函数注册为 get_sound_msg 消息的实现
DYNAMIX_DEFINE_MIXIN(cd_reader, get_sound_msg);

Referring to the Owning Object（引用宿主对象）

class headphones_output {
public:
    void play() {
        cout << "Playing " << get_sound(dm_this)
             << " through headphones\n";
    }
};
DYNAMIX_DEFINE_MIXIN(headphones_output, play_msg);

注意 dm_this 是 DynaMix 提供的宿主对象指针（类似 this，但指向的是 dynamix::object，而非 mixin 自己）。这是 DynaMix 非侵入式的关键机制。

一点视觉糖（Eye-candy time）

项目 MixQuest 展示了如何用 DynaMix 写出类似游戏引擎的代码。

DynaMix vs 脚本语言（Lua/Python）

使用脚本的缺点 DynaMix 能避免：

• 慢（解释型语言）
• 复杂的绑定层
• 重复功能（=重复的 bug）

脚本语言的优点（部分 DynaMix 能覆盖）：

• 热更新
• 非程序员也能参与 （DynaMix 不能，还是 C++）
• 快速开发 （部分）
  适用场景如手游（对性能敏感、需要热插拔组件）。

When to Use DynaMix

• 复杂的对象组合（如游戏实体系统）
• 接口驱动的子系统（而非纯数据驱动）
• 插件式架构
• CAD 系统、RPG/策略游戏、企业系统（某些）

When Not to Use DynaMix

• 小项目
• 几乎不使用多态
• 已成型的大型代码库
• 性能极致要求的代码（调用开销大于函数调用）

性能

调用开销：

• 消息调用比函数指针略慢，与 std::function 相当
• 支持线程安全的调用（消息调用）
• 但跨线程变异（mutate）不安全

内存开销：

• mixin 结构体 + 指针跳转（更大对象）
• 每种唯一类型维护自身 mixin 映射

Recap 回顾

DynaMix 提供：

• 使用 mixin 组合对象行为（非继承）
• 单播/多播消息机制
• 消息优先级控制
• 可热插拔插件架构
  未覆盖但支持的特性包括：
• 自定义分配器
• 消息投标（优先级控制）
• 多播返回值组合策略
• 内部实现细节

总结理解

#include <dynamix/define_domain.hpp>
#include <dynamix/declare_domain.hpp>
#include <dynamix/define_domain.hpp>
#include <dynamix/object.hpp>
#include <dynamix/mutate.hpp>
#include <dynamix/domain.hpp>
#include <dynamix/declare_mixin.hpp>
#include <dynamix/define_mixin.hpp>
#include <dynamix/msg/declare_msg.hpp>
#include <dynamix/msg/define_msg.hpp>
#include <dynamix/msg/func_traits.hpp>
#include <iostream>
#include <string>
using namespace std;
using namespace dynamix;
// --------------------------
// 声明消息（Message）接口
// --------------------------
DYNAMIX_DECLARE_MSG(get_sound_msg, get_sound, std::string, (const dynamix::object&));
DYNAMIX_DECLARE_MSG(play_msg, play, void, (dynamix::object&, dynamix::object&));
// --------------------------
// 声明 mixin 类型
// --------------------------
DYNAMIX_DECLARE_MIXIN(struct cd_reader);
DYNAMIX_DECLARE_MIXIN(struct headphones_output);
DYNAMIX_DECLARE_MIXIN(struct speakers_output);
DYNAMIX_DECLARE_DOMAIN(my_domain);
// --------------------------
// 定义 mixin 类
// --------------------------
struct cd_reader {
    void insert(const string& cd_name) { cd = cd_name; }
    string get_sound() const { return cd.empty() ? "silence" : "CD: " + cd; }
private:
    string cd;
};
struct headphones_output {
    void play(object& obj) const {
        auto reader = obj.get<cd_reader>();
        if (reader) {
            cout << "Playing " << reader->get_sound() << " through headphones\n";
        }
    }
};
struct speakers_output {
    void play(object& obj) const {
        auto reader = obj.get<cd_reader>();
        if (reader) {
            cout << "Playing " << reader->get_sound() << " THROUGH SPEAKERS\n";
        }
    }
};
// --------------------------
// 定义消息函数签名 traits
// （必须！）
// --------------------------
DYNAMIX_MAKE_FUNC_TRAITS(get_sound);
DYNAMIX_MAKE_FUNC_TRAITS(play);
// --------------------------
// 定义消息
// --------------------------
DYNAMIX_DEFINE_MSG(get_sound_msg, unicast, get_sound, std::string, (const dynamix::object&));
DYNAMIX_DEFINE_MSG(play_msg, multicast, play, void, (dynamix::object&, dynamix::object&));
// --------------------------
// 自定义 domain
// --------------------------
DYNAMIX_DEFINE_DOMAIN(my_domain);
// --------------------------
// 注册 mixin 到 domain 并绑定消息
// --------------------------
DYNAMIX_DEFINE_MIXIN(my_domain, cd_reader).implements<get_sound_msg>();
DYNAMIX_DEFINE_MIXIN(my_domain, headphones_output).implements<play_msg>();
DYNAMIX_DEFINE_MIXIN(my_domain, speakers_output).implements<play_msg>();
int main() {
    object sound_player(g::get_domain<my_domain>());
    // 初始状态：cd_reader + headphones
    mutate(sound_player).add<cd_reader>().add<headphones_output>();
    sound_player.get<cd_reader>()->insert("Led Zeppelin IV (1971)");
    play(sound_player, sound_player);
    // 切换输出为扬声器
    mutate(sound_player).remove<headphones_output>().add<speakers_output>();
    play(sound_player, sound_player);
}

Playing CD: Led Zeppelin IV (1971) through headphones
Playing CD: Led Zeppelin IV (1971) THROUGH SPEAKERS
[1] + Done                       "/usr/bin/gdb" --interpreter=mi --tty=${DbgTerm} 0<"/tmp/Microsoft-MIEngine-In-k1o3t0b3.xcm" 1>"/tmp/Microsoft-MIEngine-Out-n1udbbau.mao"
xiaqiu@xz:~/test/CppCon/day197/code/dynamix$ 

https://gitee.com/mrxiao_com/CppConStudy/blob/master/CppCon/day197/code/dynamix/example/hello-world/test.cpp