template<typename T>
T maxValue(T a, T b) {
    return (a > b) ? a : b;  // 這里可是暗藏玄機(jī)哦！?
}

template<typename Derived>
class Printer {
public:
    void print() {
        // 施展魔法，調(diào)用派生類的具體實(shí)現(xiàn) ?
        static_cast<Derived*>(this)->printImpl();
        // 每次打印后都來點(diǎn)花里胡哨的裝飾 ??
        cout << "=== 打印完成 ===" << endl;
    }
protected:
    void printImpl() {
        cout << "哎呀，這臺打印機(jī)還沒設(shè)置打印方式呢！??" << endl;
    }
};

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

class BWPrinter : public Printer<BWPrinter> {
public:
    void printImpl() {
        cout << "? 我是一本正經(jīng)的黑白打印機(jī)～" << endl;
    }
};

int main() {
    ColorPrinter colorful;
    BWPrinter blackwhite;
    
    cout << "彩色打印機(jī)開始工作啦：" << endl;
    colorful.print();
    
    cout << "\n換個(gè)打印機(jī)試試：" << endl;
    blackwhite.print();
    return 0;
}

彩色打印機(jī)開始工作啦：
?? 哇！我可以打印彩色的小花花！
=== 打印完成 ===

換個(gè)打印機(jī)試試：
? 我是一本正經(jīng)的黑白打印機(jī)～
=== 打印完成 ===

// ? 千萬不要這樣做，會讓編譯器困惑的！
class WrongPrinter : public Printer<ColorPrinter> {  // 搞錯(cuò)繼承了！
    // ...
};

// ? 要這樣寫才對，繼承時(shí)使用自己的類型
class CorrectPrinter : public Printer<CorrectPrinter> {
    // ...
};

template<typename Derived>
class Animal {
public:
    void makeSound() {
        cout << "動物準(zhǔn)備開口啦..." << 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 << "喵星人優(yōu)雅地說：喵~ 鏟屎官快來！??" << endl;
    }
    
    void findFoodImpl() {
        cout << "貓貓優(yōu)雅地翻翻小魚干，順便打翻零食罐 ??" << endl;
    }
};

class Duck : public Animal<Duck> {
public:
    void soundImpl() {
        cout << "鴨鴨開心地嘎嘎嘎~??" << endl;
    }
    
    void findFoodImpl() {
        cout << "鴨鴨在池塘里快樂地捕魚，順便打個(gè)水漂 ??" << endl;
    }
};

int main() {
    Cat kitty;
    Duck donald;
    
    cout << "=== 鏟屎官回家啦 ===\n" << endl;
    kitty.makeSound();    // 編譯時(shí)就知道要調(diào)用哪個(gè)喵星人啦！
    kitty.findFood();
    
    cout << "\n=== 池塘邊熱鬧起來啦 ===\n" << endl;
    donald.makeSound();   // 鴨鴨的叫聲也在編譯時(shí)就確定好啦！
    donald.findFood();
    
    return 0;
}

=== 鏟屎官回家啦 ===

動物準(zhǔn)備開口啦...
喵星人優(yōu)雅地說：喵~ 鏟屎官快來！??
嗯！好響亮的叫聲呢！??
肚子咕咕叫，該覓食啦...
貓貓優(yōu)雅地翻翻小魚干，順便打翻零食罐 ??

=== 池塘邊熱鬧起來啦 ===

動物準(zhǔn)備開口啦...
鴨鴨開心地嘎嘎嘎~??
嗯！好響亮的叫聲呢！??
肚子咕咕叫，該覓食啦...
鴨鴨在池塘里快樂地捕魚，順便打個(gè)水漂 ??

template<typename Derived>
class Shape {
public:
    // 這位可愛的檢查員會確保所有圖形都乖乖繼承自 Shape 哦！??
    static_assert(std::is_base_of<Shape<Derived>, Derived>::value,
                 "哎呀呀，你是不是忘記繼承 Shape 啦？快去補(bǔ)救吧！??");
                 
    double area() {
        // 這里的檢查就像是點(diǎn)名一樣，確保每個(gè)圖形都會計(jì)算自己的面積 ??
        static_assert(std::is_member_function_pointer<
            decltype(&Derived::computeArea)>::value,
            "咦？computeArea 方法不見啦！是不是忘記寫啦？??");
            
        // 通過檢查的小可愛就可以愉快地計(jì)算面積啦～ ??
        return static_cast<Derived*>(this)->computeArea();
    }
};

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

error: static assertion failed: 哎呀呀，你是不是忘記繼承 Shape 啦？快去補(bǔ)救吧！??

template<typename Derived>
class Builder {
public:
    // 每個(gè)積木塊都會乖乖返回自己，方便下一塊積木接上來 ??
    Derived& name(const string& name) {
        cout << "給機(jī)器人起名字啦：" << name << " ???" << endl;
        return static_cast<Derived&>(*this);
    }
    
    Derived& color(const string& color) {
        cout << "給機(jī)器人換新衣服：" << color << " ??" << endl;
        return static_cast<Derived&>(*this);
    }
};

// 這個(gè)小機(jī)器人制造商特別調(diào)皮，還能設(shè)置能量等級呢！
class RobotBuilder : public Builder<RobotBuilder> {
public:
    RobotBuilder& power(int level) {
        cout << "給機(jī)器人充能量：" << level << " ?" << endl;
        return *this;
    }
};

// 像搭積木一樣，一塊接一塊，超級好玩！
RobotBuilder()
    .name("小閃電")     // 先給機(jī)器人起個(gè)可愛的名字 ??
    .color("星空藍(lán)")    // 再給它換上漂亮的衣服 ??
    .power(100);      // 最后充滿能量，準(zhǔn)備出發(fā)！??

// 使用虛函數(shù)時(shí)，我們可以這樣愉快地玩耍
Animal* animals[] = {new Dog(), new Cat(), new Bird()};  // ? 完全沒問題！

// 但用 CRTP 時(shí)就不行啦...
template<typename Derived>
Animal<Derived>* animals[] = {
    new Dog(),     // ? 哎呀，類型不匹配啦！
    new Cat(),     // ? 沒法在一個(gè)數(shù)組里放不同的派生類呢
    new Bird()
};

template<typename Derived>
class Animal {
    // 最開始我們只有一個(gè)簡單的發(fā)聲功能 ??
    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() { /* 貓貓不情愿地跳舞 */ }  // 被迫學(xué)跳舞
};

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

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

// 現(xiàn)在可以按需組合啦! ??
class Cat : 
    public AnimalBehavior<Cat>,
    public AnimalDance<Cat>  // 想跳舞的貓咪才繼承這個(gè)
{ /* ... */ };

template<typename Derived>
class Base {
    void commonOperation() {
        // 這段代碼會在每個(gè)派生類中都復(fù)制一份 ??
        for(int i = 0; i < 1000; i++) {
            complexCalculation();  // 假設(shè)這是一段復(fù)雜的計(jì)算 ??
            dataProcessing();      // 還有一些數(shù)據(jù)處理 ??
            resultValidation();    // 以及結(jié)果驗(yàn)證 ?
        }
        // 如果這些代碼很多,每個(gè)派生類都會帶著這么一大包行李! ??
    }
};

// 創(chuàng)建多個(gè)派生類
class Derived1 : public Base<Derived1> { };  // 復(fù)制一份 ??
class Derived2 : public Base<Derived2> { };  // 又復(fù)制一份 ??
class Derived3 : public Base<Derived3> { };  // 再復(fù)制一份 ??
// 程序體積: 蹭蹭蹭↗? 

class CommonBase {
protected:
    void heavyOperation() {
        // 把占空間的代碼放這里
        // 所有派生類共用這一份! ??
    }
};

template<typename Derived>
class Base : protected CommonBase {
    // 這里只放必要的 CRTP 相關(guān)代碼 ?
};

class Strategy {
public:
    void complexOperation() {
        // 把復(fù)雜操作集中在這里管理 ??
    }
};

template<typename Derived>
class Base {
    Strategy strategy;  // 通過組合來復(fù)用代碼 ??
};

template<typename Derived>
class Base {
    void operation() {
        // 這里的 static_cast 就像是魔法咒語 ?
        static_cast<Derived*>(this)->impl();
        // 但如果咒語念錯(cuò)了(比如派生類沒實(shí)現(xiàn) impl)...
        // 編譯器就會拋出一大堆讓人頭暈眼花的錯(cuò)誤信息! ????
    }
};

class MyClass : public Base<MyClass> {
    // 糟糕!我們忘記實(shí)現(xiàn) impl 啦! ??
    // void impl() { /* ... */ }
};

error: 'class MyClass' has no member named 'impl'
  ... (還有一大堆模板相關(guān)的錯(cuò)誤信息) ...
note: in instantiation of member function 'Base<MyClass>::operation'
  ... (更多讓人眼花繚亂的信息) ... 

template<typename Derived>
class Base {
    void operation() {
        // 先檢查一下派生類是否實(shí)現(xiàn)了必要的方法 ??
        static_assert(has_impl<Derived>::value,
            "哎呀!派生類忘記實(shí)現(xiàn) impl 啦! 快去補(bǔ)充吧~ ??");
        
        static_cast<Derived*>(this)->impl();
    }
};

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

template<typename Derived>
class Base {
    // ?? 派生類必須實(shí)現(xiàn)以下方法:
    // - implementOperation(): 處理具體操作
    // - implementValidation(): 驗(yàn)證輸入數(shù)據(jù)
    void operation() {
        static_cast<Derived*>(this)->implementOperation();
    }
};

template<typename Derived>
class Animal {
    // CRTP 小朋友不太喜歡玩這些花樣 ??
    // 沒法像虛函數(shù)那樣用 dynamic_cast 
    // 或 typeid 來檢查類型呢
    void makeSound() {
        static_cast<Derived*>(this)->soundImpl();  // 只能這樣靜靜地轉(zhuǎn)換 ??
    }
};

// 反觀虛函數(shù)就活潑多了! ??
class VirtualAnimal {
    virtual void makeSound() = 0;
    virtual ~VirtualAnimal() {}
};

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

// 虛函數(shù)可以輕松玩轉(zhuǎn)類型檢查 ??
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() {
        // 在編譯時(shí)就能發(fā)現(xiàn)類型問題,超級靠譜! ??
        static_assert(std::is_base_of<Animal<Derived>, Derived>::value,
                     "嘿!你是不是忘記繼承 Animal 啦? ??");
        
        static_cast<Derived*>(this)->soundImpl();
    }
};

template<typename Derived>
class Animal {
protected:
    // 給每種動物一個(gè)獨(dú)特的標(biāo)識 ???
    enum class AnimalType { Dog, Cat, Bird };
    
    // 讓派生類告訴我們它是什么動物
    virtual AnimalType getType() const = 0;
};

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