C++

//【实现单例步骤】
// 1.构造函数私有化
// 2.增加静态的、私有的当前类的指针变量
// 3.提供一个静态的公有接口，可让用户获得单例对象

#include<iostream>

using namespace std;

class A
{
private: // 步骤1
    A() {};
public:
    static A* getInstance() //步骤3
    {
        return a;
    }
private:
    static A* a; // 步骤2
};

A* A::a = nullptr;
//【实现单例步骤】
// 1.构造函数私有化
// 2.增加静态的、私有的当前类的指针变量
// 3.提供一个静态的公有接口，可让用户获得单例对象

//单例：懒汉式 、恶汉式
// <1> 懒汉式
class Singleton_lazy 
{
private:
    Singleton_lazy() { cout << "创建 Singleton_lazy " << endl; };
public:
    static Singleton_lazy* getInstance()
    {
        if (pSingleton_lazy == nullptr) // 如果单例对象没被创建（如果创建了，那就跳过呗）
        {
            pSingleton_lazy = new Singleton_lazy; // 那就TM建一个
        }
        return pSingleton_lazy;
    }
private:
    static Singleton_lazy* pSingleton_lazy;
};
Singleton_lazy* Singleton_lazy::pSingleton_lazy = nullptr;

// <2> 饿汉式
class Singleton_hungry
{
private:
    Singleton_hungry() { cout << "创建 Singleton_hungry " << endl; };
public:
    static Singleton_hungry* getInstance()
    {
        return pSingleton_hungry;
    }
private:
    static Singleton_hungry* pSingleton_hungry;
};
Singleton_hungry* Singleton_hungry::pSingleton_hungry = new Singleton_hungry;//直接在类外创建单例对象


int main()
{
    //A::getInstance();
    cout << "main开始的地方" << endl;
    Singleton_lazy::getInstance();
    Singleton_hungry::getInstance();
}

可以看到，恶汉模式在main执行之前已经初始化好了。

 举例子：SLAM中我们需要在多个文件中读取参数文件，所以，这里必须把Config写成 Singleton。它只有一个全局对象，当我们设置参数文件时，创建该对象【整个程序之创建一个对象】并读取参数文件，随后可以在任意位置读取该文件中的参数值。

class Config
{
private:
    // <1> 步骤1：构造函数私有化
    Config(){};
    cv::FileStorage file_;
public:
    ~Config();
    // <3> 步骤3：提供静态的、公有的接口；可让用户获取单例
    static void setParameterFile(const std::string& filename); // 类似于 static void getInstance()

    template<typename T>
    static T get(const std::string& key)
    {
        return T(Config::config_->file_[key]);
    }
    
private:
    // <2> 步骤2：增加静态的、私有的当前类的指针
    static std::shared_ptr<Config> config_;
};

std::shared_ptr<Config> Config::config_ = nullptr;

void Config::setParameterFile(const std::string & filename)
{
    if (config_ == nullptr) 
    {
        config_ = std::shared_ptr<Config>(new Config);
    }
    config_->file_ = cv::FileStorage(filename.c_str(), cv::FileStorage::READ);
    // 异常处理
    if (config_->file_.isOpened() == false)
    {
        std::cerr << "parameter file " << filename << "do not exsit" << std::endl;
        config_->file_.release();
        return;
    }
}

Config::~Config()
{
    if (file_.isOpened())
    {
        file_.release();
    }    
}

显然这里是懒汉模式，不过它新增了静态 模板类型的 get函数；

调用方式如下：

Config::setParameterFile("myparameter.yaml"); // 获取一个单例对象
double distance = Config::get<double>("distance");//通过静态成员函数获取参数，static能去掉？

不能去掉,原因：与普通的成员函数相比,静态成员函数由于不是与任何的对象相联系,因此它不具有this指针.从这个意义上来说,它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，只能调用其他的静态成员函数.

//将上述两个模式中的指针改为 共享指针

#include<iostream>
#include<memory>

using namespace std;

class Singleton_lazy
{
private:
    Singleton_lazy() { cout << "Singleton_lazy" << endl; };
public:
    //static Singleton_lazy* GetInstance()
    static shared_ptr<Singleton_lazy> GetInstance()
    {
        if (sp == nullptr)
        {
            //sp = new Singleton_lazy;
            sp = shared_ptr<Singleton_lazy>(new Singleton_lazy);
        }
        return sp;
    }
private:
    //static  Singleton_lazy* sp;
    static shared_ptr<Singleton_lazy> sp;
};
//Singleton_lazy* Singleton_lazy::sp = nullptr;
shared_ptr<Singleton_lazy> Singleton_lazy::sp = nullptr;

class Singleton_hungry
{
private:
    Singleton_hungry() { cout << "Singleton_hungry" << endl; };
public:
    //static Singleton_hungry* GetInstance()
    static void GetInstance()
    {
        //return sp;
        return;
    }
private:
    //static Singleton_hungry* sp;
    static shared_ptr<Singleton_hungry> sp;
};
shared_ptr<Singleton_hungry> Singleton_hungry::sp = shared_ptr<Singleton_hungry>(new Singleton_hungry);

int main()
{
    cout << "shiruiyu" << endl;
    Singleton_lazy::GetInstance();
    Singleton_hungry::GetInstance();
    return 1;
}