Question

What’s the best practice for returning a pointer-to-non-const from a function, where that pointer was obtained by modifying a (non-const) pointer-to-const? Like this:

NODE *top_level(const NODE *input)
{
  while (input->parent != nullptr)
    input = input->parent;  // NODE::parent is (non-const) NODE*

  return input;  // Compile failure: 
                 // Cannot convert from 'const NODE *' to 'NODE *'
}

I could const_cast the const away on return, which seems fine, but is there a better way?

Answer 1

Best practice, at least in the standard library, is to provide const and non-const overloads. E.g. std::strchr is declared in <cstring> as

char *strchr(char *s, int c);
char const *strchr(char const *s, int c);

In a similar vein, functions like std::map<T>::find have overloads such as

iterator find(const Key& key);
const_iterator find(const Key& key) const;

Note that that there’s no const qualifier on the first version, even though find itself has no reason to modify the map.(*) The point is that you get something out of find that can be used to modify the map, so by a kind of “transitivity of mutability”, find cannot be const. The same situation applies in your problem, I think.

Alternatively, you could use a const_cast, but to me, that would feel like breaking a promise.

The funny thing about this situation is that, if you can guarantee that your function is never called on the top item of the tree (or whatever the input is), then there’s no need for casts or overloads:

struct node {
    node *parent;
};

node *top(node const *n)
{
    node *p = n->parent;
    while (p->parent != 0)
        p = p->parent;
    return p;
}

compiles without any warnings.

(*) If std::map were implemented as a splay tree, find would have to modify it, but I don’t think splay trees are allowed by the standard because of complexity guarantees.