C++ 语言类模板 (Class Template)

ゞ浴缸里的玫瑰 2022-09-03 15:14 163阅读 0赞

#  C++ 语言类模板 (Class Template) #

根据“`在定义变量时是否需要显式地指明数据类型`”可以将编程语言分为强类型语言和弱类型语言。

## 1. 强类型语言 ##

强类型语言在定义变量时需要显式地指明数据类型，并且一旦为变量指明了某种数据类型，该变量以后就不能赋予其他类型的数据了，除非经过强制类型转换或隐式类型转换。典型的强类型语言有 C/C++、Java 等。

int a = 100;
    a = (int)"http://c.biancheng.net"; // 强制转换 (得到字符串的地址)

## 2. 弱类型语言 ##

弱类型语言在定义变量时不需要显式地指明数据类型，编译器 (解释器) 会根据赋给变量的数据自动推导出类型，并且可以赋给变量不同类型的数据。典型的弱类型语言有 Python、Shell 等。

不管是强类型语言还是弱类型语言，在编译器 (解释器) 内部都有一个类型系统来维护变量的各种信息。

对于强类型的语言，变量的类型从始至终都是确定的、不变的，编译器在编译期间就能检测某个变量的操作是否正确，这样最终生成的程序中就不用再维护一套类型信息了，从而减少了内存的使用，加快了程序的运行。特殊情况是 C++ 中的多态。

对于弱类型的语言，变量的类型可以随时改变，赋予它什么类型的数据它就是什么类型，编译器在编译期间不好确定变量的类型，只有等到程序运行后、真的赋给变量一个值了，才能确定变量当前是什么类型，所以传统的编译对弱类型语言意义不大，因为即使编译了也有很多东西确定不下来。

弱类型语言往往是一边执行一边编译，这样可以根据上下文 (可以理解为当前的执行环境) 推导出很多有用信息，让编译更加高效。我们将这种一边执行一边编译的语言称为解释型语言，而将传统的先编译后执行的语言称为编译型语言。

强类型语言较为严谨，在编译时就能发现很多错误，适合开发大型的、系统级的、工业级的项目。弱类型语言较为灵活，编码效率高，部署容易，学习成本低。

模板所支持的类型是宽泛的，没有限制的，可以使用任意类型来替换，这种编程方式称为泛型编程。

C++ 模板也是被迫推出的，最直接的动力来源于对数据结构的封装。C++ 开发者们希望为线性表、链表、图、树等常见的数据结构都定义一个类，并把它们加入到标准库中，这样程序员直接拿来使用即可。但是这个时候遇到了一个无法解决的问题，就是数据结构中每份数据的类型无法提前预测。以链表为例，它的每个节点可以用来存储小数、整数、字符串等，也可以用来存储一名学生、教师、司机等。而 C++ 又是强类型的，数据的种类受到了严格的限制，这种矛盾是无法调和的。于是 C++ 模板技术就诞生了。

STL (Standard Template Library，标准模板库) 几乎都是使用模板来开发的。

## 3. 类模板 ##

函数模板中定义的类型参数可以用在函数声明和函数定义中，类模板中定义的类型参数也可以用在类声明和类实现中。类模板的目的同样是将数据的类型参数化。

声明类模板的语法为：

template<typename 类型参数1, typename 类型参数2, …>
    class 类名 {
    	// 语句
    };

类模板和函数模板都是以 `template` 开头 (也可以使用 `class`，它们没有任何区别)，后跟类型参数。类型参数不能为空，多个类型参数用逗号隔开。

一旦声明了类模板，就可以将类型参数用于类的成员函数和成员变量了。原来使用 int、float、char 等内置类型的地方，都可以用类型参数来代替。

定义一个类来表示坐标，要求坐标的数据类型可以是整数、小数和字符串。

x = 10、y = 10
    x = 12.88、y = 129.65
    x = "东经180度"、y = "北纬210度"

`x` 坐标和 `y` 坐标的数据类型不确定，借助类模板可以将数据类型参数化，这样就不必定义多个类了。**模板头和类头是一个整体，可以换行，但是中间不能有分号。**

上面的代码仅仅是类的声明，我们还需要在类外定义成员函数。在类外定义成员函数时，仍然需要带上模板头。

template<typename 类型参数1, typename 类型参数2, …>
    返回值类型 类名<类型参数1, 类型参数2, ...>::函数名(形参列表) {
    	// 语句
    }

**第一行是模板头，第二行是函数头，它们可以合并到一行，不过为了让代码格式更加清晰，一般是将它们分成两行。**

template<typename T1, typename T2>
    T1 Point<T1, T2>::getX() const {
    	return m_x;
    }
    
    template<typename T1, typename T2>
    void Point<T1, T2>::setX(T1 x) {
    	m_x = x;
    }
    
    template<typename T1, typename T2>
    T2 Point<T1, T2>::getY() const {
    	return m_y;
    }
    
    template<typename T1, typename T2>
    void Point<T1, T2>::setY(T2 y) {
    	m_y = y;
    }

类名 Point 后面也要带上类型参数，只是不加 typename 关键字。在类外定义成员函数时，template 后面的类型参数要和类声明时的一致。

## 4. 类模板创建对象 ##

使用类模板创建对象时，需要指明具体的数据类型。

Point<int, int> p1(5, 6);
    Point<int, float> p2(5, 6.6);
    Point<float, char*> p3(5.5, "东经 60 度");

**与函数模板不同的是，类模板在实例化时必须显式地指明数据类型，编译器不能根据给定的数据推演出数据类型。**

使用对象指针的方式来实例化。

Point<float, float> *p1 = new Point<float, float>(5.5, 6.6);
    Point<char*, char*> *p = new Point<char*, char*>("东经 5.5 度", "北纬 6.6 度");

需要注意的是，赋值号两边都要指明具体的数据类型，且要保持一致。

// 赋值号两边的数据类型不一致 - 错误写法
    Point<float, float> *p = new Point<float, int>(5.5, 2);
    // 赋值号右边没有指明数据类型 - 错误写法
    Point<float, float> *p = new Point(5.5, 2);

x = 5, y = 6
    x = 9, y = 东经 64 度
    x = 东经 64 度, y = 北纬 72 度
    请按任意键继续. . .

//============================================================================
    // Name        : Yongqiang Cheng
    // Author      : Yongqiang Cheng
    // Version     : Version 1.0.0
    // Copyright   : Copyright (c) 2020 Yongqiang Cheng
    // Description : Hello World in C++, Ansi-style
    //============================================================================
    
    #include <iostream>
    #include <cstring>
    
    using namespace std;
    
    template <class T>
    class CArray
    {
    	int size; // 数组元素的个数
    	T *ptr; // 指向动态分配的数组
    public:
    	CArray(const int s = 0);  // s 代表数组元素的个数
    	CArray(CArray &a);
    	~CArray();
    
    	void push_back(const T &v); // 用于在数组尾部添加一个元素 v
    	CArray & operator=(const CArray &a); // 用于数组对象间的赋值
    	T length() { return size; }
    	T & operator[](int i)
    	{
    		// 用以支持根据下标访问数组元素，如 a[i] = 4;
    		return ptr[i];
    	}
    };
    
    template<class T>
    CArray<T>::CArray(const int s) : size(s)
    {
    	if (0 == s) {
    		ptr = NULL;
    	}
    	else {
    		ptr = new T[s];
    	}
    }
    
    template<class T>
    CArray<T>::CArray(CArray &a)
    {
    	if (NULL == a.ptr) {
    		ptr = NULL;
    		size = 0;
    		return;
    	}
    
    	ptr = new T[a.size];
    	memcpy(ptr, a.ptr, sizeof(T) * a.size);
    	size = a.size;
    }
    
    template <class T>
    CArray<T>::~CArray()
    {
    	cout << "~CArray();" << endl;
    
    	if (ptr != NULL) {
    		delete[] ptr;
    	}
    }
    
    template <class T>
    CArray<T> & CArray<T>::operator=(const CArray &a)
    {
    	// 赋值号的作用是使 "=" 左边对象里存放的数组，大小和内容都和 "=" 右边的对象一样
    
    	// 防止 a = a 这样的赋值导致出错
    	if (this == &a) {
    		return *this;
    	}
    
    	// 如果 a 里面的数组是空的
    	if (NULL == a.ptr) {
    		if (ptr != NULL) {
    			delete[] ptr;
    		}
    		ptr = NULL;
    		size = 0;
    
    		return *this;
    	}
    
    	// 如果原有空间够大，就不用分配新的空间
    	if (size < a.size) {
    		if (ptr != NULL) {
    			delete[] ptr;
    		}
    		ptr = new T[a.size];
    	}
    
    	memcpy(ptr, a.ptr, sizeof(T) * a.size);
    	size = a.size;
    
    	return *this;
    }
    
    template <class T>
    void CArray<T>::push_back(const T &v)
    {
    	// 在数组尾部添加一个元素
    	if (ptr != NULL) {
    		T *tmp_ptr = new T[size + 1]; // 重新分配空间
    		memcpy(tmp_ptr, ptr, sizeof(T) * size); // 拷贝原数组内容
    		delete[]ptr;
    		ptr = tmp_ptr;
    	}
    	else {
    		// 数组本来是空的
    		ptr = new T[1];
    	}
    
    	ptr[size++] = v; // 加入新的数组元素
    }
    
    int main()
    {
    	CArray<int> obj;
    
    	for (int i = 0; i < 5; ++i) {
    		obj.push_back(i);
    	}
    
    	for (int i = 0; i < obj.length(); ++i) {
    		cout << obj[i] << " ";
    	}
    	cout << endl;
    
    	return 0;
    }

0 1 2 3 4
    ~CArray();
    请按任意键继续. . .

## References ##

[http://c.biancheng.net/][http_c.biancheng.net]

[http_c.biancheng.net]: http://c.biancheng.net/