Question

I try to compile the following code example from “C++ Templates – The Complete Guide” by David Vandevoorde and Nicolai M. Josuttis:

    #include <iostream>
    #include <deque>
    #include <vector>
    #include <stdexcept>
    #include <memory>

    template < typename T, 
               template < typename ELEM, typename = std::allocator< ELEM > > 
                          class CONT = std::deque >
    class ourstack
    {
    private:
        CONT< T > elems;
    public:
        void push( T const& );
        void pop();
        T top() const;
        bool empty() const
        { return elems.empty(); }
        template < typename T2 >
                template < typename ELEM2, 
                           typename = std::allocator< ELEM2 > > class CONT2 >
        ourstack< T, CONT >& operator = ( ourstack< T2, CONT2 > const & );
    };

    template < typename T, 
               template < typename, typename > class CONT >
    void ourstack< T, CONT>::push( T const& elem )
    {
        elems.push_back( elem );
    }

    template < typename T, 
               template < typename, typename > class CONT >
    void ourstack< T, CONT>::pop()
    {
        if ( elems.empty() )
        {
            throw std::out_of_range( "Stack empty" );
        }
        elems.pop_back();
    }

    template < typename T, 
               template < typename, typename > class CONT >
    void ourstack< T, CONT>::top() const
    {
        if ( elems.empty() )
        {
            throw std::out_of_range( "Stack empty" );
        }
        return elems.back();
    }

    template < typename T, 
               template < typename, typename > class CONT >
        template < typename T2 >
                   template < typename, typename > class CONT2 >
    ourstack< T, CONT >& ourstack< T, CONT >::operator = ( ourstack< T2, CONT2 > const & op2    )
    {
        if (( void*) this == (void*) op2 )
        {
            return *this;
        }
        ourstack< T2 > tmp( op2 );
        elems.clear();
        while ( !tmp.empty() )
        {
            elems.push_front( tmp.top() );
            tmp.pop();
        }
        return *this;
    }

    int main( int argc, char* argv[] )
    {
        ourstack< int > s;
        return 0;
    }

But

I’m using gcc version 4.4.3.

The compiler write messages:

    g++ -Wall template_of_template.cpp -o template_of_template 
    template_of_template.cpp:22: error: too many template-parameter-lists
template_of_template.cpp:22: error: expected unqualified-id before ‘>’ token
template_of_template.cpp:46: error: prototype for ‘void ourstack<T, CONT>::top() const’ does not match any in class ‘ourstack<T, CONT>’
template_of_template.cpp:17: error: candidate is: T ourstack<T, CONT>::top() const
template_of_template.cpp:58: error: too many template-parameter-lists
template_of_template.cpp:58: error: expected unqualified-id before ‘>’ token

What’s the problem ?

Answer 1

The only problem with the code is that you need to learn to type more accurately. ;-]

After fixing multiple typos (t instead of r, > instead of ,), here is the same code in a compilable state:

#include <iostream>
#include <deque>
#include <vector>
#include <stdexcept>
#include <memory>

template < typename T, 
           template < typename ELEM,
                      typename = std::allocator< ELEM > > class CONT = std::deque >
class ourstack
{
private:
    CONT< T > elems;
public:
    void push( T const& );
    void pop();
    T top() const;

    bool empty() const
    { return elems.empty(); }

    template < typename T2,
               template < typename ELEM2,
                          typename = std::allocator< ELEM2 > > class CONT2 >
    ourstack< T, CONT >& operator = ( ourstack< T2, CONT2 > const & );
};

template < typename T, 
           template < typename, typename > class CONT >
void ourstack< T, CONT>::push( T const& elem )
{
    elems.push_back( elem );
}

template < typename T, 
           template < typename, typename > class CONT >
void ourstack< T, CONT>::pop()
{
    if ( elems.empty() )
    {
        throw std::out_of_range( "Stack empty" );
    }
    elems.pop_back();
}

template < typename T, 
           template < typename, typename > class CONT >
T ourstack< T, CONT>::top() const
{
    if ( elems.empty() )
    {
        throw std::out_of_range( "Stack empty" );
    }
    return elems.back();
}

template < typename T, 
           template < typename, typename > class CONT >
template < typename T2,
           template < typename, typename > class CONT2 >
ourstack< T, CONT >& ourstack< T, CONT >::operator = ( ourstack< T2, CONT2 > const & op2    )
{
    if (( void*) this == (void*) op2 )
    {
        return *this;
    }
    ourstack< T2 > tmp( op2 );
    elems.clear();
    while ( !tmp.empty() )
    {
        elems.push_front( tmp.top() );
        tmp.pop();
    }
    return *this;
}

int main( int argc, char* argv[] )
{
    ourstack< int > s;
    return 0;
}