《C++语言程序设计基础》学习之模板与群体数据

函数模板：
如果重载的函数，其解决问题的逻辑是一致的、函数体语句相同，只是处理的数据类型不同，那么写多个相同的函数体，是重复劳动，而且还可能因为代码的冗余造成不一致性。

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;
}

《C++语言程序设计基础》学习之模板与群体数据

猜你喜欢