《 C++ 修炼全景指南：十六 》玩转 C++ 特殊类：C++ 六种必备特殊类设计的全面解析

标签：特殊 对象 内存 C++ 实例 玩转 单例 拷贝 构造函数

摘要

这篇博客深入探讨了六种 C++ 特殊类的设计及其技术细节。首先，介绍了如何设计只能在堆上或栈上创建对象的类，通过控制构造函数的访问权限来限定对象的内存分配区域。接着，探讨了如何设计一个不能被拷贝的类，避免资源重复释放的问题。随后，介绍了如何防止类被继承以及单例模式的实现，确保类的封闭性和唯一实例的创建。最后，讲解了只能移动的类设计，通过移动语义提升程序性能。这些设计在不同的实际场景中具有重要应用，帮助开发者优化内存管理和对象生命周期的控制。

1、前言

C++ 作为一门功能强大的编程语言，提供了极大的灵活性，允许开发者对类的设计进行精细控制。这种灵活性不仅体现在对数据成员和函数的封装，还体现在如何控制对象的创建、生命周期和行为。通过设计特定的类，程序员可以显著优化内存管理、提高系统的安全性和稳定性，避免不必要的资源消耗与错误。

在 C++ 中，灵活控制对象的创建和管理尤为重要。对象可以在堆上动态分配，也可以在栈上自动管理，甚至可以限制其被拷贝、继承或只能创建一个实例。理解并掌握这些技术，不仅能让开发者精确控制对象的生命周期和内存分配，还能提升代码的性能、可读性和安全性。

在这篇博客中，我们将探讨六种特殊类的设计：只能在堆上创建的类、只能在栈上创建的类、不能被拷贝的类、不能被继承的类，只能创建一个实例的类（单例模式），以及只能移动的类。这些设计分别解决了不同的场景需求，帮助我们更好地控制类的行为和对象的管理。

1. 只能在堆上创建的类：防止对象在栈上创建，确保动态分配。
2. 只能在栈上创建的类：限制对象只能在栈上分配，避免动态内存分配。
3. 不能被拷贝的类：禁止拷贝构造和赋值操作，确保对象的唯一性。
4. 不能被继承的类：阻止类的派生，保护其实现不被扩展。
5. 单例模式的类：确保类只能有一个实例，提供全局访问点。

通过阅读本篇博客，您将深入学习这些设计背后的原理与实现等技术细节，了解如何在 C++ 中实现这些特殊类，并明白其应用场景及相关的编程模式。掌握这些技巧不仅能让您在编写高效、健壮的代码时游刃有余，还能在面试和实际开发中脱颖而出。接下来，我们将逐一剖析这些设计的技术细节，带您全面理解它们的原理与应用，展示如何在C++中实现它们，并解释它们在现代编程中的应用场景与优劣。

2、 设计一个只能在堆上创建对象的类

在 C++ 中，通常对象既可以在堆上 (使用new运算符动态分配) 创建，也可以在栈上 (自动存储) 创建。然而，在某些场景下，我们希望强制要求对象只能在堆上创建，以确保内存的动态分配、手动管理对象的生命周期以及更灵活的资源分配。这种设计通常在需要对对象的创建和销毁进行细致控制的场景下非常有用。

堆 vs 栈的内存分配

• 栈：栈是程序在运行时自动分配和释放的内存区域。栈上的对象生命周期与其所在函数的执行周期相关联，函数结束时自动销毁，适合存储局部变量和函数参数。
• 堆：堆是动态分配的内存区域，对象的生命周期由程序员手动控制。堆上分配的对象可以在程序的任意位置持续存在，直到显式释放内存。

2.1、为什么要设计只能在堆上创建的类？

1. 内存管理的控制：堆上创建对象可以让我们手动控制对象的生命周期，使得对象可以在超出作用域后仍然存活。堆内存不会随着函数返回或作用域结束自动释放，这使得我们能够通过手动释放资源来优化内存管理。
2. 延长对象生命周期：栈上的对象生命周期是自动的，随着栈帧的结束对象也会销毁。但在某些场景下，我们希望对象能够在多个函数或模块间共享、持久存活，堆上对象能够满足这一需求。
3. 动态多态性：堆上对象经常与多态性和动态绑定结合使用，特别是在使用基类指针或引用操作派生类对象时。

通过设计只能在堆上创建的类，能避免用户错误地在栈上创建对象，确保更细粒度的内存控制与资源管理。

2.2、如何防止对象在栈上创建？

要实现 “只能在堆上创建” 的约束，我们可以通过私有化或删除类的构造函数来限制栈上对象的创建，并公开new运算符来强制用户使用动态分配。

原理

通过限制类的构造函数和析构函数，可以有效防止在栈上创建对象。

• 构造函数和析构函数控制：将构造函数设为私有，或者析构函数设为私有，可以阻止对象在栈上正确创建或销毁，从而达到限制栈上创建对象的目的。

禁止栈上创建的技术实现

1. 私有化构造函数和析构函数：将构造函数和析构函数声明为私有，防止外部直接调用和实例化。
2. 友元函数或工厂函数：通过友元函数或工厂函数，在类的内部提供特定的方法来创建对象，这些方法可以控制对象的创建方式，确保只能在堆上分配。

以下是具体实现的几个步骤：

2.2.1、私有化析构函数

通过将析构函数设为私有，栈上的对象在作用域结束时无法正确地调用析构函数，这就防止了对象在栈上被创建。

#include <iostream>

class HeapOnly {
public:
    // 公开构造函数, 允许外部使用 new 进行堆上分配
    HeapOnly() {
        std::cout << "HeapOnly object created." << std::endl;
    }

    // 提供静态的析构方法, 用户可以显式地销毁对象
    static void Destroy(HeapOnly* ptr) {
        delete ptr;
    }

private:
    // 私有化析构函数, 防止栈上自动销毁
    ~HeapOnly() {
        std::cout << "HeapOnly object destroyed." << std::endl;
    }
};

int main() {
    // 正确的堆上创建方式
    HeapOnly* obj = new HeapOnly();

    // 手动销毁对象
    HeapOnly::Destroy(obj);

    // 编译错误: 析构函数是私有的, 无法在栈上创建对象
    // HeapOnly objStack;
}

解释：

• 通过将析构函数设为私有，禁止栈上自动调用析构函数，确保对象只能通过堆分配。
• 我们提供了一个静态的 Destroy 函数，专门用于销毁堆上的对象，这样用户可以显式地管理对象的生命周期。

2.2.2、禁用拷贝构造与赋值运算符

为了进一步加强类的设计，我们通常需要禁止对象的拷贝与赋值，防止间接方式导致栈上对象创建。C++11 提供了 delete 关键字，可以用来禁用拷贝构造和赋值运算符。

class HeapOnly {
public:
    HeapOnly() {
        std::cout << "HeapOnly object created." << std::endl;
    }

    static void Destroy(HeapOnly* ptr) {
        delete ptr;
    }

    // 禁用拷贝构造函数和赋值运算符
    HeapOnly(const HeapOnly&) = delete;
    HeapOnly& operator=(const HeapOnly&) = delete;

private:
    ~HeapOnly() {
        std::cout << "HeapOnly object destroyed." << std::endl;
    }
};

解释：

• 禁用拷贝构造和赋值运算符可以防止用户通过拷贝构造或赋值创建对象，从而进一步控制对象的创建方式。

2.2.3、使用工厂模式提供更安全的创建方式

除了简单的 new 分配方式，我们还可以通过工厂模式提供对象的创建接口，确保对象只能通过堆分配，并提供更加统一的接口来管理对象的生命周期。

class HeapOnly {
public:
    // 通过静态工厂方法创建对象，确保只能在堆上创建
    static HeapOnly* Create() {
        return new HeapOnly();
    }

    static void Destroy(HeapOnly* ptr) {
        delete ptr;
    }

private:
    HeapOnly() {
        std::cout << "HeapOnly object created by factory." << std::endl;
    }

    ~HeapOnly() {
        std::cout << "HeapOnly object destroyed by factory." << std::endl;
    }

    // 禁用拷贝构造函数和赋值运算符
    HeapOnly(const HeapOnly&) = delete;
    HeapOnly& operator=(const HeapOnly&) = delete;
};

解释：

• 通过将构造函数设为私有，并提供静态的 Create 方法，我们强制用户只能通过该方法创建对象，进一步确保对象的创建方式受到控制。

2.3、额外考虑：内存泄漏与智能指针

当对象只能在堆上创建时，手动管理内存释放变得至关重要。在实际开发中，使用 new 和 delete 管理内存存在风险，特别是当程序在复杂的执行路径中忘记释放堆上对象时，可能会导致内存泄漏。为了解决这个问题，智能指针（如std::unique_ptr或std::shared_ptr）可以用来自动管理对象的生命周期，防止内存泄漏。

关于智能指针的所有细节，可以看我的这篇万字详解博客：《 C++ 修炼全景指南：八 》智能指针大揭秘：从 auto_ptr 到 unique_ptr & shared_ptr 的进化之路

以下是利用std::unique_ptr改进后的例子，展示如何通过私有化构造函数和工厂函数来限制对象只能在堆上创建：

#include <iostream>
#include <memory> // For std::unique_ptr

class HeapOnly {
public:
    // 工厂函数，创建堆上的对象，并返回智能指针
    static std::unique_ptr<HeapOnly> Create() {
        return std::unique_ptr<HeapOnly>(new HeapOnly());
    }

    // 销毁对象的方法
    static void Destroy(HeapOnly* ptr) {
        delete ptr;
    }

    // 禁止拷贝构造和赋值运算符
    HeapOnly(const HeapOnly&) = delete;
    HeapOnly& operator=(const HeapOnly&) = delete;

private:
    // 私有构造函数，防止外部实例化对象
    HeapOnly() {
        std::cout << "HeapOnly object created." << std::endl;
    }

    // 私有析构函数，防止外部销毁对象
    ~HeapOnly() {
        std::cout << "HeapOnly object destroyed." << std::endl;
    }
};

int main() {
    // 使用工厂函数创建对象，返回智能指针
    std::unique_ptr<HeapOnly> obj = HeapOnly::Create();
    
    // 销毁对象，调用静态销毁方法
    HeapOnly::Destroy(obj.release());

    return 0;
}

解释：

• HeapOnly 类将构造函数和析构函数声明为私有，确保只能在类的内部控制对象的创建和销毁。
• Create 方法是一个工厂函数，返回一个智能指针，确保对象在堆上创建，并自动管理对象的生命周期。
• Destroy 方法用于手动释放对象的堆内存，确保资源安全释放。
• std::unique_ptr负责自动释放堆上的对象，防止手动释放内存时出现忘记 delete 或重复 delete 的问题。
• 智能指针的使用能够让堆上对象的管理更加安全，减少内存管理的复杂性。

2.4、设计注意事项

1. 使用场景适配：在设计这种类时，确保其应用场景确实需要强制的堆分配。对于普通对象，不建议过多限制其创建方式，除非存在明确的需求。设计只能在堆上创建的类通常适用于以下场景：
   • 大对象：当对象大小不确定或非常庞大时，栈上分配可能导致栈溢出或者不合理的内存管理。
   • 资源管理类：如数据库连接、文件句柄等资源，需要确保生命周期与对象的管理方式一致。
2. 智能指针与内存管理：智能指针可以帮助避免内存泄漏，但要小心循环引用导致的内存无法释放问题。
3. API 设计：如果这种类会被大量使用，提供方便且安全的创建和销毁接口是非常重要的，可以通过工厂模式和静态成员函数实现。

通过限制对象只能在堆上创建，可以提升程序的稳定性和灵活性，特别是在需要动态资源管理和长期对象生存的情况下。

2.5、小结

通过对构造函数、析构函数和拷贝控制的约束，C++ 允许我们设计出只能在堆上创建的类。这类设计能够提升程序的内存控制能力，确保对象的生命周期得到更细致的管理。结合智能指针与工厂模式，开发者可以更加安全、高效地管理这类特殊对象。

3、设计一个只能在栈上创建对象的类

在 C++ 中，内存分配主要有两种方式：栈内存分配和堆内存分配。栈上对象是指那些在栈上分配内存的对象，它们通常具有较短的生命周期，由编译器自动管理。当函数执行结束时，栈上对象会自动销毁，内存也会被回收。而堆上对象则需要手动管理，通过 new 操作分配内存，并通过 delete 操作释放内存。栈内存的分配和释放速度远快于堆内存，因此在某些对性能要求较高的场景中，栈上对象成为更优的选择。

那么，为什么我们要设计一个类，使得其对象只能在栈上创建？其背后主要有以下几个动机：

1. 性能优化：栈内存分配更为高效，避免了堆内存分配的碎片化问题，提升程序运行的速度和内存利用率。
2. 内存管理控制：通过限制对象的创建方式，我们可以严格控制对象的生命周期，从而减少内存泄漏和未定义行为的发生。栈上对象的生命周期自动由编译器管理，开发者无需担心内存释放问题。
3. 禁止动态分配：在某些情况下，我们希望对象的创建是有约束的，禁止通过 new 操作动态分配内存，确保程序更加健壮、可控。

本节的目标是通过逐步讲解如何设计一个只能在栈上创建对象的类，帮助读者深入理解其中的技术细节。通过本篇博客，读者将学到如何通过私有化 new 和 delete 运算符、禁用拷贝构造函数和赋值操作等方式，实现这一设计，同时理解其背后的内存管理原理以及在实际场景中的应用。

3.1、栈上对象 vs 堆上对象的区别

在 C++ 中，内存管理主要依赖于两种不同的分配机制：栈和堆。栈内存和堆内存的使用方式有着显著的差异，理解这两者的内存管理机制对于我们设计一个只能在栈上创建对象的类至关重要。

3.1.1、栈内存

栈是程序运行时分配内存的一种方式，栈内存的分配速度非常快。每当我们在栈上创建一个局部对象，栈指针会向下移动，分配一定的内存空间给该对象；当对象超出作用域时，栈指针自动回退，释放该对象的内存。栈内存管理由编译器自动处理，程序员无需显式管理。

栈内存的优势包括：

• 分配与释放速度快：由于栈遵循 “后进先出” (LIFO) 原则，分配和释放对象的操作非常高效，通常只需要移动栈指针。
• 生命周期受限：栈上对象的生命周期由作用域决定，当离开作用域时对象会被自动销毁。

然而，栈内存也有一些限制：

• 空间有限：栈的大小通常是固定的，在嵌套函数调用过深或创建过大对象时可能导致栈溢出。
• 局部性强：栈上对象只能在当前作用域内使用，无法跨作用域持久化。

3.1.2、堆内存

堆是动态分配内存的区域，通常用于分配生命周期在程序运行期间可能跨多个函数调用的对象。通过 new 操作符分配堆内存，由程序员负责显式释放。堆内存相比栈内存的管理更加灵活，但其分配和释放速度较慢，且存在内存泄漏和碎片化的风险。

堆内存的优势包括：

• 空间相对较大：堆内存的容量通常远大于栈，因此适合用于分配大块内存。
• 生命周期灵活：对象的生命周期可以跨越多个函数调用，直到显式释放内存。

然而，堆内存的缺点也十分显著：

• 分配与释放速度慢：堆内存的分配涉及复杂的管理算法，速度较慢。
• 容易发生内存泄漏：如果忘记释放内存或重复释放内存，可能导致内存泄漏或未定义行为。

3.2、设计栈上对象的核心原理

为了设计一个只能在栈上创建对象的类，我们需要防止其通过 new 操作符在堆上进行分配。C++ 提供了控制对象创建行为的灵活性，因此可以通过以下几种方法来实现：

1. 删除或私有化 operator new 和 operator delete：通过删除或将这两个运算符声明为私有，可以确保类的对象无法在堆上动态分配。
2. 禁止拷贝和赋值：为了进一步确保对象的唯一性，防止类对象被拷贝或赋值，从而在潜在的堆上创建副本。
3. 作用域控制：通过让类的构造函数和析构函数依赖于栈上对象的作用域管理，确保对象只能在栈的作用域内存在，并且在作用域结束时自动销毁。

具体实现策略如下：

3.2.1、私有化 new 和 delete 操作符

为了禁止动态内存分配，可以将类的 new 和 delete 操作符声明为私有成员，或者显式删除它们。这可以阻止用户通过 new 操作在堆上创建对象，从而限制对象只能通过普通构造函数在栈上创建。

class StackOnly {
private:
    // 禁止使用 new 在堆上分配内存
    void* operator new(size_t) = delete;
    void operator delete(void*) = delete;
};

这种设计确保了对象无法通过 new 在堆上分配，只能在栈上创建。

3.2.2、禁用拷贝构造与移动构造

为了防止对象在不同作用域间传递或动态分配内存，我们还需要禁用拷贝构造函数和移动构造函数。这可以通过显式删除这些函数实现。

class StackOnly {
public:
    StackOnly() = default;
    
    // 禁止拷贝和移动操作
    StackOnly(const StackOnly&) = delete;
    StackOnly& operator=(const StackOnly&) = delete;
    StackOnly(StackOnly&&) = delete;
    StackOnly& operator=(StackOnly&&) = delete;
};

这种设计保证了对象只能在创建它的作用域内使用，并且无法通过赋值或移动构造函数在堆上或其他地方创建副本。

3.2.3、代码的实现

以下是实现只能在栈上创建对象的完整代码示例：

#include <iostream>

class StackOnly {
public:
    // 构造函数和析构函数
    StackOnly() {
        std::cout << "StackOnly object created." << std::endl;
    }

    ~StackOnly() {
        std::cout << "StackOnly object destroyed." << std::endl;
    }

    // 禁用堆上的内存分配
    void* operator new(size_t) = delete;      // 删除 new 运算符
    void operator delete(void*) = delete;     // 删除 delete 运算符

    // 禁止拷贝和赋值，确保对象的唯一性
    StackOnly(const StackOnly&) = delete;
    StackOnly& operator=(const StackOnly&) = delete;
    StackOnly(StackOnly&&) = delete;
    StackOnly& operator=(StackOnly&&) = delete;

    // 允许栈上分配（由默认构造和析构行为保证）
};

int main() {
    StackOnly obj;  // 在栈上创建对象，合法
    // StackOnly* objPtr = new StackOnly();  // 错误！编译失败，禁止堆上创建
    return 0;
}

代码解释：

• 删除 operator new 和 operator delete：通过显式删除 operator new 和 operator delete，确保该类的对象不能通过 new 操作符在堆上分配。如果尝试在堆上创建对象，编译器会报错。
• 禁止拷贝和赋值：为了确保对象的唯一性，拷贝构造函数和赋值操作被删除，防止对象被复制或通过赋值运算符产生新实例。
• 栈上创建：在 main 函数中，演示了如何在栈上合法地创建对象，并确保对象在离开作用域时被自动销毁。

3.3、使用场景

设计只能在栈上创建的对象类通常适用于以下场景：

1. 轻量级对象：当对象生命周期较短且占用内存较小时，在栈上创建对象可以避免堆分配的开销，并提升程序的性能。栈上对象会在离开作用域时自动释放，减少了内存管理的负担。
2. 资源敏感的系统：在某些嵌入式系统或实时系统中，栈上对象的使用能够减少内存泄漏的风险，并且提升系统的确定性行为。在此类系统中，动态分配内存的性能开销和不确定性较大，因此栈上对象是更合适的选择。
3. 内存限制环境：在一些内存受限的场景中（如嵌入式设备），由于堆内存较小或受限，开发者可能希望严格控制对象的内存分配，避免不必要的堆分配。这时，栈上对象的设计可以确保内存高效使用。

3.4、性能分析

• 内存分配效率：栈上分配和释放的速度通常比堆上分配快得多，因为栈是连续分配的，编译器能够有效地管理栈上的内存。而堆上的分配则涉及到复杂的内存管理操作，可能影响性能。
• 作用域控制：栈上对象由编译器自动管理，避免了开发人员需要手动释放内存的麻烦。对象在离开作用域时自动销毁，不存在内存泄漏的问题。
• 安全性：栈上对象无法在作用域外继续使用，这减少了 dangling pointers（悬空指针）和 double delete（重复释放）的风险。

3.5、小结

通过设计只能在栈上创建的类，我们能够在特定场景下优化程序的性能和内存使用。栈上对象的自动管理机制简化了内存管理，避免了许多常见的内存错误，如内存泄漏和动态分配失败。同时，禁止对象在堆上创建可以强制约束对象的生命周期，使得代码更加可靠和高效。这种设计在轻量级、短生命周期的对象中尤其有效，并且能够满足嵌入式系统等内存敏感环境的需求。

4、设计一个不能被拷贝的类

在 C++ 中，有时我们希望某些类的对象不被复制，以确保对象的唯一性和数据的完整性。设计一个不能被拷贝的类涉及到禁用拷贝构造函数和赋值运算符，以及考虑对象生命周期管理的问题。本节将深入讨论如何设计一个不能被拷贝的类，并解释其实现原理和使用场景。

4.1、禁止对象拷贝的原理

C++ 中禁止对象拷贝通常通过以下两种方式实现：

1. 删除拷贝构造函数和赋值运算符：通过将拷贝构造函数和赋值运算符声明为私有，并且不提供其实现，或者使用 delete 关键字删除它们，来阻止对象的复制和赋值操作。
2. 使用 deleted 特性：C++11 引入了 = delete 语法，可以明确告诉编译器某个函数（如拷贝构造函数和赋值运算符）不可用，从而在编译期间发现潜在的错误。

4.2、技术实现

以下是设计一个不能被拷贝的类的技术实现步骤：

1. 删除拷贝构造函数和赋值运算符：
   • 将拷贝构造函数和赋值运算符声明为私有，并且不提供其实现，或者使用 delete 关键字删除它们。
2. 使用 deleted 特性：
   • 在 C++11 中，可以直接使用 = delete 语法删除拷贝构造函数和赋值运算符，使得任何试图复制该类对象的操作都会在编译期间失败。
3. 移动语义：
   • 如果需要支持对象的移动语义（即移动构造函数和移动赋值运算符），则可以显式定义这两个函数，并将拷贝构造函数和赋值运算符删除或设为私有，以确保对象在被移动后仍然是唯一的。

代码实现

以下是一个设计不能被拷贝的类的完整代码示例：

#include <iostream>

class NonCopyable {
public:
    NonCopyable() {
        std::cout << "NonCopyable object created." << std::endl;
    }

    ~NonCopyable() {
        std::cout << "NonCopyable object destroyed." << std::endl;
    }

    // 删除拷贝构造函数和赋值运算符
    NonCopyable(const NonCopyable&) = delete;             // 禁止拷贝构造
    NonCopyable& operator=(const NonCopyable&) = delete;  // 禁止赋值操作

    // 允许移动构造和移动赋值，如果需要的话
    NonCopyable(NonCopyable&& other) noexcept {
        std::cout << "Move constructor called." << std::endl;
        // 移动资源
    }

    NonCopyable& operator=(NonCopyable&& other) noexcept {
        std::cout << "Move assignment operator called." << std::endl;
        if (this != &other) {
            // 移动资源
        }
        return *this;
    }
};

int main() {
    NonCopyable obj1;                           // 创建对象，正常
    // NonCopyable obj2(obj1);                  // 错误！编译失败，禁止拷贝构造
    // NonCopyable obj3 = obj1;                 // 错误！编译失败，禁止拷贝构造
    // NonCopyable obj4;
    // obj4 = obj1;                             // 错误！编译失败，禁止赋值操作

    NonCopyable obj5 = std::move(obj1);         // 合法！移动构造
    NonCopyable obj6;
    obj6 = std::move(obj5);                     // 合法！移动赋值

    return 0;
}

代码解释：

• 删除拷贝构造函数和赋值运算符：通过 = delete 关键字删除拷贝构造函数和赋值运算符，确保该类的对象不能被复制或赋值。任何试图拷贝或赋值对象的操作都会在编译期间失败。
• 移动语义：如果需要支持对象的移动语义，可以显式定义移动构造函数和移动赋值运算符，并将拷贝构造函数和赋值运算符删除或设为私有，以确保对象在被移动后仍然是唯一的。

4.3、使用场景

设计一个不能被拷贝的类通常适用于以下场景：

1. 单例模式：确保全局唯一实例，避免多次实例化。
2. 资源管理类：如文件句柄、数据库连接等，确保资源只有一个实例进行管理，避免资源泄漏和竞态条件。
3. 线程管理类：如线程池的管理类，确保线程资源的合理分配和管理。
4. 状态机类：在状态机的设计中，确保状态的唯一性和一致性，防止状态被复制导致系统行为不可预测。

4.4、性能分析

• 内存和性能：删除拷贝构造函数和赋值运算符可以减少不必要的内存分配和复制开销，提升程序的性能和效率。
• 代码安全性：禁止对象的拷贝和赋值操作可以减少因对象复制而导致的状态不一致或资源泄漏的风险，增强代码的安全性和可靠性。
• 移动语义优化：通过支持移动语义，可以在不损失对象唯一性的情况下，提高对象的传递效率和性能。

4.5、小结

设计一个不能被拷贝的类，不仅可以确保对象的唯一性和数据的完整性，还能提升程序的性能和安全性。通过删除或禁用拷贝构造函数和赋值运算符，我们可以有效地控制对象的复制行为，适用于需要严格控制对象生命周期和资源管理的各种场景。这种设计不仅在传统的应用程序中有广泛的应用，而且在并发编程和资源敏感的系统中尤为重要，能够有效地提升程序的稳定性和可维护性。

5、设计一个不能被继承的类

在 C++ 中，某些情况下我们可能希望阻止一个类被继承。特别是在设计核心组件或库时，可能希望某些类的行为保持一致，或者为了防止子类对类的接口或实现进行修改，从而导致不必要的复杂性或潜在问题。设计一个不能被继承的类主要涉及 C++ 关键字 final 和一些其他方法。本节将深入探讨如何设计一个不能被继承的类，并提供详细的技术实现和实际使用场景。

5.1、防止继承的原理

在 C++ 中，可以通过多种方式阻止类被继承，其中最常用的方法是使用 C++11 引入的 final 关键字。final 关键字可以用来修饰类，明确表示该类不能被其他类继承。此外，还可以通过一些技巧来限制继承，但这些方法通常并不如 final 关键字直接有效。

主要方法：

1. 使用 final 关键字：
   • final 关键字可用于类定义中，确保该类无法被继承。
2. 私有化构造函数：
   • 通过将构造函数私有化，并且不提供友元类或工厂方法，阻止外部类创建派生类。
3. 私有继承的基类：
   • 将基类设计为一个包含私有构造函数的类，防止其他类继承它。

5.2、技术实现

接下来，我们将讨论如何使用 final 关键字以及其他方法来实现不能被继承的类。

5.2.1、使用 final 关键字阻止继承

final 是 C++11 引入的一个功能，它可以用于类或虚函数。当用于类时，它禁止该类被继承；当用于虚函数时，它阻止该函数在子类中被重写。

代码实现如下：

#include <iostream>

// 使用 final 关键字设计一个不能被继承的类
class NonInheritable final {
public:
    NonInheritable() {
        std::cout << "NonInheritable object created." << std::endl;
    }

    ~NonInheritable() {
        std::cout << "NonInheritable object destroyed." << std::endl;
    }
};

// 错误！尝试继承 NonInheritable 会导致编译失败
/*
class Derived : public NonInheritable {
    // 编译器报错：class 'NonInheritable' is final and cannot be derived from
};
*/

int main() {
    NonInheritable obj;
    return 0;
}

代码解释：

• final 关键字：通过将 NonInheritable 类定义为 final，我们阻止任何类从它继承。如果尝试继承 NonInheritable，编译器将报错。

5.2.2、私有化构造函数阻止继承

虽然 final 关键字是最直接的方式，但在某些设计中，可能需要通过私有化构造函数来阻止继承。我们可以将构造函数声明为私有，并且不提供友元类或工厂函数，从而防止该类被继承。

代码实现如下：

#include <iostream>

class NonInheritableWithPrivateCtor {
private:
    NonInheritableWithPrivateCtor() {
        std::cout << "NonInheritableWithPrivateCtor object created." << std::endl;
    }

public:
    // 通过一个静态方法提供类的实例化方式
    static NonInheritableWithPrivateCtor CreateInstance() {
        return NonInheritableWithPrivateCtor();
    }
};

// 错误！尝试继承该类将失败，因为构造函数是私有的
/*
class Derived : public NonInheritableWithPrivateCtor {
    // 编译器报错：constructor is private
};
*/

int main() {
    auto obj = NonInheritableWithPrivateCtor::CreateInstance();
    return 0;
}

代码解释：

• 私有化构造函数：通过将 NonInheritableWithPrivateCtor 的构造函数私有化，阻止其他类继承它。由于派生类无法访问基类的私有构造函数，尝试继承该类会导致编译错误。
• 静态工厂函数：为了允许对象的创建，使用了一个静态工厂函数来实例化该类对象。

5.3、使用场景

阻止类被继承的设计可以用于多种场景，主要目的是确保类的行为和接口不被子类修改，保证类的功能一致性和完整性。

• 不可修改的核心组件：在设计库或框架时，有些类的行为需要保持不可变。这些类往往包含核心功能，不希望被继承和修改。例如，某些系统组件类、核心逻辑类，开发者希望其行为保持一致。

• 安全和稳定性要求：有些场景中，出于安全性考虑，开发者希望阻止类的继承，以确保不被恶意或错误的子类重写关键方法，导致系统不稳定。

• API 设计：在 API 设计中，某些类可能是最终的功能实现，不希望用户通过继承进行功能扩展。因此，将这些类设计为不能被继承，有助于保持 API 的简单性和一致性。

5.4、性能分析

• 编译期优化：final 关键字不仅可以阻止类被继承，还能使编译器在进行某些优化时更加有针对性。例如，编译器知道该类没有派生类后，可以对虚函数调用进行优化，减少虚表的开销。
• 维护复杂度降低：通过阻止类被继承，可以减少子类对基类的依赖性和修改，降低维护的复杂度，避免因继承带来的意外问题。

5.5、扩展思考

• 限制虚函数重写：除了禁止类继承，final 关键字还可以用于虚函数，防止子类对某些关键方法进行重写。这在设计一些复杂的类时可以确保类的核心功能不被破坏。

• 模板元编程中的应用：在某些元编程场景中，阻止类被继承可以帮助确保类在泛型编程中的一致性。例如，在某些泛型库的设计中，可以使用 final 确保类行为在不同模板实例中保持一致。

5.6、小结

通过设计一个不能被继承的类，我们可以确保类的行为保持一致，避免子类修改带来的潜在问题。这种设计在确保系统稳定性、核心组件不变性以及 API 的一致性方面尤为重要。C++ 提供了多种方法来实现这一目标，如使用 final 关键字或私有化构造函数。开发者应根据实际场景选择合适的技术手段，以实现最佳的设计效果。

6、设计一个只能创建一个对象的类（单例模式）

在软件设计中，单例模式 (Singleton) 是一种常见的设计模式，主要用于限制类的实例化次数，确保在程序的生命周期中只能创建一个对象实例，并提供全局访问该实例的方式。它不仅可以为全局资源管理提供方便，还能有效避免多个实例占用资源带来的管理和性能问题。通过单例模式，开发者可以对对象的创建、访问和生命周期进行更加精细的控制。

6.1、单例模式的原理

单例模式的核心思想是在某个类中确保只能创建一个实例，并提供全局访问该实例的方式。这可以通过以下几种技术手段来实现：

1. 私有化构造函数：阻止外部代码通过 new 运算符直接创建对象实例。
2. 静态成员变量：保存类的唯一实例。
3. 静态方法：提供获取该唯一实例的全局访问点。
4. 防止对象复制：禁用拷贝构造函数和赋值运算符，确保实例无法被复制。

单例模式通常用于全局共享资源的管理，如日志系统、配置管理器等。

C++ 中实现单例模式的主要方式包括：懒汉模式、饿汉模式，以及现代 C++ 引入的 std::call_once 等线程安全机制。

6.2、单例模式的实现方式

6.2.1、懒汉模式

懒汉模式的特点是延迟实例化，即在首次访问该类时，才创建对象。这种方法在不需要时不会创建实例，节省了初期的内存资源。

懒汉模式代码实现：

#include <iostream>

class Singleton {
private:
    // 私有化构造函数，确保外部无法直接实例化对象
    Singleton() {
        std::cout << "Singleton instance created (lazy initialization)." << std::endl;
    }

    // 禁止拷贝构造与赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 禁用拷贝构造函数和赋值运算符，防止对象复制
    static Singleton* instance;

public:
    // 静态方法，用于获取单例实例
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton(); // 延迟实例化
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Using Singleton instance." << std::endl;
    }
};

// 静态成员变量初始化为 nullptr
Singleton* Singleton::instance = nullptr;

int main() {
    Singleton* s1 = Singleton::getInstance();
    s1->doSomething();

    Singleton* s2 = Singleton::getInstance();
    s2->doSomething();

    // 验证两个指针是否相同，保证单例模式
    std::cout << "Are s1 and s2 the same instance? " << (s1 == s2) << std::endl;

    return 0;
}

实现细节：

• 私有化构造函数：该类的构造函数被私有化，阻止外部通过 new 来实例化对象。
• 静态方法 getInstance：这是获取单例实例的唯一途径，只有在首次调用时，才会创建对象。
• 静态指针 instance：用于存储类的唯一实例，在多次调用 getInstance 时，返回的都是同一个实例。

优缺点分析：

• 优点：懒汉模式不会在程序启动时立即占用内存，它只在真正需要时才进行实例化。
• 缺点：由于懒汉模式在首次调用 getInstance 时创建实例，在多线程环境下，多个线程可能同时创建对象，从而导致线程安全问题。

6.2.2、饿汉模式

饿汉模式与懒汉模式相反，它在程序启动时就直接创建对象实例，无需等待调用。由于它在类加载时就初始化，因此避免了多线程访问时的同步问题。

饿汉模式代码实现：

#include <iostream>

class Singleton {
private:
    // 构造函数私有化，禁止外部实例化对象
    Singleton() {
        std::cout << "Singleton instance created (eager initialization)." << std::endl;
    }

    // 禁用拷贝构造函数和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 静态实例在程序启动时即创建
    static Singleton instance;

public:
    // 静态方法，用于获取单例实例
    static Singleton& getInstance() {
        return instance;
    }

    void doSomething() {
        std::cout << "Using Singleton instance." << std::endl;
    }
};

// 静态成员变量的直接初始化
Singleton Singleton::instance;

int main() {
    Singleton& s1 = Singleton::getInstance();
    s1.doSomething();

    Singleton& s2 = Singleton::getInstance();
    s2.doSomething();

    // 验证两个引用是否相同，保证单例模式
    std::cout << "Are s1 and s2 the same instance? " << (&s1 == &s2) << std::endl;

    return 0;
}

实现细节：

• 静态实例初始化：在类加载时就初始化了静态成员变量 instance，因此无需担心在多线程环境下出现的竞争条件。
• 静态方法 getInstance：通过静态方法获取唯一的实例，但由于实例在类加载时已经创建，因此方法内部不再需要做任何判断。

优缺点分析：

• 优点：饿汉模式避免了多线程环境下的同步问题，因为实例在程序启动时已经创建好，且线程安全。
• 缺点：即使在不使用实例时，饿汉模式也会强制实例化，可能导致不必要的内存浪费，尤其是在实例很少使用时。

6.3、单例模式的变种与优化

单例模式不仅仅有懒汉和饿汉两种实现，还有一些其他的变种和优化方案，针对不同场景和需求，我们可以选择适合的单例模式实现。

6.3.1、双重检查锁（Double-Checked Locking）

双重检查锁是针对懒汉模式的多线程问题提出的一种优化方案。它通过两次检查实例是否为空，来减少同步的开销。在第一次检查时不加锁，如果实例为空，则进入同步块，再次检查实例是否为空，只有当实例为空时才创建。

class Singleton {
private:
    Singleton() {
        std::cout << "Singleton instance created (double-checked locking)." << std::endl;
    }

    static Singleton* instance;
    static std::mutex mtx;

public:
    static Singleton* getInstance() {
        if (instance == nullptr) { // 第一次检查
            std::lock_guard<std::mutex> lock(mtx);
            if (instance == nullptr) { // 第二次检查
                instance = new Singleton();
            }
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Using Singleton instance (double-checked locking)." << std::endl;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

// 静态成员初始化
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

这种方式避免了每次访问单例实例时都需要进行同步操作的性能开销。双重检查锁在 C++11 引入的内存模型下是安全的，但在某些旧版本编译器中可能会出现问题。

6.3.2、使用 std::call_once 和 std::once_flag

在 C++11 之后，标准库引入了 std::call_once 和 std::once_flag，这些工具可以更加简洁和高效地解决线程安全问题，且避免了双重检查锁的复杂性。

#include <iostream>
#include <mutex>

class Singleton {
private:
    Singleton() {
        std::cout << "Singleton instance created (std::call_once)." << std::endl;
    }

    static Singleton* instance;
    static std::once_flag initFlag;

public:
    static Singleton* getInstance() {
        std::call_once(initFlag, []() { instance = new Singleton(); });
        return instance;
    }

    void doSomething() {
        std::cout << "Using Singleton instance (std::call_once)." << std::endl;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

// 静态成员初始化
Singleton* Singleton::instance = nullptr;
std::once_flag Singleton::initFlag;

int main() {
    Singleton* s1 = Singleton::getInstance();
    s1->doSomething();

    Singleton* s2 = Singleton::getInstance();
    s2->doSomething();

    std::cout << "Are s1 and s2 the same instance? " << (s1 == s2) << std::endl;

    return 0;
}

通过 std::call_once，我们只需定义一次对象的初始化代码，编译器确保它在多线程环境下只会执行一次，这大大简化了代码，同时也保证了线程安全。

6.3.3、内存泄漏与对象销毁

单例模式中的对象通常是通过 new 动态分配的，这会带来内存泄漏问题，因为通常情况下单例对象的生命周期与整个程序一致。为了解决内存泄漏问题，我们可以在程序退出时显式销毁单例对象。

解决方法之一是在类中使用智能指针管理单例实例，或通过 atexit 注册析构函数。

#include <memory>
#include <iostream>

class Singleton {
private:
    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
    }

    static std::unique_ptr<Singleton> instance;

public:
    static Singleton* getInstance() {
        if (!instance) {
            instance.reset(new Singleton());
        }
        return instance.get();
    }

    void doSomething() {
        std::cout << "Using Singleton instance." << std::endl;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

// 静态成员初始化
std::unique_ptr<Singleton> Singleton::instance = nullptr;

int main() {
    Singleton* s1 = Singleton::getInstance();
    s1->doSomething();

    Singleton* s2 = Singleton::getInstance();
    s2->doSomething();

    std::cout << "Are s1 and s2 the same instance? " << (s1 == s2) << std::endl;

    return 0;
}

这里使用了 std::unique_ptr 自动管理单例的生命周期，当程序结束时，智能指针会自动销毁对象，防止内存泄漏。

6.4、单例模式的实际应用场景

单例模式常用于以下几种场景：

1. 全局配置管理：在许多系统中，配置信息通常需要全局共享，如数据库连接配置、系统参数等。使用单例模式可以确保配置类在整个程序中只有一个实例，且配置参数统一管理，避免了不同模块的配置冲突。
2. 日志系统：单例模式经常用于日志系统，确保日志记录器全局唯一。这样可以避免多个日志实例记录同样的内容，节省资源。
3. 资源管理类：如线程池、数据库连接池等共享资源，通常需要集中管理。通过单例模式，可以确保这些资源只被初始化一次，并全局共享，避免重复初始化带来的资源浪费。
4. 设备控制类：在嵌入式系统或其他硬件控制类的应用中，某些设备驱动只允许一个控制实例。例如，串口设备、摄像头、麦克风等。

6.5、性能分析与扩展思考

• 懒汉模式的性能：懒汉模式通过延迟实例化，在应用程序启动时避免了不必要的对象创建。相比饿汉模式，它更为灵活，但在多线程环境中需要额外的锁机制保证线程安全，这可能会引入少量性能开销。

• 饿汉模式的性能：饿汉模式在程序启动时直接初始化对象，无需在运行时检查实例是否已创建，避免了加锁操作，因此在性能上略优于懒汉模式。然而，它可能会导致不必要的资源占用，尤其是在对象很少使用时。

• 智能指针与单例模式：在现代 C++ 中，可以结合智能指针（如 std::unique_ptr 或 std::shared_ptr）来管理单例对象的生命周期，避免手动内存管理带来的风险。

• 懒汉模式的线程安全改进：C++11 还提供了 std::call_once，它可以确保某个初始化函数只执行一次，适合用于懒汉模式的单例实现。这比使用互斥锁更加轻量高效，进一步提高了性能。

6.6、单例模式的优缺点

尽管单例模式在许多应用场景中非常实用，但它也有一些局限性和潜在的弊端。在实际开发中，我们应当权衡其优缺点，合理地应用。

6.6.1、优点

1. 唯一实例：单例模式确保类的实例在全局范围内唯一，这非常适合需要共享全局资源的场景，如配置管理器、日志系统等。
2. 延迟实例化：懒汉模式的单例实现支持延迟加载，只有在首次需要时才进行实例化，从而节省了初期的系统资源。
3. 全局访问：通过静态方法，程序的任意部分都可以方便地访问单例实例，提供了类似全局变量的便利性。
4. 线程安全（经过优化）：通过合理的线程安全机制，如 std::call_once、互斥锁等，可以确保多线程环境下的唯一实例创建。

6.6.2、缺点

1. 隐式依赖：由于单例模式提供了全局访问，某些模块可能隐式依赖于单例对象，这会导致代码的模块化和可维护性变差。单例模式在某些情况下可能会破坏系统的分层设计。
2. 难以扩展：由于单例模式确保类的唯一性，它不易扩展。比如，无法对单例类进行子类化或替换，因此在某些设计中，单例模式会导致灵活性降低。
3. 并发性问题：尽管我们可以通过锁或 std::call_once 解决多线程环境下的并发性问题，但这无疑增加了实现的复杂性和性能开销，尤其是在频繁访问的场景下，锁的开销可能会影响性能。
4. 难以测试：单例模式由于其全局状态的特性，给单元测试带来一定的困难。通常的解决方法是使用依赖注入（Dependency Injection）来代替直接使用单例模式，这样可以在测试时轻松地替换单例对象。

6.7、小结

单例模式在现代 C++ 编程中是一个非常常见且实用的设计模式，它在资源管理、全局访问控制等场景中具有很大的应用价值。通过私有化构造函数、静态成员和线程安全的实现技术，开发者能够确保类的唯一实例，并防止对象的重复创建。然而，单例模式并不适用于所有场景，尤其是在过度使用时，可能会导致代码的复杂度和依赖性增加。因此，在使用单例模式时，应该权衡其优缺点，选择适合的实现方式并合理应用于合适的场景中。

7、设计一个只能移动的类

7.1、背景与动机

在 C++ 中，移动语义通过转移资源所有权来避免不必要的拷贝，提高程序的性能。然而，在某些特定的应用场景下，我们可能希望类的对象只能被移动，而不能被拷贝。这样的设计可以确保资源的唯一性，并避免由于对象拷贝带来的潜在问题，例如重复释放资源。

7.2、原理：禁止拷贝，允许移动

为了设计一个只能移动的类，需要禁用该类的拷贝构造函数和拷贝赋值操作符，同时保留其移动构造函数和移动赋值操作符。C++11 提供了 delete 关键字，用于显式禁用某些函数。此外，默认的移动构造函数和移动赋值操作符可以通过 = default 来保留。

7.3、实现步骤

1. 禁用拷贝操作
   • 将拷贝构造函数和拷贝赋值操作符标记为 delete。
2. 启用移动操作
   • 保留默认的移动构造函数和移动赋值操作符。

通过这种方式，类的对象无法被拷贝，只能通过移动操作进行转移。

代码实现

class MovableOnly {
public:
    // 默认构造函数
    MovableOnly() = default;

    // 禁用拷贝构造函数
    MovableOnly(const MovableOnly&) = delete;

    // 禁用拷贝赋值操作符
    MovableOnly& operator=(const MovableOnly&) = delete;

    // 允许默认的移动构造函数
    MovableOnly(MovableOnly&&) = default;

    // 允许默认的移动赋值操作符
    MovableOnly& operator=(MovableOnly&&) = default;

    // 其他成员函数
    void Show() const {
        std::cout << "This object can only be moved, not copied." << std::endl;
    }
};

7.4、代码详解

1. 禁用拷贝构造与拷贝赋值：通过将拷贝构造函数和拷贝赋值操作符标记为 delete，编译器将禁止所有对该类对象的拷贝行为。例如：

   MovableOnly obj1;
   MovableOnly obj2 = obj1;  // 编译错误：拷贝构造被禁用
   

2. 移动构造与移动赋值：通过默认的移动构造函数和移动赋值操作符，类对象可以安全地转移资源所有权。移动操作将源对象的资源转移到目标对象，而不需要进行深拷贝，提升性能。

   MovableOnly obj1;
   MovableOnly obj2 = std::move(obj1);  // 资源从 obj1 移动到 obj2
   

7.5、使用场景

只能移动的类设计在资源管理类（如文件句柄、网络连接等）中非常有用。例如，文件句柄类可以通过移动语义确保文件句柄不会在多个对象中重复使用或关闭，避免资源泄漏。此外，某些应用场景下，保持对象的唯一性也是至关重要的，这时只能移动的类设计将派上用场。

7.6、优势

• 提高性能：通过移动语义避免拷贝操作，减少了资源的重复分配和释放，特别是在处理大对象时效果显著。
• 增强安全性：禁止拷贝确保对象资源的唯一性，避免了重复释放资源的问题。

7.7、小结

设计一个只能移动的类不仅能提高程序的性能，还能有效防止资源管理中的潜在问题。在 C++ 的现代开发中，合理运用移动语义能够优化程序，确保资源的安全转移。

8、总结

在 C++ 中，设计特殊类是一种有效的编程技术，它不仅能优化程序的性能，还能提升代码的安全性与可维护性。本文通过探讨六种特殊类的设计，深入分析了这些设计背后的技术细节与应用场景。

首先，我们介绍了只能在堆上创建对象的类和只能在栈上创建对象的类。通过控制构造函数和析构函数的访问权限，我们可以强制类对象只能在指定的内存区域（堆或栈）上创建。这些设计通常应用于需要严格管理内存分配的场景，如资源密集型应用或实时系统。

接着，我们探讨了如何设计一个不能被拷贝的类。通过禁用拷贝构造函数和赋值操作符，可以避免对象在拷贝时带来的资源重复释放或意外的深拷贝问题。这一设计在资源管理类中尤为重要，尤其是那些涉及文件句柄、内存指针等需要独占资源的类。

然后，我们讨论了如何设计一个不能被继承的类。通过使用 final 关键字，可以防止类被进一步继承，确保类的封闭性。这一设计在开发库或框架时尤为重要，能够保证基类的行为不被意外改变。

接下来，我们讲解了单例模式的设计，即设计一个只能创建一个对象的类。单例模式确保了类的唯一实例，并通过私有构造函数和静态成员变量实现。这种模式常用于管理全局资源，如日志系统、数据库连接池等。

最后，我们介绍了如何设计一个只能移动的类。通过禁用拷贝操作并允许移动操作，类对象能够通过移动语义进行资源转移，避免不必要的拷贝，提升程序性能。这一设计在大对象管理中尤为有效。

总之，这六种特殊类的设计体现了 C++ 在内存管理和对象控制上的灵活性。通过合理使用这些技术，开发者可以在不同场景下有效控制对象的生命周期、资源管理和行为约束，为程序的性能优化与安全性提供有力保障。

希望这篇博客对您有所帮助，也欢迎您在此基础上进行更多的探索和改进。如果您有任何问题或建议，欢迎在评论区留言，我们可以共同探讨和学习。更多知识分享可以访问 我的个人博客网站 。

标签：特殊,对象,内存,C++,实例,玩转,单例,拷贝,构造函数
From： https://blog.csdn.net/mmlhbjk/article/details/143065124