关于模板

注：编译器版本 VS2013;

#ifndef __TEST_H__
#define __TEST_H__
#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;
#endif

函数模板

#define _CRT_SECURE_NO_WARNINGS 1
#include "test.h"
template<typename T>
T Add(T left, T right)
{
    return left + right;
}
int Add(int left, int right)
{
    return left + right;
}
double Add(double left, double right)
{
    return left + right;
}

int main()
{
    cout << Add(10, 20) << endl;
    cout << Add<>(10, 20) << endl;
    cout << Add(10.1, 20.0) << endl;
    cout << Add(10, (int)20.0) << endl;
    cout << Add<int>(10, 20.0) << endl;
    system("pause");
    return 0;
}
隐式实例化 Add(10,20),通过参数推演出来T的类型，但如果有一个处理int类型的函数,就会直接调用该函数，不会再用模板函数实例化处理int类型的加法函数。
Add<>（10,20）必须要模板函数实例化出一个函数，
Add(1,'2')像这样无法实例化解决的函数。
1：强转
a:显式强转
Add(10, (int)20.0)
b.显式实例化
Add<int>(1,'2') 隐士强转，会将字符强转为int。

模板函数重载

模板函数重载
#define _CRT_SECURE_NO_WARNINGS 1
#include "test.h"
template<typename T>  
const T& Max(const T& left, const T& right)
{
    return(left > right) ? left : right;
}
//两个函数模板构成重载
template<typename T> 
const T& Max(const T& left, const T& mid, const T& right)
{
    const T& tmp = Max(left, right);
    return(tmp > right) ? tmp : right;
}
int main()
{
cout << Max(1, 2) << endl;
cout << Max(1, 2, 3) << endl;
system("pause");
    return 0;
}

模板函数特化

特化即特殊化，

模板函数特化
#define _CRT_SECURE_NO_WARNINGS 1
#include "test.h"
template<class T>  //1111
const T& Max(const T& left, const T& right)
{
    return(left > right) ? left : right;
}
模板函数特化，必须给出基础版本  
template<>
const char*& Max<const char*&>(const char*& Pleft, const char*& Pright)
{
    if (strcmp(Pleft, Pright) > 0)
    {
        return Pleft;
    }
    return Pright;
}
int main()
{
    const char* p1 = "hello"; 
    const char* p2 = "word";
    cout << Max<const char* &>(p1, p2) << endl;
    //比较两个地址
    //cout << Max("hello", "word") << endl; 
    return 0;
}

特化版本和实例化版本的重载

#define _CRT_SECURE_NO_WARNINGS 1
#include "test.h"
template<typename T>
void Func(const T& x)
{
    count << "T" << x << endl;
}
void Func(const string& s)
{
    cout << "string" << s << endl;//是上面函数模板的特化版本
}
int main()
{
    Func(1);//void Func(const int& x)  ，实例化出来的函数和上面的特化版本的函数构成函数重载，函数名相同，参数类型不同
    Func(string("aaaa"));
    system("pause");
    return 0;
}

模板类定义格式及其特化

分为全特化和偏特化；

#define _CRT_SECURE_NO_WARNINGS 1
#include "test.h"
template<typename T>
class MyClass
{
public:
    MyClass()
    {
        cout << "MyClass(T)" << endl;
    }
    ~MyClass()
    {
        cout << "~MyClass(T)" << endl;
    }

private:
    T a;
};
//模板类特化
template<>
class MyClass<string>
{
public:
    MyClass()
    {
        cout << "MyClass(string)" << endl;
    }
    ~MyClass()
    {
        cout << "~MyClass(string)" << endl;
    }
private:
    string a;
};

int main()
{
    MyClass<int>s1;
    MyClass<string>s2;
    system("pause");
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1
#include "test.h"
template<typename T1,typename T2>
class MyClass
{
public:
    MyClass()
    {
        cout << "MyClass<T1,T2>" << endl;
    }
    ~MyClass()
    {
        cout << "~MyClass<T1,T2>" << endl;
    }
private:
    T1 a1;
    T2 a2;
};
template<>
class MyClass<int,char>//全特化
{
public:
    MyClass()
    {
        cout << "MyClass<int,char>" << endl;
    }
    ~MyClass()
    {
        cout << "~MyClass<int,char>" << endl;
    }
private:
    int a1;
    char a2;
};
template<typename T2>
class MyClass<int,T2>//偏特化
{
public:
    MyClass()
    {
        cout << "MyClass<int,T2>" << endl;
    }
    ~MyClass()
    {
        cout << "~MyClass<int,T2>" << endl;
    }
private:
    int a1;
    T2 a2;
};
template<typename T1,typename T2>
class MyClass<T1*,T2*>//偏特化，参数进一步限制
{
public:
    MyClass()
    {
        cout << "MyClass<T1*,T2*>" << endl;
    }
    ~MyClass()
    {
        cout << "~MyClass<T1*,T2*>" << endl;
    }

private:
    T1 *a1;
    T2 *a2;
};
template<typename T1, typename T2>
class MyClass<T1&, T2*>//偏特化，
{
public:
    MyClass()
    {
        cout << "MyClass<T1&,T2*>" << endl;
    }
    ~MyClass()
    {
        cout << "~MyClass<T1&,T2*>" << endl;
    }

private:
    T1 a1;
    T2 a2;
};
int main()
{
    MyClass <double, double> m1;
    MyClass<int,char>m2;
    MyClass<int,double>m3;
    MyClass<int*, int*>m4;
    MyClass<int&, int*>m5;
    system("pause");
    return 0;
}