Why duplicate code is needed with const reference arguments?

Question

In this interview Stepanov shows how to implement generic max function in C++.

Try to implement a simple thing in the object oriented way, say, max. I do not know how it can be done. Using generic programming I can write:

template <class StrictWeakOrdered>
inline StrictWeakOrdered& max(StrictWeakOrdered& x,
StrictWeakOrdered& y) {
return x < y ? y : x;
}

and
template <class StrictWeakOrdered>
inline const StrictWeakOrdered& max(const StrictWeakOrdered& x,
const StrictWeakOrdered& y) {
return x < y ? y : x;
}

(you do need both & and const &).

Why is there need to write the code twice? Is this needed to aid compiler for optimization or a convention to reduce bugs? Is max a special case where body of a const version is identical?

How many valid const and non-const permutations a function of N arguments should have to define a complete API?

Answer 1

First of all, you need the non-const version to allow stuff like

max(a, b) = something;

If you don't want to do such things, you can just provide the const version only to cover all cases. That is basically what the standard std::max does.

You also do not need to provide any more permutations of const and non-const, returning non-const& only makes sense if all inputs are non-const, all other cases are properly handled by the const version.

If you want to avoid code duplication, you can do something like this:

template <class StrictWeakOrdered>
inline StrictWeakOrdered& max(StrictWeakOrdered& x, StrictWeakOrdered& y) {
    const auto &xr = x;
    const auto &yr = y;
    return const_cast<StrictWeakOrdered&>(max(xr, yr));
}

In this special case, the const_cast is safe because you already know that the input is really non-const. Now you only have to provide the implementation for the const case.

So providing the implementation twice is not required and should not help the compiler, but whether or not the above is more readable than what Stepanov did is debatable.

Answer 2

You actually don't need both versions. You can write it this way.

template <class S, class T>
decltype(auto) max(S&& a, T&& b) {
    using Ret = std::conditional_t<
          std::is_const<std::remove_reference_t<S>>::value, S, T>;

    if (b < a)
        return std::forward<Ret>(a);
    return std::forward<Ret>(b);
}

Falling back to const if either of the arguments was const.

Answer 3

If you do not intend to modify the argument, you can just go with the const& version. Everything should bind to a const reference.

C++11 also introduced reference collapsing, and a template parameter T&& is sometimes called a universal reference. In this case, when instantiating the parameter type for e.g. a int&, we would have int& && which collapses to int&. Now, you can write the function as

template <class T1, class T2>
inline T1 const& max(T1&& x, T2&& y)  {
     T1 const& x_=x;
     T2 const& y_=y;
     return (x_ < y_) ? (y_) : (x_);
}

This can be called with const values, temporaries (r-values) and mutable variables:

int const a=1;
int b=2;
max(b,b) = 23;
std::cout << max(a,a) << max( int{4}, int{5} ) << b << max(int{4}, a);