c/c++开发，无可避免的模板编程实践（篇一）

news2025/1/7 17:16:47

一、c++模板

        c++开发中，在声明变量、函数、类时，c++都会要求使用指定的类型。在实际项目过程中，会发现很多代码除了类型不同之外，其他代码看起来都是相同的，为了实现这些相同功能，我们可能会进行如下设计：

int max(const int &v1, const int &v2){
    return (v1>v2)?v1:v2;
};
double max(const double &v1, const double &v2){
    return (v1>v2)?v1:v2;
};
string max(const string &v1, const string &v2){
    return (v1>v2)?v1:v2;
};
...

        这明明针对相同行为的不同类型比较而已，却一次又一次去重复实现它，做了如此多重复的工作，甚至还可能一不留神就引入更多错误，开始一轮痛苦的调整之旅。而借助C++的模板方法，就可以更好地优化此类代码，更好地利用c++类型检查的特点，更好格式的源代码。

        目前模板的应用在c++中非常广泛，如，在c++标准库中，几乎所有代码都是模板代码，很多第三方c++库也或多或少都会使用模板。模板编程是c++开发中无可避免的一道坎。

        模板是为多种类型而编写的函数和类，这些类型都没有指定，等在使用模板时，再把类型作为一个（显式或隐式的）实参传递给模板，完成具体场景化的应用。

二、函数模板

       2.1 函数模板定义

         函数模板提供类一种函数行为，其可以用多种不同的类型进行调用，一个函数模板就代表一个函数家族。前面提到比较两个数据的大小并返回较大值，通过模板可以简化：

//template <class T>	//class 和 typename 没有区别
template <typename T>
T max(const T &v1, const T &v2)
{
	return (v1>v2)?v1:v2;
};

        模板定义以关键字 template 开始，后接模板形参表，模板形参表是用尖括号括住的一个或多个模板形参的列表，形参之间以逗号分隔，模板形参表不能为空。这个模板定义指定一个“返回两个值中最大值”的家族函数，参数类型还没确定，采用模板参数T来替代，参数列表是typename T。注意，模板形参作用域和非模板形参的作用域是类似的，这里就不展开阐述了。

        在这里class T和 typename T是等价的，鉴于历史原因，可能会使用class取代typename，来定义类型参数。在c++语言发展演化过程中，关键字typename 的出现相对较晚一些，在它之前都是关键字class作为模板的类型参数引入的，c++也保留了下来。若要支持一些旧版本编译工具、库等就采用class，否则建议使用关键字typename。但需要注意struct关键字是不行的，不要因为class可行就产生误导了。

        像函数形参一样，程序员为模板形参选择的名字没有本质含义。将 max的模板类型形参命名为 T，但也可以将它命名为任意名字:

template <typename this_is_long_name>
this_is_long_name max(const this_is_long_name &v1, const this_is_long_name &v2)
{
	return (v1>v2)?v1:v2;
};

        2.2 模板调用

        在使用模板时，编译器会根据传入实参进行检测，编译器会推断哪个（或哪些）模板实参绑定到模板形参。一旦编译器确定了实际的模板实参，就称它实例化了函数模板的一个实例。实质上，编译器将确定用什么类型代替每个类型形参，以及用什么值代替每个非类型形参。推导出实际模板实参后，编译器使用实参代替相应的模板形参产生编译该版本的函数。

max<int>(14,16);	
//编译器实质类似于
int max_int(const int &v1, const int &v2)
{
	return (v1>v2)?v1:v2;
};
 
max_int(14,16);

        上述代码展示，使用了int作为模板参数T的函数模板，就会用具体类型替代模板参数，这个过程就叫实例化，它会产生一个模板实例。只要使用了函数模板，编译器就会自动触发这样的一个实例化过程，因此开发者并不需要额外地请求模板的实例化。

        在使用函数模板时，通过具体参数类型传递实参，编译器就会明确参数类型，其不允许自动类型转换，每个模板参数都必须正确地匹配。

    std::cout << max(14,16) << std::endl;		//OK
	std::cout << max<int>(14,16) << std::endl;	//OK,建议
	std::cout << max<std::string>(("nihao"),("hi")) << std::endl;	//显式指定
	//std::cout << max("nihao","hi") << std::endl;					//error,编译器无法明确
	//std::cout << max(14,16.5) << std::endl;					    //error,类型不匹配
	std::cout << max<float>(14,16.5) << std::endl;                  //OK,显式指定
    std::cout << max(static_cast<double>(14),16.5) << std::endl;     //OK,强制类型转换

        2.3 非类型模板形参

        模板形参不必都是类型，函数模板也可以使用的非类型形参。

template <typename T, int LEN>
void print(const T (&val)[LEN])
{
	for(int i=0; i<LEN; i++)
    {
		std::cout << val[i] << std::endl;
    }
};

//
std::string str[2] = {"hello","world"};
print(str);				//OK 
print<std::string>(str);//OK

        2.4 模板声明和定义源码分离

        模板的声明和定义一般都建议放置同一头文件内，将声明和定义分离到头文件及源文件内，c++编译器会接受，但连接器会出错。

/*test_template.h*/
#ifndef _TEST_TEMPLATE_H_
#define _TEST_TEMPLATE_H_

//
template <typename T> 
T min(const T &v1, const T &v2);

#endif //_TEST_TEMPLATE_H_


/*test_template.cpp*/
#include "test_template.h"

template <typename T>
T min(const T &v1, const T &v2)
{
	return (v1<v2)?v1:v2;
};

/*test.cpp*/
#include "test_template.h"
int main(int argc, char* argv[])
{
	std::cout << min(14,16) << std::endl;		
	return 0;
};

        编译时，连接器会出错，

ccZMcsD7.o:test.cpp:(.text+0x207): undefined reference to `int min<int>(int const&, int const&)'
collect2.exe: error: ld returned 1 exit status

       当然您也可以在头文件里包含源文件，等同于模板的声明和定义一般都建议放置同一头文件内。

/*test_template.h*/
#ifndef _TEST_TEMPLATE_H_
#define _TEST_TEMPLATE_H_

//
template <typename T> 
T min(const T &v1, const T &v2);

#include "test_template.cpp"    //仅这里不同了哦-------------------
#endif //_TEST_TEMPLATE_H_
/*---------------------------------------------------*
/*test_template.cpp*/
#include "test_template.h"

template <typename T>
T min(const T &v1, const T &v2)
{
	return (v1<v2)?v1:v2;
};
/*---------------------------------------------------*
/*test.cpp*/
#include "test_template.h"
int main(int argc, char* argv[])
{
	std::cout << min(14,16) << std::endl;		
	return 0;
};

         因此建议是模板的声明和定义都放置同一头文件内。

#ifndef _TEST_TEMPLATE_H_
#define _TEST_TEMPLATE_H_

//
template <typename T> 
T min(const T &v1, const T &v2);
{
	return (v1<v2)?v1:v2;
};
#endif //_TEST_TEMPLATE_H_

        如果非要进行分离，也是有办法就是较麻烦。另创建一个头文件放置模板函数的定义，为了区别，起名.hpp，然后再创建一个头文件，对模板函数进行显式实例化，就可以避免链接期报错。

/*test_template.h*/
#ifndef _TEST_TEMPLATE_H_
#define _TEST_TEMPLATE_H_
//
template <typename T> 
T min(const T &v1, const T &v2);

#endif //_TEST_TEMPLATE_H_

/*test_template.hpp*/
#ifndef _TEST_TEMPLATE_HPP_
#define _TEST_TEMPLATE_HPP_

#include "test_template.h"

template <typename T>
T min(const T &v1, const T &v2)
{
	return (v1<v2)?v1:v2;
};

#endif //_TEST_TEMPLATE_HPP_

/*test_template.cpp*/
#include "test_template.hpp"
template int min<int>(const int &v1, const int &v2);
template double min<double >(const double &v1, const double &v2);

/*test.cpp*/
#include "test_template.h"
int main(int argc, char* argv[])
{
	std::cout << min(14,16) << std::endl;	//OK	
	return 0;
};

        再编译时就可以通过。

         另外如果您手头上的c++编译器是支持export这个关键字特性的话，做模板声明和定义分离编写会更容易。

/*test_template.h*/
#ifndef _TEST_TEMPLATE_H_
#define _TEST_TEMPLATE_H_
//
export template <typename T> 
T min(const T &v1, const T &v2);

#endif //_TEST_TEMPLATE_H_

/*test_template.cpp*/
#include "test_template.h"

export template <typename T>
T min(const T &v1, const T &v2)
{
	return (v1<v2)?v1:v2;
};


/*test.cpp*/
#include "test_template.h"
int main(int argc, char* argv[])
{
	std::cout << min(14,16) << std::endl;	//OK	
	return 0;
};

        但是，关于export这个关键字特性，目前市面上支持的C++编译器是较少的，因此采用export时，可能就通过宏定义编译条件了集合上述两种方法才能做到代码在各个编译器平滑支持了。

        2.5 函数模板支持inline

        另外函数模板可以用与非模板函数一样的方式声明为 inline。inline说明符放在模板形参表之后、返回类型之前，不能放在关键字 template 之前。

template <typename T> inline T test(const T &v1){return v1;}; //OK
inline template <typename T> T test(const T &v1){return v1;}; //error

        2.6 函数模板重载

        和普通函数一样，函数模板也可以被重载，相同模板函数名称可具有不同函数定义，当使用函数名称进行模板函数调用时，编译器会根据调用语句进行检查推断调用匹配度更高的哪个候选模板函数。

template <typename T>
inline T max(const T &v1, const T &v2)
{
	return (v1>v2)?v1:v2;
};

template <typename T>
T max(const T &v1, const T &v2, const T &v3)
{
	return max(max(v1,v2),v3);
};

//
std::cout << max(14,16,15) << std::endl;		//OK

        但需要注意的是，模板函数和普通函数重载时，参数个数不一致是不行的

template <typename T>
inline T max(const T &v1, const T &v2)
{
	return (v1>v2)?v1:v2;
};

int max(const int &v1){	return 0;}    //编译错误，multiple definition of `max'

        但如果普通函数看着和模板函数函数名相同，参数格式一致，那就是模板函数的特例化实现。

template <typename T>
inline T max(const T &v1, const T &v2)
{
	return (v1>v2)?v1:v2;
};

inline char max(const char &v1, const char &v2)
{
	return (v1>v2)?v1:v2;
};

std::cout << max('a','c') << std::endl;	//OK,大家认为会调用哪个函数呢，如果第二个函数在前呢
std::cout << max<char>('a','b') << std::endl;

        普通函数（非模板函数）和模板函数同名及参数格式一致时，该模板函数可以被实例化为这个非模板函数，在调用时，编译器会根据重载解析过程调用匹配度更高的函数。在看看下面案例：

template <typename T>
inline T max(const T &v1, const T &v2)
{
	return (v1>v2)?v1:v2;
};

template <typename T>
T max(const T &v1, const T &v2, const T &v3)
{
	return max(max(v1,v2),v3);    //使用模板函数,int的函数声明太迟了
};

inline char max(const char &v1, const char &v2)
{
	return (v1>v2)?v1:v2;
};

std::cout << max('a','b','c') << std::endl;		//OK,这个呢，会调用那个函数（两个参数的max）

三、类模板

        3.1 类模板定义

        和函数一样，类也可以被定义为模板，像标准库中的容器就类模板，它被用于管理某种特定类型的元素，在使用它们时，不需要确定容器中元素的类型。下面以本人曾定义过的一个类模板为例来唠叨一下类模板：

/*queuedata.h*/
template <class T>
class QueueData
{
public:
	QueueData(std::string desc = "thread_queue");
	~QueueData();
	//
	/**
	 * 获取队列大小
	 * @return {int } 队列大小
	 */
	int size();
	/**
	 * 判定队列是否为空
	 * @return {bool } 是否为空队列
	 */
	bool isEmpty();
	/**
	 * 获取队列头元素
	 * @param it {T&} 头元素
	 * @return {bool } 是否成功
	 */
	bool getFirst(T &it);
	/**
	 * 删除元素
	 * @return {bool } 是否成功
	 */
	bool removeFirst();
	/**
	 * 获取队列头元素，并从队列终删除
	 * @param it {T&} 头元素
	 * @return {bool } 是否成功
	 */
	bool pop(T &it);
	/**
	 * 从队列头开始逐步获取多个元素，并剔除
	 * @param its {queue<T>&} 获取到的元素集
	 * @param sizel {int} 一次获取多少个
	 * @return {bool } 至少获取一个元素以上则成功
	 */
	bool getList(std::queue<T> &its,unsigned int sizel=5);
	/**
	 * 从队列尾部添加元素
	 * @param it {T} 被添加元素
	 * @return {void } 无返回
	 */
	void add(T it);
	/**
	 * 从队列头部添加元素
	 * @param it {T} 被添加元素
	 * @return {void } 无返回
	 */
	void add_front(T it);
	/**
	 * 清空元素
	 * @return {void }
	 */
	void clear();
private:
	void init();
	QueueData& operator=(const QueueData&) {return this;};
protected:
	std::string queue_desc;
private:
	/点集转发
	
	//协议解析结果缓存
	std::deque<T> datacache_queue;	//队列容器
	PYMutex m_Mutex;				//线程锁,或者如果更彻底采用acl库,采用acl::thread_mutex替代
	//
	static unsigned int QSize;		//队列大小约束,超出是会从队列头剔除旧数据腾出空位在对末添加数据
	//
	int queue_overS;				//队列溢出次数计数
};

        类模板也是模板，因此必须以关键字 template 开头，后接模板形参表。QueueData模板接受一个名为 T 的模板类型形参。

        除了模板形参表外，类模板的定义看起来与任意其他类问相似。 类模板可以定义数据成员、函数成员和类型成员，也可以使用访问标号控制对成员的访问，还可以定义构造函数和析构函数等等。在类和类成员的定义中，可以使用模板形参作为类型或值的占位符，在使用类时再提供那些类型或值。

        例如，上述QueueData模板有一个模板类型形参，可以在任何可以使用类型名字的地方使用该形参。在这个模板定义中，用 T作为 add操作的形参类型。QueueData模板是基于标准库中的std::deque<>来实现的，就不需要亲自实现内存管理、拷贝构造、赋值及算法等，把精力聚焦在业务逻辑开发上。

        和函数模板调用对比，使用类模板时，必须为模板形参显式指定实参。编译器使用实参来实例化这个类的特定类型版本,QueueData 不是类型，而 QueueData <int>或 QueueData <string> 是类型。实质上，编译器用用户提供的实际特定类型代替 T，重新编写 QueueData类。

#include "queuedata.h"

QueueData<int> data1;	//OK
//QueueData data2;		//error
QueueData<std::string> data3;	//OK

        3.2 类模板的成员变量及成员函数

        类模板的成员函数定义和函数模板分离时定义类似

//queuedata.h
template <class T>
void QueueData<T>::init() 
{
	queue_overS = 0;
};

        采用模板参数T定义的成员变量也和普通类成员变量用法一致

template <class T>
class QueueData{
// 省略其他
private:
    std::deque<T> datacache_queue;	//队列容器
};

template <class T>
void QueueData<T>::add(T it) 
{
	m_Mutex.Lock();
	if (datacache_queue.size() > QSize) 
	{
		queue_overS++;
		datacache_queue.pop_front();
	}
	datacache_queue.push_back(it);
	m_Mutex.Unlock();
	if (queue_overS >= 10) 
	{
		//每溢出10次，报告一次
		printf("add item to queue %s at end,but the size of QueueData is up to limmit size: %d.\n"
			, queue_desc.c_str(), QSize);
		queue_overS = 0;
	}
}

        对于static静态成员，用法也一致,无非就是带上模板定义而已：

template <class T>
class QueueData{
// 省略其他
private:
    static unsigned int QSize;//队列大小约束,超出是会从队列头剔除旧数据腾出空位在对末添加数据
};

//
template <class T>
unsigned int  QueueData<T>::QSize = 100;

        3.3 类模板的特例化

        类模板可以通过指定实参来特例化，和函数模板的重载类似，通过特化类模板，通常是用来可以克服某种特定类型在实例化类模板时所出现的不足。

template <>
class QueueData<std::string>
{
    ...
};
//相应地，类模板特例化时，每个成员函数必须都重新定义为普通函数，模板参数T也被特例化类型取代。
int QueueData<std::string>::size()
{
	int ret = 0;
	m_Mutex.Lock();
	ret = static_cast<int>(datacache_queue.size());
	m_Mutex.Unlock();
	return ret;
}

        当类模板有多个模板参数时，也可以进行局部特例化

template <typename T1, typename T2>
class TestData
{
    ...
};
//局部特例化,两个模板参数相同
template <typename T>
class TestData<T,T>
{
    ...
};

//局部特例化,第2模板参数int
template <typename T>
class TestData<T,int>
{
    ...
};
//局部特例化,两个模板参数改为指针
template <typename T1, typename T2>
class TestData<*T1,*T2>
{
    ...
};

       3.4 非类型模板参数及缺省值

         对于类模板，还可以为模板参数定义缺省值。

template<typename T, typename VALS= std::vector<T> >
class TestData{
    private:
    VALS els;
};

        此外，对于模板，模板参数并不局限于类型，普通值也可以作为模板参数，可以给类模板指定类型及指定缺省值，本专栏在讲述TCP/Socket通信代码优化时就用到过：

#define RDC_SIZE 1024	//服务端从socket读取数据时的缓存大小
#define DATA_SIZE 512	//服务及客户端的数据传输(读取及写入)的缓存大小

template<int SIZE = DATA_SIZE>
struct TCP_Data
{
	TCP_Data() 
		: len(0)
	{
		memset(Buf,0,SIZE);
	};
    ...省略其他...
	unsigned char Buf[SIZE];
	int len;
};

//调用
TCP_Data<> a;          //大小512
TCP_Data<DATA_SIZE> a; //大小512

        在这个例子里，我们使用元素数目固定的数组来实现，其优点就是避免内存开销，让用户亲自制定数组的大小。当然这个例子极端了些，再看看下面这个：

template<typename T, int MAXSIZE>
class TCP_Data
{
public:
    TCP_Data();
    void doit();
private:
    int len;
    T els[MAXSIZE];
};
//定义成员函数
template<typename T, int MAXSIZE>
TCP_Data<T,MAXSIZE>::TCP_Data() 
	: len(0)
{
};
//
template<typename T, int MAXSIZE>
void TCP_Data<T,MAXSIZE>::doit()
{
};

//使用时，同时制定模板参数类型和最大容量
TCP_Data<int,10> a;

        特别注意的是，非类型模板参数是有限制的，它们常整数（包括枚举值）或者指向外部链接对象的指针。

template<double VAT> double doit(double val){};    //error
template<std::string name> class MyClass{};        //error

template<char const * name> class MyClass{};        //error
char const* s = "hi";
MyClass<s> a;    //error,指向内部链接对象

extern char const s[] = "hi";
MyClass<s> a;    //OK,指向外部链接对象

四、编译及附录代码

         编译及运行输出

        Makefile:

CX	=	g++

GCC_CMD_DEF := 1
BIN 		:= .
TARGET      := test.exe
#FLAGS		:= -static

Include		:= .
source		:= test.cpp Mutex.cpp test_template.cpp 
#可以注释掉test_template.cpp 并在test_template.h的26行开启测试另一种伪分离的效果
$(TARGET) :
	$(CX) $(FLAGS) $(source) -I$(Include) -o $(BIN)/$(TARGET)

clean:
	rm  $(BIN)/$(TARGET)

        test_template.h

#ifndef _TEST_TEMPLATE_H_
#define _TEST_TEMPLATE_H_

#include <iostream>
//template <class T>	//class 和 typename 没有区别
template <typename T>
inline T max(const T &v1, const T &v2)
{
	return (v1>v2)?v1:v2;
};

template <typename T>
T max(const T &v1, const T &v2, const T &v3)
{
	return max(max(v1,v2),v3);
};

inline char max(const char &v1, const char &v2)
{
	return (v1>v2)?v1:v2;
};

//
template <typename T> 
T min(const T &v1, const T &v2);
//#include "test_template.hpp"	开该项,就不需要test_template.cpp咯

template <typename T, int LEN>
void print(const T (&val)[LEN])
{
	for(int i=0; i<LEN; i++)
	{
		std::cout << val[i] << std::endl;
	}
};

template<typename T, int MAXSIZE>
class TCP_Data
{
public:
	TCP_Data();
	~TCP_Data();
	void add(T const & elem);
    void doit();
private:
	int len;
    T els[MAXSIZE];
	
};
//定义成员函数
template<typename T, int MAXSIZE>
TCP_Data<T,MAXSIZE>::TCP_Data() 
	: len(0)
{
	
};

template<typename T, int MAXSIZE>
TCP_Data<T,MAXSIZE>::~TCP_Data()
{
};

template<typename T, int MAXSIZE>
void TCP_Data<T,MAXSIZE>::add(T const & elem)
{
	if(len>=MAXSIZE)
	{
		//
		return;
	}
	els[len] = elem;
	++len;
};
	
template<typename T, int MAXSIZE>
void TCP_Data<T,MAXSIZE>::doit()
{
	for(int i=0; i<len; i++)
	{
		std::cout << els[i] << std::endl;	//若T是自定义类型呢
	}
};

#endif //_TEST_TEMPLATE_H_

        test_template.hpp

#ifndef _TEST_TEMPLATE_HPP_
#define _TEST_TEMPLATE_HPP_

#include "test_template.h"

template <typename T>
T min(const T &v1, const T &v2)
{
	return (v1<v2)?v1:v2;
};

#endif //_TEST_TEMPLATE_HPP_

        test_template.cpp

#include "test_template.hpp"

template int min<int>(const int &v1, const int &v2);
template double min<double>(const double &v1, const double &v2);

        test.cpp

#include <iostream>
#include "test_template.h"
#include "queuedata.h"

int main(int argc, char* argv[])
{
	//模板调用
	std::cout << max(14,16) << std::endl;		//OK
	std::cout << max<int>(14,16) << std::endl;	//OK,建议
	std::cout << max<std::string>(("nihao"),("hi")) << std::endl;	//显式指定
	//std::cout << max("nihao","hi") << std::endl;					//error,编译器无法明确
	//std::cout << max(14,16.5) << std::endl;					    //error,类型不匹配
	std::cout << max<float>(14,16.5) << std::endl;                  //OK,显式指定
    std::cout << max(static_cast<double>(14),16.5) << std::endl;     //OK,强制类型转换
	//
	std::string str[2] = {"hello","world"};
	print(str);				//OK 
	print<std::string>(str);//OK
	//分离声明及定义
	std::cout << min(14,16) << std::endl;		//OK
	//重载
	std::cout << max(14,16,15) << std::endl;		//OK
	//重载
	std::cout << max('a','c') << std::endl;			//OK
	std::cout << max<char>('a','b') << std::endl;	//OK
	std::cout << max('a','b','c') << std::endl;		//OK
	//
	QueueData<int> data1;	//OK
	//QueueData data2;		//error
	QueueData<std::string> data3;	//OK
	data3.add("hi");
	data3.add_front("hello");
	std::string s_="0";
	data3.getFirst(s_);
	std::cout <<"first: " << s_ << std::endl;			//OK
	//
	TCP_Data<int,2> vals;
	vals.add(7);
	vals.add(17);
	vals.doit();
	return 0;
};

        queuedata.h

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#ifndef _QUEUE_DATA_H_
#define _QUEUE_DATA_H_

/***********************************************************************
  *Copyright 2020-03-06, pyfree
  *
  *File Name       : queuedata.h
  *File Mark       : 
  *Summary         : 
  *数据队列类,线程安全
  *
  *Current Version : 1.00
  *Author          : pyfree
  *FinishDate      :
  *
  *Replace Version :
  *Author          :
  *FinishDate      :

 ************************************************************************/
#include <queue>
#include <deque>
#include <stdio.h>
#include <string.h>

#include "Mutex.h"

template <class T>
class QueueData
{
public:
	QueueData(std::string desc = "thread_queue");
	~QueueData();
	//
	/**
	 * 获取队列大小
	 * @return {int } 队列大小
	 */
	int size();
	/**
	 * 判定队列是否为空
	 * @return {bool } 是否为空队列
	 */
	bool isEmpty();
	/**
	 * 获取队列头元素
	 * @param it {T&} 头元素
	 * @return {bool } 是否成功
	 */
	bool getFirst(T &it);
	/**
	 * 删除元素
	 * @return {bool } 是否成功
	 */
	bool removeFirst();
	/**
	 * 获取队列头元素，并从队列终删除
	 * @param it {T&} 头元素
	 * @return {bool } 是否成功
	 */
	bool pop(T &it);
	/**
	 * 从队列头开始逐步获取多个元素，并剔除
	 * @param its {queue<T>&} 获取到的元素集
	 * @param sizel {int} 一次获取多少个
	 * @return {bool } 至少获取一个元素以上则成功
	 */
	bool getList(std::queue<T> &its,unsigned int sizel=5);
	/**
	 * 从队列尾部添加元素
	 * @param it {T} 被添加元素
	 * @return {void } 无返回
	 */
	void add(T it);
	/**
	 * 从队列头部添加元素
	 * @param it {T} 被添加元素
	 * @return {void } 无返回
	 */
	void add_front(T it);
	/**
	 * 清空元素
	 * @return {void }
	 */
	void clear();
private:
	void init();
	QueueData& operator=(const QueueData&) {return this;};
protected:
	std::string queue_desc;
private:
	/点集转发
	
	//协议解析结果缓存
	std::deque<T> datacache_queue;	//队列容器
	PYMutex m_Mutex;				//线程锁,或者如果更彻底采用acl库,采用acl::thread_mutex替代
	//
	static unsigned int QSize;		//队列大小约束,超出是会从队列头剔除旧数据腾出空位在对末添加数据
	//
	int queue_overS;				//队列溢出次数计数
};
template <class T>
unsigned int  QueueData<T>::QSize = 100;

template <class T>
QueueData<T>::QueueData(std::string desc)
	: queue_desc(desc)
{
	init();
};

template <class T>
void QueueData<T>::init() 
{
	queue_overS = 0;
};

template <class T>
QueueData<T>::~QueueData()
{

}

//
template <class T>
int QueueData<T>::size()
{
	int ret = 0;
	m_Mutex.Lock();
	ret = static_cast<int>(datacache_queue.size());
	m_Mutex.Unlock();
	return ret;
}

template <class T>
bool QueueData<T>::isEmpty()
{
	bool ret = false;
	m_Mutex.Lock();
	ret = datacache_queue.empty();
	m_Mutex.Unlock();
	return ret;
}

template <class T>
bool QueueData<T>::getFirst(T &it) 
{
	bool ret = false;
	m_Mutex.Lock();
	if (!datacache_queue.empty()) 
	{
		it = datacache_queue.front();
		ret = true;
	}
	m_Mutex.Unlock();
	return ret;
}

template <class T>
bool QueueData<T>::removeFirst() 
{
	bool ret = false;
	m_Mutex.Lock();
	if (!datacache_queue.empty()) 
	{
		datacache_queue.pop_front();
		ret = true;
	}
	m_Mutex.Unlock();
	return ret;
}

template <class T>
bool QueueData<T>::pop(T &it)
{
	bool ret = false;
	m_Mutex.Lock();
	if (!datacache_queue.empty()) 
	{
		it = datacache_queue.front();
		datacache_queue.pop_front();
		ret = true;
	}
	m_Mutex.Unlock();
	return ret;
};

template <class T>
bool QueueData<T>::getList(std::queue<T> &its,unsigned int sizel)
{
	m_Mutex.Lock();
	while (!datacache_queue.empty())
	{
		its.push(datacache_queue.front());
		datacache_queue.pop_front();
		if (its.size() >= sizel)
		{
			break;
		}
	}
	m_Mutex.Unlock();
	return !its.empty();
};

template <class T>
void QueueData<T>::add(T it) 
{
	m_Mutex.Lock();
	if (datacache_queue.size() > QSize) 
	{
		queue_overS++;
		datacache_queue.pop_front();
	}
	datacache_queue.push_back(it);
	m_Mutex.Unlock();
	if (queue_overS >= 10) 
	{
		//每溢出10次，报告一次
		printf("add item to queue %s at end,but the size of QueueData is up to limmit size: %d.\n"
			, queue_desc.c_str(), QSize);
		queue_overS = 0;
	}
}

template <class T>
void QueueData<T>::add_front(T it)
{
	m_Mutex.Lock();
	if (datacache_queue.size() > QSize) 
	{
		queue_overS++;
		datacache_queue.pop_front();
	}
	datacache_queue.push_front(it);
	m_Mutex.Unlock();
	if (queue_overS >= 10) 
	{
		//每溢出10次，报告一次
		printf("add item to queue %s at first,but the size of QueueData is up to limmit size: %d.\n"
			, queue_desc.c_str(), QSize);
		queue_overS = 0;
	}
}

template <class T>
void QueueData<T>::clear()
{
	m_Mutex.Lock();
	datacache_queue.clear();
	m_Mutex.Unlock();
	queue_overS = 0;
}

#endif //_QUEUE_DATA_H_

        Mutex.h

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#ifndef _PYMUTEX_H_
#define _PYMUTEX_H_

/***********************************************************************
  *Copyright 2020-03-06, pyfree
  *
  *File Name       : Mutex.h
  *File Mark       : 
  *Summary         : 线程锁
  *
  *Current Version : 1.00
  *Author          : pyfree
  *FinishDate      :
  *
  *Replace Version :
  *Author          :
  *FinishDate      :

 ************************************************************************/

#ifdef WIN32
//#include <windows.h>
#else
#include <pthread.h>
#endif

typedef void *HANDLE;

class IMutex
{
public:
	virtual ~IMutex() {}

  /**
	 * 上锁
	 * @return {void} 
	 */
	virtual void Lock() const = 0;
  /**
	 * 尝试上锁
	 * @return {void} 
	 */
	virtual bool TryLock() const = 0;
  /**
	 * 解锁
	 * @return {void} 
	 */
	virtual void Unlock() const = 0;
};

class PYMutex : public IMutex
{
public:
	PYMutex();
	~PYMutex();

	virtual void Lock() const;
	virtual bool TryLock() const;
	virtual void Unlock() const;
private:
#ifdef _WIN32
	HANDLE m_mutex;
#else
	mutable pthread_mutex_t m_mutex;
#endif
};

#endif //_PYMUTEX_H_

        Mutex.cpp

#include "Mutex.h"

#ifdef WIN32
#include <windows.h>
#endif
//#include <iostream>
#include <stdio.h>

PYMutex::PYMutex()
{
#ifdef _WIN32
	m_mutex = ::CreateMutex(NULL, FALSE, NULL);
#else
	pthread_mutex_init(&m_mutex, NULL);
#endif
}


PYMutex::~PYMutex()
{
#ifdef _WIN32
	::CloseHandle(m_mutex);
#else
	pthread_mutex_destroy(&m_mutex);
#endif
}


void PYMutex::Lock() const
{
#ifdef _WIN32
	//DWORD d = WaitForSingleObject(m_mutex, INFINITE);
	WaitForSingleObject(m_mutex, INFINITE);
	/// \todo check 'd' for result
#else
	pthread_mutex_lock(&m_mutex);
#endif
}

bool PYMutex::TryLock() const
{
#ifdef _WIN32
    DWORD dwWaitResult = WaitForSingleObject(m_mutex, 0);  
	if (dwWaitResult != WAIT_OBJECT_0 && dwWaitResult != WAIT_TIMEOUT) {
		printf("thread WARNING: bad result from try-locking mutex\n");
	}
    return (dwWaitResult == WAIT_OBJECT_0) ? true : false; 
#else
	return (0==pthread_mutex_trylock(&m_mutex))?true:false;
#endif	
};

void PYMutex::Unlock() const
{
#ifdef _WIN32
	::ReleaseMutex(m_mutex);
#else
	pthread_mutex_unlock(&m_mutex);
#endif
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/343714.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

SpringBoot自定义JsonSerializer和JsonDeserializer，兼容LocalDateTime和LocalDate

SpringBoot自定义JsonSerializer和JsonDeserializer，兼容LocalDateTime和LocalDate

1.前言 JDK1.8中添加新的时间日期API&#xff0c;LocalDate、LocalDateTime、LocalTime&#xff0c;但是我们在开发中使用时间戳作为参数值来传递是比较常用的&#xff0c;然而在SpringBoot中并没有为我们提供合适的JsonSerializer和JsonDeserializer。 我们先看看使用默认的Js…
阅读更多...
Linux根文件系统移植

Linux根文件系统移植

目录 一、根文件系统 1.1根文件系统 1.2根文件系统内容 二、根文件系统移植 2.1BusyBox 2.2BusyBox的获取 2.3BusyBox的使用 2.4make menuconfig 2.5编译和安装 2.6修改根文件系统 一、根文件系统 1.1根文件系统 根文件系统是内核启动后挂载的第一个文件系统系统引…
阅读更多...
Homekit智能家居创意DIY一智能灯

Homekit智能家居创意DIY一智能灯

一、什么是智能灯 传统的灯泡是通过手动打开和关闭开关来工作。有时&#xff0c;它们可以通过声控、触控、红外等方式进行控制&#xff0c;或者带有调光开关&#xff0c;让用户调暗或调亮灯光。 智能灯泡内置有芯片和通信模块&#xff0c;可与手机、家庭智能助手、或其他智能…
阅读更多...
链表题目总结 -- 递归

链表题目总结 -- 递归

目录一. 递归反转整个链表1. 思路简述2. 代码3. 总结二. 反转链表前 N 个节点1. 思路简述2. 代码3. 总结三、反转链表的一部分1. 思路简述2. 代码3.总结四、反转链表后N个节点1. 思路简述2. 代码3.总结一. 递归反转整个链表 题目链接&#xff1a;https://leetcode.cn/problems…
阅读更多...
部署智能合约到公链

部署智能合约到公链

&#x1f341;博主简介&#xff1a; &#x1f3c5;云计算领域优质创作者 &#x1f3c5;2022年CSDN新星计划python赛道第一名 &#x1f3c5;2022年CSDN原力计划优质作者 &#x1f3c5;阿里云ACE认证高级工程师 &#x1f3c5;阿里云开发者社区专…
阅读更多...
【面试】生命周期详情解释及案例

【面试】生命周期详情解释及案例

目录 1.什么是生命周期 2.生命周期函数 3.vue2中生命周期的函数 4.生命周期的阶段 5.生命周期图示 第一个阶段&#xff1a;组件创建阶段 第二个阶段&#xff1a;编译HTML模板并渲染到浏览器中 第三阶段&#xff1a;组件更新阶段 第四阶段&#xff1a;组件销毁阶段 1.什…
阅读更多...
【数据结构】基础：图的基本概念与实现（附C++源代码）

【数据结构】基础：图的基本概念与实现（附C++源代码）

【数据结构】基础&#xff1a;图的基本概念与实现&#xff08;附C源代码&#xff09; 摘要&#xff1a;将会在数据结构专题中开展关于图论的内容介绍&#xff0c;其中包括四部分&#xff0c;分别为图的概念与实现、图的遍历、图的最小生成树以及图的最短路径问题。本文将介绍图…
阅读更多...
遗传算法(Genetic Algorithm,GA)实现数据排序，python

遗传算法(Genetic Algorithm,GA)实现数据排序，python

遗传算法(Genetic Algorithm,GA)实现数据排序&#xff0c;python 遗传算法是一种比较广泛、通用的算法体系&#xff0c;为了说明遗传算法的原理和实现&#xff0c;现在用GA解决一个计算机科学最基本、最古老的问题&#xff1a;排序问题。 需要特别说明的是&#xff0c;遗传算…
阅读更多...
【GPLT 三阶题目集】L3-016 二叉搜索树的结构

【GPLT 三阶题目集】L3-016 二叉搜索树的结构

二叉搜索树或者是一棵空树&#xff0c;或者是具有下列性质的二叉树&#xff1a; 若它的左子树不空&#xff0c;则左子树上所有结点的值均小于它的根结点的值&#xff1b;若它的右子树不空&#xff0c;则右子树上所有结点的值均大于它的根结点的值&#xff1b;它的左、右子树也分…
阅读更多...
代码随想录LeetCode | 单调栈问题

代码随想录LeetCode | 单调栈问题

前沿&#xff1a;撰写博客的目的是为了再刷时回顾和进一步完善&#xff0c;其次才是以教为学&#xff0c;所以如果有些博客写的较简陋&#xff0c;是为了保持进度不得已而为之&#xff0c;还请大家多多见谅。 预&#xff1a;看到题目后的思路和实现的代码。 见&#xff1a;参考…
阅读更多...
两种特征提取方法与深度学习方法对比的小型金属物体分类分析研究

两种特征提取方法与深度学习方法对比的小型金属物体分类分析研究

本文讨论了用于对包括螺丝、螺母、钥匙和硬币在内的小型金属物体进行分类的两种特征提取方法的效率&#xff1a;定向梯度直方图 (HOG) 和局部二进制模式 (LBP)。首先提取标记图像的所需特征并以特征矩阵的形式保存。使用三种不同的分类方法&#xff08;非参数 K 最近邻算法、支…
阅读更多...
云计算|OpenStack|社区版OpenStack（实务操作---cloud-init的使用）

云计算|OpenStack|社区版OpenStack（实务操作---cloud-init的使用）

前言&#xff1a; 接上一篇文章&#xff1a;https://zskjohn.blog.csdn.net/article/details/128931042 我们可以从官方获取到现成的镜像&#xff0c;例如&#xff0c;从Ubuntu 18.04 LTS (Bionic Beaver) Daily Build [20230210]官方下载的bionic-server-cloudimg-amd64.img…
阅读更多...
春招Leetcode刷题日记-D2-贪心算法-区间问题

春招Leetcode刷题日记-D2-贪心算法-区间问题

D2-贪心算法-区间问题力扣435. 无重叠区间思路代码力扣435. 无重叠区间 题目链接&#xff1a;435. 无重叠区间 思路 1、贪心策略&#xff1a; 1、题目中&#xff0c;给了若干个区间&#xff0c;现在&#xff0c;我想留下尽可能多的&#xff0c;不重叠的区间 2、考虑&#…
阅读更多...
Git配置多仓库账户密码

Git配置多仓库账户密码

前言说明&#xff1a; 由于我们在工作中可能会遇到公司是用的gitlab仓库&#xff0c;代码下载需要github仓库&#xff0c;自己的项目需要gitee仓库&#xff0c;如何在同一台电电脑配置多个仓库账户密码就尤为重要。 (一) 配置流程 这里是在windows电脑上配置多仓库以github为例…
阅读更多...
使用Spring框架的好处是什么

使用Spring框架的好处是什么

使用Spring框架的好处是什么&#xff1f; 1、轻量&#xff1a;Spring 是轻量的&#xff0c;基本的版本大约2MB。 2、控制反转&#xff1a;Spring通过控制反转实现了松散耦合&#xff0c;对象们给出它们的依赖&#xff0c;而不是创建或查找依赖的对象们。 3、面向切面的编程(AOP…
阅读更多...
JCIM|Chemistry42：一个人工智能驱动的分子设计和优化平台

JCIM|Chemistry42：一个人工智能驱动的分子设计和优化平台

题目&#xff1a;Chemistry42: An AI-Driven Platform for Molecular Design and Optimization 文献来源&#xff1a;https://doi.org/10.1021/acs.jcim.2c01191 代码&#xff1a;https://insilico.com/pipeline (平台网址) 1.背景介绍 Chemistry42是Insilico Medicine提出…
阅读更多...
Git_合并多次提交记录

Git_合并多次提交记录

Git_合并多次提交记录 前言&#xff1a;使用git rebase将多条提交记录合并成一条 应用场景&#xff1a;公司代码分支在master上&#xff0c;张三接到一个开发任务&#xff0c;需要在master上开发一个新功能&#xff0c;首先张三不能直接使用master分支进行开发&#xff0c;因为…
阅读更多...
论文阅读：GeoAug: Data Augmentation for Few-Shot NeRF with Geometry Constrain

论文阅读：GeoAug: Data Augmentation for Few-Shot NeRF with Geometry Constrain

中文标题&#xff1a;使用几何约束增强小样本神经辐射场 提出的问题 NeRF尽管简介有效&#xff0c;但是往往不能收敛到正确的几何结构。这个问题在小样本学习中尤为明显&#xff0c;往往在没有足够训练数据的情况下&#xff0c;很难使得MLP网络学习到正确的几何的隐表示&#…
阅读更多...
Solon Java Framework 2.1.2 发布。简单！高效！国产！

Solon Java Framework 2.1.2 发布。简单！高效！国产！

Solon 是一个高效的 Java 应用开发框架&#xff1a;更快、更小、更简单。它不是 Spring&#xff0c;没有用 Servlet&#xff0c;也无关 JavaEE&#xff1b;它也是一个新兴独立的开放生态。主框架仅 0.1 MB。 150来个生态插件&#xff0c;覆盖各种不同的应用开发场景&#xff1…
阅读更多...
Linux Capabilities 入门

Linux Capabilities 入门

目录 Linux capabilities 是什么&#xff1f; capabilities 的赋予和继承 线程的 capabilities Permitted Effective Inheritable Bounding Ambient 文件的 capabilities Permitted Inheritable Effective 运行 execve() 后 capabilities 的变化 案例 Linux capab…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023