defining const and non-const version of traversal function

Question

I have a datastructure similar to a list:

template<typename T>
struct node {
  T val;
  unique_ptr<node<T>> next;
};

and a simple traversal function:

template<typename T, typename UnaryOp>
void traverse(node<T>& list, UnaryOp op) {
  node<T>* current = &list;
  while(current) {
    op(*current);
    current = current->next.get();
}

I now need a const and a non-const version of the traverse function that accepts either a const node<T>& list or a node<T>& list, depending on the context, preferably avoiding code duplication. How could this be achieved?

Answer 1

A possible solution is creating a static template function that takes *this as a forwarding reference:

class node
{
private:
    template <typename TSelf>
    static void traverse_impl(TSelf& self, node<T>& list, UnaryOp op)
    {
        node<T>* current = &list;
        while(current)
        {
            op(*current);
            current = current->next.get();
        }
    }

public:
    void traverse(node<T>& list, UnaryOp op)
    {
        traverse_impl(*this, list, op);
    }

    void traverse(node<T>& list, UnaryOp op) const
    {
        traverse_impl(*this, list, op);
    }
};

This works because of template argument deduction rules - in short, TSelf will accept both const and non-const references.

If you need to access members of this inside traverse_impl, use self.member.

Additionally, you can use std::conditional or similar facilities inside traverse_impl to do different things depending on the const-ness of TSelf. You can also use a forwarding reference (TSelf&&) and handle the case where this is being moved thanks to ref-qualifiers and perfect-forwarding.