子类方法签名不同时，如何将基类设置为抽象类？

针对你的需求，有几种不需要定义纯虚函数就能让基类无法实例化的方案，下面逐一说明：

方案1：将基类构造函数设为protected #

这是最直接的方法，无需引入虚函数机制。把基类的构造函数改为protected，外部代码无法直接实例化基类，但子类可以正常继承并调用基类构造函数。

修正后的代码示例：

class base {
protected:  // 构造函数改为protected
    base() : i{0}, j{0} {}
    
public:
    void compute_i() {
        // computes i
    }

private:
    double i;
    double j;
};

class inherited1 : public base {  // 补全继承关系
public:
    inherited1() = default;

    void compute_j(double val, double k) {
        // compute j here
    }
};

class inherited2 : public base {  // 补全继承关系
public:
    inherited2() = default;

    void compute_j(double val) {
        // compute j here
    }
};

此时base b;会编译报错（构造函数不可访问），但子类对象如inherited1 obj1;可以正常创建。

方案2：protected虚析构实现抽象类（无纯虚函数） #

如果基类后续可能需要多态特性，可给基类添加protected的虚析构函数，同样能阻止基类实例化，同时为多态预留基础：

class base {
public:
    void compute_i() {
        // computes i
    }

protected:
    base() : i{0}, j{0} {}
    virtual ~base() = default;  // protected虚析构

private:
    double i;
    double j;
};

这种方式既禁止了基类实例化，又允许子类通过基类指针/引用实现多态（如果后续扩展）。

方案3：CRTP实现编译期统一调用 #

如果需要给子类提供统一的调用接口，同时避免运行时虚函数开销，可使用CRTP（奇异递归模板模式）：

template<typename Derived>
class base {
protected:
    base() : i{0}, j{0} {}
    
public:
    void compute_i() {
        // computes i
    }

    // 统一转发接口，适配子类不同签名的compute_j
    template<typename... Args>
    void compute_j(Args&&... args) {
        static_cast<Derived*>(this)->compute_j(std::forward<Args>(args)...);
    }

private:
    double i;
    double j;
};

class inherited1 : public base<inherited1> {
public:
    inherited1() = default;

    void compute_j(double val, double k) {
        // compute j here
    }
};

class inherited2 : public base<inherited2> {
public:
    inherited2() = default;

    void compute_j(double val) {
        // compute j here
    }
};

使用时可通过基类接口统一调用：

inherited1 obj1;
obj1.compute_j(1.0, 2.0);

inherited2 obj2;
obj2.compute_j(3.0);

总结 #

• 仅需禁止基类实例化：优先选方案1，简洁高效；
• 后续可能用到多态：选方案2，预留多态基础；
• 需要统一调用接口且追求性能：选方案3，实现编译期调度。

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