一篇文章带你搞定面试常问的单例模式

在很多面试中会问到大家熟悉的设计模式，单例模式就是一个常考的且在项目中经常会用到的设计模式。今天就和大家一起写一个单例模式。

概念

单例模式：顾名思义就是这个类只能创建一个对象。

单例模式写法的不断完善

让用户调用你的方法，创建对象，而不是通过类名的方法来创建对象。

class Singleton {
public:
    ~Singleton() {
        cout << "Singleton() destruct" << endl;
    }
    Singleton* CreateObject() {
        return new Singleton();
    }
private:
    Singleton() {
        cout << "Singleton() construct" << endl;
    }
};

调用函数来返回一个指向对象的指针，但是存在的问题是这个函数需要对象来调用，但是只能通过这个方法创建对象，所以无法执行。

在这个函数前面加上static后，变为静态函数，就不需要对象了。

再次测试

class Singleton {
public:
    ~Singleton() {
        cout << "Singleton() destruct" << endl;
    }
    static Singleton* CreateObject() {
        return new Singleton();
    }
private:
    Singleton() {
        cout << "Singleton() construct" << endl;
    }
};
int main(int argc, char** argv) {
    Singleton* s1 = Singleton::CreateObject();
    Singleton* s2 = Singleton::CreateObject();
    return 0;
}

在这里插入图片描述

发现每调用一次，就会调用一次new，返回的是新的对象地址。我们只需要一个对象。

那么我们新建一个静态指针变量，让指针的初始值为nullptr；然后如果没创建过对象，就给他new一个地址，然后赋值给这个变量；如果之前已经创建过了，就直接返回即可。

class Singleton {
public:
    ~Singleton() {
        cout << "Singleton() destruct" << endl;
    }
    static Singleton* CreateObject() {
        if (m_pObject == nullptr) {
            m_pObject = new Singleton();
        }
        return m_pObject;
    }
private:
    Singleton() {
        cout << "Singleton() construct" << endl;
    }
    static Singleton* m_pObject;
};
Singleton* Singleton::m_pObject = nullptr;
int main(int argc, char** argv) {
    Singleton* s1 = Singleton::CreateObject();
    Singleton* s2 = Singleton::CreateObject();
    return 0;
}

在这里插入图片描述

这是懒汉式，同时出现一个重大的问题就是出现了内存泄漏，不会调用类的析构函数。
在这里插入图片描述

在主函数中，用完以后还需要将这个对象指针手动释放掉。

而且还处在线程安全问题。

那么应该怎么写

在函数中，创建一个静态的对象，然后将他的地址返回。

class Singleton {
public:
    ~Singleton() {
        cout << "Singleton() destruct" << endl;
    }
    static Singleton* CreateObject() {
        static Singleton obj;
        return &obj;
    }
private:
    Singleton() {
        cout << "Singleton() construct" << endl;
    }
};
int main(int argc, char** argv) {
    Singleton* s1 = Singleton::CreateObject();
    Singleton* s2 = Singleton::CreateObject();
    return 0;
}

但是用指针还存在一个问题，如果用户在主函数中delete 这个指针，就会出错。因为这个对象不是在堆中构建的。

那么我们应该怎么做？

那就不返回指针，而是返回引用。

class Singleton {
public:
    ~Singleton() {
        cout << "Singleton() destruct" << endl;
    }
    static Singleton& CreateObject() {
        static Singleton obj;
        return obj;
    }
private:
    Singleton() {
        cout << "Singleton() construct" << endl;
    }
};
int main(int argc, char** argv) {
    Singleton& s1 = Singleton::CreateObject();
    Singleton& s2 = Singleton::CreateObject();
    return 0;
}

程序修改为这样

在这里插入图片描述

添加监视以后值都是一致的。

但是，如果此时主函数中返回的类型不是引用类型，那就存在了复制构造的过程,引用赋值给了其他对象。

Singleton s2 = Singleton::CreateObject();

说明还需要限制赋值构造函数。

可以将类的拷贝构造函数私有。就是在私有属性中添加拷贝构造函数

    Singleton(Singleton& obj) {
        cout << "Singleton(Singleton& obj) construct" << endl;
    }

此时上面那个存在赋值构造的方法就无法编译通过。

另一个不用私有的方法，把拷贝构造禁用。使用=delete方法

//单例--只有一个实例
class Singleton {
public:
    ~Singleton() {
        cout << "Singleton() destruct" << endl;
    }
    static Singleton& CreateObject() {
        static Singleton obj;
        return obj;
    }
    //不允许产生拷贝构造
    Singleton(Singleton& obj) = delete;
    //默认的赋值运算符重载
    Singleton* operator=(Singleton& obj) = delete;
private:
    Singleton() {
        cout << "Singleton() construct" << endl;
    }
};
int main(int argc, char** argv) {
    Singleton& s1=Singleton::CreateObject();
    return 0;
}