C++ 特殊类设计

最新推荐文章于 2024-09-15 11:40:06 发布

康熙38bdc

最新推荐文章于 2024-09-15 11:40:06 发布

阅读量1k

点赞数 8

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/wxk2227814847/article/details/141089411

版权

C++ 专栏收录该内容

27 篇文章 1 订阅

订阅专栏

目录

0.前言

1.设计一个不能被拷贝的类

1.1C++98实现

1.2C++11实现

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

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

4.设计一个不能被继承的类

4.1C++98实现

4.2C++11实现

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

5.1设计模式简介

5.2单例模式

5.2.1饿汉模式

5.2.2懒汉模式

6.小结

（图像由AI生成）

0.前言

在C++中，类的设计往往需要考虑到特定的使用场景和需求。为了满足这些需求，有时我们需要设计一些具备特殊性质的类，例如不能被拷贝的类、只能在堆上或栈上创建对象的类、不能被继承的类，或者是只能创建一个对象的类（单例模式）。本文将探讨如何通过C++语言的特性和不同版本的标准来实现这些特殊的类设计。

1.设计一个不能被拷贝的类

在C++中，有时需要设计一个类，使得该类的对象不能被拷贝或赋值。这种设计可以防止对象在不合适的上下文中被复制，确保数据的一致性和安全性。以下是如何在不同版本的C++中实现这样的类。

1.1C++98实现

在C++98中，为了禁止一个类的对象被拷贝，我们可以将类的拷贝构造函数和赋值运算符声明为私有，并且不提供这两个函数的实现。这样，当尝试对该类对象进行拷贝或赋值操作时，编译器会因为无法访问私有成员而产生编译错误，从而阻止拷贝行为。

class CopyBan
{
    // ...
private:
    CopyBan(const CopyBan&);
    CopyBan& operator=(const CopyBan&);
    // ...
};

实现原理：

设置成员为私有：如果拷贝构造函数和赋值运算符被声明为私有，那么它们无法在类外部被调用，无法执行拷贝操作。
只声明不定义私有成员函数：由于该函数被声明为私有且没有实现，因此即使在类内部也无法使用它们，确保了类的不可拷贝性。

1.2C++11实现

在C++11中，这种设计变得更加直观和简洁。C++11引入了= delete关键字，可以显式地删除拷贝构造函数和赋值运算符，表示这些操作不允许被调用。这样可以直接通过语法来禁止拷贝行为。

class CopyBan
{
    // ...
public:
    CopyBan(const CopyBan&) = delete;
    CopyBan& operator=(const CopyBan&) = delete;
    // ...
};

实现原理：

使用= delete：通过在函数声明后使用= delete，我们明确告知编译器该函数不应被使用，任何试图调用这些函数的代码都会导致编译错误。

C++11的这种实现方式不仅简化了代码，还提高了代码的可读性，直接表明了类设计的意图。

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

有时候，我们希望一个类的对象只能通过动态内存分配（即在堆上创建），而不能在栈上创建。这种设计在某些需要严格控制对象生命周期的场景中非常有用。为了实现这一目标，我们可以将类的析构函数声明为私有或保护成员。

实现方法

通过将析构函数设为私有或保护，我们可以防止对象在栈上创建。因为栈上创建的对象在作用域结束时会自动调用析构函数，如果析构函数是私有的，编译器将无法访问，从而导致编译错误。

以下是一个示例：

class HeapOnly
{
public:
    // 提供一个公共的静态方法用于创建对象
    static HeapOnly* createInstance() {
        return new HeapOnly();
    }

private:
    // 私有构造函数，防止直接实例化
    HeapOnly() {}
    
    // 私有析构函数，防止栈上创建对象
    ~HeapOnly() {}
};

实现原理：

私有化析构函数：由于析构函数是私有的，栈上创建的对象在离开作用域时将无法调用析构函数，这会导致编译错误。这样就强制要求对象只能通过new操作符在堆上创建。
提供静态工厂方法：通过提供一个静态方法createInstance，我们可以控制对象的创建过程，确保它们只在堆上创建。这个静态方法返回一个指向新分配对象的指针。
私有化构造函数：构造函数被私有化，防止类在外部被直接实例化，这也是为了确保对象只能通过工厂方法创建。

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

在某些场景中，我们希望类的对象只能在栈上创建，而不能在堆上动态分配。这种设计可以确保对象在函数结束时自动销毁，从而简化内存管理，避免手动释放内存的麻烦。

实现方法

为了实现只能在栈上创建对象的类，我们可以禁用new和delete操作符。这可以通过将这些操作符声明为私有成员函数来实现。由于在类外部无法访问私有成员，因此无法通过new操作符在堆上创建对象。

以下是一个示例：

class StackOnly
{
public:
    // 公共构造函数，允许栈上创建对象
    StackOnly() {}

private:
    // 禁用堆上创建对象
    void* operator new(size_t) = delete;
    void operator delete(void*) = delete;
};

实现原理：

禁用new操作符：通过将operator new声明为私有并使用= delete，我们明确告诉编译器不允许在堆上创建该类的对象。任何试图通过new操作符创建对象的代码都会导致编译错误。
禁用delete操作符：同样地，将operator delete声明为私有并使用= delete，防止对象在堆上被错误地销毁。
公共构造函数：构造函数是公共的，允许对象在栈上正常创建。

4.设计一个不能被继承的类

有时候，我们希望设计一个类，使得它不能被继承。这在防止类的行为被修改或确保类的接口不被破坏时非常有用。在不同的C++版本中，实现这个目标的方式有所不同。

4.1C++98实现

在C++98中，设计一个不能被继承的类相对繁琐。通常的做法是将类的构造函数和析构函数声明为私有成员，并通过友元类或静态工厂方法来控制类的实例化。这种方法虽然有效，但实现上比较复杂。

class NonInheritable {
private:
    NonInheritable() {}
    ~NonInheritable() {}

    // 声明一个友元类或静态工厂函数，用于实例化对象
    friend class Factory;
};

class Factory {
public:
    static NonInheritable createInstance() {
        return NonInheritable();
    }
};

实现原理：

私有化构造函数和析构函数：将类的构造函数和析构函数声明为私有，防止其他类从该类继承，因为子类无法访问基类的私有构造函数和析构函数。
通过友元类或静态工厂方法创建实例：由于构造函数是私有的，我们需要通过友元类或静态工厂方法来创建对象，从而确保类不能被继承，同时还能创建实例。

这种方法虽然有效，但代码相对复杂，而且增加了类的维护成本。

4.2C++11实现

C++11引入了final关键字，大大简化了设计不可继承类的过程。只需在类声明时使用final关键字即可直接禁止该类被继承。

class NonInheritable final {
public:
    NonInheritable() {}
    ~NonInheritable() {}
};

实现原理：

使用final关键字：在类声明时使用final关键字，表明该类不能被继承。任何尝试继承该类的操作都会导致编译错误。

这种方法不仅简单明了，还提高了代码的可读性，明确了类设计的意图。final关键字的引入，使得在C++11及以后的标准中设计不可继承类变得更加容易和直观。

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

单例模式（Singleton Pattern）是一种非常重要的设计模式，用于确保一个类在整个程序运行期间只能有一个实例，并提供一个全局访问点。这种模式在需要唯一性对象的场景中非常有用，如配置管理器、日志管理器等。

5.1设计模式简介

设计模式是软件开发中反复出现的解决特定问题的通用解决方案。它们不是现成的代码，而是可以在各种情况下被灵活应用的代码设计思想。单例模式就是其中的一种，旨在控制对象的创建数量，确保一个类只有一个实例，并且提供一个方法来访问这个唯一实例。

5.2单例模式

单例模式可以通过多种方式实现，常见的有饿汉模式和懒汉模式。下面将分别介绍这两种模式的实现方法。

5.2.1饿汉模式

饿汉模式是一种单例模式的实现方式，它在类加载时就创建单例对象，无论该对象是否会被使用。由于实例在类加载时就完成了初始化，这种方式是线程安全的，不需要额外的同步机制。

实现方式：

class Singleton {
public:
    // 提供一个全局访问点
    static Singleton& getInstance() {
        static Singleton instance; // 静态局部变量，在类加载时创建实例
        return instance;
    }

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

private:
    // 私有化构造函数，防止外部实例化
    Singleton() {}
};

实现原理：

静态局部变量：getInstance方法中使用了静态局部变量instance，它在第一次调用时被创建，并在程序的整个生命周期内存在。
私有化构造函数：构造函数是私有的，防止类在外部被直接实例化，确保只有一个实例存在。
删除拷贝构造函数和赋值运算符：通过删除拷贝构造函数和赋值运算符，防止类实例被复制，确保单例的唯一性。

5.2.2懒汉模式

懒汉模式是一种延迟初始化的单例模式实现方式，它在第一次需要使用单例对象时才创建实例。这种方式节省了资源，避免了在不需要单例对象时的提前创建，但需要额外的同步机制来保证线程安全。

实现方式：

#include <mutex>

class Singleton {
public:
    // 提供一个全局访问点
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mtx); // 锁定，以保证线程安全
            if (instance == nullptr) {
                instance = new Singleton(); // 延迟创建实例
            }
        }
        return instance;
    }

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

private:
    Singleton() {} // 私有化构造函数

    static Singleton* instance; // 静态指针，指向单例对象
    static std::mutex mtx;      // 互斥量，确保线程安全
};

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

实现原理：

静态指针：使用静态指针instance来指向单例对象，初始值为nullptr，表明尚未创建对象。
延迟初始化：在getInstance方法中，第一次调用时检查instance是否为空，如果为空则创建单例对象。
线程安全：通过std::mutex和std::lock_guard实现线程安全的延迟初始化，防止多个线程同时创建多个实例。
私有化构造函数和删除拷贝操作：和饿汉模式一样，通过私有化构造函数和删除拷贝构造函数及赋值运算符，确保单例的唯一性。

以上是单例模式的两种常见实现方式，饿汉模式简单且线程安全，适合在启动时即可确定需要单例的场景；懒汉模式则更为灵活，适合在资源紧张且单例对象并非总是必要的场景。选择哪种实现方式取决于具体的应用需求。

6.小结

在这篇博客中，我们探讨了如何在C++中设计几种具有特殊性质的类，包括不可拷贝类、只能在堆上或栈上创建的类、不可继承的类，以及单例模式的实现。通过这些设计技巧，我们能够更好地控制对象的创建、使用和生命周期，从而编写出更健壮、更易维护的代码。理解并灵活应用这些模式和技巧，不仅可以满足特定的编程需求，还能提升整体代码质量。