.. _C++templates:

Templates and Containers
========================


- 
   Templates enable us to specify a range of related (overloaded)
   functions-called function-template specializations-or a range of
   related classes-called class-template specializations.

- 
   To use function-template specializations, the programmer writes a
   single function-template definition. Based on the argument types
   provided in calls to this function, C++ generates separate
   specializations to handle each type of call appropriately. These
   are compiled along with the rest of a program's source code.

- 
   All function-template definitions begin with the keyword template
   followed by formal type parameters to the function template
   enclosed in angle brackets ( and ); each formal type parameter must
   be preceded by keyword class or typename. Keywords class and
   typename used to specify function-template type parameters mean
   "any built-in type or user-defined type."

- 
   Template-definition formal type parameters are used to specify the
   kinds of arguments to the function, the return type of the function
   and to declare variables in the function.

- 
   The name of a formal type parameter can be used only once in the
   type-parameter list of a template header. Formal type-parameter
   names among function templates need not be unique.

- 
   A function template may be overloaded in several ways. We can
   provide other function templates that specify the same function
   name but different function parameters. A function template can
   also be overloaded by providing other non-template functions with
   the same function name, but different function parameters.

- 
   Class templates provide the means for describing a class
   generically and for instantiating classes that are type-specific
   versions of this generic class.

- 
   Class templates are called parameterized types; they require type
   parameters to specify how to customize a generic class template to
   form a specific class-template specialization.

- 
   The programmer who wishes to use class-template specializations
   writes one class template. When the programmer needs a new
   type-specific class, the programmer uses a concise notation, and
   the compiler writes the source code for the class-template
   specialization.

- 
   A class-template definition looks like a conventional class
   definition, except that it is preceded by template class T (or
   template typename T ) to indicate this is a class-template
   definition with type parameter T indicating the type of the class
   to create. The type T is mentioned throughout the class header and
   member-function definitions as a generic type name.

- 
   Member-function definitions outside a class template each begin
   with template class T (or template typename T ). Then, each
   function definition resembles a conventional function definition,
   except that the generic data in the class always is listed
   generically as type parameter T. The binary scope-resolution
   operator is used with the class-template name to tie each member
   function definition to the class template's scope.

- 
   It is possible to use nontype parameters in the header of a class
   template.

- 
   A class for a specific type can be provided to override the class
   template for that type.

- 
   A class template can be derived from a class-template
   specialization. A class template can be derived from a non-template
   class. A class-template specialization can be derived from a class
   template. A non-template class can be derived from a class
   template.

- 
   Functions and entire classes can be declared as friends of
   non-template classes. With class templates, the obvious kinds of
   friendship arrangements can be declared. Friendship can be
   established between a class template and a global function, a
   member function of another class (possibly a class-template
   specialization) or even an entire class (possibly a class-template
   specialization).

- 
   Each class-template specialization instantiated from a class
   template has its own copy of each static data member of the class
   template; all objects of that specialization share that static data
   member. And as with static data members of non-template classes,
   static data members of class-template specializations must be
   initialized at file scope.

- 
   Each class-template specialization gets a copy of the class
   template's static member functions.


STL
---

::

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    #include <iostream>
    #include <string>
    #include <list>
    #include <algorithm> // for copy
    
    using std::cout;
    using std::endl;
    using std::string;
    
    
    template < class T >
    void printList( const std::list< T > & listRef );
    
    #define INITSIZE 2
    
    char *ReadLine(char *, FILE *);
    
    int linesize;
    
    int main( int argc, char *argv[] )
    {
        char *line;
        FILE *fp;
        string *st;
        std::list< string > top;
    
        if( argc < 2 ) {
            fp = stdin;
        }
        else {
            if(( fp = fopen( argv[1], "r")) == NULL ) {
                fprintf(stderr,"Error: could not open file %s\n", argv[1]);
                exit(1);
            }
        }
        linesize = INITSIZE;
        if( (line = (char *)malloc(linesize*sizeof(char))) == NULL) {
            fprintf( stderr, "Memory Allocation error.\n" );
            exit(1);
        }
        /*
        * Read data from file and insert into linked list
        */
        while( (line = ReadLine(line, fp)) != NULL ) {
            st = new string( line );
            top.push_front( *st );
        }
    
        if( fp != stdin ) fclose( fp );
        /*
        * Sort the list
        */
        top.sort();
        /*
        * print the sorted file.
        */
        printList( top );
        return 0;
    }
    
    char *ReadLine(char *buff, FILE *fp)
    {
        int c, i;
    
        buff[0] = '\0';
        buff[linesize - 1] = '\0';             /* mark end of buffer */
    
        for( i = 0; ((c = fgetc(fp) ) != EOF) && (c != '\n'); i++ ) {
            if( i == linesize - 1 ) {
                linesize *= 2;
                if( (buff = (char *)realloc(buff, linesize*sizeof(char))) == NULL) {
                fprintf( stderr, "Memory Allocation error.\n" );
                exit(1);
                }
            }
            *(buff + i) = (char)c;
        }
        if( c == EOF && i == 0) return NULL;
        *(buff + i) = '\0';
        return buff;
    }
    
    template < class T >
    void printList( const std::list< T > & listRef )
    {
        if( listRef.empty () )
            cout << "List is empty";
        else {
            std::ostream_iterator< T > output( cout, "\n" );
            std::copy( listRef.begin(), listRef.end(), output );
        }
    }