如果赶时间，直接看最后一部分。
还是老规矩：为了避免歧义我还是要先列下我的环境
$ uname -a
Linux debian9-64-Desktop 4.9.0-8-amd64 #1 SMP Debian 4.9.110-3+deb9u6 (2018-10-08) x86_64 GNU/Linux
$ gcc --version
gcc (Debian 6.3.0-18+deb9u1) 6.3.0 20170516
需求：
写个模板类，有个自增唯一ID
这里只是给了一个思路，也是我在工作过程中使用到的。
需要建立一个 ReqSession.h
"C++模板类的成员函数定义与声明必须在一个头文件中"
#ifndef REQSESSION_H
#define REQSESSION_H
#include <stdint.h>
#include <iostream>
//自增的参数
static uint32_t m_sessionId =0 ;
//模板类
template <typename T>
class ReqSessionTMP
{
public:
ReqSessionTMP(T* data){
++m_sessionId;
m_data =data;
}
void printSession(){
std::cout<<"模板类：id:"<<m_sessionId<<",param:"<<m_data<<std::endl;
delete m_data; // 这里做了释放的操作
}
private:
//携带的参数
T * m_data =nullptr;
};
#endif // REQSESSION_H
如果发现修改模板类的头文件没有用处，则需要增加预编译参数 **-MMD**
在我的工程项目里面就是加到 *.pro 文件， QMAKE_CXXFLAGS += -MMD
开始调用：
void UA4Qml2::createReqSession(const QString str)
{
//创建一个会话
//基本数据类型
//const char* conver to char* ，const char* 强转char*
std::string tmpStr = str.toStdString();
char* c_str=new char[tmpStr.length()]; //注意这里的内存释放
memcpy(c_str,tmpStr.c_str(),tmpStr.length());
ReqSessionTMP<char> session(c_str) ;
session.printSession();
}
看下打印
模板类：id:1,param:hello session
模板类：id:2,param:hello session
看到这里也许有人问，这里为啥要用模板类，用个void* 不就可以了吗？
我们再继续实践，增加普通类,和上面的 ReqSessionTMP 放在同一个文件里（ PS :c++就是不一样，一个文件可以放多个不同类的声明，想我java好像不行）
//普通类
class ReqSession
{
public:
ReqSession(void* data){
++m_sessionId;
m_data =data;
}
void printSession(){
std::cout<<"普通类：id:"<<m_sessionId<<",param:"<<m_data<<std::endl;
delete m_data;// 这里做了释放的操作，注意这里没有强转
}
private:
//携带的参数
void * m_data =nullptr;
};
事实证明，使用刚才的方式进行打印，其实是没有区别的。
我们现在改成复杂一点的例子。我们再新建一个普通类，用于会话传输的内容
#include <stdint.h>
#include <iostream>
class Session{
public:
char * name =nullptr;
uint32_t age =0;
~Session(){
std::cout<<"~Session"<<std::endl;
}
};
让我们来看下两种不同的调用
void UA4Qml2::createReqSession(const QString str)
{
//复杂数据类型
std::string tmpStr = str.toStdString();
char* c_str=new char[tmpStr.length()];
memcpy(c_str,tmpStr.c_str(),tmpStr.length());
Session* session =new Session();
session->name = c_str;
#if 0
ReqSession reqSession(session) ;
//可以看到，没有调用析构函数
reqSession.printSession();
#else
ReqSessionTMP<Session> reqSession(session) ;
//可以看到调用了析构函数
reqSession.printSession();
#endif
}
看下输出的结果：
# 使用模板类
模板类：id:1,param:0x556faa8f7f20
~Session
模板类：id:2,param:0x556faa3c62a0
~Session
# 使用普通类
普通类：id:1,param:0x563bfec51f50
普通类：id:2,param:0x563bfe7055d0
好像有点偏题啊。而且 本着哪里申请哪里释放的原则，这里不应该在模板类里面进行 释放内存的操作，这是有问题的。所以，如果把delete的相关代码删除，则两边效果是一致的，当然，需要在外部进行释放内存咯。
来，在说：上面这样写的就没有问题吗？
这是一个隐藏的很深的bug。【这是我今天特别想说的点】
如果有很多个不同的模板类，被打到了不同的库里面会怎样？（什么意思？就是说我有很多个不同的特例模板类，然后打成不同的库，这个时候就有问题了）
当然是，static 关键字不生效了。啥叫不生效了，就是在同一个so里面的 static 还是唯一的，但是和别的库就会是一样的Id，导致程序出现异常。
来给出最终的方案，因为把static关键字放在了头文件的缘故，所以导致上面的问题。现在改下，直接上代码
采用继承的方案
新建一个 basereqsession.h basereqsession.cpp
#include <stdint.h>
class BaseReqSession
{
public:
BaseReqSession();
static uint32_t& get_session_id();
};
#include "basereqsession.h"
BaseReqSession::BaseReqSession()
{}
static uint32_t m_session_id = 0; //在cpp里面进行定义
uint32_t &BaseReqSession::get_session_id() //返回值类型必须是引用
{
return m_session_id;
}
然后模板类只要继承即可
#include "basereqsession.h"
template <typename T>
class ReqSessionTMP :BaseReqSession //这里用继承
{
public:
ReqSessionTMP(T* data){
++get_session_id();
m_data =data;
}
private:
//携带的参数
T * m_data =nullptr;
};
最后完善一下：之前的代码
#ifndef REQSESSION_H
#define REQSESSION_H
#include <stdint.h>
#include <iostream>
#include "basereqsession.h"
template <typename T>
class ReqSessionTMP :BaseReqSession
{
public:
ReqSessionTMP(T* data){
autoIncreateSessionId();
m_data =data;
}
int getSessionId()
{
return get_session_id();
}
private:
void autoIncreateSessionId()
{
++get_session_id();
if(get_session_id() == 0)
{
get_session_id() = 1;
}
}
private:
//携带的参数
T * m_data =nullptr;
};
#endif // REQSESSION_H
