C++泛型编程学习(二)——类模板

目录

前言

C++泛型编程学习(一)记录了函数模板。这部分记录下类模板相关的知识。

类模板

类模板与函数模板的定义和使用类似，如果有多个类的功能是相同的，但是数据类型不同，就可以使用类模板。
类模板用于实现类所需数据的类型参数化。类模板在表示如数组、表、图、队列等数据结构显得特别重要。这些数据结构的表示和算法不受所包含的元素类型的影响。

类模板由模板说明和类说明构成
template <类型形式参数表>
类声明

template <typename Type>
class TClass
{
    // TClass的成员函数
    private:
        Type d;   // 类属参数必须至少在类说明中出现一次
}

单个类模板语法

// 单个模板类
template <typename T>
class A{
public:
    A(T a=0)
    {
        this->a = a;
    }
public:
    void printA()
    {
        cout << "a=" << a << endl;
    }
protected:
private:
//    T a; 
};

// 类模板做函数参数,注意这里要确定参数类型
void useA(A<int> &a)
{
    a.printA();
}

int main()
{
    // 模板类本身就是类型化的->具体的类->定义具体的变量
    // 类模板中如果使用了构造函数,则遵守以前的类的构造函数的调用规则
    A<int> a1(12);  // 类型具体化
    // 此时a1就是一个int类型的普通A类而已
    a1.printA();

    useA(a1);

    cout << "Hello world!" << endl;
    return 0;
}

继承中的类模板语法

• 从类模板A中派生普通类B
  子类从模板类继承的时候，需要让编译器知道，父类的数据类型具体是什么(数据类型的本质：固定大小内存块的别名)

#include <iostream>
using namespace std;
template <typename T>
class A
{
public:
    A(T x) { t=x };
    void out()
    {
        cout << t <<endl;
    }   
protected:
    T t;     // 注意：如果是private 不能被子类使用
};

class B:public A<int>
{
public:
    B(int a, double x):A<int>(a)
    {
        y=x;
    }
    void out()
    {
        A<int>::out();
        cout << y << endl;
    }   
protected:
    double y;   
}

总之，模板类派生普通类，需要具体化父类，这样才能知道父类所占的内存的大小，只有数据类型固定下来，才知道如何分配类型。

模板类派生模板类

如果模板类派生模板类，这子类中必须要包含父类的类属，因为如果不包含父类的类属，则在定义具体化子类的时候，无法确定父类的类型。同时，子类的类属可以比父类多。

template <typename T>
class A{
public:
    A(T a=0)
    {
        this->a = a;
    }
public:
    void printA()
    {
        cout << "a=" << a << endl;
    }
protected:
    T a;
private:
//    T a; // 父类的私有成员不能被子类调用
};

// 模板类派生模板类
template <typename T, typename T1>
class C:public A<T>
{
public:
    C(T c, T a, T1 d):A<T>(a)
    {
        this->c = c;
        this->d = d;
    }
    // A<T>::a 不能是private
    void printC()
    {
        cout << "c=" << c << " a=" << A<T>::a << "d=" << d << endl;
    }
private:
    T c;
    T1 d;
};

int main()
{
    C<int, int> c(1, 2, 3);
    c.printC();
}

小结：上面的代码举例，所有的类的成员函数都写在类的内部。但是这样看起来不是很简洁。

---

类模板函数写在类的外部

注意：这里只记录类成员函数写在类外部，对于友元函数，目前没有需要，而且对于模板现在博主也用的不多，主要是了解些用得到的。

template<typename T>
class Complex
{
public:
    Complex(T a=0, T b=0);
    void printCom();
    Complex operator+(Complex &c2);
    virtual ~Complex()
    { }
    T a, b;
protected:

private:
};

// 对于函数实现,在书写的时候,只有函数返回值,函数参数列表
template <typename T>
Complex<T>::Complex(T a, T b)
{
    this->a = a;
    this->b = b;
}

template <typename T>
void Complex<T>::printCom()
{
    cout << "a=" << a << " b=" << b << endl;
}

// 注意：函数参数和返回值要具体化
// 成员函数实现+运算符重载
template <typename T>
Complex<T> Complex<T>::operator+(Complex<T> &c2)
{
    Complex tmp(a+c2.a, b+c2.b);
    return tmp;
}

int main()
{
    Complex<int> c1(1, 2);
    Complex<int> c2(3, 4);
    c1.printCom();

    Complex<int> c3 = c1 + c2;
    cout << c3 << endl;
    return 0;
}

注意：对于友元函数在Code Block中测试失败。对于类模板在源文件和头文件中分开下，下篇记录。

类模板中的static关键字

从类模板实例化的每个模板类有自己的类模板数据成员，该模板类的所有对象共享一个static数据成员。
和非模板的static数据成员一样，模板类的static数据成员也应该在文件范围内定义和初始化。

• 举例

template <typename T>
class A
{
public:
    static T m_a;
protected:
private:

};

// 注意：类中定义static类型的变量需要初始化,普通函数也是一样的
template <typename T>
T A<T>::m_a = 0;

int main()
{
    A<int> a1, a2, a3;
    a1.m_a = 11;
    a2.m_a = 22;
    a3.m_a = 33;

    cout << A<int>::m_a << endl;

    A<char> c1, c2, c3;
    c1.m_a = 'a';
    c2.m_a = 'b';
    c3.m_a = 'c';
    cout << A<char>::m_a << endl;

    cout << "Hello world!" << endl;
    return 0;
}

总结

感觉模板也不是那么神秘，工作一段时间，感觉就是要一步一步脚踏实地地走！自己还有很多东西都不懂，有时候工作不能只考虑代码，慢慢要有架构意识！但是如何才能学到架构这种层次的东西呢？会有视频吗？总有自己要开动脑筋的时候，但现在要好好打基础。
附上《传智播客扫地僧c++基础和进阶课堂讲义.docx》下载地址。