How do I remove code duplication between similar ref-qualified member functions?

Question

Similarly to How do I remove code duplication between similar const and non-const member functions?, I want to remove the code duplication between nearly identical member functions, except for ref qualifiers.

Let's say I have a class that's something like this:

class MyStringBuilder
{
    std::string member;
public:
    // Other functions
    std::string create() const& {
        // Some work
        std::string result = member;
        // More work
        return result;
    }

    std::string create() && {
        // Some work
        std::string result = std::move(member);
        // More work
        return result;
    }
};

It's not inconceivable that we would want to do this for a builder object, as it saves a copy if we are done with the MyStringBuilder.

Except for where members are used, the code between the const& version and && version are identical. The only difference between the two functions is that the && version std::moves any members whenever they are referenced.

How can I avoid this code duplication?

Answer 1

One thing you can do is you can implement the logic in a non-member function and take the type of *this as a template parameter:

class MyStringBuilder
{
    std::string member;

    template<typename Self>
    static std::string create_impl(Self&& self) {
        // Some work
        std::string result = std::forward<Self>(self).member;
        // More work
        return result;
    }
public:
    // Other functions
    std::string create() const& {
        return create_impl(*this);
    }

    std::string create() && {
        return create_impl(std::move(*this));
    }
};