如何限制派生类仅在构造函数中调用基类的SpecialType创建方法？

C++没有原生语法支持这种精准的访问限制——protected成员一旦对派生类开放，派生类的所有成员函数（包括普通成员函数）都有权访问。不过可以通过以下设计技巧近似实现需求，避免误用：

方案1：构造专属令牌机制（推荐） #

核心思路是给SpecialType的创建方法增加一个仅构造阶段才能获取的令牌参数，普通成员函数无法生成或获取该令牌，从而被禁止调用创建逻辑。

基础实现 #

class SpecialType{
    friend class Base;
private:
    SpecialType() = default; // 仅Base能直接构造
};

class Base{
    // 令牌类：构造函数私有，仅Base可创建
    struct ConstructionToken {
    private:
        explicit ConstructionToken() = default;
        friend class Base;
    };

    // 私有创建逻辑，必须传入合法令牌
    SpecialType createVerySpecialTypeImpl(ConstructionToken) {
        // 执行注册逻辑
        return SpecialType{};
    }

protected:
    // 仅允许在构造阶段调用的创建接口：由Base生成令牌并传递
    SpecialType createForConstruction() {
        return createVerySpecialTypeImpl(ConstructionToken{});
    }
};

class Derived : public Base{
    // 合法：成员初始化属于构造阶段，可调用createForConstruction
    SpecialType mSpecial = createForConstruction();
    
public:
    Derived() = default;

    void memberFunction(){
        // 若需彻底禁止普通函数调用，可使用更严格的令牌传递实现
    }
};

更严格的令牌传递实现（彻底禁止普通函数调用） #

class SpecialType{
    friend class Base;
private:
    SpecialType() = default;
};

class Base{
private:
    struct ConstructionToken {
        explicit ConstructionToken() = default;
    };

    SpecialType createVerySpecialTypeImpl(ConstructionToken) {
        return SpecialType{};
    }

protected:
    // 派生类构造函数必须接收令牌才能创建实例
    explicit Base(ConstructionToken) {}

    SpecialType createSpecialWithToken(ConstructionToken token) {
        return createVerySpecialTypeImpl(token);
    }

public:
    Base() : Base(ConstructionToken{}) {}
};

class Derived : public Base {
    SpecialType mSpecial;

public:
    // 仅在构造初始化列表中能获取合法令牌
    Derived() : Base(Base::ConstructionToken{}),
                mSpecial(createSpecialWithToken(Base::ConstructionToken{})) {}

    void memberFunction() {
        // 非法：无法创建ConstructionToken（Base私有类型），编译报错
        // auto tmp = createSpecialWithToken(...);
    }
};

方案2：Base预创建实例，派生类仅可复用 #

调整设计思路：让Base在自身构造时创建SpecialType实例，派生类只能在构造阶段拷贝/移动该实例，无法主动创建新实例。

class SpecialType{
    friend class Base;
private:
    SpecialType() = default;
    // 允许拷贝/移动，让派生类可复制实例
    SpecialType(const SpecialType&) = default;
    SpecialType(SpecialType&&) = default;
};

class Base{
private:
    SpecialType createVerySpecialType() {
        // 执行注册逻辑
        return SpecialType{};
    }

protected:
    // Base预创建的实例，派生类仅能在构造阶段访问
    const SpecialType mBaseSpecial;

public:
    Base() : mBaseSpecial(createVerySpecialType()) {}
};

class Derived : public Base{
    // 合法：构造阶段拷贝Base的实例
    SpecialType mSpecial = mBaseSpecial;
    
public:
    Derived() = default;

    void memberFunction(){
        // 非法：无法调用私有createVerySpecialType，也无法直接构造SpecialType
        // auto tmp = createVerySpecialType();
        // auto tmp = SpecialType{};
    }
};

方案3：CRTP自动分配实例（无手动调用） #

利用CRTP（奇异递归模板模式），让Base在派生类构造时自动创建并分配SpecialType实例，派生类无需手动调用创建方法，从根源避免误用。

class SpecialType{
    template<typename Derived>
    friend class Base;
private:
    SpecialType() = default;
};

// CRTP基类，绑定派生类类型
template<typename Derived>
class Base{
protected:
    // 自动创建的SpecialType实例
    SpecialType mSpecial;

private:
    SpecialType createVerySpecialType() {
        // 注册逻辑，可关联到具体派生类类型
        return SpecialType{};
    }

public:
    Base() : mSpecial(createVerySpecialType()) {}
};

class Derived : public Base<Derived>{
    // 直接使用继承来的mSpecial即可
public:
    Derived() = default;

    void memberFunction(){
        // 无法创建新的SpecialType，无合法调用途径
    }
};

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