单例、顾名思义存在一个，比如一些序号生成器、
某个时间段只能允许一个窗口获取---类似火车票，购票窗口很多，单一时间内只允许一个窗口生成车票序号。
定义：确保一个类只有一个实例、而且自行实例化并向整个系统提供这个实例，这个类为单例类。提供全局访问的方法。
定义抽象：1、这个类只能存在一个实例、2、自行实例 3、全局提供。
附注：本文涉及较多C++ 储备，会在文末进行统一解释，涉及静态成员变量/成员方法、对象实例化、锁、初始化列表、构造函数私有化等。在阅读本文困难的情况可以先看附注。
一个基本单例类图如下：
补充一个类图阅读常识：
类图最上为类名、Singleton
第二行：成员变量
第三行：成员方法。此处暂不讨论静态和友员 ；constrcut： 构造函数
- “+”表示
public； - “-”表示
private； - “#”表示
protected； - 不带符号表示
default。 - 抽象类斜体。
简单demo：
Singleton.cpp
#include "Singleton.h"
#include <iostream>
using namespace std；
Singleton* Singleton::instance = NULL;
class Singleton
{
private:
//构造函数私有处理
Singleton(){}
public:
//析构删除资源
~Singleton()
{
delete instance;
}
//公有静态成员方法
static Singleton* getInstance()
{
if (instance == NULL)
{
instance = new Singleton();
}
return instance;
}
void singletonOperation()
{
cout << "singleton operation" << end;
}
private:
//私有静态成员变量用于承接对象
static Singleton* instance；
}
#include <iostream>
#include "Singleton.h"
using namespace std;
int main (int argc, char *argv[])
{
Singleton * sg = Singleton::getInstance();
sg->singletonOperation();
}结论：
1、在对类对象实例化过程会默认调用构造函数，
2、本类构造函数做了私有化处理，所以在类外部正常情况下的对象实例化会编译出错。禁止外部实例化
3、引入了静态成员方法，此静态成员方法，可以在对象没有实例化的时候调用。然后反向在内部完成对象实例化。内部实例化。
4、对象实例化后，引入私有静态成员变量，对对象进行存储。同时私有静态成员变量也能保证外部不能有赋值行为，对私有变量的动作都在类内部。实例的存储
进而通过判空逻辑保证对象的单一实例。也可以在这里通过锁机制进行多个实例的扩展。
5、通过静态成员方法获取单一实例对象，（注意任何场景都可以获取这个实例对象，因为目标只有一个）然后完成动作。静态成员获取对象。
优点：受控访问、可增加为多对象实例、节约系统资源
缺点：无抽象，不好扩展。
补充注释：
本部分由浅到深进行知识引入。
最简部分：
1、类的三种实例化
class A
{
private:
int n;
public:
A(int m ):n(m){}
~A(){}
};
int main()
{
A a(1); //栈
A b = A(1); //栈
A* c = new A(1) ; //堆 注意返回值为指针。地址承接
delete c；
return 0；
}2、类的初始化列表
看上图发现构造函数如下写法
private：
int n；
public：
A(int m ):n(m){}
==
A(int m){
n = m;
}3、 静态成员变量和成员函数
1、静态成员变量在所有类中都是共享的，创建第一个对象时候被初始化为0
2、静态成员变量的初始化，类外部，如 int A::count == 0; 初始化需要加类型。不需要加static
3、定义位置类内部
class A{
public ：
A(){}
~A(){}
static int count_public; //公有成员变量。
private:
static int count_private;//私有成员变量。
}3、静态成员变量访问控制，权限公有私有正常处理。公有可以被外部直接访问，私有只能在类内部访问。
类外部使用：
A:: count_public = 3;
A::count_private = 3; //error
4、静态成员方法
1、一个定义demo
#include <iostream>
using namespace std;
class Box
{
public:
static int objectCount;
int n;
Box(int m)
{
n = m;
};
~Box(){};
static int getCount()
{
objectCount = n;
return objectCount;
}
};2、 demo2
#include <iostream>
using namespace std;
class Box
{
public:
static int objectCount;
int n;
Box(int m)
{
n = m;
};
~Box(){};
static int getCount();
};
类外部定义。只有声明的时候需要加static
int Box::getCount()
{
objectCount = n;
return objectCount;
}// 初始化类 Box 的静态成员
int Box::objectCount = 0;
int main(void)
{
cout << "Inital Stage Count: " << Box::getCount() << endl;
Box Box1(3) ; // 声明 box1
Box Box2(8) ; // 声明 box2
cout << "Final Stage Count: " << Box::getCount() << endl;
return 0;
}2、方法定义在类的内部。使用方式： 类名::xxxx();如 Box::getCount();
3、限制静态成员函数只能访问静态成员变量、其他静态成员函数、类外部函数
4、没有this指针、不能访问this指针。
5、静态成员变量方法的私有公有处理
#include <iostream>
class A {
public:
A() {}
~A() {}
public: //公有静态成员函数
static void setA1(int val) {
A::a1 = val;
}
static int getA1() {
return a1;
}
static int getAA() {
return getA();
}
public:
static int a; //公有静态成员变量
private:
static int getA() { //私有成员只能在类内调用，可以在getAA内调用
return a;
}
private:
static int a1; //私有成员的赋值和取值，都只能在类内进行
};
class B {
public:
B() {}
~B() {}
public:
static void setB1(int val) {
B::b1 = val;
}
static int getB1() {
return b1;
}
void setB2(int val) {
b2 = val;
}
//static int getB2() { // 会报错，静态成员函数，只能访问静态成员变量
int getB2() {
return b2;
}
int getB21() { //正常，非静态成员函数，可以访问静态成员变量
return b1;
}
public:
static int b;
private:
static int b1; //私有成员的赋值和取值，都只能在类内进行
int b2;
};
int A::a = 10; //初始化必须带类型
int A::a1 = 15;
int B::b = 20;
int B::b1 = 25;
int main() {
std::cout << "A::a " << A::a << ", B::b " << B::b << std::endl;
std::cout << "A::a1 " << A::getA1() << ", B::b1 " << B::getB1() << std::endl;
A::a = 11; // 第二次可直接赋值
B::b = 21;
std::cout << "A::a " << A::a << ", B::b " << B::b << std::endl;
//以下三行会编译报错
//A::a1 = 18; // private member 不能在类外操作
//B::b1 = 28;
//std::cout << "A::a1 = " << A::a1 << "B::b1 = " << B::b1 << std::endl;
A::setA1(18);
B::setB1(28);
std::cout << "A::getA1() [a1] = " << A::getA1() << ", B::getB1() [b1] = " << B::getB1() << std::endl;
//std::cout << "A::getA() = " << A::getA() << std::endl; //编译报错
std::cout << "A::getAA() [a] = " << A::getAA() << std::endl;
B b;
b.setB2(222);
std::cout << "b.getB2() [b2] = " << b.getB2() << ", b.getB21() [b1] = " << b.getB21() <<std::endl;
return 0;
}运行结果：
A::a 10, B::b 20
A::a1 15, B::b1 25
A::a 11, B::b 21
A::getA1() [a1] = 18, B::getB1() [b1] = 28
A::getAA() [a] = 11
b.getB2() [b2] = 222, b.getB21() [b1] = 28
————————————————
总结：
1. private static 和 public static 都是静态变量,在类加载时就定义,不需要创建对象
2. private static 是私有的,不能在外部访问,只能通过静态方法调用,这样可以防止对变量的修改
3. static 成员函数只能访问static成员变量，非static成员函数可以访问static成员变量
6、构造函数私有化
1、对象在创建的时候会调用构造函数，如果私有化，会造成编译错误，在类外部无法创建对象。
2、静态成员函数无需要创建类对象就可以使用，在类内部使用静态成员函数创建类对象。
3、防止别人对类实例化。
class OnlyHeapClass
{
public:
static OnlyHeapClass* GetInstance()
{
// 创建一个OnlyHeapClass对象并返回其指针
return (new OnlyHeapClass);
}
void Destroy();
private:
OnlyHeapClass() { }
~OnlyHeapClass() {}
};
int main()
{
OnlyHeapClass *p = OnlyHeapClass::GetInstance();
... // 使用*p
delete p;
return 0;
}
1301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
