C++ 设计不可被继承的类

在 C++ 开发中，某些场景下我们需要设计不可被继承的类

比如核心工具类、单例类、或封装了关键资源的类

防止子类随意修改其行为、破坏封装性或引发逻辑错误。

一、为什么需要不可被继承的类？

不可被继承的类（也称为 "最终类"）通常用于以下场景：

• 核心逻辑保护：类的功能已固化，子类继承后重写成员函数可能破坏原有逻辑（如数学工具类、底层算法类）；
• 单例类约束：单例类的核心是 "唯一实例"，子类继承可能导致多实例化，违背设计初衷；
• 资源安全管理：类封装了独占资源（如硬件句柄、全局配置），继承后易引发资源重复释放 / 访问冲突。

C++ 本身没有原生的 "最终类" 语法（如 Java 的 final），但可通过语法特性间接实现，且 C++11 新增了专门的 final 关键字，让实现更简洁。

二、C++98 实现方案：私有化构造函数

1. 核心原理

C++ 中，子类继承基类时，子类的构造函数必须调用基类的构造函数（无论是显式还是隐式调用）。若将基类的构造函数私有化：

• 子类无法访问基类的私有构造函数，编译阶段直接报错；
• 基类需提供静态成员函数作为对象创建入口（因构造函数私有，外部无法直接创建）。

2. 完整代码实现

#include <iostream>
using namespace std;

// C++98 不可被继承的类
class NonInherit 
{
public:
    // 静态成员函数：创建对象的唯一入口
    static NonInherit GetInstance() 
    {
        return NonInherit(); // 静态成员函数可访问私有构造函数
    }

    // 示例：成员函数
    void Print() const 
    {
        cout << "NonInherit object (cannot be inherited)" << endl;
    }

private:
    // 私有化构造函数：阻断子类的构造调用
    NonInherit() 
    {
        cout << "NonInherit constructor called" << endl;
    }

    // 可选：禁用拷贝构造（强化约束）
    NonInherit(const NonInherit&) = delete;
    NonInherit& operator=(const NonInherit&) = delete;
};

3. 测试验证（继承会编译报错）

// 尝试继承 NonInherit（错误示例）
class Derived : public NonInherit 
{
public:
    Derived() {} // 编译报错：无法访问基类 NonInherit 的私有构造函数
};

int main() 
{
    // 正确用法：通过静态函数创建对象
    NonInherit obj = NonInherit::GetInstance();
    obj.Print();

    // 错误用法：继承失败
    // Derived d; // 编译报错，无法实例化子类
    return 0;
}

4. 方案说明

• 私有化构造函数：这是实现 "不可继承" 的核心，子类构造函数无法调用基类私有构造函数，直接阻断继承；
• 静态成员函数创建对象 ：构造函数私有化后，外部无法直接创建对象（如 NonInherit obj;），需通过静态成员函数作为唯一入口；
• 可选禁用拷贝构造：防止用户通过拷贝绕过 "静态函数创建" 的约束，强化类的使用规范。

三、C++11 实现方案：final 关键字（推荐）

C++11 引入 final 关键字，专门用于限制类的继承或函数的重写 ------final 修饰类时，表示该类是 "最终类"，禁止任何类继承它，语义更直观、实现更简洁。

1. 核心原理

final 是编译器级别的语法约束，直接告诉编译器："该类不允许被继承"。相比 C++98 的 "间接阻断"，final 无需私有化构造函数，代码更简洁，可读性更高。

2. 完整代码实现

#include <iostream>
using namespace std;

// C++11 不可被继承的类（final 修饰）
class NonInherit final 
{ 
public:
    // 构造函数公有（无需私有化）
    NonInherit() 
    {
        cout << "NonInherit constructor called" << endl;
    }

    // 示例：成员函数
    void Print() const 
    {
        cout << "NonInherit object (final class, cannot be inherited)" << endl;
    }
};

3. 测试验证（继承会编译报错）

// 尝试继承 final 类（错误示例） // 编译报错：无法继承 final 类
class Derived : public NonInherit 
{ 
public:
    Derived() {}
};

int main() 
{
    // 正确用法：直接创建对象（构造函数公有）
    NonInherit obj;
    obj.Print();

    // 错误用法：继承失败
    // Derived d; // 编译报错：NonInherit is a final class
    return 0;
}

4. 扩展：final 修饰成员函数（防止重写）

除了修饰类，final 还可修饰虚函数，防止子类重写：

class Base 
{
public:
    virtual void Func() final  // final 修饰虚函数：禁止子类重写
    { 
        cout << "Base::Func" << endl;
    }
};

class Derived : public Base 
{
public:
    // void Func() override {} // 编译报错：无法重写 final 函数
};

四、两种方案对比

表格

特性	C++98 方案（私有化构造函数）	C++11 方案（final 关键字）
实现原理	阻断子类构造函数调用基类构造	编译器直接禁止继承
语法复杂度	较高（需静态函数创建对象）	极低（仅需 final 关键字）
语义清晰度	间接实现，需理解构造函数逻辑	直接直观，语义明确
构造函数访问权限	必须私有	可公有（使用更灵活）
报错阶段	编译期	编译期
适用场景	旧编译器、C++98 环境	现代 C++ 开发（推荐）

五、注意事项

1. C++98 方案的局限性 ：
   • 必须通过静态函数创建对象，使用方式不如普通类灵活；
   • 若基类有多个构造函数（如带参数构造），需全部私有化，否则子类可能通过公有构造函数继承。
2. final 关键字的兼容性 ：
   • final 是 C++11 新增特性，需确保编译器支持（如 GCC 4.7+、Clang 3.0+、MSVC 2012+）；
   • final 修饰的类仍可正常创建对象（构造函数可公有），仅限制继承。
3. 不可继承 ≠ 不可组合：即使类不可被继承，仍可通过 "组合" 方式复用其功能（如在另一个类中定义该类的对象成员），这是更推荐的复用方式（符合 "组合优于继承" 的设计原则）。

组合 复用 不可继承类 的示例

下面通过具体代码，展示如何通过组合 的方式复用 final 修饰的不可继承类，同时对比 "继承失败" 和 "组合成功" 的差异，体现 "组合优于继承" 的设计原则。

#include <iostream>
#include <string>
using namespace std;

// 不可被继承的核心StringTool工具类（final 修饰）
class StringTool final 
{
public:
    StringTool() = default;

    // 核心功能：字符串拼接
    string Concat(const string& a, const string& b) 
    {
        return a + "-" + b;
    }

    // 核心功能：字符串转大写
    string ToUpper(string str) 
    {
        for (char& c : str)  c = toupper(c);
        return str;
    }
};

2. 尝试继承（编译报错，验证不可继承）

// 错误示例：尝试继承 final 类，编译直接报错
// class MyTool : public StringTool 
// {
// public:
//     // 即使想扩展功能，也无法继承
//     string ConcatThree(const string& a, const string& b, const string& c) 
//     {
//         return Concat(Concat(a, b), c);
//     }
// };

3. 组合方式复用（推荐，可正常复用 + 扩展）

组合的核心是：在新类中定义不可继承类的对象成员，通过调用该成员的方法实现功能复用，同时可自由扩展新功能。

// 组合方式复用 StringTool 功能
class BusinessTool 
{
public:
    // 扩展功能：拼接三个字符串（复用 StringTool 的 Concat 方法）
    string ConcatThree(const string& a, const string& b, const string& c) 
    {
        // 调用组合的 _strTool 对象的核心方法
        string ab = _strTool.Concat(a, b);
        return _strTool.Concat(ab, c);
    }

    // 扩展功能：转大写后拼接（复用 ToUpper + Concat）
    string ConcatUpper(const string& a, const string& b) 
    {
        string aUpper = _strTool.ToUpper(a);
        string bUpper = _strTool.ToUpper(b);
        return _strTool.Concat(aUpper, bUpper);
    }

private:
    // 组合核心：定义不可继承类的对象成员
    StringTool _strTool;
};

4. 测试验证（组合复用成功）

int main() 
{
    BusinessTool tool;

    // 测试扩展功能1：拼接三个字符串
    string res1 = tool.ConcatThree("hello", "world", "c++");
    cout << "ConcatThree: " << res1 << endl; // 输出：hello-world-c++

    // 测试扩展功能2：转大写后拼接
    string res2 = tool.ConcatUpper("hello", "world");
    cout << "ConcatUpper: " << res2 << endl; // 输出：HELLO-WORLD

    return 0;
}

组合复用的优势解析

1. 规避继承限制 ：即使类被 final 修饰不可继承，组合仍能完整复用其所有公有功能；
2. 低耦合：新类 仅依赖 StringTool 的公有接口，无需关心其内部实现，修改 StringTool 不会影响 BusinessTool 的核心逻辑；
3. 灵活性高：可自由扩展新功能（如 ConcatThree、ConcatUpper），且可组合多个类的功能（比如同时组合 StringTool 和 NumberTool）；
4. 符合设计原则："组合优于继承" 的核心是避免继承带来的强耦合（子类依赖基类实现），组合通过 "调用接口" 复用功能，更灵活、易维护。

总结

1. 实现不可被继承的类，C++98 依赖 "私有化构造函数" 阻断子类构造调用，需配合静态函数创建对象；C++11 优先使用 final 关键字，语法简洁、语义明确；
2. final 不仅可修饰类禁止继承，还可修饰虚函数禁止重写，是现代 C++ 限制继承 / 重写的首选方案；
3. 不可被继承的类核心是保护核心逻辑不被修改，而非禁止功能复用，可通过组合方式实现功能复用。

通过以上方法，可精准控制类的继承权限，避免子类随意修改核心逻辑，提升代码的健壮性和可维护性。