背景：

接触到一个很有意思的题目：如果在单例模式中返回share_ptr ???

static std::shared_ptr<Singleton> getInstance() ;

分析：

这个问题的难点在于如果要实现单例，那么一定要把构造函数变成私有的，但是make_shared一定是调用的public的函数。

破题思路是：把构造函数变成public，但是通过别的手段限制外部调用。 同时又保证 getInstance可以调用到。

具体而言：定义一个私有的类成员，在构造函数中通过参数传递进来。

上代码：

#include <iostream>
#include <memory>
#include <mutex>

class Singleton {
private:
    struct privatenum {
        int num;
    }k;
public:
    // 获取单例实例的方法
    static std::shared_ptr<Singleton> getInstance() {
        // 使用双重检查锁定来确保线程安全
        static std::shared_ptr<Singleton> instance; // 未初始化
        if (!instance) {
            std::lock_guard<std::mutex> lock(mutex_); // 锁定以确保线程安全
            if (!instance) {
                privatenum k;
                instance = std::make_shared<Singleton>(k); // 使用make_shared创建实例
            }
        }
        return instance;
    }

    // 其他成员函数
    void showMessage() {
        std::cout << "Hello from Singleton!" << std::endl;
    }

　　// 只要 k是私有的，那么就不能在外面调用。
    Singleton(privatenum k) {};
private:
    // 私有化构造函数，避免外部实例化
    // 禁用拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static std::mutex mutex_; // 互斥锁
};

// 定义静态成员变量
std::mutex Singleton::mutex_;

int main() {
    // 使用单例
    std::shared_ptr<Singleton> singleton1 = Singleton::getInstance();
    singleton1->showMessage();

    std::shared_ptr<Singleton> singleton2 = Singleton::getInstance();
    singleton2->showMessage();

    // 检查两个实例是否相同
    std::cout << "Instances are equal: " << (singleton1 == singleton2) << std::endl;

    return 0;
}