如何优先调用const成员函数并回退到非const版本?

Question

考虑一个类Bar在两个版本的库中:

/// v1
class Bar
{
void get_drink()
{
std::cout << "non-const get_drink() called" << std::endl;
}
};

/// v2
class Bar
{
void get_drink()
{
std::cout << "non-const get_drink() called" << std::endl;
}
void get_drink() const
{
std::cout << "const get_drink() called" << std::endl;
}
};

在客户端代码中，我们拥有一个Bar对象，并且想要get_drink。我希望能够更喜欢调用get_drink()的const版本，如果它是可用的(当使用v2库)和回退到非const版本(当使用v1库)。即:

Bar bar;
bar.get_drink(); // this does not call the const version of v2
static_cast<const Bar&>(bar).get_drink(); // this does not compile against v1 library

不幸的是，库没有版本控制，没有其他方法可以区分这两个版本。

我认为必须使用一些模板魔法。问题是怎么做?

Answer 1

这似乎可以工作:

#include <type_traits>
#include <iostream>
template<typename T, typename=void>
struct find_a_drink {
void operator()(T &t) const
{
t.get_drink();
}
};
template<typename T>
struct find_a_drink<T,
std::void_t<decltype( std::declval<const T &>()
.get_drink())>
> {
void operator()(T &t) const
{
static_cast<const T &>(t).get_drink();
}
};
template<typename T>
void drink_from(T &&t)
{
find_a_drink<std::remove_reference_t<T>>{}(t);
}
/// v1
class Bar1
{
public:
void get_drink()
{
std::cout << "non-const get_drink() called (Bar1)" << std::endl;
}
};
class Bar2
{
public:
void get_drink()
{
std::cout << "non-const get_drink() called (Bar2)" << std::endl;
}
void get_drink() const
{
std::cout << "const get_drink() called (Bar2)" << std::endl;
}
};
int main()
{
Bar1 b1;
Bar2 b2;
drink_from(b1);
drink_from(b2);
return 0;
}

结果:

non-const get_drink() called (Bar1)
const get_drink() called (Bar2)

Answer 2

这与Sam的回答的基本思想相同，但使用了表达式表达式，我认为这更清楚

// 1
template<typename T>
auto drink_from(T &t) -> decltype(static_cast<const T&>(t).get_drink())
{
static_cast<const T &>(t).get_drink();
}
// 2
template<typename T>
auto drink_from(T &&t)
{
t.get_drink();
}

如果实参t可以被强制转换为const并在其上调用get_drink

(这要求存在const限定的成员)，则首选重载1。如果这样的成员不可用，则调用重载2，从而调用非const限定成员。

Bar b;
drink_from(b);  // calls const qualified member if available

演示