Question

I’m building a large project on Debian 6.0.6 (with gcc 4.4.5) that was initially built in Microsoft VS (2008, I think).

What seems to be the problem is that when I declare a member as
typedef typename std::set<T>::iterator iterator, and then later use this iterator, gcc appears to interpret this as (const T*).

The part of the class containing the typename designation:

template <class entityType>
class entityArray
{
    private:                 std::set<entityType>             m_array;
    public: typedef typename std::set<entityType>::iterator   iterator;
 ...
    public:
        entityType*     At( const char* name);
 ...
};

plus a few other classes that are needed for the discussion:

class entity
{
    private:
        entity*     m_parent;
        int         m_ncid;
        std::string     m_name;
    public:
             entity () { m_ncid = 0; m_parent = NULL;}
    virtual ~entity () {};
 ...
};

class attribute : public entity
{
    public:
                   attribute(){};
        virtual   ~attribute(){};
};

class var : public entity
{
    private:
        entityArray<attribute>      m_atts;
    public:
                 var(){}
        virtual ~var(){}
       ...
};

class dim : public entity
{
    public:
                 dim() {};
        virtual ~dim() {};
};

class group : public entity
{
    private:
        entityArray<var>    m_vars;
        entityArray<dim>    m_dims;
...
    public:
        dim*     DimAt( const char* dimname )  { return m_dims.At(dimname);}
};

Now an iterator is initialized through a call to the function DimAt which in turn calls At. The At function in the first class is defined as:

template <class entityType>
entityType* entityArray<entityType>::At( const char* name )
{
    entityType  dummy;
    iterator    iter;
    entityType* ptr;

    ... define dummy ...

    iter = m_array.find( dummy );
    ptr  = (iter != m_array.end()) ? &(*iter) : NULL;
    return ptr;
}

Compiling the above produces
error: invalid conversion from const dim* to dim*., referring to &(*iter).
I realize that typename is required for declaring iterator, since the type is a dependent and qualified name, but I don’t see why this substitution (const *) is being performed by the compiler. I would appreciate any help that you could provide. Thanks!

Answer 1

This has absolutely nothing to do with typename.

The standard allows std::set<T>::iterator and std::set<T>::const_iterator to be the same type, and with GCC the types are the same.

The reason is that modifying an element of a std::set e.g. by *iter = val might invalidate the ordering of the set elements, breaking the invariant that the elements of the set are always in order. By making the iterator type a constant iterator instead of a mutable iterator it’s not possible to alter the element, preventing you from corrupting the set’s ordering.

So with GCC’s implementation, when you dereference the iterator using *iter you get a const entitType& and when you take its address using &*iter you get a const entityType*