模板

1、定义函数模板

#include <iostream>
#include <string>
using namespace std;

template <typename T>
int compare(const T &v1, const T &v2)
{
    if(v1 < v2)
        return -1;
    if(v2 < v1)
        return 1;
    return 0;
}

int main()
{
    // T is int---compiler instantiates int compare(const int&, const int&)
    cout << compare(1, 0) << endl;
    // T is string---compiler instantiates int compare(const string&, const string&)
    string s1 = "hi", s2 = "world";
    cout << compare(s1, s2) << endl;
    system("pause");
    return 0;
}

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

// ok:inline specifier follows templacement of inline specifier
template <typename T> inline T min(const T&, const T&);
// error: incorrect placement f inline specifier
inline template <typename T> T min(const T&, const T&);

 定义多个模板形参:

/**
 *    编写一个函数模板，接受一个ostream引用和一个值，将该值写入流。用至少四种不同类型调用函数。
 *通过写至cout、写至文件和写至stringstream来测试你的程序。
 */

#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
using namespace std;

template <typename T1, typename T2>
T1& print(T1& s, T2 val)
{
    s << val;
    return s;
}

int main()
{
    double dval = 0.88;
    float fval = -12.3;
    string oristr = "this is a test", desstr;
    ostringstream oss(desstr);
    ofstream outFile("result.dat");
    
    // 写至 cout
    print(cout, -3) << endl;
    print(cout, dval) << endl;
    print(cout, fval) << endl;
    print(cout, oristr) << endl;
    
    // 写至文件
    print(outFile, -3) << endl;
    print(outFile, dval) << endl;
    print(outFile, fval) << endl;
    print(outFile, oristr) << endl;
    outFile.close();
    
    // 写至 stringstream
    print(oss, -3) << endl;
    print(oss, dval) << endl;
    print(oss, fval) << endl;
    print(oss, oristr) << endl;
    
    // 将 stringstream 中的字符串输出到cout以进行验证
    cout << oss.str() << endl; //oss.str()返回的是 string 类型的字符串

    system("pause");
    return 0;
}

注意：

#include <iostream>
#include <string>
using namespace std;

template <typename T>
int compare(const T &v1, const T &v2)
{
    if(v1 < v2)
        return -1;
    if(v2 < v1)
        return 1;
    return 0;
}

int main()
{
    // Error
    cout << compare("hi", "world") << endl;
    /* 这样调用将会出编译错误，因为根据第一个实参"hi" 可将模板形参T推断为char[3]，
    而第二个实参"world"可将模板形参T推断为char[6],T被推断为两个不同的类型，编译器无法实例化。*/
    
    system("pause");
    return 0;
}

2、定义类模板

// 编写类似于标准库中 find 算法的模板函数。使用该函数在 vector<int> 和 vector<string>中查找指定值
#include <iostream>
#include <string>
#include <vector>
using namespace std;

//template <typename InIt, typename T>
template <class InIt, class T>  // 使用 class 或 typename 关键字都可以
InIt findElem(InIt first, InIt last, const T& val)
{
    while(first != last)
    {
        if(*first == val)
            return first;
        ++first;
    }
    return last;
}

int main()
{
    int ia[] = {1, 2, 3, 4, 5, 6, 7};
    string sa[] = {"this", "is", "Mary", "test", "example"};
    vector<int> ivec(ia, ia+7);
    vector<string> svec(sa, sa+5);
    
    vector<int>::iterator itor;
    if((itor = findElem(ivec.begin(), ivec.end(), 6)) != ivec.end())
        cout << "found this element: " << *itor << endl;
    else
        cout << "no such element" << endl;
        
    vector<string>::iterator itor1;
    if((itor1 = findElem(svec.begin(), svec.end(), "Mary")) != svec.end())
        cout << "found this element: " << *itor1 << endl;
    else
        cout << "no such element" << endl;
        
    system("pause");
    return 0;
}

      如果要在函数模板内部使用在类中定义的类型成员，必须在该成员名前加上关键字typename,告诉编译器将该成员当做类型。 

/**
 * 编写一个函数，接受一个容器引用并打印该容器的元素，
 * 
 */
// 代码一：使用容器的 size_type 和 size成员控制打印元素的循环。
#include <iostream>
#include <string>
#include <vector>
using namespace std;

template <typename Parm>
void print(const Parm& c)
{
    typename Parm::size_type index = 0;
    while(index != c.size())
    {
        cout << c[index] << ' ';
        ++index;
    }
}

int main()
{
    int ia[] = {1, 2, 1, 4, 1, 6, 1};
    string sa[] ={"this", "is", "Mary", "test", "example"};
    vector<int> ivec(ia, ia+7);
    vector<string> svec(sa, sa+5);
    print(ivec);
    cout << endl;
    print(svec);
    
    system("pause");
    return 0;
}

// 代码二：使用 begin 和 end 返回迭代器来控制循环
#include <iostream>
#include <string>
#include <vector>
using namespace std;

template <typename Parm>
void print(const Parm& c)
{
    typename Parm::const_iterator itor = c.begin();
    while(itor != c.end())
    {
        cout << *itor++ << ' ';
    }
}

int main()
{
    int ia[] = {1, 2, 1, 4, 1, 6, 1};
    string sa[] ={"this", "is", "Mary", "test", "example"};
    vector<int> ivec(ia, ia+7);
    vector<string> svec(sa, sa+5);
    print(ivec);
    cout << endl;
    print(svec);

    system("pause");
    return 0;
}

 模板形参也可以是非类型的：模板非类型形参是模板定义内部的常量值，在需要常量表达式的时候，可使用非类型形参

 例如：编写可以确定数组长度的函数模板

template <typename T, std::size_t N>
std::size_t size(T (&arr)[N])
{
    return N;
}

 对于模板类型形参，传给它的实参必须完全匹配，如果想要用兼容类型调用，可以使用显示模板实参或者强制类型转换（类型转换的限制只适用于类型为模板形参的那些实参，非模板类型的形参可以隐式转换）

#include <iostream>
using namespace std;

template <typename T>
int compare(const T& v1, const T& v2)
{
    if(v1 < v2)
        return -1;
    if(v2 < v1)    // 注意这里不要写成 v1 > v2, 在泛型编程中注意规范
        return 1;
    return 0;
}

int main()
{
    short sval = 123;
    int ival = 1024;
    //cout << compare(sval, ival) << endl;  // ERROR：cannot instantiate compare(short, int), 形参必须完全匹配
    // 转换类型
    cout << compare(static_cast<int>(sval), ival) << endl;
    cout << compare(sval, static_cast<short>(ival)) << endl;
    // 显示指定形参类型
    cout << compare<short>(sval, ival) << endl;
    cout << compare<int>(sval, ival) << endl;
    
    system("pause");
    return 0;
}

 一般而言，不会转换实参以匹配已有的实例化，相反，会产生新的实例。除产生新的实例外，编译器只会执行两种转化：

1、const 转换：接收const 引用或 const 指针的函数可以分别用非 const 对象的引用或指针来调用，无须产生新的实例化。如果函数接受非引用类型，形参类型和实参都忽略const，即，无论传递 const 或 非 const 对象给接受非引用类型的函数，都使用相同的实例化。

2、数组或函数到指针的转换：如果模板形参不是引用类型，则对数组或函数类型的实参应用常规指针转换，数组实参将当作指向其第一个元素的指针，函数实参当作指向函数类型的指针。举例说明如下：

template <typename T> T fobj(T, T);  // arguments are copied
template <typename T> T fref(const T&, const T&);    // reference argements

/*
    传递 string 对象和 const string 对象作为实参，即使这些类型不完全匹配，两个调用也都是合法的。
在 fobj 的调用中，实参被复制，因此原来的对象是否为 const 无关紧要，在 fref 的调用中，形参类型是
const 引用，对引用形参而言，转换为 const 是可以接受的转换，所以这个调用也正确
*/
string s1("a value");
const string s2("another value");
fobj(s1, s2);    // ok: calls f(string, string), const is ignored
fref(s1, s2);    // ok:non const object s1 converted to const reference


/*
     传递不同长度的数组实参--fobj 的调用中，数组不同无关紧要，两个数组都转换为指针，
fobj 的模板形参类型是 int*，但是，fref的调用是非法的，当形参为引用时数组不能转换为指针，
a 和 b 的类型不匹配（引用类型会检查数组长度），所以调用会出错
*/
int a[10], b[42];
fobj(a, b);    // ok: calls f(int*, int*)
fref(a, b);    // error:array types don't match; arguments aren't converted to pointers