static的共享特性实现简单的银行取号服务

Service.cpp

#include <iostream> 


using namespace std;


class Server      //服务窗口类
{
public:

Server(char name)      //构造出不同的服务窗口，使用name区分
		:_name(name) {}
	void serviceWindow()    //服务窗口进行服务
	{
		if (_openFlag && _lastServedIdx < _turnCount)//如果窗口没有关闭，并且还有号码，就进行服务
		{
			
			cout << "Server: " << _name << " is serving " << _lastServedIdx << endl;//进行服务
			_lastServedIdx++;//服务之后继续向后服务
		}
		if (_lastServedIdx >= _turnCount)//如果最后一个顾客服务完就关闭服务窗口
			_openFlag = false;
	}
	static int getTurn()

	{
		++_turnCount;
		return _turnCount;   //获得在排队的总人数
	}
	static bool stillOpen()
	{
		return _openFlag;    //获得窗口状态
	}
private:
	char _name;              //name区别不同的服务窗口
	static int _turnCount;   //当前排队取号的总人数
	static int _lastServedIdx;  //最后一次服务的号码
	static bool _openFlag;     //窗口状态标志
};
int Server::_turnCount = 0;       //初始人数为0
int Server::_lastServedIdx = 0;     //最后一个顾客号码也为0
bool Server::_openFlag = true;      //窗口打开
int main()
{
	Server s1('A'), s2('B');   //创建两个窗口
	do
	{
		int num;
		cout << "How many in your groups:";  //模拟提示
		cin >> num;                                 //输入排队人数
		cout << "your turns are" << endl;
		for (int i = 0; i < num; i++)
		{
			cout << Server::getTurn() << endl;  //排队人数递增
		}
		s1.serviceWindow();   //1号窗口服务
		s2.serviceWindow();   //2号窗口服务
	} while (Server::stillOpen()); 
	//如果窗口没有关闭就继续等待是否有人在排队或者是否有人继续抽取号码
	cout << "now closing server" << endl;
	return 0;
}

运行结果：

我们可以看到如果只有两个人，那么服务完之后就会直接关闭。

使用static的体现

在实现的时候只要必须要在有人排队的时候即使还有人进来仍然可以抽取号码，所以需要一直监听并且给用户分配号码，但是每次服务只能服务两个人，所以使用static对于服务总人数和当前服务的号码进行共享是非常重要的。

那么我们在别写过程中，要提高代码的可维护性，如果我们的服务窗口不够了，现在需要添加窗口，只需要多生成一个窗口类对象，然后直接让3号窗口服务即可：

int main()
{
	Server s1('A'), s2('B'),s3("C");   //创建两个窗口
	do
	{
		int num;
		cout << "How many in your groups:";  //模拟提示
		cin >> num;                                 //输入排队人数
		cout << "your turns are" << endl;
		for (int i = 0; i < num; i++)
		{
			cout << Server::getTurn() << endl;  //排队人数递增
		}
		s1.serviceWindow();   //1号窗口服务
		s2.serviceWindow();   //2号窗口服务
		s3.serviceWindow();   //3号窗口服务
	} while (Server::stillOpen()); //如果窗口没有关闭就继续等待是否有人在排队或者是否有人继续抽取号码
	cout << "now closing server" << endl;
	return 0;
}

上面设计给代码带来了极大的可扩展性，也为分布式服务带来了便利。

单例模式引入

一个类仅有一个实例的现像，称为单例模式
实现一个实例的技术手段
单例模式主要实现共享;

#include <iostream>
using namespace std;

//单例模式主要实现共享;

//见new见delete


class Singleton
{
public:
    static Singleton* getInsertance()
    {
        if (_ins == nullptr)
            _ins = new Singleton;
        return _ins;
    }

    static void releaseInstance()
    {
        if (_ins != nullptr)
        {
            delete _ins;   //释放
            _ins = nullptr;
        }
    }
private:
    Singleton(){}    //构造器私有化，此时不能通过常规方法生成对象（实例）
    Singleton(const Singleton&) {}    //不允许拷贝构造
    ~Singleton() {}
    Singleton& operator = (const Singleton&) {}  //不能允许自己赋值给自己
    static Singleton * _ins;
};


Singleton* Singleton::_ins = nullptr;
int main()
{
    Singleton* ps = Singleton::getInsertance();
    Singleton* ps2 = Singleton::getInsertance();
    Singleton* ps3 = Singleton::getInsertance();
    cout << ps << endl;
    cout << ps2 << endl;
    cout << ps3 << endl;
    Singleton::releaseInstance();


    return 0;
}

运行结果：

上面的三个对象使用同一个地址。

static const 修饰

如果一个类的成员，既要实现共享，又要实现不可改变，那就用 static const 组合模式来修饰。

修饰成员函数，格式并无二异，修饰数据成员，必须要类内部初始化。

#include <iostream>
using namespace std;

class A
{
public:
    static const int a = 100;    //存储于data  段的ro段
private
    
};

int main()
{
    A a;
    cout << A::a << endl;
    return 0;
}