–

Templates eru partur af C++, fjölhæf og geta leyst vandamál varðandi endurnotkun klasa. Þessi grein byggir á eldri grein um skilgreiningu á röðun punkta, Punktar. Þar er tekið á almennri röðun punkta, hérna er sami klasi færður í Template form.

Ástæðan fyrir því að færa punktaklasa í þetta form er til að spara kóðunarvinnu ásamt því að koma með alhliða punktklasa. Hann þarf að vinna með tölur af mismunandi gerðum, td. integer eða float, og geta unnið með mismunandi gerðir af punktum í einni aðgerð.

Sem dæmi uppfylla:

(type float)Punktur != (type int)Punktur

Hugmyndin er að líkja eftir flestum eiginleikum punkta í stærðfræðinni, án þess að þurfa búa til nýjan klasa fyrir hverja gerð af tölum sem eru notaðar. Frá fyrri grein er punktur skilgreindur sem:

class Point {
public: 
	float x,y,z;
	
	// Operators ... +,-,*,==,!=,<,>
	//
	....
	};
Klasinn í template formi er skrifaður sem:

template< class T > class Point {
public: 
	T x,y,z;
	
	// Operators ... +,-,*,==,!=,<,>
	//
	....
	};
Síðan þarf að skilgreina operators betur, “minna en”( < ) og “jafnt og”( == ) verða:

bool Point::operator<( const Point<T> & rhs){
if( 
	(x > rhs.x) ||
	( (x == rhs.x) && (y > rhs.y) ) ||
	( (x == rhs.x) && (y == rhs.y) && (z > rhs.z) ) ||
	( (x == rhs.x) && (y == rhs.y) && (z == rhs.z) )
	) 
	return false;
return true;
};
bool Point::operator==( const Point<T> & rhs){
if( 
	(x == rhs.x) &&
	(y == rhs.y) &&
	(z == rhs.z)
	) 
	return false;
return true;
};
Aðferðirnar eru eins, burtséð frá sérhæfingunni T. Þegar forrit ætlar sér að líkja saman, klasa af mismunandi sérhæfingu, þarf það vita hvernig það gerist. Þá er hentugt að nota copy constructors, þar sem við getum ekki skilgreint hverja týpu í hverri aðferð(þeas. operator overloading). Þá eru copy constructors skilgreindir sem:
Point::Point( const Point<int> & rhs){ 
	x=rhs.x; y=rhs.y; z=rhs.z;
	};
Point::Point( const Point<float> & rhs){ 
	x=rhs.x; y=rhs.y; z=rhs.z;
	};
Það er hins vegar engin Point::Point( const Point<T> & rhs) skilgreindur, þar sem sérhæfingin er compile-time, þá myndi koma upp villukskilboð(Borland Compiler 5.5) um að týpan sé þegar skilgreind.
template< class T > class Point {
public: 
	// vars..
	Point::Point( const Point<T> & rhs);
	Point::Point( const Point<int> & rhs);
	Point::Point( const Point<float> & rhs);
	
	// other..
	};
// some main..
Point<double> DPoint; // Ok: no Point( const Point<double> & rhs);
Point<int> IPoint;   // Error: Already defined Point( const Point<int> & rhs);
Point<float> FPoint; // Error: Already defined Point( const Point<float> & rhs);
Að líkja saman punkta af mismunandi sérhæfingum er núna hægt, með copy constructor mun einn af punktunum vera færður í þá sérhæfingu sem hinn hefur, þeas: 
Point<int> IPoint;
Point<float> FPoint;
IPoint.x = 2;
FPoint.x = 2.5;
if( IPoint == FPoint ) // 2 == 2 -> true
	//... do something
Athuga skal að IPoint == FPoint er þýdd af þýðandanum sem:

operator==( IPoint, (Point<int>)FPoint )

eða

IPoint.operator==( (Point<int>)FPoint )

FPoint verður neyddur til int, og þar með verður FPoint.x að heiltöluinni 2. Þá verður if setningin sönn, punktarnir eru þeir “sömu” í heiltöluformi, ef FPoint == IPoint, þá væri if setningin fölsk, 2.5 == 2 -> false.

Frá þessu er hægt að gera ýmsar gerðir af punktur eða vektorum, sem geta leyst ekki einungis þrívíð vandamál, líka margvíð vandamál.

Kv. lain