告别运行时多态？CRTP 让代码更高效

template<typename T>
T maxValue(T a, T b) {
    return (a > b) ? a : b;  // 这里可是暗藏玄机哦！✨
}

template<typename Derived>
class Printer {
public:
    void print() {
        // 施展魔法，调用派生类的具体实现 ✨
        static_cast<Derived*>(this)->printImpl();
        // 每次打印后都来点花里胡哨的装饰 🎀
        cout << "=== 打印完成 ===" << endl;
    }
protected:
    void printImpl() {
        cout << "哎呀，这台打印机还没设置打印方式呢！😅" << endl;
    }
};

class ColorPrinter : public Printer<ColorPrinter> {
public:
    void printImpl() {
        cout << "🎨 哇！我可以打印彩色的小花花！" << endl;
    }
};

class BWPrinter : public Printer<BWPrinter> {
public:
    void printImpl() {
        cout << "⚫ 我是一本正经的黑白打印机～" << endl;
    }
};

int main() {
    ColorPrinter colorful;
    BWPrinter blackwhite;
    
    cout << "彩色打印机开始工作啦：" << endl;
    colorful.print();
    
    cout << "\n换个打印机试试：" << endl;
    blackwhite.print();
    return 0;
}

彩色打印机开始工作啦：
🎨 哇！我可以打印彩色的小花花！
=== 打印完成 ===

换个打印机试试：
⚫ 我是一本正经的黑白打印机～
=== 打印完成 ===

// ❌ 千万不要这样做，会让编译器困惑的！
class WrongPrinter : public Printer<ColorPrinter> {  // 搞错继承了！
    // ...
};

// ✅ 要这样写才对，继承时使用自己的类型
class CorrectPrinter : public Printer<CorrectPrinter> {
    // ...
};

template<typename Derived>
class Animal {
public:
    void makeSound() {
        cout << "动物准备开口啦..." << endl;
        static_cast<Derived*>(this)->soundImpl();
        cout << "嗯！好响亮的叫声呢！🎵" << endl;
    }
    
    void findFood() {
        cout << "肚子咕咕叫，该觅食啦..." << endl;
        static_cast<Derived*>(this)->findFoodImpl();
    }

protected:
    void soundImpl() { cout << "（这只小可爱还在害羞呢~）😊" << endl; }
    void findFoodImpl() { cout << "（还不知道吃什么好...）🤔" << endl; }
};

class Cat : public Animal<Cat> {
public:
    void soundImpl() {
        cout << "喵星人优雅地说：喵~ 铲屎官快来！🐱" << endl;
    }
    
    void findFoodImpl() {
        cout << "猫猫优雅地翻翻小鱼干，顺便打翻零食罐 🐟" << endl;
    }
};

class Duck : public Animal<Duck> {
public:
    void soundImpl() {
        cout << "鸭鸭开心地嘎嘎嘎~🦆" << endl;
    }
    
    void findFoodImpl() {
        cout << "鸭鸭在池塘里快乐地捕鱼，顺便打个水漂 💦" << endl;
    }
};

int main() {
    Cat kitty;
    Duck donald;
    
    cout << "=== 铲屎官回家啦 ===\n" << endl;
    kitty.makeSound();    // 编译时就知道要调用哪个喵星人啦！
    kitty.findFood();
    
    cout << "\n=== 池塘边热闹起来啦 ===\n" << endl;
    donald.makeSound();   // 鸭鸭的叫声也在编译时就确定好啦！
    donald.findFood();
    
    return 0;
}

=== 铲屎官回家啦 ===

动物准备开口啦...
喵星人优雅地说：喵~ 铲屎官快来！🐱
嗯！好响亮的叫声呢！🎵
肚子咕咕叫，该觅食啦...
猫猫优雅地翻翻小鱼干，顺便打翻零食罐 🐟

=== 池塘边热闹起来啦 ===

动物准备开口啦...
鸭鸭开心地嘎嘎嘎~🦆
嗯！好响亮的叫声呢！🎵
肚子咕咕叫，该觅食啦...
鸭鸭在池塘里快乐地捕鱼，顺便打个水漂 💦

template<typename Derived>
class Shape {
public:
    // 这位可爱的检查员会确保所有图形都乖乖继承自 Shape 哦！🎯
    static_assert(std::is_base_of<Shape<Derived>, Derived>::value,
                 "哎呀呀，你是不是忘记继承 Shape 啦？快去补救吧！🤔");
                 
    double area() {
        // 这里的检查就像是点名一样，确保每个图形都会计算自己的面积 📏
        static_assert(std::is_member_function_pointer<
            decltype(&Derived::computeArea)>::value,
            "咦？computeArea 方法不见啦！是不是忘记写啦？✍️");
            
        // 通过检查的小可爱就可以愉快地计算面积啦～ 🌟
        return static_cast<Derived*>(this)->computeArea();
    }
};

// 糟糕，忘记继承 Shape 啦！🙈
class Circle {  
    double radius;
public:
    double computeArea() { return 3.14 * radius * radius; }
};

error: static assertion failed: 哎呀呀，你是不是忘记继承 Shape 啦？快去补救吧！🤔

template<typename Derived>
class Builder {
public:
    // 每个积木块都会乖乖返回自己，方便下一块积木接上来 🧩
    Derived& name(const string& name) {
        cout << "给机器人起名字啦：" << name << " 🏷️" << endl;
        return static_cast<Derived&>(*this);
    }
    
    Derived& color(const string& color) {
        cout << "给机器人换新衣服：" << color << " 🎨" << endl;
        return static_cast<Derived&>(*this);
    }
};

// 这个小机器人制造商特别调皮，还能设置能量等级呢！
class RobotBuilder : public Builder<RobotBuilder> {
public:
    RobotBuilder& power(int level) {
        cout << "给机器人充能量：" << level << " ⚡" << endl;
        return *this;
    }
};

// 像搭积木一样，一块接一块，超级好玩！
RobotBuilder()
    .name("小闪电")     // 先给机器人起个可爱的名字 🤖
    .color("星空蓝")    // 再给它换上漂亮的衣服 👕
    .power(100);      // 最后充满能量，准备出发！🚀

// 使用虚函数时，我们可以这样愉快地玩耍
Animal* animals[] = {new Dog(), new Cat(), new Bird()};  // ✅ 完全没问题！

// 但用 CRTP 时就不行啦...
template<typename Derived>
Animal<Derived>* animals[] = {
    new Dog(),     // ❌ 哎呀，类型不匹配啦！
    new Cat(),     // ❌ 没法在一个数组里放不同的派生类呢
    new Bird()
};

template<typename Derived>
class Animal {
    // 最开始我们只有一个简单的发声功能 🔊
    void makeSound() {
        static_cast<Derived*>(this)->soundImpl();
    }
};

// 突然有一天,我们想教动物们跳舞... 💃
void dance() {  // ❌ 哇哦!这下可热闹了! 
    static_cast<Derived*>(this)->danceImpl();
}

// 再过几天,又想教它们做体操... 🤸
void exercise() {  // ❌ 天呐!又要重新编译所有代码! 
    static_cast<Derived*>(this)->exerciseImpl();
}

// 原本可爱又简单的动物世界 🌈
template<typename Derived>
class Animal {
    void makeSound() { /* ... */ }
};

class Cat : public Animal<Cat> {
    void soundImpl() { cout << "喵~" << endl; }
};

// 某一天我们想让动物们会跳舞...
template<typename Derived>
class Animal {
    void makeSound() { /* ... */ }
    void dance() { /* ... */ }  // 新增的跳舞功能 💃
};

// 糟糕!所有的动物类都要改代码了! 😫
class Cat : public Animal<Cat> {
    void soundImpl() { cout << "喵~" << endl; }
    void danceImpl() { /* 猫猫不情愿地跳舞 */ }  // 被迫学跳舞
};

template<typename Derived>
class AnimalBehavior {
    void makeSound() { /* ... */ }
};

template<typename Derived>
class AnimalDance {
    void dance() { /* ... */ }
};

// 现在可以按需组合啦! 🎨
class Cat : 
    public AnimalBehavior<Cat>,
    public AnimalDance<Cat>  // 想跳舞的猫咪才继承这个
{ /* ... */ };

template<typename Derived>
class Base {
    void commonOperation() {
        // 这段代码会在每个派生类中都复制一份 📝
        for(int i = 0; i < 1000; i++) {
            complexCalculation();  // 假设这是一段复杂的计算 🧮
            dataProcessing();      // 还有一些数据处理 💽
            resultValidation();    // 以及结果验证 ✅
        }
        // 如果这些代码很多,每个派生类都会带着这么一大包行李! 🎒
    }
};

// 创建多个派生类
class Derived1 : public Base<Derived1> { };  // 复制一份 📋
class Derived2 : public Base<Derived2> { };  // 又复制一份 📋
class Derived3 : public Base<Derived3> { };  // 再复制一份 📋
// 程序体积: 蹭蹭蹭↗️ 

class CommonBase {
protected:
    void heavyOperation() {
        // 把占空间的代码放这里
        // 所有派生类共用这一份! 🎉
    }
};

template<typename Derived>
class Base : protected CommonBase {
    // 这里只放必要的 CRTP 相关代码 ✨
};

class Strategy {
public:
    void complexOperation() {
        // 把复杂操作集中在这里管理 🎮
    }
};

template<typename Derived>
class Base {
    Strategy strategy;  // 通过组合来复用代码 🤝
};

template<typename Derived>
class Base {
    void operation() {
        // 这里的 static_cast 就像是魔法咒语 ✨
        static_cast<Derived*>(this)->impl();
        // 但如果咒语念错了(比如派生类没实现 impl)...
        // 编译器就会抛出一大堆让人头晕眼花的错误信息! 😵💫
    }
};

class MyClass : public Base<MyClass> {
    // 糟糕!我们忘记实现 impl 啦! 🙈
    // void impl() { /* ... */ }
};

error: 'class MyClass' has no member named 'impl'
  ... (还有一大堆模板相关的错误信息) ...
note: in instantiation of member function 'Base<MyClass>::operation'
  ... (更多让人眼花缭乱的信息) ... 

template<typename Derived>
class Base {
    void operation() {
        // 先检查一下派生类是否实现了必要的方法 🔍
        static_assert(has_impl<Derived>::value,
            "哎呀!派生类忘记实现 impl 啦! 快去补充吧~ 😊");
        
        static_cast<Derived*>(this)->impl();
    }
};

template<typename Derived>
class Base {
    void doOperation() {  // 基类方法用 do 前缀
        static_cast<Derived*>(this)->implementOperation();  
        // 派生类方法用 implement 前缀
    }
};

template<typename Derived>
class Base {
    // 🌟 派生类必须实现以下方法:
    // - implementOperation(): 处理具体操作
    // - implementValidation(): 验证输入数据
    void operation() {
        static_cast<Derived*>(this)->implementOperation();
    }
};

template<typename Derived>
class Animal {
    // CRTP 小朋友不太喜欢玩这些花样 🙈
    // 没法像虚函数那样用 dynamic_cast 
    // 或 typeid 来检查类型呢
    void makeSound() {
        static_cast<Derived*>(this)->soundImpl();  // 只能这样静静地转换 🤫
    }
};

// 反观虚函数就活泼多了! 🎪
class VirtualAnimal {
    virtual void makeSound() = 0;
    virtual ~VirtualAnimal() {}
};

class Dog : public VirtualAnimal { /* ... */ };

// 虚函数可以轻松玩转类型检查 🎯
void checkAnimalType(VirtualAnimal* animal) {
    if (dynamic_cast<Dog*>(animal)) {      // ✅ 哇!轻松识别出是不是小狗呢! 🐕
        cout << "汪星人来啦! 🐶" << endl;
    }
    
    if (typeid(*animal) == typeid(Dog)) {  // ✅ 用 typeid 也可以哦! 
        cout << "又见到汪星人啦! 🐾" << endl;
    }
}

template<typename Derived>
class Animal {
    void makeSound() {
        // 在编译时就能发现类型问题,超级靠谱! 🎯
        static_assert(std::is_base_of<Animal<Derived>, Derived>::value,
                     "嘿!你是不是忘记继承 Animal 啦? 🤔");
        
        static_cast<Derived*>(this)->soundImpl();
    }
};

template<typename Derived>
class Animal {
protected:
    // 给每种动物一个独特的标识 🏷️
    enum class AnimalType { Dog, Cat, Bird };
    
    // 让派生类告诉我们它是什么动物
    virtual AnimalType getType() const = 0;
};

class Dog : public Animal<Dog> {
protected:
    AnimalType getType() const override {
        return AnimalType::Dog;  // 我是汪星人! 🐕
    }
};