Object Oriented Programming

Templates

?template
:swap '
void swap(int &v1, int &v2) {
int t = v1;
v1 = v2;
v2 = t;
}

?? double sawp
void swap(double &v1, double &v2) {
double t = v1;
v1 = v2;
v2 = t;
}

 ?template
(
)?
:

>template<class T
{ )void swap (T &v1, T &v2
;T t = v1
;v1 = v2
;v2 = t


LL = Linked List
:LL
LL int
LL double

C++- :
LL
Node LL-
Node-

?
:
Integer : public Node
Double : public Node
Node

Integer

Double

 ?
( )int, double
( LL - )

:
heap-
stack
' Node-

 template



(
hiding ,RTTI-')
,Node , '

:casting-


template
: .

exe-
:
, >LL<int

LL-
: / ."
( template- )
, :LL ,
, ..


:)C (4
void printChar (char i)
{cout << i <<endl;}
void printInt (int i)
{cout << i <<endl;}
void printDouble (double i) {cout << i <<endl;}
void printString (string i) {cout << i <<endl;}
,


:)C++ (function overloading-
void print (char i) { cout << i << endl; }
void print (int i)
{ cout << i << endl; }
void print (double i) { cout << i << endl; }
void print (string i) { cout << i << endl; }


:template '
template <typename T>
void print (T i) {
cout << i << endl;
}
main
print(2);
print(2.2);
print("6.6");

* - RTTI
*
template <typename T>
void print (T i) {
cout << typeid(T).name() << i << endl;
}
Main Implicit:
print(49);
print(2.2);
print("6.6");
Output:
int 49
double 2.2
char const * 6.6

Main Explicit:
print<char>(49);
print<long>(2.2);
print<void *>("6.6");
Output:
char 1
long 2
void * 00117800

template<class T>
void swap (T &v1, T &v2) {
T t = v1;
v1 = v2;
v2 = t;

}
template< typename U>
void swap (U &u1, U &u2) {
U u = u1;
u1 = u2;
u2 = u;

?
Compilation Error:
error C2995:
'void swap (T &,T &)'
: function template
has already been
defined

Function Template & Class Template

Function Template
' template-

Class Template
Class template-

template class example

template <class T>
class A1 {
private:
T _val;
public:
A1(T val) : _val(val) {}
T getVal() { return _val; }
};
void main() {
A1<double> d(5.5);
A1<int> i(3);
}

:
A1<double> d(5.5);
: ,
class A1<double> {
private: double _val;
public:
A1(double val) : _val(val) {}
double getVal() { return _val; }
};
:
A1<int> i(3);
: ,
class A1<int> {
private: int _val;
public:
A1(int val) : _val(val) {}
int getVal() { return _val; }
};

default type
template <typename T1,
typename T2=float,
int i=1o>
class AClass { }
AClass<int, double, 100> c1;
AClass<double, string> c2;
AClass<long> c3;
AClass<double, float, 5> c4;

// specific all types

// omit last type
// use all defaults
// must specify T2 to set
// the last type

 type-

template <typename T, T V>

class AClass {
public:
void foo() { cout << V << endl;
};

AClass<int, 7>
c1; c1.foo(); // 7
AClass<char, 'x'> c2; c2.foo(); // x
AClass<char, 49.2> c3; c3.foo(); // 1

 type
>template <typename T
)void foo1(LinkedList<T*> ll
}{...
foo1 T-
>template <typename T
)void foo2(LinkedList<LinkedList<T>* > list
}{...
foo2
T

template's code outside of class

A1.h

template <class T>

class A1 {
private:
T _val;
public:
A1(T val) : _val(val) {}
T getVal();
};
template <class T>
T A1<T>::getVal() { return _val; }
"" , .H
.H , , , ,

?member '

template <typename T>

class AClass{
public:
void print(T* p){ p->print(); }
};
void main() {
AClass<int>
c1;
AClass<double> c2;
double d=3;
c2.print(&d);
}

// compilation OK
// compilation OK
// Compilation Error:
// Member function
// is instantiated only if called

Template Specialization
// General Template
template <class T>
class AClass{
public:
void print(T &p)
{cout<<"G- "<< p; }
};
AClass<double> e;
double d = 2.2;
e.print(d);
// output: G- 2.2

// Specialization Class
template <>
class AClass <char> {
public:
void print(char &p)
{cout<<"S- "<<p-'A'; }
};
AClass<char> a;
char c = 'C';
a.print(c);
// output: S- 2

Template Specialization
// General Template
template <class T> bool less (const T &t1, const T &t2)
{cout<< "in #1\n"; return t1<t2;}
// Specialization Class
template <> bool less <const char*> (const char* s1,
const char* s2)
{ cout<< "in #2\n"; return strcmp(s1, s2)<0; }

less (1, 2) ;
less (101.2, 23.2);
less ("C++", "Java");
less ('C', 4);

in #1: 1
in #1: 0
in #2: 1
Compilation Error

Template Specialization
// More General Template
template <class T, class U> bool less (T t1, U u2)
{cout<< "in #0\n";return t1<u2;}
// General Template
template <class T> bool less (T t1, T t2)
{cout<< "in #1\n"; return t1<t2;}
// Specialization Class
template <> bool less <const char*> (const char* s1,
const char* s2)
{ cout<< "in #2\n"; return strcmp(s1, s2)<0; }

less ('C', 4);

#0: 0

Template Specialization
- VC++
:g++
Specialization' ( class
') VC- g++-
:
Template +
' " Template"
inline' specialization-

Calculate 2 power at compile time

template <int N>
class Power2 {
public:
enum {
val = 2*Power2<N-1>::val };
};

template <>
class Power2<0> {
public:
enum { val = 1 };
};

Main:
// == 2^3 = 8
Power2<3>::val;
// == 2^0 = 1
Power2<0>::val;
// == 2^-1 = ???
Power2<-1>::val;

 -Template
"" , ==
!= :

template <class T>

inline bool operator != (const T& x, const T& y) {
return !(x == y);
}

 -Template

"" , <
=> ,=< ,< :

template <class T>

inline bool operator >(const T& x, const T& y)
{ return y < x; }
template <class T>
inline bool operator <=(const T& x, const T& y)
{ return !(y < x); }

template <class T>

inline bool operator >=(const T& x, const T& y)
{ return !(x < y); }

-Template

" template-
:
... ,int, double, object :
- " template-
: ,-
... ,int, double, object :

STL ..
()Standard Template Library