Adam Badura wrote:
Lets consider following (typical as I think) code:
class tree_node {
public:
typedef std::vector< tree_node* > children_vector;
const children_vector& get_children() const { return children_; }
children_vector& get_children() { return children_; }
const tree_node* get_parent() const { return parent_; }
tree_node* get_parent() { return parent_; }
private:
children_vector children_;
tree_node* parent_;
};
(Code was not compiled and important parts - like constructors and
destructor - are not present since they are not important for the
problem inhere.)
There is an obvious problem of constness. Lets say we have a variable
"p_node" of type "const tree_node*". The pointer is to a const object
so we would except the object not being modified using this pointer
(compiler ought to check that). ...
I used to think that too, until I realized that these semantics simply
do not work this way in C++.
Given a type T there are two pointer-types. A pointer_to_T (T*) and a
pointer_to_const_T (T const* or const T* which are the same).
These two can be const-qualified and will then be a const_pointer_to_t
or a const_pointer_to_const_T.
There simply no way to make something that references a T* to reference
a T const* through const qualifying that something.
Consider:
struct B {};
struct A {
B* b_;
};
You will _always_ be able to modify the B pointed to by b_ through any
conceivable reference/pointer to A.
...
How to solve this problem?
I already came to two solutions:
1) Do not return the container, but add functions like
"children_begin" and "children_end" and define iterators so that the
will be const or non-const as appropriate. This requires somewhat more
coding but on the other hand makes tree_node's interface independent
on the actual implementation of children_. But this solution does not
go well with code which requires container and not pair of iterators,
like inserter iterators, BOOST_FOREACH, legacy code and so on...
2) Make tree_node behave like it was a container of "tree_node*". This
implies a lot of writing, since we would have to cover the all
requirements placed on a container. But using the same trick with
defining const and non-const iterators we can solve problem of
modifying const object. And the object of "tree_node" behaves like a
vector so we can use insert iterators, BOOST_FOREACH and all those
things mentioned in 1. But this solution is not good when tree_node
has children of two types, for example if we want to distinguish
children being leafs and children not being leafs. Since then
tree_node is a container of both other tree_nodes and appropriate
children.
So is there another solution?
One way is to make tree_node a template that defines the type of the
children (so either tree_node* or tree_node const*). And then use the
version with tree_node const* where you need const-semantics. This
solution is also a bit complicated, but I think it has different
drawbacks than the other two so it may be an alternative.
This is another solution to the problem. However it does not go
well with conversions. Since pointer to tree_node<tree_node*> cannot
[ comp.lang.c++.moderated. First time posters: Do this! ]