传统制造企业如何向智能化转型？-CFANZ编程社区

class MyClass {
private:
    MyClass() {} // 私有构造函数，禁止外部直接调用
public:
    static MyClass* CreateInstance() {
        return new MyClass();
    }
    // 其他成员函数和数据成员
};

优点：

缺点：

2. 只在堆上创建对象

设计策略：使用智能指针（如 std::unique_ptr 或 std::shared_ptr）来管理对象的生命周期。

实现步骤：

代码示例：

#include <memory>

class MyClass {
public:
    MyClass() {
        // 初始化代码
    }
    // 其他成员函数和数据成员
};

int main() {
    std::unique_ptr<MyClass> myObject = std::make_unique<MyClass>(); // 在堆上创建对象
    // 使用myObject
    return 0;
}

优点：

缺点：

总结

二、特殊类：不能被继承

1. 使用 `final` 关键字

在 C++ 中，final 关键字可以用来声明一个类或者成员函数，使其不能被进一步继承。

1.1 声明一个不可继承的类

class Base {
public:
    virtual void doSomething() = 0; // 纯虚函数，使得类成为抽象类
};

class Derived final : public Base {
    // 这里尝试继承 Base 类将会导致编译错误
};

在这个例子中，Derived 类通过继承自 Base 类，并且使用了 final 关键字，使得 Derived 类本身也不能被继承。

1.2 声明一个不可继承的成员函数

class Base {
public:
    virtual void doSomething() = 0;

    virtual void finalize() final {
        // 不可覆盖的成员函数
    }
};

在这个例子中，finalize 成员函数被声明为 final，这意味着它不能被派生类覆盖。

2. 使用 `private` 访问控制

将一个类声明为私有（private）可以防止外部代码创建该类的实例，但并不能阻止继承。为了防止继承，可以将基类的构造函数和析构函数设置为私有。

2.1 私有构造函数和析构函数

class Base {
private:
    Base() {} // 私有构造函数
    ~Base() {} // 私有析构函数

public:
    virtual void doSomething() = 0;
};

class Derived : public Base {
    // 这里尝试继承 Base 类将会导致编译错误
};

在这个例子中，由于 Base 类的构造函数和析构函数都是私有的，因此它不能被继承。

3. 使用 `deleted` 关键字

在 C++11 及以后的版本中，可以使用 deleted 关键字来声明一个不能被继承的类。

3.1 使用 `deleted` 关键字

class Base {
public:
    virtual void doSomething() = 0;

    virtual ~Base() = default;

    class Derived final : public Base {
        // 这里尝试继承 Base 类将会导致编译错误
    };
};

class DeletedBase {
public:
    class Derived : public DeletedBase {
        // 这里尝试继承 DeletedBase 类将会导致编译错误
    };
};

在这个例子中，DeletedBase 类的 Derived 类继承尝试会导致编译错误，因为 DeletedBase 类被声明为不能被继承。

总结

三、特殊类：单例模式

单例模式是一种常用的设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。在 C++ 中，有多种方法可以实现单例模式。

1. 单例模式概述

2. 实现单例模式的基本方法

2.1 饿汉式

饿汉式单例模式在类加载时就立即初始化单例对象。

class Singleton {
private:
    static Singleton instance; // 静态成员变量

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

public:
    static Singleton& getInstance() {
        return instance; // 返回单例实例
    }

    // 其他成员函数
};

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

在这个例子中，Singleton 类的构造函数是私有的，外部无法直接创建其实例。通过 getInstance 方法，我们可以获取到类的唯一实例。

2.2 懒汉式

懒汉式单例模式在第一次使用时才创建实例。

class Singleton {
private:
    static Singleton* instance; // 静态成员指针

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

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton(); // 第一次调用时创建实例
        }
        return instance; // 返回单例实例
    }

    static void releaseInstance() {
        if (instance != nullptr) {
            delete instance;
            instance = nullptr;
        }
    }

    // 其他成员函数
};

Singleton* Singleton::instance = nullptr; // 静态成员指针的初始化

在这个例子中，getInstance 方法检查实例是否已经创建，如果没有，则创建一个新的实例。这种方法在第一次使用时才创建实例，但需要注意内存泄漏的问题。

2.3 饿汉式（线程安全）

（这个涉及到线程安全的问题，如果还没有学习线程，可以先跳过这一部分）

#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex;

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

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance; // 返回单例实例
    }

    static void releaseInstance() {
        std::lock_guard<std::mutex> lock(mutex);
        if (instance != nullptr) {
            delete instance;
            instance = nullptr;
        }
    }

    // 其他成员函数
};

Singleton* Singleton::instance = nullptr; // 静态成员指针的初始化
std::mutex Singleton::mutex; // 互斥锁的初始化

在这个例子中，我们使用了 std::mutex 来确保在多线程环境下，单例实例只被创建一次。

总结