C++模板

C++ 模板

本文使用百度搜索修改而来，虽然工作中模板用的少，但是写本文可以回忆模板，以前都是用云笔记，现在试试博客这样才能和大家分享知识
-主要讲模板与特化

类模板

---

其实无非两种，一种是具体化（又叫偏特化）一种是实例化（又叫全特话），对于具体化，就是
对模板的范围进一步压缩，并给这个更小的范围从新定义类成员（包括数据成员和方法）。对于实例化就是直接生成模板中某种实例（注意：同时给一个模板生成同一个实例化和具体化将报错）。举例：

 #include<iostream>
 #include<cstdio>
 #include<stdlib.h>
 using namespace std;
 template <typename  T1,typename T2>//#1
 class A
 {
   int a;
   public:
    A (){cout<<"this is A<T1,T2> default constructor function!\n";} 
 };
 template <typename T1> 
 class A<T1,int>//部分的具体化 #2
 {
  int b;
  public:
 A (){cout<<"this is A<T1,int> default constructor function!\n";}
 };
template class A<int,char>;//显示的实例化，将直接生成该类型类定义
int main()
 {
  class A<int ,int>  a;//隐式实例化 ,将隐式生成#2 的实例
  class A<int ,char> b; //隐式实例化，将隐式生成#1的实例 
  return 0;
}

实例

#include <iostream>
#include <string>


//模板类
class MyClass
{
public:
    int a;
    int b;
    std::string desc;
};

class HeClass
{
public:
    HeClass(std::string l1, std::string l2, std::string l3) : level1(l1), level2(l2), level3(l3)
    {}
    std::string level1;
    std::string level2;
    std::string level3;
};

template<typename T>
class classDescriptor
{

};


template<>
class classDescriptor<HeClass>
{
public:
    template<typename TCallback>
    void for_each_property(TCallback& callback)
    {
        callback("level1", &HeClass::level1);
        callback("level2", &HeClass::level2);
        callback("level3", &HeClass::level3);
    }
};

template<>
class classDescriptor<MyClass>
{
public:
    template<typename TCallback>
    void for_each_property(const TCallback& callback)
    {
        callback("a", &MyClass::a);
        callback("b", &MyClass::b);
        callback("desc", &MyClass::desc);
    }
};

template class classDescriptor<MyClass>;

template<typename TClass>
class SamplePropertyAlgorithm
{
    TClass& m_t;
public:
    SamplePropertyAlgorithm(TClass& t):m_t(t)
    {

    }

    template<typename TPropertyType>
    void operator()(const char* szProperty, TPropertyType TClass::*pPropertyOffset) const
    {
        std::cout << szProperty << ": " << m_t.*pPropertyOffset << std::endl;
    }
};

template<typename T>
void RunAlgorithm(T& t)
{
    classDescriptor<T> myt;
    SamplePropertyAlgorithm<T> mysample(t);
    myt.for_each_property(mysample);
}


//模板函数
template<typename T1, typename T2>
const char* myequal(T1& a, T2& b)
{
    return a == b ? "equal" : "not equal";
}

template<>
const char* myequal(float& a, float& b)
{
    return abs(a - b) < 0.0001 ? "equal" : "not equal";
}

int main()
{
    MyClass my;
    my.a = 100;
    my.b = 200;
    my.desc = "this is test";

    HeClass he("test1", "test2", "test3");

    RunAlgorithm(he);
    RunAlgorithm(my);

    int a = 1, b = 2;
    float c = 1.0, d = 1.00001;
    std::cout << myequal(a,b) << std::endl;
    std::cout << myequal(c,d) << std::endl;


    getchar();
}

总结下：

定义一个类模板：

Template < class或者也可以用typename T >
class类名｛
／／类定义．．．．．．
｝；

说明：其中，template是声明各模板的关键字，表示声明一个模板，模板参数可以是一个，也可以是多个。

定义一个函数模板：

Template