如何实现C++基类从子类获取Member类型参数？

需求背景 #

你希望定义一个Collection基类，仅声明以下接口，所有实现细节由子类提供：

• 类型Member
• 静态函数Member first_object()
• 静态函数Member last_object()
• 静态函数std::vector<Member> all_objects()

当前实现需要手动向基类传递Member类型参数，在多类型参数场景下会非常繁琐，因此期望一种无需手动传递类型参数的简洁写法。

为什么期望的写法无法实现 #

你给出的理想写法存在两个语法和逻辑上的问题：

1. C++中没有static typename Member;这种语法，无法在基类中声明一个待子类填充的类型占位符。
2. 类继承的初始化顺序是基类先于子类，基类定义阶段无法知晓子类中后续定义的Member类型别名，因此基类无法直接使用这个类型。

最优替代方案：CRTP（奇异递归模板模式） #

要实现“基类自动获取子类的Member类型”的需求，CRTP是C++中最常用的解决方案。通过将子类本身作为基类的模板参数，基类可以直接引用子类的Member类型，无需手动传递该参数。

完整实现代码 #

#include <string>
#include <vector>
#include <iostream>

template <typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v)
{
    os << "{ ";
    bool first = true;
    for (const T& t : v) {
        if (first)
            first = false;
        else
            os << ", ";
        os << t;
    }
    os << " }";
    return os;
}

// CRTP基类，模板参数为子类类型
template <typename Derived>
struct CollectionBase {
    using Member = typename Derived::Member;
    
    static Member first_object() {
        return Derived::first_object();
    }
    static Member last_object() {
        return Derived::last_object();
    }
    static std::vector<Member> all_objects() {
        return Derived::all_objects();
    }
};

// 子类继承CRTP基类，无需手动传递Member类型
struct CollectionA : CollectionBase<CollectionA> {
public:
    using Member = int;
private:
    static const std::vector<Member> objects;
public:
    static Member first_object() {
        return objects.front();
    }
    static Member last_object() {
        return objects.back();
    }
    static std::vector<Member> all_objects() {
        return objects;
    }
};

const std::vector<CollectionA::Member> CollectionA::objects = {1, 2, 3};

struct CollectionB : CollectionBase<CollectionB> {
public:
    using Member = std::string;
private:
    static const std::vector<Member> objects;
public:
    static Member first_object() {
        return objects.front();
    }
    static Member last_object() {
        return objects.back();
    }
    static std::vector<Member> all_objects() {
        return objects;
    }
};

const std::vector<CollectionB::Member> CollectionB::objects = {"One", "Two", "Three"};

template <typename Collection>
void do_stuff() {
    typename Collection::Member first_object = Collection::first_object();
    typename Collection::Member last_object = Collection::last_object();
    std::vector<typename Collection::Member> all_objects = Collection::all_objects();
    std::cout
        << "First object: " << first_object << std::endl
        << "Last object: " << last_object << std::endl
        << "All objects: " << all_objects << std::endl
    ;
}

int main() {
    do_stuff<CollectionA>();
    do_stuff<CollectionB>();
}

关键说明 #

1. CRTP基类设计：CollectionBase<Derived>通过模板参数接收子类类型，利用typename Derived::Member直接获取子类定义的类型别名，彻底避免了手动传递Member参数的繁琐。
2. 子类实现：子类只需继承CollectionBase<自身类型>，然后定义Member类型和接口实现即可，写法简洁且符合接口规范。
3. 接口转发：基类的静态函数会直接转发到子类的对应实现，保证了所有子类遵循统一的接口约束。

运行输出 #

First object: 1
Last object: 3
All objects: { 1, 2, 3 }
First object: One
Last object: Three
All objects: { One, Two, Three }

内容的提问来源于stack exchange，提问作者Elia Immanuel Auer