C++回顾day03---<模板>

最新推荐文章于 2024-11-15 23:31:30 发布

weixin_30587025

最新推荐文章于 2024-11-15 23:31:30 发布

阅读量80

点赞数

文章标签： c/c++

原文链接：http://www.cnblogs.com/ssyfj/p/10777240.html

版权

一：函数模板

建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就称为函数模板。
凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需要在模板中定义一次即可

（一）函数模板语法

template <类型形式参数表>
类型 函数名(形参参数表)
{
    执行语句;
}

其中类型形式参数表形式为：
typename T1,typename T2,...,typename Tn
或者
class T1,class T2,...,class Tn

（二）函数模板和普通函数相比

（1）参数转换问题

普通函数可以进行隐式函数类型转换
模板函数不允许存在这种转换，类型严格一致

（2）调用规则问题

1.函数模板可以像普通函数一样被重载
2.C++编译器优先考虑普通函数
3.如果函数模板可以产生一个更好的匹配，那么选择模板
4.可以通过空模板实参列表的语法限定编译器只通过模板匹配

（三）函数模板的使用

template <typename T1,typename T2>    //参数列表为2个
void sortArray(T1* arr, T2 num)
{
    T2 i, j;
    T1 temp;
    for (i = 0; i < num; i++)
        for (j = 0; j < num; j++)
            if (arr[i]>arr[j])
            {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
}

template <typename T>
void printArr(T* arr, int num)    //参数列表可以含有固定类型参数  返回值类型可以自定义，也可以为typename定义类型
{
    int i;
    for (i = 0; i < num; i++)
    {
        cout << arr[i]<<" ";
    }
    cout << endl;
}
void main()
{
    //测试int类型
    int a[5] = { 1, 37, 20, 19, 49 };
    sortArray(a, 5);
    printArr(a, 5);

    //测试float类型
    float fa[5] = { 2.6, 37.1, 62.9, 16.2, 38 };
    sortArray(fa, 5);
    printArr(fa, 5);
    
    system("pause");
}

（四）当函数模板遇到函数重载《重点》

1.函数模板可以像普通函数一样被重载

//实现参数交换
template<typename T>
void mySwap(T& t1, T& t2)
{
    T temp;
    temp = t1;
    t1 = t2;
    t2 = temp;
}

void mySwap(char &b, int& a)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}

void main()
{
    char a = 'A';
    int b = 97;
    mySwap(a, b);

    cout << "a:" << a<<endl;
    cout << "b:" << b << endl;
    
    system("pause");
}

由于模板函数参数类型严格定义，故会去找下面的进行调用。但是不难看出是允许函数模板重载的

2.C++编译器优先考虑普通函数

//实现参数交换
template<typename T>
void mySwap(T& t1, T& t2)
{
    T temp;
    temp = t1;
    t1 = t2;
    t2 = temp;
    cout << "template func" << endl;
}

void mySwap(int &b, int& a)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
    cout << "ordinary func" << endl;
}

void main()
{
    int a = 16, b = 64;
    mySwap(a, b);

    cout << "a:" << a<<endl;
    cout << "b:" << b << endl;
    
    system("pause");
}

可以看出模板函数和普通函数都是可以匹配成功的，但是C++编译器却优先选取了普通函数

3.如果函数模板可以产生一个更好的匹配，那么选择模板

//实现参数交换
template<typename T>
void mySwap(T& t1, T& t2)
{
    T temp;
    temp = t1;
    t1 = t2;
    t2 = temp;
    cout << "template func" << endl;
}

void mySwap(int &b, int& a)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
    cout << "ordinary func" << endl;
}

void main()
{
    float a = 16.5, b = 64.6;
    mySwap(a, b);

    cout << "a:" << a<<endl;
    cout << "b:" << b << endl;
    
    system("pause");
}

可以看出，在符合模板函数参数列表严格匹配的条件下，若是和模板函数更好匹配，那么会去选择模板函数

4.可以通过空模板实参列表的语法限定编译器只通过模板匹配

template<typename T>
void mySwap(T& t1, T& t2)
{
    T temp;
    temp = t1;
    t1 = t2;
    t2 = temp;
    cout << "template func" << endl;
}

void mySwap(int &b, int& a)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
    cout << "ordinary func" << endl;
}

void main()
{
    int a = 16, b = 64;
    mySwap(a, b);    //若是不做处理会优先调用普通函数

    //下面通过<>类型列表，显示调用模板函数
    mySwap<>(a, b);

    cout << "a:" << a<<endl;
    cout << "b:" << b << endl;
    
    system("pause");
}

通过空模板<>列表可以显示调用模板函数

（五）总结

1.编译器并不是把函数模板处理成能够处理任意类的函数
2.编译器从函数模板通过具体类型产生不同的函数
3.编译器会对函数模板进行两次编译：
    在声明的地方对函数模板进行编译
    在调用的地方对参数替换后的代码进行编译

二：类模板

（一）单个类模板语法

//也可以通过类属参数进行直接传参
template<typename T,int exp1,typename T3>    //类属参数列表写了，可以不用（不会报错），但是既然不用，写他也就没有意义
class A
{
public:
    T t;    //注意：类属参数列表中的参数，至少在类说明中出现一次
public:
    A(int a)
    {
        this->t = a + exp1;
    }

    void getInfo()
    {
        cout <<"getInfo:"<<this->t << endl;
    }
};

void main()
{
    A<int,10,int> a(5);    //模板类调用
    a.getInfo();

    system("pause");
}

（二）继承中的函数模板：派生类必须实例化基类（指定好参数列表）

template<typename T>
class A
{
public:
    T t;
public:
    A(T a)
    {
        this->t = a ;
    }

    void getInfo()
    {
        cout <<"A getInfo:"<<this->t << endl;
    }
};

class B :public A<float>
{
public:
    int b;
public:
    B(int n, float m) :A<float>(m)
    {
        b = n;
    }

    void getInfo()
    {
        cout << "B getInfo:" << this->b << endl;;
        A<float>::getInfo();
    }
};

void main()
{
    B b(5, 6.5);
    b.getInfo();

    system("pause");
}

总之：子类从模板类继承时，一定要让编译器知道父类的具体类型，才可以进行内存分配。

（三）类模板方法在类外部进行定义（上面都是在内部定义）

template <class 虚拟类型参数>
函数类型 类模板名<虚拟类型参数>::成员函数名(函数参数列表)
{
    ....
}

template<typename T>
class A
{
public:
    T t;
public:
    A(T a)
    {
        this->t = a ;
    }

    T getInfo();　　//需要提前声明
};

template<class T>　　//typename也可以
T A<T>::getInfo()
{
    cout << "A outfunc" << endl;
    return this->t;
}

void main()
{
    int ret;
    A<int> a(5);
    ret=a.getInfo();
    cout << "ret:" << ret << endl;
    system("pause");
}

（四）类模板友元函数使用（声明，实现，调用3个都要注意）

template<typename T>
class A
{
public:
    T t;
public:
    A(T a)
    {
        this->t = a ;
    }

    T getInfo();

    friend A<T> mySub(A<T> &a1, A<T> &a2);　　//1.声明
};

template <typename T>　　　　　　　　　　　　　　 //2.实现
A<T> mySub(A<T> &a1, A<T> &a2)
{
    A<T> a(a1.t - a2.t);
    return a;
}

template<typename T>
T A<T>::getInfo()
{
    cout << "A outfunc" << endl;
    return this->t;
}


void main()
{
    int ret;
    A<int> a(5);
    A<int> b(2);

    //注意友元函数的调用方法
    A<int> c = mySub<int>(a, b);　　　　　　//3.调用    //返回匿名对象，直接初始化给c

    ret=c.getInfo();
    cout << "ret:" << ret << endl;
    system("pause");
}