Linked List reversal

Recursive version. The only interesting function:

List& List::reverse()
        {
            if (empty())
            {   return *this;
            }
            int val = head();
            //
            // The fun bit.
            // See if you can figure this bit out.
            return pop().reverse().append(val);
        }

The rest:

#include 
#include 
struct List
{
    struct Node
    {
        int     val;
        std::unique_ptr   next;
        Node(){}
        Node(int v, Node* oldTail)
            : val(v)
            , next(nullptr)
        {
            oldTail->next.reset(this);
        }
        friend std::ostream& operatorval;
        }
        List& append(int val)
        {
            tail = new Node(val, tail);
            return *this;
        }
        List& pop()
        {
            // Pre-Condition not empty
            sentinal.next.reset(sentinal.next->next.release());
            tail = sentinal.next.get() ? tail : &sentinal;
            return *this;
        }
        List& reverse();
        friend std::ostream& operatornext.get())
            {   s << *loop;
            }
            return s << "\n";
        }

};

See if you can figure this bit out.

Is this meant to be a Programming Puzzle?

You don't call append until after you finish calling reverse; reverse is recursive; so all the append calls will be called after all the reverse calls: and that explains why reverse will eventually terminate i.e. why the list will eventually be empty.

From a code-review point of view:

• I fear that a recursive implementation might exceed your finite maximum stack size if the list is long.

• You're deleting and creating new Node objects; you might instead be able to do it in a way that reuses existing Node instances.

Also, it should be spelled "sentinel".

StackExchange Code Review Q#46019, answer score: 5