Re: Containers of pointers and const-correctness
Stuart Golodetz wrote:
Hi guys,
This is possibly a silly question (i.e. maybe I should know better), but
here goes. It's actually about const-correctness ultimately, as will
become clear.
- Given types D1 and D2 derived from a type B, I know that a container
of D1* is not in general a container of B*, since you can insert a D2*
into the container of B* and you can't into the container of D1*.
- In similar vein, given a type T, I can see that it would be
undesirable for you to be able to obtain a reference of type
std::vector<const T*>& to a std::vector<T*>, since then you could insert
a const T* into the vector and use the original vector to obtain a T*
through which you could modify the pointee.
- What I'm not clear on is why it should be impossible to obtain a
reference of type const std::vector<const T*>& to a std::vector<T*>. I
can't see how that would cause type safety problems (you can't modify
the vector through the const reference), and I can see some use cases
for it. An obvious one might be to allow a client to access a private
vector in a read-only way (it's possible to argue about the (de)merits
of such a design, but it's merely an illustrative example here).
Please can someone explain the error of my ways? :-)
Cheers,
Stu
Hmm, I've been doing some more digging around the net and it seems (by
piecing a few ideas together) that this sort of thing might do the
trick. Just thought I'd post it here in case anyone has any comments, or
it's of any use to anyone reading the thread. I guess the same idea
would be applicable for raw pointers - it's not shared_ptr-specific.
Cheers,
Stu
#include <vector>
#include <boost/shared_ptr.hpp>
using boost::shared_ptr;
struct X
{
void f() const {}
void g() {}
};
template <typename T>
class wrapped_shared_ptr
{
private:
shared_ptr<T> m_p;
public:
wrapped_shared_ptr(const shared_ptr<T>& p)
: m_p(p) {}
operator shared_ptr<T>&()
{ return m_p; }
operator const shared_ptr<const T>() const
{ return m_p; }
T& operator*()
{ return *m_p; }
const T& operator*() const
{ return *m_p; }
shared_ptr<T>& operator->()
{ return m_p; }
const shared_ptr<const T> operator->() const
{ return m_p; }
};
int main()
{
std::vector<wrapped_shared_ptr<X> > vec;
vec.push_back(shared_ptr<X>(new X));
const std::vector<wrapped_shared_ptr<X> >& cvec = vec;
vec[0]->f();
vec[0]->g();
cvec[0]->f();
//cvec[0]->g(); // doesn't compile
(*vec[0]).f();
(*vec[0]).g();
(*cvec[0]).f();
//(*cvec[0]).g(); // doesn't compile
return 0;
}