C++ concept for argument matching of const/non-const references to specified type on template functions

Question

I want to know if there is a better way to solve the code duplication problem on template functions like this

struct Z {
    void doSomething() { std::cout << "non-const version\n"; }
    void doSomething() const { std::cout << "const version\n"; }
};

void tempFunc( Z& z ) {
    z.doSomething(); // calls non-const member function
}
void tempFunc( const Z& z ) {
    z.doSomething(); // calls const member function
}

int main() {
    Z z;
    const Z cz;
    tempFunc(z);
    tempFunc(cz);
    return 0;
}

As you can see, both definitions of tempFunc are the same, so in order to avoid code duplication I rewrote that function under C++20 using constraints like this

void tempFunc( std::convertible_to<Z> auto&& z ) {
    z.doSomething();
}

Note the use of std::is_convertible_to<> and it works fine, but I suspect that there should be a standard (or if not an easy to write constraint) to use instead of is_convertible_to<> that restricts the argument matching only to const and non-const references.

Answer 1

std::convertible_to is the wrong concept. You don't want something that is convertible to Z. You need something that is a Z.

Or, not specifically is-a, since Z const and Z&& are both not literally Z but you want to allow those too.

For this, typically what people write is:

template <typename T, typename U>
concept DecaysTo = std::same_as<std::decay_t<U>, T>;

Used as:

void tempFunc( DecaysTo<Z> auto&& z ) {
    z.doSomething();
}

This now matches any type T such that std::decay_t<T> is Z. Which is Z [const][&|&&], basically. That's what you want.

Answer 2

You can use std::same_as to constrain the un-cvref type of the deduced type to be Z

template<class T>
  requires std::same_as<Z, std::remove_cvref_t<T>>
void tempFunc( T&& z ) {
    z.doSomething();
}

It is worth noting that member functions of class Z can also take advantage of C++23 Deducing this to reduce duplication

struct Z {
  void doSomething(this auto&& self) { /* */ }
};