C++
C++ 六种特殊类设计详解：堆栈限制、拷贝控制与单例模式
C++ 特殊类设计涉及内存分配控制、对象生命周期管理及行为约束。主要包括只能在堆上创建（私有析构函数）、只能在栈上创建（删除 operator new）、不能被拷贝（= delete 拷贝构造）、不能被继承（final 关键字）、单例模式（全局唯一实例）以及只能移动的类（禁用拷贝允许移动）。这些设计通过构造函数权限、运算符重载及标准库特性实现，用于优化资源管理、提升安全性及性能。
C++ 特殊类设计涉及内存分配控制、对象生命周期管理及行为约束。主要包括只能在堆上创建（私有析构函数）、只能在栈上创建（删除 operator new）、不能被拷贝（= delete 拷贝构造）、不能被继承（final 关键字）、单例模式（全局唯一实例）以及只能移动的类（禁用拷贝允许移动）。这些设计通过构造函数权限、运算符重载及标准库特性实现，用于优化资源管理、提升安全性及性能。
本文深入探讨了六种 C++ 特殊类的设计及其技术细节。首先，介绍了如何设计只能在堆上或栈上创建对象的类，通过控制构造函数的访问权限来限定对象的内存分配区域。接着，探讨了如何设计一个不能被拷贝的类，避免资源重复释放的问题。随后，介绍了如何防止类被继承以及单例模式的实现，确保类的封闭性和唯一实例的创建。最后，讲解了只能移动的类设计，通过移动语义提升程序性能。这些设计在不同的实际场景中具有重要应用，帮助开发者优化内存管理和对象生命周期的控制。
C++ 作为一门功能强大的编程语言，提供了极大的灵活性，允许开发者对类的设计进行精细控制。这种灵活性不仅体现在对数据成员和函数的封装，还体现在如何控制对象的创建、生命周期和行为。通过设计特定的类，程序员可以显著优化内存管理、提高系统的安全性和稳定性，避免不必要的资源消耗与错误。
在 C++ 中，灵活控制对象的创建和管理尤为重要。对象可以在堆上动态分配，也可以在栈上自动管理，甚至可以限制其被拷贝、继承或只能创建一个实例。理解并掌握这些技术，不仅能让开发者精确控制对象的生命周期和内存分配，还能提升代码的性能、可读性和安全性。
在这篇文章中，我们将探讨六种特殊类的设计：只能在堆上创建的类、只能在栈上创建的类、不能被拷贝的类、不能被继承的类，只能创建一个实例的类（单例模式），以及只能移动的类。这些设计分别解决了不同的场景需求，帮助我们更好地控制类的行为和对象的管理。
接下来，我们将逐一剖析这些设计的技术细节，带您全面理解它们的原理与应用，展示如何在 C++ 中实现它们，并解释它们在现代编程中的应用场景与优劣。
在 C++ 中，通常对象既可以在堆上 (使用 new 运算符动态分配) 创建，也可以在栈上 (自动存储) 创建。然而，在某些场景下，我们希望强制要求对象只能在堆上创建，以确保内存的动态分配、手动管理对象的生命周期以及更灵活的资源分配。这种设计通常在需要对对象的创建和销毁进行细致控制的场景下非常有用。
堆 vs 栈的内存分配
通过设计只能在堆上创建的类，能避免用户错误地在栈上创建对象，确保更细粒度的内存控制与资源管理。
要实现'只能在堆上创建'的约束，我们可以通过私有化或删除类的构造函数来限制栈上对象的创建，并公开 new 运算符来强制用户使用动态分配。
原理
通过限制类的构造函数和析构函数，可以有效防止在栈上创建对象。
禁止栈上创建的技术实现
以下是具体实现的几个步骤：
通过将析构函数设为私有，栈上的对象在作用域结束时无法正确地调用析构函数，这就防止了对象在栈上被创建。
#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 函数，专门用于销毁堆上的对象，这样用户可以显式地管理对象的生命周期。为了进一步加强类的设计，我们通常需要禁止对象的拷贝与赋值，防止间接方式导致栈上对象创建。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; }
};
解释：
除了简单的 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 方法，我们强制用户只能通过该方法创建对象，进一步确保对象的创建方式受到控制。当对象只能在堆上创建时，手动管理内存释放变得至关重要。在实际开发中，使用 new 和 delete 管理内存存在风险，特别是当程序在复杂的执行路径中忘记释放堆上对象时，可能会导致内存泄漏。为了解决这个问题，智能指针（如 std::unique_ptr 或 std::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 的问题。通过限制对象只能在堆上创建，可以提升程序的稳定性和灵活性，特别是在需要动态资源管理和长期对象生存的情况下。
通过对构造函数、析构函数和拷贝控制的约束，C++ 允许我们设计出只能在堆上创建的类。这类设计能够提升程序的内存控制能力，确保对象的生命周期得到更细致的管理。结合智能指针与工厂模式，开发者可以更加安全、高效地管理这类特殊对象。
在 C++ 中，内存分配主要有两种方式：栈内存分配和堆内存分配。栈上对象是指那些在栈上分配内存的对象，它们通常具有较短的生命周期，由编译器自动管理。当函数执行结束时，栈上对象会自动销毁，内存也会被回收。而堆上对象则需要手动管理，通过 new 操作分配内存，并通过 delete 操作释放内存。栈内存的分配和释放速度远快于堆内存，因此在某些对性能要求较高的场景中，栈上对象成为更优的选择。
那么，为什么我们要设计一个类，使得其对象只能在栈上创建？其背后主要有以下几个动机：
new 操作动态分配内存，确保程序更加健壮、可控。本节的目标是通过逐步讲解如何设计一个只能在栈上创建对象的类，帮助读者深入理解其中的技术细节。通过这篇文章，读者将学到如何通过私有化 new 和 delete 运算符、禁用拷贝构造函数和赋值操作等方式，实现这一设计，同时理解其背后的内存管理原理以及在实际场景中的应用。
在 C++ 中，内存管理主要依赖于两种不同的分配机制：栈和堆。栈内存和堆内存的使用方式有着显著的差异，理解这两者的内存管理机制对于我们设计一个只能在栈上创建对象的类至关重要。
栈是程序运行时分配内存的一种方式，栈内存的分配速度非常快。每当我们在栈上创建一个局部对象，栈指针会向下移动，分配一定的内存空间给该对象；当对象超出作用域时，栈指针自动回退，释放该对象的内存。栈内存管理由编译器自动处理，程序员无需显式管理。
栈内存的优势包括：
然而，栈内存也有一些限制：
堆是动态分配内存的区域，通常用于分配生命周期在程序运行期间可能跨多个函数调用的对象。通过 new 操作符分配堆内存，由程序员负责显式释放。堆内存相比栈内存的管理更加灵活，但其分配和释放速度较慢，且存在内存泄漏和碎片化的风险。
堆内存的优势包括：
然而，堆内存的缺点也十分显著：
为了设计一个只能在栈上创建对象的类，我们需要防止其通过 new 操作符在堆上进行分配。C++ 提供了控制对象创建行为的灵活性，因此可以通过以下几种方法来实现：
operator new 和 operator delete：通过删除或将这两个运算符声明为私有，可以确保类的对象无法在堆上动态分配。具体实现策略如下：
new 和 delete 操作符为了禁止动态内存分配，可以将类的 new 和 delete 操作符声明为私有成员，或者显式删除它们。这可以阻止用户通过 new 操作在堆上创建对象，从而限制对象只能通过普通构造函数在栈上创建。
class StackOnly {
private:
// 禁止使用 new 在堆上分配内存
void* operator new(size_t) = delete;
void operator delete(void*) = delete;
};
这种设计确保了对象无法通过 new 在堆上分配，只能在栈上创建。
为了防止对象在不同作用域间传递或动态分配内存，我们还需要禁用拷贝构造函数和移动构造函数。这可以通过显式删除这些函数实现。
class StackOnly {
public:
StackOnly() = default;
// 禁止拷贝和移动操作
StackOnly(const StackOnly&) = delete;
StackOnly& operator=(const StackOnly&) = delete;
StackOnly(StackOnly&&) = delete;
StackOnly& operator=(StackOnly&&) = delete;
};
这种设计保证了对象只能在创建它的作用域内使用，并且无法通过赋值或移动构造函数在堆上或其他地方创建副本。
以下是实现只能在栈上创建对象的完整代码示例：
#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 函数中，演示了如何在栈上合法地创建对象，并确保对象在离开作用域时被自动销毁。设计只能在栈上创建的对象类通常适用于以下场景：
通过设计只能在栈上创建的类，我们能够在特定场景下优化程序的性能和内存使用。栈上对象的自动管理机制简化了内存管理，避免了许多常见的内存错误，如内存泄漏和动态分配失败。同时，禁止对象在堆上创建可以强制约束对象的生命周期，使得代码更加可靠和高效。这种设计在轻量级、短生命周期的对象中尤其有效，并且能够满足嵌入式系统等内存敏感环境的需求。
在 C++ 中，有时我们希望某些类的对象不被复制，以确保对象的唯一性和数据的完整性。设计一个不能被拷贝的类涉及到禁用拷贝构造函数和赋值运算符，以及考虑对象生命周期管理的问题。本节将深入讨论如何设计一个不能被拷贝的类，并解释其实现原理和使用场景。
C++ 中禁止对象拷贝通常通过以下两种方式实现：
delete 关键字删除它们，来阻止对象的复制和赋值操作。= delete 语法，可以明确告诉编译器某个函数（如拷贝构造函数和赋值运算符）不可用，从而在编译期间发现潜在的错误。以下是设计一个不能被拷贝的类的技术实现步骤：
delete 关键字删除它们。= delete 语法删除拷贝构造函数和赋值运算符，使得任何试图复制该类对象的操作都会在编译期间失败。代码实现
以下是一个设计不能被拷贝的类的完整代码示例：
#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 关键字删除拷贝构造函数和赋值运算符，确保该类的对象不能被复制或赋值。任何试图拷贝或赋值对象的操作都会在编译期间失败。设计一个不能被拷贝的类通常适用于以下场景：
设计一个不能被拷贝的类，不仅可以确保对象的唯一性和数据的完整性，还能提升程序的性能和安全性。通过删除或禁用拷贝构造函数和赋值运算符，我们可以有效地控制对象的复制行为，适用于需要严格控制对象生命周期和资源管理的各种场景。这种设计不仅在传统的应用程序中有广泛的应用，而且在并发编程和资源敏感的系统中尤为重要，能够有效地提升程序的稳定性和可维护性。
在 C++ 中，某些情况下我们可能希望阻止一个类被继承。特别是在设计核心组件或库时，可能希望某些类的行为保持一致，或者为了防止子类对类的接口或实现进行修改，从而导致不必要的复杂性或潜在问题。设计一个不能被继承的类主要涉及 C++ 关键字 final 和一些其他方法。本节将深入探讨如何设计一个不能被继承的类，并提供详细的技术实现和实际使用场景。
在 C++ 中，可以通过多种方式阻止类被继承，其中最常用的方法是使用 C++11 引入的 final 关键字。final 关键字可以用来修饰类，明确表示该类不能被其他类继承。此外，还可以通过一些技巧来限制继承，但这些方法通常并不如 final 关键字直接有效。
主要方法：
final 关键字：
final 关键字可用于类定义中，确保该类无法被继承。接下来，我们将讨论如何使用 final 关键字以及其他方法来实现不能被继承的类。
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;
}
代码解释：
NonInheritable 类定义为 final，我们阻止任何类从它继承。如果尝试继承 NonInheritable，编译器将报错。虽然 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 的构造函数私有化，阻止其他类继承它。由于派生类无法访问基类的私有构造函数，尝试继承该类会导致编译错误。阻止类被继承的设计可以用于多种场景，主要目的是确保类的行为和接口不被子类修改，保证类的功能一致性和完整性。
final 关键字不仅可以阻止类被继承，还能使编译器在进行某些优化时更加有针对性。例如，编译器知道该类没有派生类后，可以对虚函数调用进行优化，减少虚表的开销。final 关键字还可以用于虚函数，防止子类对某些关键方法进行重写。这在设计一些复杂的类时可以确保类的核心功能不被破坏。final 确保类行为在不同模板实例中保持一致。通过设计一个不能被继承的类，我们可以确保类的行为保持一致，避免子类修改带来的潜在问题。这种设计在确保系统稳定性、核心组件不变性以及 API 的一致性方面尤为重要。C++ 提供了多种方法来实现这一目标，如使用 final 关键字或私有化构造函数。开发者应根据实际场景选择合适的技术手段，以实现最佳的设计效果。
在软件设计中，单例模式 (Singleton) 是一种常见的设计模式，主要用于限制类的实例化次数，确保在程序的生命周期中只能创建一个对象实例，并提供全局访问该实例的方式。它不仅可以为全局资源管理提供方便，还能有效避免多个实例占用资源带来的管理和性能问题。通过单例模式，开发者可以对对象的创建、访问和生命周期进行更加精细的控制。
单例模式的核心思想是在某个类中确保只能创建一个实例，并提供全局访问该实例的方式。这可以通过以下几种技术手段来实现：
new 运算符直接创建对象实例。单例模式通常用于全局共享资源的管理，如日志系统、配置管理器等。
C++ 中实现单例模式的主要方式包括：懒汉模式、饿汉模式，以及现代 C++ 引入的 std::call_once 等线程安全机制。
懒汉模式的特点是延迟实例化，即在首次访问该类时，才创建对象。这种方法在不需要时不会创建实例，节省了初期的内存资源。
懒汉模式代码实现：
#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 时创建实例，在多线程环境下，多个线程可能同时创建对象，从而导致线程安全问题。饿汉模式与懒汉模式相反，它在程序启动时就直接创建对象实例，无需等待调用。由于它在类加载时就初始化，因此避免了多线程访问时的同步问题。
饿汉模式代码实现：
#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：通过静态方法获取唯一的实例，但由于实例在类加载时已经创建，因此方法内部不再需要做任何判断。优缺点分析：
单例模式不仅仅有懒汉和饿汉两种实现，还有一些其他的变种和优化方案，针对不同场景和需求，我们可以选择适合的单例模式实现。
双重检查锁是针对懒汉模式的多线程问题提出的一种优化方案。它通过两次检查实例是否为空，来减少同步的开销。在第一次检查时不加锁，如果实例为空，则进入同步块，再次检查实例是否为空，只有当实例为空时才创建。
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 引入的内存模型下是安全的，但在某些旧版本编译器中可能会出现问题。
在 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，我们只需定义一次对象的初始化代码，编译器确保它在多线程环境下只会执行一次，这大大简化了代码，同时也保证了线程安全。
单例模式中的对象通常是通过 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 自动管理单例的生命周期，当程序结束时，智能指针会自动销毁对象，防止内存泄漏。
单例模式常用于以下几种场景：
std::unique_ptr 或 std::shared_ptr）来管理单例对象的生命周期，避免手动内存管理带来的风险。std::call_once，它可以确保某个初始化函数只执行一次，适合用于懒汉模式的单例实现。这比使用互斥锁更加轻量高效，进一步提高了性能。尽管单例模式在许多应用场景中非常实用，但它也有一些局限性和潜在的弊端。在实际开发中，我们应当权衡其优缺点，合理地应用。
std::call_once、互斥锁等，可以确保多线程环境下的唯一实例创建。std::call_once 解决多线程环境下的并发性问题，但这无疑增加了实现的复杂性和性能开销，尤其是在频繁访问的场景下，锁的开销可能会影响性能。单例模式在现代 C++ 编程中是一个非常常见且实用的设计模式，它在资源管理、全局访问控制等场景中具有很大的应用价值。通过私有化构造函数、静态成员和线程安全的实现技术，开发者能够确保类的唯一实例，并防止对象的重复创建。然而，单例模式并不适用于所有场景，尤其是在过度使用时，可能会导致代码的复杂度和依赖性增加。因此，在使用单例模式时，应该权衡其优缺点，选择适合的实现方式并合理应用于合适的场景中。
在 C++ 中，移动语义通过转移资源所有权来避免不必要的拷贝，提高程序的性能。然而，在某些特定的应用场景下，我们可能希望类的对象只能被移动，而不能被拷贝。这样的设计可以确保资源的唯一性，并避免由于对象拷贝带来的潜在问题，例如重复释放资源。
为了设计一个只能移动的类，需要禁用该类的拷贝构造函数和拷贝赋值操作符，同时保留其移动构造函数和移动赋值操作符。C++11 提供了 delete 关键字，用于显式禁用某些函数。此外，默认的移动构造函数和移动赋值操作符可以通过 = default 来保留。
delete。通过这种方式，类的对象无法被拷贝，只能通过移动操作进行转移。
代码实现
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;
}
};
移动构造与移动赋值：通过默认的移动构造函数和移动赋值操作符，类对象可以安全地转移资源所有权。移动操作将源对象的资源转移到目标对象，而不需要进行深拷贝，提升性能。
MovableOnly obj1;
MovableOnly obj2 = std::move(obj1); // 资源从 obj1 移动到 obj2
禁用拷贝构造与拷贝赋值：通过将拷贝构造函数和拷贝赋值操作符标记为 delete，编译器将禁止所有对该类对象的拷贝行为。例如：
MovableOnly obj1;
MovableOnly obj2 = obj1; // 编译错误：拷贝构造被禁用
只能移动的类设计在资源管理类（如文件句柄、网络连接等）中非常有用。例如，文件句柄类可以通过移动语义确保文件句柄不会在多个对象中重复使用或关闭，避免资源泄漏。此外，某些应用场景下，保持对象的唯一性也是至关重要的，这时只能移动的类设计将派上用场。
设计一个只能移动的类不仅能提高程序的性能，还能有效防止资源管理中的潜在问题。在 C++ 的现代开发中，合理运用移动语义能够优化程序，确保资源的安全转移。
在 C++ 中，设计特殊类是一种有效的编程技术，它不仅能优化程序的性能，还能提升代码的安全性与可维护性。本文通过探讨六种特殊类的设计，深入分析了这些设计背后的技术细节与应用场景。
首先，我们介绍了只能在堆上创建对象的类和只能在栈上创建对象的类。通过控制构造函数和析构函数的访问权限，我们可以强制类对象只能在指定的内存区域（堆或栈）上创建。这些设计通常应用于需要严格管理内存分配的场景，如资源密集型应用或实时系统。
接着，我们探讨了如何设计一个不能被拷贝的类。通过禁用拷贝构造函数和赋值操作符，可以避免对象在拷贝时带来的资源重复释放或意外的深拷贝问题。这一设计在资源管理类中尤为重要，尤其是那些涉及文件句柄、内存指针等需要独占资源的类。
然后，我们讨论了如何设计一个不能被继承的类。通过使用 final 关键字，可以防止类被进一步继承，确保类的封闭性。这一设计在开发库或框架时尤为重要，能够保证基类的行为不被意外改变。
接下来，我们讲解了单例模式的设计，即设计一个只能创建一个对象的类。单例模式确保了类的唯一实例，并通过私有构造函数和静态成员变量实现。这种模式常用于管理全局资源，如日志系统、数据库连接池等。
最后，我们介绍了如何设计一个只能移动的类。通过禁用拷贝操作并允许移动操作，类对象能够通过移动语义进行资源转移，避免不必要的拷贝，提升程序性能。这一设计在大对象管理中尤为有效。
总之，这六种特殊类的设计体现了 C++ 在内存管理和对象控制上的灵活性。通过合理使用这些技术，开发者可以在不同场景下有效控制对象的生命周期、资源管理和行为约束，为程序的性能优化与安全性提供有力保障。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online