1.类模板
类模板的作用
使用类模板使用户可以为类声明一种模式，使得类中的某些数据成员、某些成员函数的参数、某些成员函数的返回值，能取任意类型（包括基本类型的和用户自定义类型）。
类模板的声明
类模板 template <模板参数表> class 类名 {类成员声明};
如果需要在类模板以外定义其成员函数，则要采用以下的形式： template <模板参数表> 类型名 类名<模板参数标识符列表>::函数名（参数表）
#include <iostream>
#include <cstdlib>
using namespace std;
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) {
// 将haveValue 置为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;
}运行结果：
2.整数集合类
实现整数集合类
要求：1、类中含两个私有变量，集合中元素的个数和集合中元素组成的数组。
2、用Set函数输入，Show函数输出结果（按从小到大的顺序输出各个元素）。
3、实现运算符+的重载，表示两个集合的并集。
实现运算符&的重载，表示两个集合的交集。
实现运算符-的重载，表示两个集合的差。
提示：1、集合中不可出现重复元素。
2、空集时，输出empty。
样例1
输入
3
1 2 3
4
1 2 5 6
输出
1 2 3 5 6
1 2
3
样例2
输入
3
1 2 3
3
1 2 3
输出
1 2 3
1 2 3
empty
#include <iostream>
using namespace std;
class Cassemblage {
private:
int num[1000];
int count;
public:
Cassemblage() : count(0) {};
void Set(int *c_num, int c_count);
Cassemblage operator+ (Cassemblage &c);
Cassemblage operator& (Cassemblage &c);
Cassemblage operator- (Cassemblage &c);
void Show();
};
void Cassemblage::Set(int *c_num, int c_count) {
// 初始对象
for (int i = 0; i < c_count; i++) {
if (count == 0) {
num[count++] = c_num[i];
} else {
int flag = 1;
for (int j = 0; j < count; j++) {
if (c_num[i] == num[j]) {
flag = 0;
continue;
}
}
if (flag) {
num[count++] = c_num[i];
}
}
}
// 对象元素排序
for (int i = 0; i < count; i++) {
for (int j = 1; j < (count - i); j++) {
if (num[j] < num[j-1]) {
int temp = num[j];
num[j] = num[j-1];
num[j-1] = temp;
}
}
}
}
Cassemblage Cassemblage::operator+ (Cassemblage &c) {
Cassemblage t;
int t_num[1000], t_count = 0;
for (int i = 0; i < count; i++) {
t_num[t_count++] = num[i];
}
for (int i = 0; i < c.count; i++) {
t_num[t_count++] = c.num[i];
}
t.Set(t_num, t_count);
return t;
}
Cassemblage Cassemblage::operator& (Cassemblage &c) {
Cassemblage t;
int t_num[1000], t_count = 0;
for (int i = 0; i < count; i++) {
for (int j = 0; j < c.count; j++) {
if(num[i] == c.num[j]) {
t_num[t_count++] = num[i];
}
}
}
t.Set(t_num, t_count);
return t;
}
Cassemblage Cassemblage::operator- (Cassemblage &c) {
Cassemblage t;
int t_num[1000], t_count = 0;
for (int i = 0; i < count; i++) {
int flag = 1;
for (int j = 0; j < c.count; j++) {
if(num[i] == c.num[j]) {
flag = 0;
}
}
if (flag) {
t_num[t_count++] = num[i];
}
}
t.Set(t_num, t_count);
return t;
}
void Cassemblage::Show() {
if (count != 0) {
for (int i = 0; i < count; i++) {
cout << num[i] << " ";
}
} else {
cout << "empty";
}
}
int main(int argc, char* argv[]) {
Cassemblage z1, z2, x1, x2, x3;
int i, n1, n2, a1[1000], a2[1000];
cin >> n1;
for(i=0; i<n1; i++) {
cin >> a1[i];
}
z1.Set(a1, n1);
cin >> n2;
for(i=0; i<n2; i++) {
cin >> a2[i];
}
z2.Set(a2, n2);
x1=z1+z2;
x1.Show();
cout << endl;
x2=z1&z2;
x2.Show();
cout << endl;
x3=z1-z2;
x3.Show();
return 0;
}运行结果：
3.复数集合类,模板结合
实现复数集合类
要求：1、实现两个类：集合类（Cassemblage ）和复数类（Cmycomplex）。
2、输入：分别输入集合中元素个数和元素（实部和虚部）。
3、输出：按照复数模的大小从小到大输出，不考虑两个复数模相等的情况。
当为空集时，输出empty。
对于复数虚部为负时，输出形如(1-1i)。
4、集合中不能出现相同元素。
5、实现集合的并（+）、交（&）、差（-）。
样例1：
输入
3
1 2
2 4
1 -1
4
1 3
2 4
2 2
1 2
输出
(1-1i) (1+2i) (2+2i) (1+3i) (2+4i)
(1+2i) (2+4i)
(1-1i)
样例2：
输入
3
1 2
2 4
3 2
3
1 2
2 4
3 2
输出
(1+2i) (3+2i) (2+4i)
(1+2i) (3+2i) (2+4i)
empty
#include <iostream>
#include <cmath>
using namespace std;
class Cmycomplex {
private:
double a;
double b;
public:
Cmycomplex(int c_a = 0, int c_b = 0) : a(c_a), b(c_b) {};
void Set(int c_a, int c_b);
double getA();
double getB();
friend istream& operator>> (istream& in, Cmycomplex& cc);
friend ostream& operator<< (ostream& out, const Cmycomplex& cc);
int operator== (Cmycomplex &cc);
};
void Cmycomplex::Set(int c_a, int c_b) {
a = c_a;
b = c_b;
}
double Cmycomplex::getA() {
return a;
}
double Cmycomplex::getB() {
return b;
}
istream& operator>> (istream& in, Cmycomplex& cc) {
in >> cc.a >> cc.b;
return in;
}
ostream& operator<< (ostream& out, const Cmycomplex& cc) {
if (cc.b < 0) {
out << "(" << cc.a << cc.b << "i)";
} else {
out << "(" << cc.a << "+" << cc.b << "i)";
}
return out;
}
int Cmycomplex::operator==(Cmycomplex &cc) {
if (a == cc.a && b == cc.b) {
return 1;
} else {
return 0;
}
}
template <class T>
class Cassemblage {
private:
T elem[1000];
int count;
public:
Cassemblage() : count(0) {};
void Set(T *c_elem, int c_count);
Cassemblage operator+ (Cassemblage &c);
Cassemblage operator& (Cassemblage &c);
Cassemblage operator- (Cassemblage &c);
void Show();
};
template <class T>
void Cassemblage<T>::Set(T *c_elem, int c_count) {
// 初始对象
for (int i = 0; i < c_count; i++) {
if (count == 0) {
elem[count++] = c_elem[i];
} else {
int flag = 1;
for (int j = 0; j < count; j++) {
if (c_elem[i] == elem[j]) {
flag = 0;
continue;
}
}
if (flag) {
elem[count++] = c_elem[i];
}
}
}
// 对象元素排序
for (int i = 0; i < count; i++) {
for (int j = 1; j < (count - i); j++) {
if ((elem[j].getA() * elem[j].getA() + elem[j].getB() * elem[j].getB()) < ((elem[j-1].getA() * elem[j-1].getA() + elem[j-1].getB() * elem[j-1].getB()))) {
T temp = elem[j];
elem[j] = elem[j-1];
elem[j-1] = temp;
}
}
}
}
template <class T>
Cassemblage<T> Cassemblage<T>::operator+ (Cassemblage &c) {
Cassemblage<T> t;
T t_elem[1000];
int t_count = 0;
for (int i = 0; i < count; i++) {
t_elem[t_count++] = elem[i];
}
for (int i = 0; i < c.count; i++) {
t_elem[t_count++] = c.elem[i];
}
t.Set(t_elem, t_count);
return t;
}
template <class T>
Cassemblage<T> Cassemblage<T>::operator& (Cassemblage &c) {
Cassemblage<T> t;
T t_elem[1000];
int t_count = 0;
for (int i = 0; i < count; i++) {
for (int j = 0; j < c.count; j++) {
if(elem[i] == c.elem[j]) {
t_elem[t_count++] = elem[i];
}
}
}
t.Set(t_elem, t_count);
return t;
}
template <class T>
Cassemblage<T> Cassemblage<T>::operator- (Cassemblage &c) {
Cassemblage<T> t;
T t_elem[1000];
int t_count = 0;
for (int i = 0; i < count; i++) {
int flag = 1;
for (int j = 0; j < c.count; j++) {
if(elem[i] == c.elem[j]) {
flag = 0;
}
}
if (flag) {
t_elem[t_count++] = elem[i];
}
}
t.Set(t_elem, t_count);
return t;
}
template <class T>
void Cassemblage<T>::Show() {
if (count != 0) {
for (int i = 0; i < count; i++) {
cout << elem[i] << " ";
}
} else {
cout << "empty";
}
}
int main() {
Cassemblage <Cmycomplex> z1, z2, x1, x2, x3;
int i, n1, n2;
Cmycomplex a1[1000], a2[1000];
cin >> n1;
for(i=0; i<n1; i++) {
cin >> a1[i];
}
z1.Set(a1, n1);
cin >> n2;
for(i=0; i<n2; i++) {
cin >> a2[i];
}
z2.Set(a2, n2);
x1=z1+z2;
x1.Show();
cout << endl;
x2=z1&z2;
x2.Show();
cout << endl;
x3=z1-z2;
x3.Show();
return 0;
}运行结果：
