函数模板:
如果重载的函数,其解决问题的逻辑是一致的、函数体语句相同,只是处理的数据类型不同,那么写多个相同的函数体,是重复劳动,而且还可能因为代码的冗余造成不一致性。
template<typename T>
T abs(T x) {
return x < 0 ? -x : x;
}
int main(){
int n = -5;//编译器根据实参的类型推导出模板T的类型
double d = -5.5;
cout << abs(n) << endl;
cout << abs(d) << endl;
return 0;
}
函数模板定义语法:语法形式: template <模板参数表>
函数定义:
模板参数表的内容:类型参数:class(或typename) 标识符,常量参数:类型说明符 标识符,模板参数:template <参数表> class标识符
注意:一个函数模板并非自动可以处理所有类型的数据;只有能够进行函数模板中运算的类型,可以作为类型实参;自定义的类,需要重载模板中的运算符,才能作为类型实参。
template <class T> //定义函数模板
void outputArray(const T*array, int count) {
for (int i = 0; i < count; i++)
//如果数组元素是类的对象,需要该对象所属类重载了流插入运算符“<<”
cout << array[i] << " ";
cout << endl;
}
int main(){
const int A_COUNT = 9, B_COUNT = 9, C_COUNT = 10;
int a[A_COUNT] = { 1,2,3,4,5,6,7,8,9 };
double b[B_COUNT] = { 1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9 };
char c[C_COUNT] = "Welcome!";
cout << " a array contains: " << endl;
outputArray(a, A_COUNT);
cout << " b array contains: " << endl;
outputArray(b, B_COUNT);
cout << " c array contains: " << endl;
outputArray(c, C_COUNT);
return 0;
}
类模板:
类模板的作用:使用类模板使用户可以为类声明一种模式,使得类中的某些数据成员、某些成员函数的参数、某些成员函数的返回值,能取任意类型(包括基本类型的和用户自定义类型)。
类模板的声明:类模板 template <模板参数表> class 类名 {类成员声明};如果需要在类模板以外定义其成员函数,则要采用以下的形式:
template <模板参数表>
类型名 类名<模板参数标识符列表>::函数名(参数表)
struct Student {
int id; //学号
float gpa;//平均分
};
template <class T>
class Store {//类模板:实现对任意类型数据进行存取
private:
T item;//item用于存放任意类型的数据
bool haveValue;//haveValue标记item是否已被存入内容
public:
Store();
T &getElem();//提取数据函数
void putElem(const T&x);//存入数据函数
};
template<class T>
Store<T>::Store() :haveValue(false) {}
template<class T>
T &Store<T>::getElem() {
//如试图提取未初始化的数据,则终止程序
if (!haveValue) {
cout << "No item present!" << endl;
exit(1);//使程序完全退出,返回到操作系统。
}
return item;//返回item中存放的数据
}
template<class T>
void Store<T>::putElem(const T&x) {
//将havaValue置为true,表示item中已存入数值
haveValue = true;
item = x;//将x值存入item
}
int main() {
Store<int> s1, s2;
s1.putElem(3);
s2.putElem(-7);
cout << s1.getElem() << " " << s2.getElem() << endl;
Student g = { 1000,23 };
Store<Student> s3;
s3.putElem(g);
cout << "The student id is " << s3.getElem().id << endl;
Store<double> d;
cout << "Retrieving object D... ";
cout << d.getElem() << endl;
//d未初始化,执行函数D.getElement()时导致程序终止
return 0;
}
数组类模板:
静态数组是具有固定元素个数的群体,其中的元素可以通过下标直接访问。缺点:大小在编译时就已经确定,在运行时无法修改。
动态数组由一系列位置连续的,任意数量相同类型的元素组成。优点:其元素个数可在程序运行时改变。
vector就是用类模板实现的动态数组。
Array.h
#pragma once
#ifndef ARRAY_H
#define ARRAY_H
#include<cassert>
template<class T> //数组类模板定义
class Array{
private:
T* list; //用于存放动态分配的数组内存首地址
int size; //数组大小(元素个数)
public:
Array(int sz = 50);//构造函数
Array(const Array<T> &a);//复制构造函数
~Array();//析构函数
Array<T>& operator =(const Array<T> &rhs);//重载“=”
T & operator [](int i);//重载“[]”
const T & operator [](int i) const;//重载“[]”常函数
operator T *();//重载到T*类型的转换,对象转数组指针
operator const T * ()const;
int getSize() const;//取数组的大小
void resize(int sz);//修改数组的大小
};
template<class T>
Array<T>::Array(int sz) {//构造函数
assert(sz >= 0);//sz为数组大小(元素个数),应当非负
size = sz;//将元素个数赋值给变量size
list = new T[size];//动态分配size个T类型的元素空间
}
template<class T>
Array<T>::~Array(){//析构函数
delete[] list;
}
template<class T>
Array<T>::Array(const Array<T> &a) {//复制构造函数
size = a.size;//从对象x取得数组大小,并赋值给当前对象的成员
list = new T[size];//动态分配n个T类型的元素空间
for (int i = 0; i < size; i++)//从对象x复制数组元素到本对象
list[i] = a.list[i];
}
//重载“=”运算符,将对象rhs赋值给本对象,实现对象之间的整体赋值
template<class T>
Array<T> &Array<T>::operator =(const Array<T>& rhs) {
if (&rhs != this) {//判断地址是否相同
//如果本对象中数组大小与rhs不同,则删除数组原有内存,然后重新分配
if (size != rhs.size) {
delete[] list;//删除数组原有内存
size = rhs.size;//设置本对象的数组大小
list = new T[size];//重新分配size个元素的内存
}
//从对象X复制数组元素到本对象
for (int i = 0; i < size; i++)
list[i] = rhs.list[i];
}
return *this;//返回当前对象的引用
}
//重载下标运算符,实现与普通数组一样通过下标访问元素,具有越界检查功能
template<class T>
T &Array<T>::operator[](int n) {
assert(n >= 0 && n < size);//检查下标是否越界
return list[n]; //返回下标为n的数组元素
}
template<class T>
const T &Array<T>::operator[](int n) const {
assert(n >= 0 && n < size);//检查下标是否越界
return list[n]; //返回下标为n的数组元素
}
//重载指针转换运算符,将Array类的对象名转换为T类型的指针
template<class T>
Array<T>::operator T *() {
return list; //返回当前对象中私有数组的首地址
}
//取当前数组的大小
template<class T>
int Array<T>::getSize()const {
return size;
}
template<class T>
void Array<T>::resize(int sz) {
assert(sz >= 0);//检查sz是否非负
if (sz == size)//如果指定的大小与原有大小一样,pass
return;
T* newList = new T[sz];//申请新的数组内存
int n = (sz < size) ? sz : size;//将sz与size中较小的一个赋值给n
//将原有数组中前n个元素复制到新数组中
for (int i = 0; i < n; i++)
newList[i] = list[i];
delete[] list;//删除原数组
list = newList;//使list指向新数组
size = sz;
}
#endif // !ARRAY_H
有的函数返回引用:如果一个函数的返回值是一个对象的值,就是右值,不能成为左值。如果返回值为引用。由于引用是对象的别名,通过引用可以改变对象的值,因此是左值。
main.cpp
#include "pch.h"
#include <iostream>
#include"Array.h"
using namespace std;
void read(int *p, int n) {
for (int i = 0; i < n; i++)
cin >> p[i];
}
int main(){
//int a[10];
//read(a, 10);
Array<int> a(10);
read(a, 10);
return 0;
}
求范围2~N中的质数,N在程序运行时由键盘输入:
#include "pch.h"
#include <iostream>
#include<iomanip>
#include"Array.h"
using namespace std;
void read(int *p, int n) {
for (int i = 0; i < n; i++)
cin >> p[i];
}
int main() {
//用来存放质数的数组,初始状态有10个元素
Array<int>a(10);
int n, count = 0;
cout << "Enter a value >=2 as upper limit for prime numbers: ";
cin >> n;
for (int i = 2; i <= n; i++) {//检查i 是否能被比它小的质数整除
bool isPrime = true;
for (int j=0;j<count;j++)
if (i%a[j] == 0) {
isPrime = false; break;
}
if (isPrime) {
if (count == a.getSize())
a.resize(count * 2);
a[count++] = i;
}
}
for (int i = 0; i < count; i++)
cout << setw(8) << a[i];
cout << endl;
return 0;
}