C++--模板进阶--模板的编译--0927

1. 模板参数

模板参数分为 类型形参与 非类型形参。

类型形参

出现在模板参数列表中，跟在class或者typename之类的参数类型名称。

template<class T,class T2,class T3>//每一个T代表一个类型，如int char等

template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
 return left + right;
}
void Test()
{
 Add(1, 2.0); 
}

 这里T1是int 类型 T2是double类型，相加时发生整形提升为double类型，但是返回值为T1，是int类型，数据精度会丢失。

注：如模板参数仅有T1，传参时仍是Add(1, 2.0);//这里设计隐式类型转化，在模板初阶已经描述过。

非类型形参

就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

template< class T,size_t N=10>//缺省值给不给都可以

class array

{

private:

        T _a[N];//创建T类型的 大小为10的数组

};

 注意：浮点数、类对象以及字符串是不允许作为非类型模板参数的。

2. 模板的特化

出现的问题，以日期类为例：

template<class T>
bool Less(T left, T right)
{
 return left < right;
}
int main()
{
 cout << Less(1, 2) << endl; // 可以比较，结果正确
 Date d1(2022, 7, 7);
 Date d2(2022, 7, 8);
 cout << Less(d1, d2) << endl; // 可以比较，结果正确
 Date* p1 = &d1;
 Date* p2 = &d2;
 cout << Less(p1, p2) << endl; // 可以比较，结果错误，比指针大小了
 return 0;
}

为了避免这类错误，就需要对一些特定的类型进行特殊化处理。

2.1 函数模板特化

书写规则：

1. 必须要先有一个基础的函数模板
2. template跟空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同

template<class T>
bool less(T left,T right)
{
    return left<right;
}
template<>
bool less<Date*> (Date* left, Date* right)
{
    return *left<*right;
}
int main()
{
    Date d1(2022.9,27);
    Date d2(2022,9,28);
    Date* p1=&d1;
    Date* p2=&d2;
    cout<<less(p1,p2)<<endl;
    return 0;
}

2.2 类模板特化

对类模板特化而言分为全特化和偏特化，这里先给出解决方案。

template<class T>
struct Less //用于排升序
{
    bool operator()(const T& x, const T& y) const
    {
        return x < y;
    }
};
template<>
struct Less<Date*>
{
    bool operator()(const T& x,const T& y) const
    {
        return *x<*y;
    }
}

int main()
{
    Date d1(2022.9,27);
    Date d2(2022,9,28);
    Date d3(2022,9,29)
    Date* p1=&d1;
    Date* p2=&d2;
    //函数模板特化 cout<<less(p1,p2)<<endl;

    vector<Date> v1;
    v1.push_back(d1);
    v1.push_back(d2);
    v1.push_back(d3);
    sort(v1.begin(),v1.end(),Less<Date>);//正常结果

    //利用类模板特化
    vector<Date*> v2;
    v2.push_back(&d1);
    v2.push_back(&d2);
    v2.push_back(&d3);
    sort(v2.begin(),v2.end(),Less<Date*>);
    //正常结果
    
    
    return 0;
}

2.2.1 全特化

类中所有参数都确定化

template<class T1, class T2>
class Data
{
public:
 Data() {cout<<"Data<T1, T2>" <<endl;}
private:
 T1 _d1;
 T2 _d2;
};
template<>
class Data<int, char>
{
public:
 Data() {cout<<"Data<int, char>" <<endl;}
private:
 int _d1;
 char _d2;

2.2.2 偏特化

//对于 template<class T1,class T2>
 //    class Date<T1,T2>
//的偏特化       

template<class T1>
class Date<T1,int>
{
public:
    Date()
    {
        cout<<"Date<T1,int>"<<end;
    }
};

template<class T1,class T2>
class Date<T1*,T2*>
{
public:
    Date()
    {
        cout<<"Date<T1*,T2*>"<<endl;
    }
};

template<class T1,class T2>
class Date<&T1,&T2>
{
    Date()
    {
        cout<<"Date<&T1,&T2>"<<endl;
    }
};

int main()
{
    Data<int,int> d0;    //Date<T1,int>
    Data<double,int>d1;    //Date<T1,int>
    Data<int,char>d2;        //Date<T1,T2>
    Data<double,double>d3;    //Date<T1,T2>
    Date<double*,double*>d4;//Date<T1*,T2*>
    Date<int*,char*>d5;    //Date<T1*,T2*>
    Date<int*,char>d6;     //Date<T2,T2>
}

完全不搭边的才会实例化一个新的。

3. 模板的编译

• 模板不支持分离编译
• 模板程序一般只能放在一个文件里实现
• 模板程序被编译两次，这是不能分离编译的原因所在
• 不支持分离编译并不是语法错误，而是暂时的编译器不支持