Re: Oppinion on 'least priviledge', 'const correctness', etc.
On 23 juuli, 09:09, Stuart Redmann <DerTop...@web.de> wrote:
On 22 juuli, Stuart Redmann wrote:
C++ offers the means to extend the const correctness even over
pointers:
class SomeClass
{
public:
void foo () const {}
void bar () {}
};
class AnotherClass
{
protected:
SomeClass* SomeObject;
public:
AnotherClass (SomeClass* Object)
: SomeObject (Object)
{}
SomeClass* GetObject ()
{
return SomeObject;
}
const SomeClass* GetObject () const
{
return SomeObject;
}
};
int main ()
{
SomeClass a;
const AnotherClass b (&a);
b.GetObject ()->foo (); // OK
b.GetObject ()->bar (); // Compilation error: b is const
AnotherClass c (&a);
c.GetObject ()->foo (); // OK
c.GetObject ()->bar (); // OK: c is not const
}
Stroustrup mentiones this technique in his book (can't cite the page
since I seem to haave mislaid it). Although it's a pain in the neck t=
o
write const-overloaded accessors for member pointers, this is a
technique that can extend const-correctness so that it works for
everything.
On 22 Jul., =D6=F6 Tiib wrote:
Yes, this is obvious. Only problem of it is that *SomeObject is not
const within implementation of some const member of AnotherClass and
so may be modified by mistake there. Special smart pointer that
extends constness by its nature removes that issue as well.
I see what you mean. I think the following template class should
achieve this:
// Wrapper for plain pointers that behaves as const-correct
// accessor.
template<class t_Class>
class ConstCorrectAccessor
{
t_Class* m_InternalPointer;
public:
ConstCorrectAccessor (t_Class* Pointer)
: m_InternalPointer (Pointer)
{}
// Accessor methods with const-correct overload.
const t_Class* operator-> () const {return m_InternalPointer;}
t_Class* operator ->() {return m_InternalPointer;}
};
Yes, something like that ... operator*() is missing.
class SomeClass
{
public:
void foo () const {}
void bar () {}
};
class AnotherClass
{
public:
ConstCorrectAccessor<SomeClass> SomeObject;
public:
AnotherClass (SomeClass* Object)
: SomeObject (Object)
{}
void foo () const
{
SomeObject->foo (); // OK
SomeObject->bar (); // Error: Non-const method on SomeObject.
}
};
int main ()
{
SomeClass a;
const AnotherClass b (&a);
b.SomeObject->foo (); // OK
b.SomeObject->bar (); // Compilation error: b is const
AnotherClass c (&a);
c.SomeObject->foo (); // OK
c.SomeObject->bar (); // OK: c is not const
}
Do you know whether such a thing is part of the STL/boost?
No, but usually i want RAII as well for such a polymorphic component.
So i took "boost::scoped_ptr<>" and modified it into a
"component_ptr<>" with transitive constness. Probably it might be idea
to add custom deleter (like boost::shared_ptr<> has), since
polymorphic things are often created and destroyed by factories. Also,
custom deleter helps when wrapping some sort of "handle" (lets say
from some C library) into class.