c++ primer笔记12

1. Member Templates

Any class (template or otherwise) may have a member that is itself a class or function template. Such members are referred to as member templates. One example of a member template is the assign member of the standard containers. The version assign that takes two iterators uses a template parameter to represent the type of its iterator parameters. Another member template example is the container constructor that takes two iterators. This constructor and the assign member allow containers to be built from sequences of different but compatible element types and/or different container types.

Consider the Queue copy constructor: It takes a single parameter that is a reference to a Queue . If we wanted to create a Queue by copying elements from a vector, we could not do so; there is no conversion from vector to Queue . Similarly, if we wanted to copy elements from a Queue into a Queue, we could not do so. Again, even though we can convert a short
to an int , there is no conversion from Queue to Queue. The same logic applies to the Queue assignment operator, which also takes a parameter of type Queue&.

The problem is that the copy constructor and assignment operator fix both the container and element type. We’d like to define a constructor and an assign member that allow both the container and element type to vary. When we need a parameter type to vary, we need to define a function template. In this case, we’ll define the constructor and assign member to take a pair ofiterators that denote a range in some other sequence. These functions will have a single template type parameter that represents an iterator type.

2. Defining a Member Template

template <class Type> class Queue {
    public:
        // construct a Queue from a pair of iterators on some sequence
        template <class It>
        Queue(It beg, It end):
        head(0), tail(0) { copy_elems(beg, end); }
        // replace current Queue by contents delimited by a pair of iterators
        template <class Iter> void assign(Iter, Iter);
        // rest of Queue class as before
    private:
        // version of copy to be used by assign to copy elements from iterator range
        template <class Iter> void copy_elems(Iter, Iter);
}

When we define a member template outside the scope of a class template, we must include both template parameter lists:

template <class T> template <class Iter>
void Queue<T>::assign(Iter beg, Iter end)
{
    destroy(); // remove existing elements in this Queue
    copy_elems(beg, end); // copy elements from the input range
}

When a member template is a member of a class template, then its definition must include the class-template parameters as well as its own template parameters. The class-template parameter list comes first, followed by the member’s own template parameter list. The definition of assign starts with template <class T> template <class Iter>.

3. Member Templates and Instantiation

Like any other member, a member template is instantiated only when it is used in a program. Member templates have two kinds of
template parameters: Those that are defined by the class and those defined by the member template itself. The class template parameters are fixed by the type of the object through which the function is called. The template parameters defined by the member act like parameters of ordinary function templates. These parameters are resolved through normal template argument deduction.

short a[4] = { 0, 3, 6, 9 };
// instantiates Queue<int>::Queue(short *, short *)
Queue<int> qi(a, a + 4); // copies elements from a into qi
vector<int> vi(a, a + 4);
// instantiates Queue<int>::assign(vector<int>::iterator,
//                                          vector<int>::iterator)
qi.assign(vi.begin(), vi.end());

4. The Complete Queue Class

// declaration that Queue is a template needed for friend declaration in QueueItem
template <class Type> class Queue;
// function template declaration must precede friend declaration in QueueItem
template <class T>
    std::ostream& operator<<(std::ostream&, const Queue<T>&);

template <class Type> class QueueItem {
    friend class Queue<Type>;
    // needs access to item and next
    friend std::ostream& // defined on page 659
    operator<< <Type> (std::ostream&, const Queue<Type>&);
    // private class: no public section
    QueueItem(const Type &t): item(t), next(0) { }
    Type item; // value stored in this element
    QueueItem *next; // pointer to next element in the Queue
};

template <class Type> class Queue {
    // needs access to head
    friend std::ostream& // defined on page 659
                operator<< <Type> (std::ostream&, const Queue<Type>&);
    public:
        // empty Queue
        Queue(): head(0), tail(0) { }
        // construct a Queue from a pair of iterators on some sequence
        template <class It>
        Queue(It beg, It end):
                head(0), tail(0) { copy_elems(beg, end); }
        // copy control to manage pointers to QueueItems in the Queue
        Queue(const Queue &Q): head(0), tail(0)
        { copy_elems(Q); }
        Queue& operator=(const Queue&); // left as exercise for the reader
        ~Queue() { destroy(); }
        // replace current Queue by contents delimited by a pair of iterators
        template <class Iter> void assign(Iter, Iter);
        // return element from head of Queue
        // unchecked operation: front on an empty Queue is undefined
        Type& front() { return head->item; }
        const Type &front() const { return head->item; }
        void push(const Type &);// defined on page 652
        void pop(); // defined on page 651
        bool empty() const { // true if no elements in the Queue
        return head == 0;
        }
    private:
        QueueItem<Type> *head; // pointer to first element in Queue
        QueueItem<Type> *tail; // pointer to last element in Queue
        // utility functions used by copy constructor, assignment, and destructor
        void destroy(); // defined on page 651
        void copy_elems(const Queue&); // defined on page 652
        // version of copy to be used by assign to copy elements from iterator range
        // defined on page 662
        template <class Iter> void copy_elems(Iter, Iter);
};

// Inclusion Compilation Model: include member function definitions as well
#include "Queue.cc"

5. static Members of Class Templates

template <class T> class Foo {
    public:
        static std::size_t count() { return ctr; }
        // other interface members
    private:
        static std::size_t ctr;
        // other implementation members
};

// Each object shares the same Foo<int>::ctrand Foo<int>::count members
Foo<int> fi, fi2, fi3;

// has static members Foo<string>::ctrand Foo<string>::count
Foo<string> fs;

Foo<int> fi, fi2; // instantiates Foo<int> class
size_t ct = Foo<int>::count(); // instantiates Foo<int>::count
ct = fi.count(); // ok: uses Foo<int>::count
ct = fi2.count(); // ok: uses Foo<int>::count
ct = Foo::count(); // error: which template instantiation?

As with any other static data member, there must be a definition for the data member that appears outside the class. In the case of a class template static , the member definition must inidicate that it is for a class template:

template <class T>
size_t Foo<T>::ctr = 0; // define and initialize ctr