#include <iostream.h> /* テンプレート化関数 */
template < class t1 > void disp ( t1 x ) { cout << x << endl; }
void main()
{ char s[20]={"ABC"};
  disp(s);             // 文字列のポインタで呼び出します。
  disp('a');           // 文字で呼び出します。
  disp(5);             // 整数で呼び出します。
  int xx; cin >> xx;
}

#include <iostream.h> /* テンプレート化クラス(クラスの中に定義 １) */
template < class t1, int x > class C1    // クラス C2
{ public: t1 s[x];         // データメンバ
          // オブジェクトの宣言時に、t1 → char 、x → 5 になります。
          C1()             // デフォルトコンストラクタ
          { s[0]='A';s[1]='B';s[2]='C';s[3]='\0'; }
};
void main()
{ C1 <char,5> OB;          // クラス C1 のオブジェクト OB1 を宣言
  // コンストラクタ C1 は、int 5 を受け取ることができます。
  cout << OB.s << endl;    // s[5]="ABC" になっているかどうか確認　
  int q; cin >> q;
}

#include <iostream.h> /* テンプレート化クラス(クラスの中に定義 ２) */
template < class t1, class t2 > class C1    // クラス C1
{ public: t1 a; t2 b; t2 c;                  // データメンバ
          void set(t1 i, t2 j) { a=i; b=j; } // メンバ関数
          C1(t2 k) { c=k; }                  // コンストラクタ
};
void main()
{ C1 <int,char> OB( 'C');    // クラス C1 のオブジェクト OB1 を宣言
  OB.set(5, 'B');            // メンバ関数で代入 OB.a=5 OB.b='B'
  cout << OB.a << OB.b << OB.c << endl; // 確認　　5 B C
  int q; cin >> q;
}

template <class t1,class t2,int x>      C1<t1,t2,x>::C1( t1 a, int b)
{ A=a; B=b; }
template <class t1,class t2,int x> void C1<t1,t2,x>::func1( t2 c )
{ C=c; }
template <class t1,class t2,int x> void C1<t1,t2,x>::func2( int d )
{ D=d;}
// int x は、コンストラクタが、(引数)とは別に受け取ることができる変数です。　

template <class t1,class t2,int x>      C1<t1,t2,x>::C1( t1 a, int b)
{ A=a; B=b; }
template <class t1,class t2,int x> void C1<t1,t2,x>::func1( t2 c )
{ C=c;}
template <class t1,class t2,int x> void C1<int,int,5>::func1( t2 c )
{ C=c+c; }
template < class t1, class t2 > void C1<int, char>::func2( int d )
{ D=d;}
// t1,t2,x を <int,int,5> にして宣言したオブジェクトに対しては、
// func1() は、二番目の func1() が働きます。
// この機能は、メンバ関数の定義をクラスの外に書く場合だけ、使用できるようです。

template<class t1,class t2,int x> inline      C1<t1,t2,x>::C1( t1 a, int b)
{ A=a; B=b; }
template<class t1,class t2,int x> inline void C1<t1,t2,x>::func1( t2 c )
{ C=c; }
template<class t1,class t2,int x> inline void C1<t1,t2,x>::func2( int d )
{ D=d;}
template<class t1,class t2,int x> void inline C1<t1,t2,x>::func2( int d )
{ D=d;}

#include <iostream.h> /* テンプレート化クラス(クラスの外に定義) */
template <class t1,class t2,int x> class C1      // クラス C1
{ public : int X; int A; t1 B; t2 C; char D;     // メンバデータ
               C1<t1,t2,x>::C1( t1 a, int b);     // コンストラクタ
          void C1<t1,t2,x>::func1( t2 c );        // メンバ関数
          void C1<t1,t2,x>::func2( int d );
};
template <class t1,class t2,int x>      C1<t1,t2,x>::C1( t1 a, int b)
{ A=a; B=b; X=x; }
template <class t1,class t2,int x> void C1<t1,t2,x>::func1( t2 c )
{ C=c; }
template <class t1,class t2,int x> void C1<int,int,x>::func1( t2 c )
{ C=c; X=X+2; }
template <class t1,class t2,int x> void C1<t1,t2,x>::func2( int d )
{ D=d;}

void main()
{ // オブジェクト作成 ⇒  int X=0; int A=1; int B=2; char C; char D;
  C1<int,char,0> OB(1,2);           // クラス C1 のオブジェクト OB1 を宣言
  OB.func1( 'C' ); // OB.C='C'
  OB.func2( 'D' ); // OB.D='D'
  cout << OB.X << OB.A << OB.B << OB.C << OB.D << endl; // 確認　0 1 2 C D
  // 別なオブジェクト ⇒  int X=5; int A=1; int B=2; int C; char D;
  C1<int,int,5> Ob(1,2);            // クラス C1 のオブジェクト OB1 を宣言
  Ob.func1( 3 );   // OB.C=3 X=X+2 
  Ob.func2( 'D' ); // OB.D='D'
  cout << Ob.X << Ob.A << Ob.B << Ob.C << Ob.D << endl; // 確認　7 1 2 3 D
  int q; cin >> q;
}