Why is the use of typedef in this template necessary?

Question

When I compile this code in Visual Studio 2005:

  template <class T>
  class CFooVector : public std::vector<CFoo<T>>
  {
  public:
    void SetToFirst( typename std::vector<CFoo<T>>::iterator & iter );
  };

  template <class T>
  void CFooVector<T>::SetToFirst( typename std::vector<CFoo<T>>::iterator & iter )
  {
    iter = begin();
  }

I get these errors:

c:\home\code\scantest\stltest1\stltest1.cpp(33) : error C2244:     'CFooVector<T>::SetToFirst' : unable to match function definition to an existing declaration
    c:\home\code\scantest\stltest1\stltest1.cpp(26) : see declaration of 'CFooVector<T>::SetToFirst'
    definition
    'void CFooVector<T>::SetToFirst(std::vector<CFoo<T>>::iterator &)'
    existing declarations
    'void CFooVector<T>::SetToFirst(std::_Vector_iterator<_Ty,_Alloc::rebind<_Ty>::other> &)'

If I add a typedef to the CFooVector template, I can get the code to compile and work:

  template <class T>
  class CFooVector : public std::vector<CFoo<T>>
  {
  public:
    typedef typename std::vector<CFoo<T>>::iterator FooVIter;
    void SetToFirst( FooVIter & iter );
  };

  template <class T>
  void CFooVector<T>::SetToFirst( FooVIter & iter )
  {
    iter = begin();
  }

My question is, why does the typedef work when using the bare 'typename std::vector>::iterator' declaration did not work?

Answer 1

The question isn't really about typedef but typename.

Whenever the compiler encounters a name that is dependent on a template (basically, anything using :: after a template, it is unable to determine if that is a type or a value (it could be a static int, for example), so it needs a hint.

When you add typename you're specifying that the dependent member is actually a type.

In your typedef example, you still have the typename in the typedef declaration, but once the typedef is declared, that is not a dependent name. It's just a type, so the typename isn't necessary when referring to the typedef.

Basically, the compiler can't be sure that std::vector<CFoo<T>>::iterator is a type.

But it knows that FooVIter is a type, because it's a typedef. Typedefs are always types.

Answer 2

typename is the most important keyword here.

It is important to note:

>>

should have a space between them to not confuse the compiler into thinking you are using

operator>>

Without your entire code, I don't know why there is a problem after using typename. Maybe you don't need it in the definition outside of the class definition?

Also it may be better to do:

template <typename T>

instead of

template <class T>

BTW, it is not a good idea to derive from the STL classes, unless you are very, very careful.

STL classes do not have virtual destructors.

Answer 3

Seems to work fine fine for me if I make the following changes -

template <class T>
class CFoo
{
public:
T m_t;
};

template <class T>
class CFooVector : public std::vector< CFoo<T> >
{
public:
void SetToFirst( typename std::vector<CFoo<T> >::iterator & iter );
};

template <class T>
void CFooVector<T>::SetToFirst( typename std::vector<CFoo<T> >::iterator & iter )
{
iter = begin();
}

I've basically changed the std::vector<CFoo<T>> to std::vector<CFoo<T> >, cause otherwise the compiler (gcc, in my case) recognizes it as the >> operator.

Answer 4

This compiles as well and reveals the source of VC++ confusion -- allocator type. Apparently outside of the class VS selects different default. Or maybe it can't recognize them to be the same.

Compiles on VS2008 (as is) and VS2003 (with space between >>)

template <class T>
class CFoo
{
public:
    T m_t;
};

template <class T>
class CFooVector : public std::vector<CFoo<T>>
{
public:
    void SetToFirst(typename std::vector<CFoo<T>, typename CFooVector::_Alloc>::iterator & iter);

};

template <class T>
void CFooVector<T>::SetToFirst( typename std::vector<CFoo<T>, typename CFooVector::_Alloc>::iterator & iter )
{
    iter = begin();
}

GCC 3.4 wanted this->begin() and space, but otherwise it can compile the code without explicit allocator type... Definitely looks like MS compiler not as smart as it should be...

Answer 5

Another interesting bit: VS2008 compiles your second attempt if you don't use the std:: name qualification on the vector in the definition of SetToFirst():

  template <class T>
  class CFooVector : public std::vector< CFoo<T> >
  {
  public:
      void SetToFirst( typename std::vector< CFoo<T> >::iterator & iter );
  };

  template <class T>
  void CFooVector<T>::SetToFirst( typename /*std::*/vector< CFoo<T> >::iterator & iter )
  {
    iter = begin();
  };

Note that it only seemed to matter on the defintion, not the declaration. Also interesting to me was that it didn't matter if there was a "using namespace std;" or not...

I don't really know what to make of this.