C++单例设计模式

ServerSocket.cpp

#include "pch.h"
#include "ServerSocket.h"
//类内的静态变量  指针在类外置空
CServerSocket* CServerSocket::m_instance = NULL;
CServerSocket* pserver = CServerSocket::getInstance();
//类内的静态变量   对象在类外在写一次  就会创立这个对象
CServerSocket::Chelper CServerSocket::m_chelper;

ServerSocket.h

#pragma once

#include "pch.h"
#include "framework.h"
class CServerSocket
{
public:
	static CServerSocket* getInstance()
	{
		if (m_instance==NULL)
		{
			m_instance = new CServerSocket;
		}
		return m_instance;
	}
	BOOL InitSocket()
	{
		
		//TODO:校验
		if (m_sock==-1)
		{
			return FALSE;
		}
		sockaddr_in serv_adr;
		memset(&serv_adr,0, sizeof(serv_adr));
		serv_adr.sin_family = AF_INET;
		serv_adr.sin_addr.s_addr = INADDR_ANY;
		serv_adr.sin_port = htons(9527);
		//绑定
		if (bind(m_sock, (sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
		{
			return FALSE;
		}
		if (listen(m_sock, 1)==-1)
		{
			return FALSE;
		}
		
		return TRUE;
	}
	BOOL AcceptClient()
	{
		sockaddr_in client_adr;
		int cli_sz = sizeof(client_adr);
		 m_client = accept(m_sock, (sockaddr*)&client_adr, &cli_sz);
		 if (m_client==-1)
		 {
			 return FALSE;
		 }
		 return TRUE;
	}
	int DealCommand()
	{
		if (m_client==-1)
		{
			return -1;
		}
		char buffer[1024];
		while (TRUE)
		{
			int len=recv(m_client, buffer, sizeof(buffer), 0);
			if (len<=0)
			{
				return -1;
			}
			//TODO 处理命令
		}
	}
	BOOL Send(const char* pData, int nSize)
	{
		return send(m_client, pData, nSize,0) > 0;
	}

private:
	SOCKET m_client;
	SOCKET m_sock;
	CServerSocket& operator=(const CServerSocket& ss) {};
	CServerSocket(const CServerSocket& ss) 
	{
		m_sock = ss.m_sock;
		m_client = ss.m_client;
	};
	CServerSocket()
	{
		m_client = INVALID_SOCKET;
		if (InitSockEnv()==FALSE)
		{
			MessageBox(NULL, _T("无法初始化套节字"), _T("初始化错误"), MB_OK | MB_ICONERROR);
			exit(0);
		}
		m_sock = socket(PF_INET, SOCK_STREAM, 0);
	}
	~CServerSocket() 
	{
		closesocket(m_sock);
		WSACleanup();
	}
	static void ReleaseeInstance()
	{
		if (m_instance!=NULL)
		{
			CServerSocket* tmp = m_instance;
			m_instance = NULL;
			delete tmp;
		}
	}
	BOOL InitSockEnv()
	{
		WSADATA data;
		if (WSAStartup(MAKEWORD(1, 1), &data)!=0)//TODO:返回值处理
		{
			return FALSE;
		}
		return TRUE;
	}
	static CServerSocket* m_instance;
	class Chelper 
	{
	public:
		Chelper()
		{
			CServerSocket::getInstance();
		}
		~Chelper()
		{
			CServerSocket::ReleaseeInstance();
		}
	};
	static Chelper m_chelper;
};

单例设计模式的总结：

1.类的构造函数与析构函数都要设置为private，因为不能让外部实例化
2.类里面还有一个类的原因是，如果没有类内类的化，CServerSocket 不会自己析构
3.类内的静态变量 指针在类外置空
4.类内的静态变量 对象在类外在写一次 就会创立这个对象
5.Chelper是不会被外部创立的，因为他是私有类
6.CServerSocket::Chelper CServerSocket::m_chelper;意思是定义的那个静态，不是用Chelper 创立了一个对象。