类模板 示例代码

#ifndef ARRAY_CLASS
#define ARRAY_CLASS
#include <iostream>
#include <stdlib.h>
//数组类模板
template <class TA>
class Array
{
public:
	Array(int sz = 50);   //构造函数
	Array(const Array<TA>& A);   //拷贝构造函数
	~Array(void);   //析构函数
					//重载下标符"[ ]"，使Array对象可以起到C++普通数组的作用
	TA& operator[ ](int i);
private:
	TA*  a;  //TA类型指针，用于存放动态分配的数组内存首地址
	int size;   //数组大小（元素个数）
};
//以下为类成员函数的实现
// 构造函数
template <class TA>
Array<TA>::Array(int sz)
{
	size = sz;   // 将元素个数赋值给变量size
	a = new TA[size];    //动态分配size个TA类型的元素空间
}
// 析构函数
template <class TA>
Array<TA>::~Array(void)
{
	delete[] a;
}
// 拷贝构造函数
template <class TA>
Array<TA>::Array(const Array<TA>& X)
{
	//从对象X取得数组大小，并赋值给当前对象的成员
	int n = X.size;
	size = n;
	//为对象申请内存并进行出错检查
	a = new TA[n];    // 动态分配n个TA类型的元素空间
					  // 从对象X复制数组元素到本对象  
	TA* src = X.a;    // X.a是对象X的数组首地址
	TA* dest = a;     // a是本对象中的数组首地址
	while (n--)             // 逐个复制数组元素
		*dest++ = *src++;
}
// 重载下标操作符，实现与普通数组一样通过下标访问元素，并且具有越界检查功能
template <class TA>
TA& Array<TA>::operator[ ] (int n)
{
	// 检查下标是否越界
	if (n < 0 || n > size - 1)
	{
		cout << n << " is out_of_bound.\n";
		exit(1);
	}
	return a[n];   // 返回下标为n的数组元素
}
#endif  // ARRAY_CLASS
#pragma once

#include <iostream>
#include <stdlib.h>
#include "array.h"
using std::cout;
using std::endl;
int main()
{
	int i;
	//数组类模板Array实例化为int 型模板类，创建整型数组
	Array<int> intarr1(10);
	for (i = 0; i<10; i++)
		intarr1[i] = i + 3;   //数组元素作左值
	cout << "int array1:";
	for (i = 0; i<10; i++)
		cout << intarr1[i] << " ";  //返回元素值
	cout << endl;
	//数组类模板Array实例化为float型模板类，创建实型数组
	Array<double> douarr(8);
	for (i = 0; i<8; i++)
		douarr[i] = (double)(i + 1)*3.14;
	cout << "double array:";
	for (i = 0; i<8; i++)
		cout << douarr[i] << " ";
	cout << endl;
	//数组类模板Array实例化为int 型模板类，利用数组intarr1拷贝生成整型数组intarr2
	Array<int> intarr2(intarr1);
	cout << "int array2:";
	for (i = 0; i<10; i++)
		cout << intarr2[i] << " ";
	cout << endl;
	//下标越界检查
	intarr1[20] = 100;
	return 0;
}

/*类模板静态成员示例*/
#include <iostream>
using std::cout;
using std::endl;
template <class T>
class ClassA
{
public:
	T getValue()
	{
		return a;
	}
	void setValue(T val)
	{
		a = val;
	}
private:
	static T a;  //类模板静态成员a
};
int ClassA < int > ::a = 100;    //类模板静态成员a的初始化
char ClassA < char > ::a = 'Z';  //类模板静态成员a的初始化
int main()
{
	ClassA< int > ObjectInt1, ObjectInt2;
	ClassA< char > ObjectChar1, ObjectChar2;
	ObjectInt1.setValue(200);
	cout << ObjectInt2.getValue() << " , " << ObjectChar2.getValue();
	cout << endl;
	ObjectChar1.setValue('X');
	cout << ObjectInt2.getValue() << " , " << ObjectChar2.getValue();
	cout << endl;
	return 0;
}

/* 一个通用数组类模板友元的实例  */

/* 模板类的友元函数分为：约束（bound）友元函数 和 非约束（unbound）友元函数*/

#include <iostream>

using std::cout;
using std::endl;

template <typename T> class Array;
template <typename T> void Print(Array <T> & myarr);
template<class T1, class T2>
void ItoF (Array <T1> &Iarr, Array <T2> &Carr);


template <class T>
class Array    //通用数组类模板定义
{
public:
	Array(int s)   // 构造函数
	{
		size = s;
		elem = new T[size];    //分配数组空间
	}
	Array()
	{
		delete[]elem;
	}
	T& operator[] (int index)    //下标运算符[]重载函数
	{
		return elem[index];
	}
	// 未实例化友元函数模板声明
	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	friend void Print<>(Array <T> & myarr);
	// 实例化的友元函数模板声明
	friend void ItoF<>(Array <int> &Iarr, Array <char> &Carr);
private:
	T* elem;
	int size;
};
// 未实例化友元函数模板定义
template<class T>
void Print (Array <T> &myarr)
{
	for (int i = 0; i < myarr.size; i++)
		cout << myarr.elem[i] << "  ";
}
//void Print(Array <char> &myarr)
//{
//	for (int i = 0; i < myarr.size; i++)
//		cout << myarr.elem[i] << "  ";
//}
// 实例化的友元函数模板定义
template<class T1, class T2>
void ItoF (Array <T1> &Iarr, Array <T2> &Carr)
{
	Carr.size = Iarr.size;
	for (int i = 0; i < Iarr.size; i++)
		//强制类型转换，将T1类型的数组元素转换成为T2类型数组元素
		Carr.elem[i] = T2(Iarr.elem[i]);
}
int main()
{
	Array< int > arri(10);  // 生成 int类型模板类和创建int类型数组对象
	Array< char > arrc(10); // 生成 char类型模板类和创建char类型数组对象
	for (int i = 0; i < 10; i++)
		arri[i] = i + 65;
	Print(arri);  cout << endl;
	ItoF(arri, arrc);
	Print(arrc);  cout << endl;
	return 0;
}

// manyfrnd.cpp -- unbound template friend to a template class
#include <iostream>
using std::cout;
using std::endl;

template <typename T>
class ManyFriend
{
private:
    T item;
public:
    ManyFriend(const T & i) : item(i) {}
    template <typename C, typename D> friend void show2(C &, D &);
};

template <typename C, typename D> void show2(C & c, D & d)
{
    cout << c.item << ", " << d.item << endl;
}

int main()
{
    ManyFriend<int> hfi1(10);
    ManyFriend<int> hfi2(20);
    ManyFriend<double> hfdb(10.5);
    cout << "hfi1, hfi2: ";
    show2(hfi1, hfi2);
    cout << "hfdb, hfi2: ";
    show2(hfdb, hfi2);
    // std::cin.get();
    return 0;
}