Question

I have a really simple method:

void SomeClass::GetListStuff(std::vector<Stuff const *> &listStuff) const
{   listStuff = m_listStuff;   }

Where m_listStuff is a member of SomeClass and is of type

std::vector<Stuff *> 

This code gives me an error saying

there's no match for 'operator='
in 'listStuff = ((const SomeClass*)this)->SomeClass::m_listStuff

It works fine if I take the const away from the ListStuff pointer. I can also call insert() on listStuff (without changing the const correctness) and it works. Could anyone explain why?

Answer 1

I think you should do this:

void SomeClass::GetListStuff(std::vector<Stuff*> &listStuff) const
{   
       listStuff = m_listStuff;   
}

That is, use std::vector<Stuff*> instead of std::vector<Stuff const*> because I suspect that m_listStuff is declared to be std::vector<Stuff*>. So the argument type should match that.

I think a better approach would be this:

std::vector<Stuff*> SomeClass::GetListStuff() const
{   
       return m_listStuff; //return a copy!
}

Or even better is to expose iterators:

std::vector<Stuff*>::const_iterator cbegin() const
{   
       return m_listStuff.cbegin(); //return const_iterator (C++11 only)
                                    //in C++03, you can use begin()
                                    //it will work same as cbegin()
}
std::vector<Stuff*>::const_iterator cend() const
{   
       return m_listStuff.cend(); //return const_iterator (C++11 only)       
                                  //in C++03, you can use end()
                                    //it will work same as cend()
}

Write the non-const version yourself.