C++单例模式

关于c++单例模式，网上有很多说明，也很详细，多不赘述，最近有个工程，想到了单例模式，结果也没用上，这里记录一下代码，留作备用。

头文件：

#ifndef _CYCQUEUE_H_
#define _CYCQUEUE_H_
#include <string>
class CycQueue	//实现单例模式
{
public:
	static CycQueue* getInstance(int m_size = 0); //获取对象
	~CycQueue(void);
	void Add(char* data,int len);		//添加元素
	void Get(char* data,int len); 		//获取元素
	void JudSize();						//判断数据量大小
	void Print();
public:
	bool m_Iswrite;				   //判断是否在写
	bool m_Isread;				   //判断是否在读
private:
	//把复制构造函数和=操作符也设为私有,防止被复制	
	CycQueue(int m_size);   //队列大小
	CycQueue(const CycQueue&);
	CycQueue& operator=(const CycQueue&);
	static CycQueue* instance;

private:
			 
	int  m_readindex;		    //读指针
	int  m_writeindex;			//写指针
	int  m_totsize;				//指定队列大小
	int  m_cursize;             //当前大小
	char *m_Audio;				//队列
};

#endif

.cpp

#include "CycQueue.h"

#define M_SIZEBUFF 8192*4		//最少保留四次读取的数据量

CycQueue* CycQueue::instance(0);//这里必须要初始化
//在此处初始化
CycQueue* CycQueue::getInstance(int m_size)
{
	if(instance==NULL)
	{	
		instance = new CycQueue(m_size);
	}
	return instance;
}

CycQueue::CycQueue(int m_size)
{
	m_Audio = new char[m_size];//初始化队列大小
	memset(m_Audio,0,m_size);
	m_readindex = 0;
	m_writeindex =0;
	m_cursize = 0;
	m_totsize = m_size;
	m_Iswrite = false;
	m_Isread = false;
	return;
}
CycQueue::CycQueue(const CycQueue&)
{
}

CycQueue& CycQueue::operator=(const CycQueue&)
{
	return (*instance);
}

CycQueue::~CycQueue(void)
{
	delete[] m_Audio;
	return;
}

void CycQueue::Add(char* data,int len)
{
	 m_Iswrite = true;
	//长度超出循环覆盖
	if((m_writeindex+len)>m_totsize)//大于总长度
	{
	   int overlen = m_writeindex+len - m_totsize;  //超出长度部分
	   int curlen = len-overlen;						//可容纳长度
	   memcpy(m_Audio+m_writeindex,data,curlen);	//写入缓冲区	  
	   memcpy(m_Audio,data+curlen,overlen);			//写入缓冲区	 //覆盖原来
	   m_writeindex = (m_writeindex+len)%m_totsize;	//取余 写指针位置
	}else//长度不超出
	{
	   memcpy(m_Audio+m_writeindex,data,len);//写入缓冲区
	   m_writeindex+=len;
	}
	m_Iswrite = false;
	return;
}

void CycQueue::Get(char* data,int len) 	//获取元素
{
	m_Isread = true;
	if(m_readindex+len>m_totsize)//取数据大于长度
	{
	   int overlen =  m_readindex+len - m_totsize;	//超出部分长度
	   int curlen = len-overlen;			   //可用长度
	   memcpy(data,m_Audio+m_readindex,curlen);
	   memcpy(data+curlen,m_Audio,overlen);
	   m_readindex = (m_readindex+len)%m_totsize;	//取余 读指针位置
	}else
	{
		memcpy(data,m_Audio+m_readindex,len);
		m_readindex+=len;
	}
	m_Isread = false;
	return;
}

void CycQueue::JudSize()//判断数据量大小
{
  	int m_ressize = (m_writeindex+m_totsize-	m_readindex)%m_totsize;	//可读空间大小
	int m_freesize = m_totsize - m_ressize;		//可写空间大小 
	if(m_ressize < M_SIZEBUFF)	
		//仅可写

	if(m_freesize < M_SIZEBUFF)
		//仅可读

	return;

}

void CycQueue::Print() 	//获取元素
{
	printf("m_readindex:%d m_writeindex:%d \n",m_readindex,m_writeindex);//指针位置
	int m = 0;
	while(m<m_totsize)
	{
	  printf("%c \n",m_Audio[m]);
	  m++;
	}
	return;
}

测试：

#include "CycQueue.h"
#include "CycQueData.h"
#if 1
void PrintA(char data[],int size)
{  
	int m = 0;
	while(m<size)
	{
		printf("%c\n",data[m]);
		m++;
	}
	return;
}

int main ()
{
	CycQueue*m_que = CycQueue::getInstance(8);
	char buf[5] = {'A','B','C','D','E'};
	char data[3];
	m_que->Add(buf,5);
	m_que->Get(data,3);
	printf("========读取数据========\n");
	PrintA(data,3);
	printf("========写入数据========\n");
	m_que->Print();

	m_que->Add(buf,5);
	m_que->Get(data,3);
	printf("========读取数据========\n");
	PrintA(data,3);
	printf("========写入数据========\n");
	m_que->Print();
	getchar();
	delete m_que;
	return 0;
}
#endif

测试截图：

 

总结：

本来打算实现一个，可自行控制的读写操作的环状存储空间，后来发现了另一种更好的实现方式，这里就仅写了一半，留待以后有时间完善。