Computer Notes - Resolution Order

8/3/2019 Computer Notes - Resolution Order

1/33

Resolution Order

http://ecomputernotes.com


2/33

Resolution Order

template< typename T >class Vector { };

template< typename T >class Vector< T* > { };

template< >

class Vector< char* > { };



3/33

Resolution Order

Compiler searches a complete specialization

whose type matches exactly with that ofdeclaration

If it fails then it searches for some partialspecialization

In the end it searches for some generaltemplate



4/33

Example Resolution Orderint main() {

Vector< char* > strVector;

// Vector< char* > instantiated

Vector< int* > iPtrVector;// Vector< T* > instantiated

Vector< int > intVector;// Vector< T > instantiated

return 0;

} http://ecomputernotes.com


5/33

Function Template Overloadingtemplate< typename T >

void sort( T );

template< typename T >

void sort( Vector< T > & );

template< >

void sort< Vector >(

Vector< char* > & );

void sort( char* );



6/33

Resolution Order

Compiler searches target of a function call in

the following order

Ordinary Function

Complete Specialization

Partial Specialization Generic Template



7/33

Example Resolution Order

int main() {

char* str = Hello World!;

sort(str); // sort( char* )

Vector v1 = {ab, cd, };

sort(v1); //sort( Vector & )



8/33

Example Resolution Order

Vector v2 = { 5, 10, 15, 20 };sort(v2); // sort( Vector &)

int iArray[] = { 5, 2, 6 , 70 };sort(iArray); // sort( T )

return 0;

}



9/33

Templates and Inheritance

We can use inheritance comfortably with

templates or their specializations

But we must follow one rule:

Derived class must take at least as many

template parameters as the base class

requires for an instantiation



10/33

Derivations of a Template

A class template may inherit from another

class template

template< class T >

class A{ };

template< class T >

class B : public A< T >

{ };



11/33


int main() {

A< int > obj1;

B< int > obj2;

return 0;

}



12/33


A partial specialization may inherit from a

class template

template< class T >

class B< T* > : public A< T >

{ };



13/33


int main() {

A< int > obj1;

B< int* > obj2;

return 0;

}



14/33

Derivations of a Template Complete specialization or ordinary class

cannot inherit from a class template

template< >

class B< char* > : public A< T >{ }; // Error: T undefined

class B : public A< T >

{ }; // Error: T undefined



15/33

Derivations of a Partial Sp. A class template may inherit from a partial

specialization

template< class T >

class A{ };

template< class T >

class A< T* >

{ };



16/33

Derivations of a Partial Sp.template< class T >

class B : public A< T* >{ }

int main() {A< int* > obj1;

B< int > obj2;

return 0;}



17/33

Derivations of a Partial Sp.

A partial specialization may inherit from a

partial specialization

template< class T >

class B< T* > : public A< T* >

{ };



18/33

Derivations of a Partial Sp.

int main() {A< int* > obj1;

B< int* > obj2;

return 0;

}



19/33

Derivations of a Partial Sp. Complete specialization or ordinary class

cannot inherit from a partial specialization

template< >

class B< int* > : public A< T* >{ } // Error: Undefined T

class B : public A< T* >{ } // Error: Undefined T



20/33

Derivations of a Complete Sp.

A class template may inherit from a complete

specialization

template< class T > class A{ };

template< >

class A< float* >

{ };



21/33

Derivations of a Complete Sp.template< class T >

class B : public A< float* >{ };

int main() {

A< float* > obj1;

B< int > obj2;

return 0;

}



22/33


A partial specialization may inherit from acomplete specialization

template< class T >

class B< T* > : public A< float* >

{ };



23/33


int main() {A< float* > obj1;

B< int* > obj2;

return 0;

}



24/33


A complete specialization may inherit from acomplete specialization

template< >

class B< double* > :

public A< float* >{ };



25/33



B< double* > obj2;

return 0;

}



26/33


An ordinary class may inherit from a completespecialization

class B : public A< float* >

{ };



27/33



B obj2;

return 0;

}



28/33

Derivations of Ordinary Class

A class template may inherit from an ordinary

class

class A{ };

template< class T >class B : public A

{ }; http://ecomputernotes.com


29/33


int main() {A obj1;

B< int > obj2;

return 0;

}



30/33


A partial specialization may inherit from anordinary class

template< class T >

class B< T* > : public A

{ };



31/33


int main() {A obj1;

B< int* > obj2;

return 0;

}



32/33


A complete specialization may inherit from anordinary class

template< >

class B< char* > : public A

{ };



33/33


int main() {A obj1;

B< char* > obj2;

return 0;

}


Date post:	06-Apr-2018
Category:	Documents
Upload:	ecomputernotes
View:	222 times
Download:	0 times

Computer Notes - Resolution Order

Documents