十八、array 类

今后123

于 2024-08-28 21:13:31 发布

阅读量453

点赞数 17

分类专栏： C++ 文章标签： c++ 模板模板的特化

本文链接：https://blog.csdn.net/2301_79989168/article/details/141637562

版权

C++ 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Ⅰ . 非类型模板参数

01 什么是非类型模板参数？

STL 中的 array 就有一个非类型模板参数

注意看，我们普通定义的 T 是类型，而 N 这里并不是类型，而是一个常量

类型模板参数定义的是虚拟类型，注重的是你要传什么，而非类型模板参数定义的是变量

               "非类型模板参数"
                     👇
template<class T, size_t N> class array;
             👆    
        "类型模板参数"

02 非类型模板参数的使用场景

假设我们要定义一个静态栈：

#define N 100
 
template<class T> 
class Stack 
{
    private:
        int _arr[N];
        int _top;
};

那么我们如果想定义两个容量不同的栈，可以做到嘛？

这里无论 #define 改成 100 还是 500 都无法解决这里的问题

这里只能使用非类型模板参数来解决

代码实现：

template<class T, size_t N>
class Stack {
    private:
        int _arr[N];
        int _top;
};
 
int main() 
{
    Stack<int, 100> st1;     
    Stack<double, 500> st2;  
 
    return 0;
}

这里我们在模板这定义一个常量 N，于是我们就可以在实例化时去指定其实例化对象的大小了

这个 N 就是非类型模板参数

03 非类型模板参数不能修改

非类型模板参数是常量，是不能被修改的

template<class T, size_t N> 
class Stack {
    public:
        void f() {    // 修改常量试试看
            N = 10; 
        }
    private:
        int _arr[N];
        int _top;
};
 
int main()
{
    Stack<int, 100> st1;
    st1.f();
 
    return 0;
}

运行结果如下：

test1711.cpp:10:15: error: lvalue required as left operand of assignment
N = 10;

04 非类型模板参数类型规定

有些类型是不能作为非类型模板参数的，比如浮点数、类对象和字符串

非类型模板参数基本上都是整型

05 STL 中的 array

文档介绍：array - C++ Reference

我们现在再来看 array：

array 是 C++ 11 新增的，那么它有什么特别的地方嘛？

很可惜，基本没有

#include <iostream>
#include <array>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v1(100, 0);
    array<int, 100> a1;
    
    cout << "size of v1: " << sizeof(v1) << endl;
    cout << "size of a1: " << sizeof(a1) << endl;
 
    return 0;
}

运行结果如下：

vector 是开在堆上，而 array 是开在堆上

尴尬的是 array 能做的操作 vector 几乎都能做，array 也只是封装过的原生数组罢了

array<int, 100> a1;  // 封装过的原生数组
int a2[100];         // 原生数组

比起原生数组，array 的最大优势也只是越界的检擦，读和写都可以检查到是否越界

总结：array 相较于原生数组，有越界检查，实际中还是建议直接用 vector

Ⅱ . 模板的特化

01 给特殊类型准备特殊模板

通常情况下，使用模板可以实现一些与类型无关的代码

但对于一些特殊类型，我们需要一些特殊的处理

代码演示：

#include <iostream>
#include"Date.h"
using namespace std;

template<class T>
bool Less(T left, T right)
{
	return left < right;
}

int main()
{
	cout << Less(1, 2) << endl;

	Date d1(2024, 8, 28);
	Date d2(2024, 8, 29);
	cout << Less(d1, d2) << endl;

	Date* d3 = new Date(2024, 1, 1);
	Date* d4 = new Date(2024, 1, 2);
	cout << Less(d3, d4) << endl;

	return 0;
}

运行结果如下：每次运行的结果都不一样

问题出在没传指针，传 *d3 和 *d4 就能解决

但如果不让你传指针怎么办呢？

这里就需要用到模板的特化，针对特定的类型做特殊化处理

02 模板特化的步骤

首先，需要有一个基础的函数模板

其次，关键字 template 后面接上一堆空的尖括号 <>

然后，函数名后跟上一对尖括号，尖括号中指定需要特化的内容

最后，函数形参表必须要和模板函数的基础参数类型完全相同

代码实现：

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()
{
	cout << Less(1, 2) << endl;

	Date d1(2024, 8, 28);
	Date d2(2024, 8, 29);
	cout << Less(d1, d2) << endl;

	Date* d3 = new Date(2024, 1, 1);
	Date* d4 = new Date(2024, 1, 2);
	cout << Less(d3, d4) << endl;

	return 0;
}

运行结果如下：

对于普通类型，它还是会调用正常的模板，对于 Date* 编译器就会发现这里有一个专门为它准备的特化版本，编译器会优先选择该特化版本，这就是模板的特化

那如果我们直接加一个普通函数，会调用哪个呢？

template<class T>
bool Less(T left, T right)
{
	return left < right;
}

// 特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

// 普通
bool Less(Date* left, Date* right)
{
	return *left < *right;
}

函数重载，会直接调用普通函数的版本，因为是现成的，不需要实例化

03 类模板的特化

刚才的函数模板不一定要特化，可以写一个具体的函数

但类模板没法实现一个具体的实际类型，就必须要特化

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

int main()
{
	Date<int, int> d1;
	Date<int, double> d2;
	return 0;
}

这种情况就需要类模板的特化

代码实现：

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

// 类模板的特化
template<>
class Date<int, double>
{
public:
	Date()
	{
		cout << "Date<int, double>" << endl;
	}
};

int main()
{
	Date<int, int> d1;
	Date<int, double> d2;
	return 0;
}

运行结果如下：

04 全特化和半特化

全特化：将模板参数列表中的所有参数全都确定化

...
// 全特化
template<>
class Data<int, double> 
{
public:
	Data() {
		cout << "Data<int, double>" << endl;
	}
};

半特化（偏特化）：将部分参数列表中的一部分参数特化

...
// 半特化（偏特化）
template<class T1>
class Data<T1, char> 
{
public:
	Data() 
    {
		cout << "Data<T1, char>" << endl;
	}
};
 
int main()
{
	// 只要第二个值是 char 都会匹配到半特化
	Data<int, char> d3;
	Data<char, char> d4;
 
	return 0;
}

半特化还可以用来对参数进行进一步限制

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

int main()
{
	Date<int*, char*> d3;
	Date<char*, string*> d4;
	Date<char**, void*> d5;
	return 0;
}

运行结果如下：

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

int main()
{
	Date<int&, char&> d6;
	return 0;
}