C++20 Concepts与CRTP静态多态：派生类如何调用基类成员？

我正在学习用C++20 Concepts替代CRTP实现静态多态。CRTP的优势在于派生类可以直接使用基类的变量和方法——比如下方示例中，Derived就直接使用了基类Base的shared变量。但用Concepts实现静态多态时，我只能从基类调用派生类的方法，无法反向操作。请问如何在基于Concepts的静态多态中，让派生类调用基类的方法并使用基类变量？

CRTP示例代码：

#include <iostream>
using namespace std;

template <class TImpl>
class Base {
private:
  TImpl &impl = static_cast<TImpl &>(*this);
  friend TImpl;
  int shared = 0;

public:
  void say_hello() { impl.do_say_hello(); }
};

class Derived : public Base<Derived> {
  friend Base<Derived>;
  void do_say_hello() {
    shared = 3;
    cout << "Hello " << shared << endl;
  }
};

int main() {
  Derived d;
  d.say_hello();
}

要在Concepts驱动的静态多态中实现派生类对基类成员的访问，有几种可行方案，核心是明确拆分通用逻辑、共享状态和派生类的特化逻辑：

方案1：共享状态基类 + Concept接口约束 #

将共享状态和通用方法放在独立基类中，派生类继承该基类，同时用Concept约束派生类必须实现特化接口。这种方式既保留了CRTP中派生类直接访问基类成员的便利，又通过Concept明确了接口契约：

#include <iostream>
#include <concepts>

// 定义Concept：要求类型必须实现do_say_hello方法
template<typename T>
concept Helloable = requires(T t) {
    { t.do_say_hello() } -> std::same_as<void>;
};

// 封装共享状态和通用方法的基类
class SharedBase {
protected:
    int shared = 0;
    void base_common_method() {
        std::cout << "Base common logic executed" << std::endl;
    }
};

// 派生类继承共享基类，满足Helloable约束
class Derived : public SharedBase {
public:
    void do_say_hello() {
        // 直接访问基类的共享变量和方法
        shared = 3;
        base_common_method();
        std::cout << "Hello " << shared << std::endl;
    }
};

// 通用静态多态函数，用Concept约束参数类型
template<Helloable T>
void invoke_say_hello(T& obj) {
    obj.do_say_hello();
}

int main() {
    Derived d;
    invoke_say_hello(d);
    return 0;
}

方案2：组合模式 + Concept约束 #

如果不想用继承关系，可以通过组合让派生类持有基类实例，用Concept约束派生类提供访问基类的接口，实现状态和方法的共享：

#include <iostream>
#include <concepts>

// 封装共享状态和通用方法的组件类
class BaseComponent {
public:
    int shared = 0;
    void base_method() {
        std::cout << "Base component method called" << std::endl;
    }
};

// 定义Concept：要求类型能访问BaseComponent，且实现do_say_hello
template<typename T>
concept HasBaseComponent = requires(T t) {
    { t.get_base() } -> std::same_as<BaseComponent&>;
    { t.do_say_hello() } -> std::same_as<void>;
};

// 派生类通过组合持有BaseComponent
class Derived {
private:
    BaseComponent base_;
public:
    BaseComponent& get_base() { return base_; }
    
    void do_say_hello() {
        auto& base = get_base();
        base.shared = 3;
        base.base_method();
        std::cout << "Hello " << base.shared << std::endl;
    }
};

// 通用调用函数
template<HasBaseComponent T>
void invoke_say_hello(T& obj) {
    obj.do_say_hello();
}

int main() {
    Derived d;
    invoke_say_hello(d);
    return 0;
}

方案3：CRTP + Concept增强 #

如果想保留CRTP的继承结构，同时用Concept强化接口约束（替代原有的隐式依赖），可以给CRTP基类加上Concept约束，确保派生类满足接口要求：

#include <iostream>
#include <concepts>
#include <type_traits>

// 定义Concept：要求类型实现do_say_hello，且继承自Base<T>
template<typename T>
concept DerivedFromHelloBase = requires(T t) {
    { t.do_say_hello() } -> std::same_as<void>;
    requires std::is_base_of_v<Base<T>, T>;
};

// CRTP基类，用Concept约束模板参数
template<DerivedFromHelloBase T>
class Base {
protected:
    int shared = 0;
public:
    void say_hello() {
        static_cast<T&>(*this).do_say_hello();
    }
};

// 派生类继承CRTP基类，自动满足Concept约束
class Derived : public Base<Derived> {
public:
    void do_say_hello() {
        shared = 3;
        std::cout << "Hello " << shared << std::endl;
    }
};

int main() {
    Derived d;
    d.say_hello();
    return 0;
}

三种方案各有优势：

• 方案1适合需要保留继承语义、希望派生类直接访问基类成员的场景；
• 方案2更符合组合优于继承的设计原则，耦合度更低；
• 方案3是CRTP的增强版，用Concept明确接口契约，避免隐式依赖带来的问题。

内容的提问来源于stack exchange，提问作者CowKeyMan