Re: Getting non "const" pointers to object data using "const" members
Gingko wrote:
The returned pointers are not arbitrary, they are *selected* parts of the
object, other parts are still expected to be not accessible.
My object is actually a tree container, and the member function explores
all branches for returning a flattened list of pointers to all leaves.
There are a few things you can do to achieve that, while not violating type
safety or const correctness.
1. Separate the container part from the content:
template<typename element_type>
struct node
{
element_type value;
node* parent;
node* left;
node* right;
};
Make this a private nested class of the tree container.
2. Provide an interface to access the elements of the tree. One such
interface is an iterator (take a look at Boost's iterator builder library).
Another such interface is a visitor:
struct tree {
...
template<typename Visitor>
void visit(Visitor v);
template<typename Visitor>
void visit(Visitor v) const;
};
Note that this is not exactly the visitor pattern, since that is intended to
do double dispatch rather. The function above will invoke "v(e)" for every
node's value 'e'. This allows you to e.g. create a flat list of all nodes,
but the list will point to const objects when you use the const overload of
this function. Note that I would _not_ call it with every node but only its
value, because the node is an internal thing to the tree.
Leaves are expected to be modifiable (and randomly accessible like in a
subscripted array), but I want the structure of the tree itself to be
protected.
You really support 'tree[index]'? That tempts to write horribly inefficient
code like using a 'for(int i=0; ...)' loop to iterate the tree.
Uli
--
C++ FAQ: http://parashift.com/c++-faq-lite
Sator Laser GmbH
Gesch??ftsf??hrer: Thorsten F??cking, Amtsgericht Hamburg HR B62 932