类模板（上）

类是C++的核心，那是否能够将模板的思想应用于类呢？

类模板

一些类主要用于存储和组织数据元素

如：数组类，链表类、Stack类、Queue类等等

C++中可以将模板的思想应用于类，使得类可以不关注具体所操作的数据类型，而只关注类所需要实现的功能。

C++中的类模板

​ 提供一种特殊的类以相同的行为处理不同的类型；

​ 在类声明前使用template进行标识

​ 用于说明类中使用的泛指类型T

template <typename T>
class Operator{
	T add(T a, T b){
		return a + b;
	}  
	
	T minus(T a, T b){
		return a - b;
	}
};

声明的泛指类型 T 可用于声明成员变量和成员函数

​ 编译器对类模板的处理方式和函数模板相同

​ 编译器从类模板通过具体类型产生不同的类

​ 编译器在声明的地方对类模板代码本身进行编译

​ 编译器在使用的地方对参数替换后的代码进行编译

类模板的应用

​ 使用具体类型定义对象

代码实例

#include <cstdlib>
#include <iostream>

using namespace std;

template<typename T>
class Operator{
public:
	T add(T a, T b)	{
		return a+b;
	}
	
	T minus(T a, T b) {
		return a-b;
	}
};



int main(int argc, char *argv[])
{
    Operator<int> op1;
    Operator<double> op2;
    
	cout  <<  op1.add(5, 4)<<endl;
    cout  <<  op1.add(4, 5)<<endl;
    
    cout <<op2.add(1.3, 0.01)<<endl;
    cout <<op2.minus(0.01,1.3)<<endl;
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

类模板的工程应用

在模板类外部定义成员函数的实现时，需要加上template的声明

#include <cstdlib>
#include <iostream>

using namespace std;

template<typename T>
class Operator{
public:
	T add(T a, T b);
	
	T minus(T a, T b);
};


template<typename T>
T Operator<T>::add(T a, T b)	{
	return a+b;
}

template<typename T>	
T Operator<T>::minus(T a, T b) {
	return a-b;
}


int main(int argc, char *argv[])
{
    Operator<int> op1;
    Operator<double> op2;
    
	cout  <<  op1.add(5, 4)<<endl;
    cout  <<  op1.add(4, 5)<<endl;
    
    cout <<op2.add(1.3, 0.01)<<endl;
    cout <<op2.minus(0.01,1.3)<<endl;
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

由于类模板的编译机制不同，所以不能像普通类一样分开实现后，在使用时只包含头文件（应该为.hpp文件：模板类的实现文件）

在工程实践上，一般会把类模板 的定义直接放到头文件中！！（缺点：难以维护）

只有被调用的类模板成员函数才会被编译器生成可执行代码！！！（即：二次编译）

实例代码 数组类加入类模板

Array.h

#ifndef _ARRAY_H_
#define _ARRAY_H_

template<typename T>
class Array
{
private:
    int mLength;
    T* mSpace;

public:
    Array(int length);
    Array(const Array& obj);
    int length();
    ~Array();
    T& operator[](int i);
    Array& operator= (const Array& obj);
    bool operator== (const Array& obj);
    bool operator!= (const Array& obj);
};

#endif

Array.hpp

/*
类模板的实现为.hpp ,区分.cpp 
*/ 
#ifndef _ARRAY_DEF_H_ //避免重复包含文件 
#define _ARRAY_DEF_H_

#include "Array.h"

template<typename T>
Array<T>::Array(int length)
{
    if( length < 0 )
    {
        length = 0;
    }
    
    mLength = length;
    mSpace = new T[mLength];
}

template<typename T>
Array<T>::Array(const Array& obj)
{
    mLength = obj.mLength;
    
    mSpace = new int[mLength];
    
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
}

template<typename T>
int Array<T>::length()
{
    return mLength;
}

template<typename T>
Array<T>::~Array()
{
    mLength = -1;
    
    delete[] mSpace;
}

template<typename T>
T& Array<T>::operator[](int i)
{
    return mSpace[i];
}

template<typename T>
Array<T>& Array<T>::operator= (const Array<T>& obj)
{
    delete[] mSpace;
    
    mLength = obj.mLength;
    
    mSpace = new int[mLength];
    
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
    
    return *this;
}

template<typename T>
bool Array<T>::operator== (const Array<T>& obj)
{
    bool ret = true;
    
    if( mLength == obj.mLength )
    {
        for(int i=0; i<mLength; i++)
        {
            if( mSpace[i] != obj.mSpace[i] )
            {
                ret = false;
                break;
            }
        }
    }
    else
    {
        ret = false;
    }
    
    return ret;
}

template<typename T>
bool Array<T>::operator!= (const Array& obj)
{
    return !(*this == obj);
}

#endif

main.cpp

#include <cstdlib>
#include <iostream>

#include "Array.hpp"

using namespace std;



int main(){
	Array<int> ai(5);
	for(int i=0; i<ai.length(); i++){
		ai[i] = i+1;
	}	 
	for(int i =0; i<5; i++){
		cout << ai[i] <<endl;
	}
		
	Array<double> ad(10);
	for(int i=0; i<ad.length(); i++){
		ad[i] = (i+1)/100.0;
	}
	for(int i=0; i<ad.length(); i++){
		cout << ad[i] << endl;
	}
	
	
	return 0;
}

类模板的特化

类模板可以被特化

用template<>声明一个类时，表示这是一个特化类

//Test 类模板
template<typename T>
class Test
{
public:
    T test(T v)
    {
        cout<<"T test(T v)"<<endl;
        cout<<"sizeof(T) = "<<sizeof(T)<<endl;
        
        return v;
    }
};

//Test类模板的 int 特化
template<>
class Test<int>
{
public:
    int test(int v)
    {
        cout<<"int test(int v)"<<endl;
        cout<<"sizeof(int) = "<<sizeof(int)<<endl;
        
        return v;
    }
};

完整代码

#include <cstdlib>
#include <iostream>

using namespace std;

template<typename T>
class Test
{
public:
    T test(T v)
    {
        cout<<"T test(T v)"<<endl;
        cout<<"sizeof(T) = "<<sizeof(T)<<endl;
        
        return v;
    }
};

//类模板的特化
template<>
class Test<int>
{
public:
    int test(int v)
    {
        cout<<"int test(int v)"<<endl;
        cout<<"sizeof(int) = "<<sizeof(int)<<endl;
        
        return v;
    }
};

//可以继承 类模板的特化 
//MyTest变成一个普通的类
class MyTest : public Test<int>
{

};

int main(int argc, char *argv[])
{
    Test<int> t1;    
    cout<<t1.test(1)<<endl;
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

特化类模板的意义

当类模板在处理某种特定类型有缺陷时，可以通过 类模板的特化来克服处理这种特定类型带来的不足

注意：编译器优先选择特化类生成对象！！