单例模式 总结

原创 已于 2024-11-13 17:29:33 修改 · 1.1k 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#单例模式 #开发语言

于 2024-06-22 11:39:59 首次发布

一、采用 new 对象指针的方式

1.1、new 一个类的对象指针
class StoreBatteryData {
public:
    StoreBatteryData();
    ~StoreBatteryData();
    static StoreBatteryData *GetInstance()
    {
        if (storeDataPtr_ == nullptr) {
            storeDataPtr_ = new StoreBatteryData();
        }
        return storeDataPtr_;
    }
    ...
private:
    static StoreBatteryData *storeDataPtr_;
	...
};

定义 静态的 对象指针，他是不依赖当前类的对象的，他是在进程的 静态存储区。
通过 static 的 GetInstance 同样 不依赖当前的类对象，从而在当前进程中 获取类的一个实例。

使用 方式

// 私有 static 成员变量 需要 在 .cpp 文件中定义
StoreBatteryData *StoreBatteryData::storeDataPtr_;
void test () {
	StoreBatteryData *g_storems = StoreBatteryData::GetInstance();
	if (g_storems != nullptr) {
	    g_storems->SetStoreRun(false);
	}
}
1.2、懒汉式 方式 把构造函数 放在 private 里面

在上面的 类中，虽然 通过 GetInstance() 可以获得当前类的实例。但在进程中，仍然 可以通过其他的方式 定义类的对象 ，这样就破坏了类的唯一性。那么如何做呢，这就需要 添加 禁止 copy 和 move 的操作。

在类的单例模式中，禁止复制（copy）和移动（move）操作是为了确保单例对象的唯一性和避免意外的对象复制或移动，从而维护单例模式的正确性和稳定性。以下是为什么要设置禁止复制和移动操作的一些原因：

  1. 确保单例对象的唯一性：单例模式要求类的实例在整个程序中只能有一个，因此如果允许复制或移动操作，可能会导致多个实例的存在，破坏了单例模式的设计初衷。

  2. 避免资源泄漏：如果单例类管理了一些资源（如文件句柄、数据库连接等），复制或移动操作可能导致资源的多重所有权或泄漏，从而引发资源管理问题。

  3. 防止意外的行为：复制或移动操作可能会导致单例对象的状态不一致或未定义行为，使得程序行为变得不可预测。

  4. 提高代码的清晰性：禁止复制和移动操作可以使代码更加清晰明了，强调该类是一个单例类，只能通过特定的方式获取其实例。

为了禁止复制和移动操作，可以通过以下方式实现：

  • 删除复制构造函数和复制赋值运算符：通过将复制构造函数和复制赋值运算符声明为私有并不实现，或者使用 C++11 中的 delete 关键字来删除这些函数，从而禁止复制操作。

  • 删除移动构造函数和移动赋值运算符：同样地，可以删除移动构造函数和移动赋值运算符，以禁止移动操作。

通过显式地禁止复制和移动操作，可以有效地保护单例对象的唯一性，避免潜在的问题，并使单例模式的设计更加健壮和可靠。

如何做
  • 首先 需要把 构造函数 放在 private 里面，
    将构造函数放在私有部分是实现单例模式的一种常见做法，因为这样可以防止类的实例化，从而确保单例类只有一个实例。在这种情况下，你可以在类的静态成员函数中创建类的唯一实例。这种方法通常被称为"懒汉式"单例模式。

下面是一个示例，展示了如何在单例模式中将构造函数设置为私有，并在静态函数中创建单例对象：

class Singleton {
private:
    Singleton() {} // 将构造函数设为私有

public:
    static Singleton& getInstance() {
        static Singleton instance; // 在静态函数中创建单例对象
        return instance;
    }

    void doSomething() {
        // 单例类的其他操作
    }
};

在这个示例中，构造函数被放在私有部分，只能在类的内部访问，外部代码无法直接创建类的实例。通过静态函数 getInstance() 返回类的唯一实例，实现了单例模式。

在这种实现方式下，静态函数中创建的单例对象只会在第一次调用 getInstance() 函数时被创建，后续调用都会返回同一个实例。这种方式通常是线程安全的，因为静态局部变量在 C++11 标准中被保证只会初始化一次。

因此，将构造函数设置为私有，然后在静态函数中创建单例对象是一种有效的实现单例模式的方法，通常不会出现问题。这种方法能够确保单例对象的唯一性，并且在需要时延迟创建单例对象。

**但是需要注意的是 由于 **

  • 那么 为啥析构 函数 需要放在public 里面
    在单例模式中，通常将析构函数放在公共部分是为了确保单例对象在程序结束时能够正确地被销毁。在C++中，析构函数负责释放对象所占用的资源，执行清理操作，并在对象生命周期结束时被调用。

如果将析构函数放在私有部分，外部代码将无法直接调用析构函数来销毁单例对象。这可能会导致单例对象在程序结束时无法正确地进行资源清理和释放，从而造成资源泄漏或其他潜在的问题。

通过将析构函数放在公共部分，外部代码可以正常调用析构函数来销毁单例对象。这样可以确保单例对象在程序生命周期结束时能够正确地执行清理操作，释放资源，避免潜在的内存泄漏或资源泄漏问题。

下面是一个示例，展示了将析构函数放在公共部分的单例模式实现：

class Singleton {
private:
    Singleton() {} // 将构造函数设为私有

public:
    static Singleton& getInstance() {
        static Singleton instance; // 在静态函数中创建单例对象
        return instance;
    }

    void doSomething() {
        // 单例类的其他操作
    }

    ~Singleton() {
        // 析构函数用于资源清理和释放操作
    }
};

在这个示例中，析构函数被放在公共部分，外部代码可以通过调用析构函数来销毁单例对象。这样可以确保单例对象在程序结束时能够正确地进行资源清理和释放，保证程序的稳定性和正确性。

  • 改造上面的类，把构造函数 放在 private 里面
class StoreBatteryData {
public:
    ~StoreBatteryData();
    static StoreBatteryData *GetInstance()
    {
        if (storeDataPtr_ == nullptr) {
            storeDataPtr_ = new StoreBatteryData();
        }
        return storeDataPtr_;
    }
    ...
private:
    static StoreBatteryData *storeDataPtr_;
    StoreBatteryData();
	...
};
1.3、添加 禁止 copy 和 move，不采用懒汉式
  • 如果采用 禁止 copy 和 move 的方式，那么 就不需要把构造函数放在 private，

是的，如果你使用 delete 关键字来禁止类的复制（copy）和移动（move）操作，那么构造函数就不需要放在私有部分了。因为即使构造函数是公共的，由于复制构造函数和移动构造函数被删除了，外部代码也无法进行复制或移动操作。

下面是一个示例，展示了禁止复制和移动操作，同时将构造函数设置为公共的情况：

#include <iostream>

class NoCopyNoMove {
public:
    NoCopyNoMove() {
        std::cout << "Constructor called" << std::endl;
    }

    NoCopyNoMove(const NoCopyNoMove&) = delete; // 删除复制构造函数
    NoCopyNoMove& operator=(const NoCopyNoMove&) = delete; // 删除复制赋值运算符
    NoCopyNoMove(NoCopyNoMove&&) = delete; // 删除移动构造函数
    NoCopyNoMove& operator=(NoCopyNoMove&&) = delete; // 删除移动赋值运算符

    ~NoCopyNoMove() {
        std::cout << "Destructor called" << std::endl;
    }
};

int main() {
    NoCopyNoMove obj1; // 创建对象
    // NoCopyNoMove obj2 = obj1; // 编译错误，禁止复制
    // NoCopyNoMove obj3 = std::move(obj1); // 编译错误，禁止移动

    return 0;
}

在这个示例中，构造函数被放在公共部分，而复制构造函数和移动构造函数都被删除了。因此，尽管构造函数是公共的，但外部代码仍无法进行复制或移动操作。这种方法可以简化类的定义，同时确保类的对象不会被复制或移动，保持了设计的约束和规范。

  • 那么 如果仍然 把 构造函数 放在 private 中 会有啥问题吗
    如果将构造函数放在私有部分，即使使用 delete 关键字禁止了复制和移动操作，仍然会导致一些问题。主要问题包括：

  1. 继承问题: 如果构造函数是私有的，子类将无法直接调用基类的构造函数，这样就会限制子类的设计和扩展。

  2. 友元函数问题: 如果构造函数是私有的，友元函数也无法直接访问构造函数，这可能会导致友元函数无法正常操作类的实例。

  3. 可读性问题: 将构造函数放在私有部分可能会导致代码的可读性下降，因为通常来说，构造函数应该是公共的，并且能够被直接访问。

  4. 单例模式问题: 在某些设计模式中，如单例模式，构造函数通常被放在私有部分以确保只有一个实例。但是如果同时禁止了复制和移动操作，将构造函数放在私有部分可能会导致实例化的灵活性受到限制。

综上所述，虽然使用 delete 关键字可以有效禁止复制和移动操作，但将构造函数放在私有部分可能会带来一些设计上的限制和问题。通常情况下，为了保持代码的清晰性、可读性和可扩展性，构造函数应该放在公共部分，而通过删除复制构造函数和移动构造函数来限制复制和移动操作。

所以 最好的方式 是 不采用 懒汉式 而是采用 禁止 copy 和禁止 move的方式

  • 改造上面的类，采用 禁止 copy 和禁止 move 的方式
class StoreBatteryData {
public:
    StoreBatteryData();
    ~StoreBatteryData();
    static StoreBatteryData *GetInstance()
    {
        if (storeDataPtr_ == nullptr) {
            storeDataPtr_ = new StoreBatteryData();
        }
        return storeDataPtr_;
    }
    ...
private:
    // no copy
    StoreBatteryData(const StoreBatteryData &) = delete;
    StoreBatteryData& operator= (const StoreBatteryData &) = delete;
    // no move
    StoreBatteryData(StoreBatteryData &&) = delete;
    StoreBatteryData& operator= (StoreBatteryData &&) = delete;
    ...
};

二、采用 智能 指针的方式

  • 上面 采用 new 的对象指针的方式 ，存在 指针 释放的问题，所以 最好采用 智能指针的方式 来处理对象。继续改造吧。
2.1、首先把私有的static 成员变量 改造为 shared_ptr
  • 在单例模式中，将私有静态成员对象改造为 std::shared_ptr 智能指针是一种常见的做法，有一些优点和好处。下面是一些优点：
    在单例模式中，将私有静态成员对象改造为 std::shared_ptr 智能指针是一种常见的做法，有一些优点和好处。下面是一些优点：

  1. 内存管理: 使用 shared_ptr 智能指针可以更方便地进行内存管理，避免内存泄漏的风险。shared_ptr 使用引用计数来管理资源的所有权，确保在没有引用时正确释放资源。

  2. 线程安全: shared_ptr 在多线程环境下提供了一定程度的线程安全，通过引用计数来确保在适当的时候释放资源，避免了一些线程安全问题。

  3. 灵活性: 使用 shared_ptr 可以更灵活地管理单例对象的生命周期，不需要手动管理对象的创建和销毁。当最后一个引用离开作用域时，shared_ptr 会自动释放对象。

  4. 方便的访问控制: shared_ptr 可以在需要时延迟初始化单例对象，从而避免在程序启动时立即创建对象。这种延迟初始化的方式可以提高程序的性能。

  5. 不需要手动释放资源: 使用 shared_ptr 可以避免手动释放资源的麻烦，避免出现忘记释放资源导致的问题。

下面是一个简单的示例，展示了如何在单例模式中使用 shared_ptr 智能指针：

#include <iostream>
#include <memory>

class Singleton {
public:
    static std::shared_ptr<Singleton> getInstance() {
        static std::shared_ptr<Singleton> instance = std::make_shared<Singleton>();
        return instance;
    }

    void doSomething() {
        std::cout << "Singleton is doing something" << std::endl;
    }

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

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

int main() {
    std::shared_ptr<Singleton> singleton = Singleton::getInstance();
    singleton->doSomething();

    return 0;
}

在这个示例中，Singleton 类的单例对象使用 shared_ptr 进行管理，确保对象在适当的时候被释放。这种方式提供了更好的内存管理、线程安全性和灵活性，是一种常见的单例模式实现方式。

2.2、static std::shared_ptr instance 这里 把instance 定义在 初始的地方，也可以直接定义在 private 里面把，例如 private: static std::shared_ptr instance;

是的，你完全可以将 std::shared_ptr<Singleton> instance 直接定义在 private 部分，而不是在 getInstance() 函数内部。这种做法也是常见的，并且有一些优点，例如：

  1. 提高可读性: 将 instance 直接定义在 private 部分可以更清晰地表明这是单例对象的声明，使代码更易于理解。

  2. 延迟初始化: 将 instance 定义在 private 部分可以在需要时延迟初始化单例对象，而不是在每次调用 getInstance() 时都创建新对象。

  3. 更好的控制: 将 instance 定义在 private 部分可以更好地控制单例对象的创建和访问，避免了在 getInstance() 函数内部进行对象的创建。

下面是一个示例代码，展示了将 instance 直接定义在 private 部分的单例模式实现：

#include <iostream>
#include <memory>

class Singleton {
public:
    static std::shared_ptr<Singleton> getInstance() {
        if (!instance) {
            instance = std::make_shared<Singleton>();
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Singleton is doing something" << std::endl;
    }

private:
    static std::shared_ptr<Singleton> instance;

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

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

std::shared_ptr<Singleton> Singleton::instance = nullptr;

int main() {
    std::shared_ptr<Singleton> singleton1 = Singleton::getInstance();
    std::shared_ptr<Singleton> singleton2 = Singleton::getInstance();

    singleton1->doSomething();
    singleton2->doSomething();

    return 0;
}

在这个示例中，instance 被直接定义在 private 部分，并在 getInstance() 函数中进行了延迟初始化。这种方式提供了更好的可读性和控制，是一种常见的单例模式实现方式。

2.3、某些编译 在用make_shared 创建单例模式的 shared_ptr 智能指针的时候，如果 构造函数 和析构函数 都在 private 里面，会出现编译报错的问题，例如 error: static_assert failed due to requirement 'is_constructible<OHOS::PowerMgr::StoreBatteryData>::value' "Can't construct object in make_shared"

当将类的构造函数放在 private 部分，并尝试使用 std::make_shared 创建智能指针时，可能会导致编译器报错，错误信息类似于 “Can’t construct object in make_shared”。这通常是由于 std::make_shared 要求能够访问类的构造函数，但由于构造函数是私有的，导致了编译错误。在这种情况下，编译器无法在 std::make_shared 中直接访问私有构造函数，因此会报错。

为了解决这个问题，可以考虑使用 std::shared_ptr 的构造函数来显式创建对象，而不是依赖于 std::make_shared。通过直接调用 std::shared_ptr 的构造函数，可以绕过 std::make_shared 对构造函数可访问性的要求，从而成功创建对象。

下面是一个示例，展示了如何在类的构造函数放在 private 部分的情况下，使用单例模式手动创建 std::shared_ptr 对象：

#include <iostream>
#include <memory>

class Singleton {
public:
    static std::shared_ptr<Singleton> getInstance() {
        if (!instance) {
            instance = std::shared_ptr<Singleton>(new Singleton());
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Singleton is doing something" << std::endl;
    }

private:
    static std::shared_ptr<Singleton> instance;

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

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

std::shared_ptr<Singleton> Singleton::instance = nullptr;

int main() {
    std::shared_ptr<Singleton> singleton1 = Singleton::getInstance();
    std::shared_ptr<Singleton> singleton2 = Singleton::getInstance();

    singleton1->doSomething();
    singleton2->doSomething();

    return 0;
}

在这个示例中，通过直接调用 std::shared_ptr 的构造函数来创建 Singleton 类的实例，绕过了 std::make_shared 对构造函数可访问性的限制，从而成功实现了单例模式。

2.4、虽然上面已经改成不用make_shared,但是某些编译器还是会编译报错，因为 析构函数 不能放在 private error: calling a private destructor of class 'OHOS::PowerMgr::StoreBatteryData' delete __ptr;

在C++中，即使你使用std::shared_ptr显式创建对象，编译器仍然会检查该类的析构函数的可访问性。如果类的析构函数是私有的，即使你使用std::shared_ptr也无法调用该类的析构函数，因为在释放std::shared_ptr所管理的对象时，会调用对象的析构函数。

如果你想在类的析构函数放在private部分的情况下使用std::shared_ptr，你可以考虑以下两种方法：

  1. 友元类：将需要访问私有析构函数的类声明为友元类。这样，友元类就可以访问该类的私有成员，包括析构函数。

  2. 自定义删除器：可以在创建std::shared_ptr时使用自定义删除器，在自定义删除器中调用类的析构函数。这样可以绕过私有析构函数的限制。

下面是一个示例，演示了如何使用自定义删除器来绕过私有析构函数的限制：

#include <iostream>
#include <memory>

class Singleton {
public:
    static std::shared_ptr<Singleton> getInstance() {
        if (!instance) {
            instance = std::shared_ptr<Singleton>(new Singleton(), [](Singleton* ptr){
                delete ptr;
            });
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Singleton is doing something" << std::endl;
    }

private:
    static std::shared_ptr<Singleton> instance;

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

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

std::shared_ptr<Singleton> Singleton::instance = nullptr;

int main() {
    std::shared_ptr<Singleton> singleton1 = Singleton::getInstance();
    std::shared_ptr<Singleton> singleton2 = Singleton::getInstance();

    singleton1->doSomething();
    singleton2->doSomething();

    return 0;
}

在这个示例中，我们使用了自定义删除器来调用类的析构函数，从而绕过了私有析构函数的限制。这样就能够成功创建单例模式并使用私有析构函数。

将需要访问私有析构函数的类声明为友元类 这个如何实现 ，请写一个demo
当一个类需要访问另一个类的私有成员（包括私有析构函数）时，可以将需要访问的类声明为友元类。这样，友元类就可以访问另一个类的私有成员。下面是一个示例演示如何实现这一点：

#include <iostream>
#include <memory>

class Singleton;

class FriendClass {
public:
    void destroySingleton(Singleton* singleton);
};

class Singleton {
    friend class FriendClass; // 声明FriendClass为友元类

public:
    static std::shared_ptr<Singleton> getInstance() {
        if (!instance) {
            instance = std::shared_ptr<Singleton>(new Singleton());
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Singleton is doing something" << std::endl;
    }

private:
    static std::shared_ptr<Singleton> instance;

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

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

std::shared_ptr<Singleton> Singleton::instance = nullptr;

void FriendClass::destroySingleton(Singleton* singleton) {
    delete singleton;
}

int main() {
    std::shared_ptr<Singleton> singleton1 = Singleton::getInstance();
    std::shared_ptr<Singleton> singleton2 = Singleton::getInstance();

    singleton1->doSomething();
    singleton2->doSomething();

    // 使用友元类来销毁 Singleton 实例
    FriendClass friendObj;
    friendObj.destroySingleton(singleton1.get());

    return 0;
}

在上面的示例中，FriendClass被声明为Singleton的友元类，这样FriendClass就可以访问Singleton的私有成员，包括私有析构函数。在main函数中，我们创建了一个FriendClass对象friendObj，并使用它来调用destroySingleton方法来销毁Singleton实例。这样就成功实现了通过友元类访问私有析构函数的功能。

那么这个时候原来类里面的析构函数 还起作用吗

在上面的示例中，我们通过友元类来销毁Singleton实例，实际上是直接调用了delete操作符来销毁对象。这种方式绕过了std::shared_ptr的析构函数调用，因此原来类里面的析构函数不会被调用。

在使用delete操作符销毁对象时，只会调用对象的析构函数，而不会调用std::shared_ptr中的删除器。因此，如果你选择使用友元类来销毁对象，那么原来类中定义的析构函数将不会被调用。

如果你希望在销毁对象时仍然调用原来类中定义的析构函数，可以修改destroySingleton方法来使用std::shared_ptr的方式来销毁对象。这样可以确保在对象被销毁时，析构函数会被正确调用。下面是修改后的示例：

#include <iostream>
#include <memory>

class Singleton;

class FriendClass {
public:
    void destroySingleton(std::shared_ptr<Singleton> singleton);
};

class Singleton {
    friend class FriendClass; // Declare FriendClass as a friend class

public:
    static std::shared_ptr<Singleton> getInstance() {
        if (!instance) {
            instance = std::shared_ptr<Singleton>(new Singleton());
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Singleton is doing something" << std::endl;
    }

private:
    static std::shared_ptr<Singleton> instance;

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

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

std::shared_ptr<Singleton> Singleton::instance = nullptr;

void FriendClass::destroySingleton(std::shared_ptr<Singleton> singleton) {
    singleton.reset(); // This will call the destructor of Singleton
}

int main() {
    std::shared_ptr<Singleton> singleton1 = Singleton::getInstance();
    std::shared_ptr<Singleton> singleton2 = Singleton::getInstance();

    singleton1->doSomething();
    singleton2->doSomething();

    // Use the friend class to destroy the Singleton instance
    FriendClass friendObj;
    friendObj.destroySingleton(singleton1);

    return 0;
}

在这个修改后的示例中，FriendClass的destroySingleton方法接受一个std::shared_ptr<Singleton>参数，通过调用reset方法来销毁对象。这样就会触发std::shared_ptr的析构函数调用，从而确保原来类中定义的析构函数会被正确调用。

2.5 改造 上面的代码，采用 智能指针 形式的单例
class StoreBatteryData {
public:
    static std::shared_ptr<StoreBatteryData> GetInstance()
    {
        if (storeDataPtr_ == nullptr) {
            storeDataPtr_ = std::shared_ptr<StoreBatteryData>(new StoreBatteryData(), [](StoreBatteryData *ptr) {
                delete ptr;
            });
        }
        return storeDataPtr_;
    }
private:
    StoreBatteryData();
    ~StoreBatteryData();  // 这个时候 析构函数 实际上不会调用到，只会调用到上面
    // 自定义的 delete ptr
    static std::shared_ptr<StoreBatteryData> storeDataPtr_;
};

三、采用智能指针 同时 采用 no copy 和 no move 的方式

四、采用static 静态局部变量的方式

在 C/C++ 中，可以使用函数内部的静态局部变量来实现单例模式。静态局部变量在函数第一次调用时初始化，在函数生命周期内保持其值不变，这使得它们非常适合用于实现单例模式。以下是一个简单的示例代码，展示如何使用静态局部变量定义单例：

C++ 示例代码：

#include <iostream>

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

public:
    static Singleton& getInstance() {
        static Singleton instance;  // 静态局部变量，在第一次调用时初始化
        return instance;
    }

    void printMessage() {
        std::cout << "Singleton instance created!" << std::endl;
    }
};

int main() {
    Singleton& singleton = Singleton::getInstance();
    singleton.printMessage();

    return 0;
}

在上面的示例中，Singleton 类的 getInstance() 函数返回一个静态局部变量 instance 的引用。由于静态局部变量只会在第一次调用时初始化，因此在整个程序生命周期内只会创建一个实例，从而实现了单例模式。

通过这种方式，可以确保在多次调用 getInstance() 时始终返回相同的单例实例，而不会创建多个实例。

注意事项：

  • 使用静态局部变量实现单例模式是一种常见的方法，但在多线程环境下可能会存在线程安全性问题。可以考虑使用互斥锁等机制来确保线程安全。

  • 单例模式虽然提供了全局访问点，但也可能导致代码的耦合性增加，因此在设计时需要慎重考虑是否真正需要使用单例模式。

Singleton& getInstance() 函数可以在多个文件实现
在 C++ 中，如果想要在多个文件中实现 Singleton 模式的 getInstance() 函数，需要注意以下几点：

  1. 声明和定义分离：首先需要在一个头文件中声明 Singleton 类和 getInstance() 函数，以便在多个文件中引用该声明。

  2. 定义静态成员变量：静态成员变量只能在类的实现文件中定义，而不能在头文件中定义，否则可能会引起多重定义错误。

  3. 链接器问题：确保链接器能够正确链接多个文件中的实现，避免出现重复定义的问题。

下面是一个简单的示例来展示如何在多个文件中实现 Singleton 模式的 getInstance() 函数：

Singleton.h：

#ifndef SINGLETON_H
#define SINGLETON_H

class Singleton {
private:
    Singleton() {}

public:
    static Singleton& getInstance();
};

#endif

Singleton.cpp：

#include "Singleton.h"

Singleton& Singleton::getInstance() {
    static Singleton instance;
    return instance;
}

main.cpp：

#include <iostream>
#include "Singleton.h"

int main() {
    Singleton& singleton = Singleton::getInstance();
    singleton.printMessage();

    return 0;
}

在这个示例中，Singleton.h 中包含了 Singleton 类的声明，Singleton.cpp 包含了 getInstance() 函数的定义，而 main.cpp 中使用了 Singleton 类并调用了 getInstance() 函数。

确保在编译时将 Singleton.cpp 和 main.cpp 链接在一起，以便正确生成可执行文件。这样，就可以在多个文件中实现 Singleton 模式的 getInstance() 函数，确保返回的是同一个单例实例。

Singleton* Singleton::getInstance() {
    static Singleton instance;
    return &instance;
}

可以把上面的实现 改为 返回 一个指针吗

当你希望在 Singleton 模式中返回一个指针而不是引用时，你可以将 getInstance() 函数的返回类型从 Singleton& 改为 Singleton*。这样做是完全可行的，允许你返回指向单例实例的指针。下面是相应的更改：

Singleton.h：

#ifndef SINGLETON_H
#define SINGLETON_H

class Singleton {
private:
    Singleton() {}

public:
    static Singleton* getInstance();
};

#endif

Singleton.cpp：

#include "Singleton.h"

Singleton* Singleton::getInstance() {
    static Singleton instance;
    return &instance;
}

main.cpp：

#include <iostream>
#include "Singleton.h"

int main() {
    Singleton* singleton = Singleton::getInstance();
    singleton->printMessage();

    return 0;
}

在这个示例中，getInstance() 函数返回了一个指向 Singleton 实例的指针。使用指针可以让你更加灵活地处理单例实例，但同时也需要注意指针的生命周期和潜在的内存管理问题。

确保在使用返回指针的 Singleton 模式时，要注意避免悬挂指针（dangling pointer）和内存泄漏等问题。最好在程序的生命周期中保证单例实例的有效性，以免出现意外情况。

对于上面 这种 单例模式 需要 delete 释放资源吗

在这种单例模式的实现中，getInstance() 函数返回的是指向静态局部变量 instance 的指针，而静态局部变量的生命周期是从第一次调用 getInstance() 开始直到程序结束，因此不需要手动释放这个实例，也就不需要在程序结束时调用 delete 来释放资源。

在这种情况下，静态局部变量的内存管理是由编译器负责的，编译器会在程序结束时自动调用析构函数来释放静态局部变量的内存，确保资源的正确释放。因此，你无需手动释放这个实例，也无需调用 delete。

总的来说，在这种单例模式的实现中，不需要手动释放资源。编译器会在程序结束时自动处理静态局部变量的内存释放。

Singleton& Singleton::getInstance() {
    static Singleton instance;
    return instance;
}

这种做法为啥事线程安全的
在这种实现方式中，使用静态局部变量的初始化只会在程序首次调用该函数时进行，而在后续调用时会直接返回已经初始化好的静态局部变量。这种行为保证了在单线程环境下静态局部变量的初始化是安全的，因为静态局部变量的初始化是在函数第一次调用时进行的，而且在 C++11 标准中规定了静态局部变量的初始化是线程安全的。

C++11 标准对静态局部变量的初始化进行了改进，保证了线程安全。具体来说，C++11 标准规定了当程序执行到静态局部变量的初始化时，会加锁以确保只有一个线程可以执行初始化操作，从而避免了多线程环境下的竞态条件问题。

因此，虽然这种实现方式在多线程环境下仍然可能存在竞态条件问题，但在 C++11 标准下，静态局部变量的初始化是线程安全的，因此在多线程环境下也可以保证单例模式的实现是安全的。

如果需要在多线程环境下确保线程安全性，可以考虑使用更加安全的线程安全技术，比如使用互斥锁（mutex）或者使用双重检查锁定（double-checked locking）等方法来保证单例模式的线程安全性。

Unity框架学习【单例模式基类】{个人单例模式总结，框架单例模式总结}
asukastar的博客
04-28 791
这三天花了点时间，学习了B站唐老师的框架，里面有很多知识都有很强的复用性。 即，完成一次之后的很多工作都可以节省，而且优化整个程序的结构。 首先就是唐老师的课程都是递进式的，也就是前面的课程会很大程度的影响到后面的课程，而单例模式，是我目前使用最多的模式【要加紧学习新的设计模式】，例如在我的一本介绍《游戏设计模式》课本里面就有明确的写到。 “唯独单例模式，我们是要考虑怎么尽可能少的去使用他” 然后...
unity C# 单例模式总结
yunjianxi0000的博客
08-11 481
一、什么是单例模式     单例模式是最简单的设计模式之一，这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建，并提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 单例模式只有一个实例； 单例类必须自己创建自己的唯一实例； 单例类必须给所有其他对象提供这一实例； 单例模式在多线程中需要小心使用，否则可能创建多个实例，违反单例唯一实例的原则； 应用场景： 需要频繁实例化然后销毁的对象； 创建时耗时过多但又经常用到的对象； 一些管理类对象
这怕是最全的【单例模式】，可以拉着面试官掰扯半小时(面试必备）
AMSRY的博客
09-09 2513
单例模式是面向对象的编程语言23种设计模式之一，属于创建型设计模式。主要用于解决对象的频繁创建与销毁问题，因为单例模式保证一个类仅会有一个实例。大部分对单例模式应该都知道一些，但面试的时候可能回答不会很完整，不能给自己加分，甚至扣分。 单一的知识点并不能对自己在面试的时候带来加分，而系统的知识树则会让面试官另眼相看，而本文会系统的介绍单例模式的基础版本与完美版本，基本上将单例模式的内容完全包括。如果认为有不同的意见可以留言交流。 源码已收录github查看源码 单例模式最重要的就是保证一个类只会出现.
单例模式总结
weixin_48439438的博客
01-20 482
单例模式的优点 我们从单例模式的定义和实现，可以知道单例模式具有以下几个优点： 1.在内存中只有一个对象，节省内存空间； 2.避免频繁的创建销毁对象，可以提高性能； 3.避免对共享资源的多重占用，简化访问； 4.为整个系统提供一个全局访问点。 单例模式的使用场景 由于单例模式具有以上优点，并且形式上比较简单，所以是日常开发中用的比较多的一种设计模式，其核心在于为整个系统提供一个唯一的实例，其应用场景包括但不仅限于以下几种： 　　 1.有状态的工具类对象； 2.频繁访问数据库或文件的对象； 饿汉式 publi
43丨单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？1
08-03
总结来说，单例模式在进程内保证对象的唯一性，但在分布式环境中需要额外的策略来实现跨进程的唯一性。线程唯一的单例则关注于在单个线程内的对象唯一，允许不同线程拥有各自的实例。在实际应用中，应根据系统的需求...
C# 设计模式之单例模式归纳总结
08-30
"C# 设计模式之单例模式归纳总结" C# 设计模式之单例模式是一种常用的设计模式，它限制了类的实例化，使得某个类只能有一个实例，并提供了一个全局访问点来访问该实例。本文将对单例模式的定义、优缺点、实现要点和...
单例模式最全总结
码上一元
10-13 280
单例模式：在整个软件系统中，某个类只存在唯一的一个对象实例，且该类只提供一个取得其对象实例的静态方法。如Hibernate的SessionFactory 单例模式的实现 饿汉式：类一加载就会创建该单例对象。 懒汉式：类加载不会创建该单例对象，而是首次使用该对象时才会创建。 具体实现 1.饿汉式（静态常量方式） class Singleton{ //私有构造方法 private Singleton(){} //类内部创建对象实例 private stati.
单例模式的归纳与总结
MJPaul的博客
08-01 262
单例模式单例模式的特征 单列模式是我们平时adroid 开发中经常用到的设计模式 一般实现的方法常见的分为5种 单例模式的特征 1)构造方法一般不对外开放 （private） 2)通过一个静态方法或者枚举返回单列类的对象 3)注意多线程的场景 4)单列类的对象在反序列化时不会重新创建对象 ...
单例模式学习总结
cai_niao2015的博客
06-07 327
单例模式是确保一个类只有一个实例，并提供一个全局访问点。单例模式没有公开的构造器，也就是不允许new，它只提供一个静态方法getInstance()（这个方法名是书上写的，自己写的时候应该可以根据情况自定义命名）来创建这个类的对象。在通过这种方式创建对象时，先判断内存中是否存在这个对象，如果存在，则直接返回该对象，反之则创建对象，然后再通过这个对象进行类中的方法。这样可以保证这个对象是独一无二的。...
常见的单例模式学习总结
chenkaibsw的专栏
05-19 679
1.单例模式介绍： 1）单例模式的作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。 2）单例模式的优点：单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。 3）单例模式有多种，评价一个单例模式的参数有，是否立刻加载还是延时加载，是否线程安全，...
C++ 单例模式智能指针实现
春天花会开的专栏
05-27 1973
单例模式
单例模式之C++实现，智能指针，线程安全版本
m0_72035301的博客
04-19 375
单例模式
C++11 使用智能指针改进单例模式
HelloKandy's Blog
01-14 7199
本文主要关于如何使用C++11的智能指针改进单例模式。智能指针在C++11版本之后提供，包含在头文件中，shared_ptr、unique_ptr、weak_ptr。设计初衷：线程安全、垃圾回收、单例对象可接受多个参数。 1、使用shared_ptr 相对于一般的单例实现而言，使用了可变参数模板使得单例对象可接受多个参数： #pragma once #include <mutex> #include <memory> template<typename T> class
C++实现单例模式（包括采用C++11中的智能指针）
热门推荐
FS's Home
02-05 2万+
对于设计模式来说，以前只是看过基础的理论，很多都没有实现和使用过。这段时间看到了别人C++代码中使用了单例模式，发现了很多新的东西，特此总结记录一下。说话比较啰嗦，希望由浅入深，帮助大家理解！     单例模式，顾名思义，即一个类只有一个实例对象。C++一般的方法是将构造函数、拷贝构造函数以及赋值操作符函数声明为private级别，从而阻止用户实例化一个类。那么，如何才能获得该类的对象呢？这时，
使用智能指针来实现单例模式
最新发布
panxixia的博客
05-07 816
使用智能指针实现单例模式，通过维护一个引用计数来跟踪有多少个 std::shared_ptr 指向同一个对象。当引用计数为零时，对象会被自动删除；使用 std::weak_ptr 避免循环引用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值