模板类，模板成员函数，模板嵌套类

在模板类中声明一个模板成员函数，定义方式：
.h文件
 

template <typename T, std::size_t N>
struct MsgOperaTrait : MsgOperaBase
{
    enum {MSGID = N};

    template<class K>
    void NotifyCardOperFunc(K* pCardOper, LONG tokenExcept, int nNtfMsg = 0);
};

.cpp文件

template<class T, std::size_t N>
template<class K>
void MsgOperaTrait<T, N>::NotifyCardOperFunc(K* pCardOper, LONG tokenExcept, int nNtfMsg)
{
}

在上面组合中如果需要对外提过一个接口，内部通过结构体区分调用不同的实现：
.h文件
 

//初等模板 
#define MSG_OPERTRAIT_NOTIFY_CARD_OPER_BASE()       \
    template<class M, class Enable = void>\
struct NotifyCardOper\
{\
    void operator()(M* pCardOper, LONG tokenExcept, CGameTable* pTable, CGameServer* pMainServer, int nNtfMsg = 0){}\
};

//部分特化模板
#define MSG_OPERTRAIT_NOTIFY_CARD_OPER(class_name)       \
    template<class M> \
struct NotifyCardOper<M, typename std::enable_if<std::is_same<M, class_name>::value>::type>\ 
{\
    void operator()(M* pCardOper, LONG tokenExcept, CGameTable* pTable, CGameServer* pMainServer, int nNtfMsg = 0); \
};

template <typename T, std::size_t N>
struct MsgOperaTrait : MsgOperaBase
{
    enum {MSGID = N};

    template<class K>
    void NotifyCardOperFunc(K* pCardOper, LONG tokenExcept, int nNtfMsg = 0);
    
        注册notifyCard*通知事件
    MSG_OPERTRAIT_NOTIFY_CARD_OPER_BASE()
    MSG_OPERTRAIT_NOTIFY_CARD_OPER(CATCH_CARD);
    MSG_OPERTRAIT_NOTIFY_CARD_OPER(CHI_CARD);
    MSG_OPERTRAIT_NOTIFY_CARD_OPER(CHANGE_CARD);
};

.cpp文件

#define MSG_OPERA_NTF_CLASS_FUNC_DECLARE(class_name)\
template<class T, std::size_t N>\
template<class M>\
void MsgOperaTrait<T, N>::NotifyCardOper<M, typename std::enable_if<std::is_same<M, class_name>::value>::type>::operator()(M* pCardOper, LONG tokenExcept, CGameTable* pTable, CGameServer* pMainServer, int nNtfMsg)\


template<class T, std::size_t N>
template<class K>
void MsgOperaTrait<T, N>::NotifyCardOperFunc(K* pCardOper, LONG tokenExcept, int nNtfMsg)   //对外提供这个接口
{
    NotifyCardOper<K> oper;
    oper(pCardOper, tokenExcept, pTable, pMainServer, nNtfMsg);
}

MSG_OPERA_NTF_CLASS_FUNC_DECLARE(CATCH_CARD)
{
    std::cout<<"caught"<<std::endl;
}

MSG_OPERA_NTF_CLASS_FUNC_DECLARE(CHI_CARD)
{
    std::cout<<"chi"<<std::endl;
}

MSG_OPERA_NTF_CLASS_FUNC_DECLARE(CHANGE_CARD)
{
    std::cout<<"change"<<std::endl;
}

调用：

   CATCH_CARD caughtCard;
    NotifyCardOperFunc(&caughtCard, 0);  //输出 caught
    
    
    CHI_CARD chiCard;
    NotifyCardOperFunc(&chiCard, 0);  //输出 chi
    
    CHANGE_CARD changeCard;
    NotifyCardOperFunc(&changeCard, 0);  //输出 change

 

参考std::enable_if提供的实例

#include <type_traits>
#include <iostream>
#include <string>

namespace detail { struct inplace_t{}; }
void* operator new(std::size_t, void* p, detail::inplace_t){
	return p;
}

// #1 ，通过返回类型使用
template<class T, class... Args>
typename std::enable_if<std::is_trivially_constructible<T, Args&&...>::value>::type
construct(T* t, Args&&... args)
{
	std::cout << "constructing trivially constructible T\n";
}

// #2
template<class T, class... Args>
std::enable_if_t<!std::is_trivially_constructible<T, Args&&...>::value> // 使用帮助类型
construct(T* t, Args&&... args)
{
	std::cout << "constructing non-trivially constructible T\n";
	new(t, detail::inplace_t{}) T(args...);
}

// #3 ，通过形参启用
template<class T>
void destroy(T* t,
	typename std::enable_if<std::is_trivially_destructible<T>::value>::type* = 0)
{
	std::cout << "destroying trivially destructible T\n";
}

// #4 ，通过模板形参启用
template<class T, typename std::enable_if<!std::is_trivially_destructible<T>::value && (std::is_class<T>::value || std::is_union<T>::value), int>::type = 0>
void destroy(T* t)
{
	std::cout << "destroying non-trivially destructible T\n";
	t->~T();
}

// #5 ，通过模板形参启用
template<class T,
	typename = std::enable_if_t<std::is_array<T>::value> >
	void destroy(T* t) // 注意，不修改函数签名
{
		for (std::size_t i = 0; i < std::extent<T>::value; ++i) {
			destroy((*t)[i]);
		}
	}
/*
template<class T,
typename = std::enable_if_t<std::is_void<T>::value> >
void destroy(T* t){} // 错误：与 #5 拥有相同签名
*/

// A 的部分特化通过模板形参启用
template<class T, class Enable = void>
class A {}; // 初等模板

template<class T>
class A<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
}; // 为浮点类型特化


//template void func<X>(); // #2

int main()
{
	std::aligned_union_t<0, int, std::string> u;

	construct(reinterpret_cast<int*>(&u));
	destroy(reinterpret_cast<int*>(&u));

	construct(reinterpret_cast<std::string*>(&u), "Hello");
	destroy(reinterpret_cast<std::string*>(&u));

	A<int> a1; // OK ，匹配初等模板
	A<double> a2; // OK ，匹配部分特化

	system("pause");

	return 0;
	//func<X, X::value1>();
}