避免使用概念进行隐式转换

Question

由于模板和动态多态性不能很好地结合，我目前正在设计一个概念，而不是接口（用抽象 class 实现），用于支持操作的 Loggable 类型:

logger.log(LogLevel::info) << "some message" << 0 << 0.0 << 'c';

提供定义的日志级别：

enum class LogLevel
{
    info,
    warning,
    error
};

这个概念看起来像这样：

template<typename T>
concept Loggable = requires(T v)
{
    {
        v.log(LogLevel{})
        } -> std::convertible_to<T&>;

    {
        v << "log message" << static_cast<unsigned>(0) << static_cast<int>(0) << static_cast<float>(0.0)
          << static_cast<unsigned char>(0) << static_cast<char>('0')
        } -> std::convertible_to<T&>;
};

为了测试记录器，定义了以下函数：

template<typename T>
requires Loggable<T>
void fun(T& v)
{
    v.log(LogLevel::error);
}

我定义了一个Logger:

struct Logger1
{
    Logger1& log(LogLevel)
    {
        return *this;
    }

    Logger1& operator<<(float)
    {
        return *this;
    }

    Logger1& operator<<(std::string)
    {
        return *this;
    }
};

然后调用记录器：

Logger1 l1{};
fun(l1);

没有给出编译器错误。这是因为字符串文字被隐式转换为 std::string，而 unsigned、int、char、unsigned char 最终被隐式转换为 float。

我怎样才能：

禁止将 int、char、unsigned char、unsigned 隐式转换为 float，但 ...
仍然允许将字符串文字隐式转换为 std::string?

Answer 1

为避免隐式转换，我们可以定义一个匹配所有其他类型的模板operator<<。

另外，为了避免blocking string literal，我们可以给这个operator<<加一个约束，保证操作数不能转换为std::string:

#include <string>

template<typename T>
concept WeaklyLoggable = requires(T v) {
  { v.log(LogLevel{}) } -> std::convertible_to<T&>;
};

template<WeaklyLoggable T, class U>
  requires (!std::convertible_to<U, std::string>)
auto operator<<(T, U) = delete;

template<typename T>
concept Loggable = WeaklyLoggable<T> && requires(T v) {
  { 
     v << "log message"
       << static_cast<unsigned>(0) 
       << static_cast<int>(0) 
       << static_cast<float>(0.0) 
       << static_cast<unsigned char>(0) 
       << static_cast<char>('0')
  } -> std::convertible_to<T&>;
};

Demo.

避免使用概念进行隐式转换

Avoiding implicit conversion with concepts

c++

c++20

implicit-conversion

c++-concepts