***

一.クラステンプレート
クラステンプレートがインスタンス化された後のオブジェクトをテンプレートクラスと呼ぶ
1.クラステンプレート定義、クラステンプレート内のメンバー関数定義の場合、外部で定義されている場合は、クラステンプレートの説明を追加する必要があります.

#include
#include
using namespace std;
//    
template
T add(T a, T b)
{
	return a + b;
}
//   
template
class com
{
public:
	T a;
	T b;
	T add()
	{
		cout << typeid(T).name() << endl;
		return a + b;
	}
};

void main2()
{
	com c1;
	c1.a = 10;
	c1.b = 20;
	cout << c1.add() << endl;
	com ff;

	vector my;//      
	my.push_back(10);


	cin.get();
}
void main1()
{
	int sum;
	float ff;
	sum=add(1,2);
	ff = add(1.1, 2.0);
	cout <

2.クラステンプレートによる簡単なarrayコンテナ(コンテナの概念は後述するが、静的配列、定義時にタイプを指定する)

#pragma once
#include
template
//       
//template	 myarray<> my;
class myarry
{
public:
	myarry();
	~myarry();
};

#include
#include "myarry.h"
#include
#include
using namespace std;
template
myarry::myarry()
{
	cout << "  " << typeid(T).name() << endl;
}

template
myarry::~myarry()
{
}
void main()
{
	myarry my1;
}
void main5()
{
	array strarry = {"calc","notepad"};
	for (auto i : strarry)
	{
		cout << i.c_str() << endl;
	}

	cin.get();
}

3.クラステンプレートには複数のタイプが含まれています

#include
#include
using namespace std;
template
class myclass
{
public:
	T1 a;
	T2 b;
	myclass(T1 c,T2 d):a(c),b(d)
	{

	}
	void print()
	{
		cout << a << ' '<< b << endl;
	}
};
void main3()
{
	myclass my(10,20.8);
	my.print();
	myclass my1(10, "123456789");
	my1.print();
	cin.get();
}

4.クラステンプレートによるArray配列の実現
クラステンプレートが関数パラメータとして使用される場合、関数のパラメータはクラステンプレートまたはクラステンプレートの参照であり、対応するインスタンスはそのクラステンプレートがインスタンス化されたテンプレートクラスオブジェクトである

#pragma once
template //          
class Array
{
public:
	Array();
	//Array(int len);
	~Array();
	int size();//      
	T get(int num);//         
	void set(T data, int num);//     
	T& operator [](int num);//      
        void print(Array &myarray);
public:
	T *p;
	//int n;
};

//      
#include "Array.h"
#include
#include
using namespace std;
//template
//Array::Array()
//{
//	this->p = nullptr;
//	//this->n = 0;
//	 
//}
template//       
Array::Array()
{
	this->p = new T[n];
	//this->n = len;
}

template
Array::~Array()
{
	delete[] this->p;
	//this->n = 0;
}
template
int  Array::size()
{
	return n;//this->n ;
}
template
T Array::get(int num)
{
	if (num >= n || num < 0)
	{
		//   
		T *p(nullptr);
	}
	else
	{
		return this->p[num];//*(p+num)
	}
}
template
void Array::set(T data,int num)
{
	if (num >= n || num < 0)
	{
		//   
		T *p(nullptr);
	}
	else
	{
		this->p[num] = data;;//*(p+num)
	}
}

template
T&  Array::operator [](int num)
{
		  if (num >= n || num < 0)
		  {
			  //   
			  T *p(nullptr);
		  }
		  else
		  {
			 return this->p[num];//*(p+num)
		  }
}

template
void print(Array &myarray)//             
{
	for (int i = 0;i < myarray.size();i++)
	{
		myarray.set("hi", i);
		//cout << myarray.get(i) << endl;
		cout << myarray[i] << endl;
	}
}

void main()
{
	Array myarray;
	print(myarray);
	cin.get();
}
void main1()
{
	Array myarray;
	for (int i = 0;i < myarray.size();i++)
	{
		myarray.set("hi", i);
		//cout << myarray.get(i) << endl;
		cout << myarray[i]<< endl;
	}


	cin.get();

}

二.クラステンプレートの継承、クラス階層の特徴
クラステンプレートは継承時に明確なタイプでなければなりません
1.クラステンプレートは、テンプレートクラスから派生できます.
2.テンプレートクラスは、非テンプレートクラスから派生してもよい.
3.非テンプレートクラスはテンプレートクラスから派生し、テンプレートクラスはインスタンス化、転送タイプが必要である.
4.テンプレートクラスに虚関数を含めることができます.

#include
#include
using namespace std;
class A
{
public: 
	//virtual void print() final //    
	 void print()	                        //override     
	{
		cout << "A
";
	}
	 virtual void run()
	 {

	 }
};
class B:public A
{
public:
	void run() override// override              
	{

	}
	void print()
	{
		cout << "B
";
	}
};
//      
template
class C 
{
public:
	T x;
	C(T t) :x(t)
	{

	}
	void print()
	{
		cout << x<
class D :public C
{
public:
	T y;
	D(T t1, T t2) :C(t1), y(t2)
	{

	}
	void print()
	{
		cout < dd("aaa","ggggg");
	C *p = new D(1,2);
	p->run();//          
	cin.get();

}
void main2()
{
	D d1("hello", "world");
	d1.print();
	cin.get();
}
void main1()
{
	B b1;
	b1.print();
	cin.get();

}
//       
class xyz
{
public:
	int x;
	int y;
	int z;
	xyz()
	{
		x = y = z = 0;
	}
	void print()
	{
		cout << x << ' ' << y << ' ' << z << endl;
	}
};
template
class E :public xyz
{
public:
	T a;
	E(T t1) :a(t1)
	{

	}
	void print()
	{
		cout << "a=" <//  タイプ
{
public:
int ff=0;
F(int a, int b) :E(a), ff(b)
{
}
void print()
{
cout << ff << endl;
cout << "a=" << a << endl;
cout << x << ' ' << y << ' ' << z << endl;
}
};
void main4()
{
F f(1,2);
f.print();
cin.get();
}
void main3()
{
E e1("hahahhaha");
e1.print();
cin.get();
}