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

Question

由于模板和动态多态不能很好地混合，我目前正在设计一个概念，而不是接口（用抽象类实现），用于支持操作的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;
    }
};

然后调用 Logger：

Logger1 l1{};
fun(l1);

不提供编译器错误。这是因为字符串文字被隐式转换为 std::string 并且 unsigned、int、char、unsigned char 最终被隐式转换为 float。

我该怎么做：

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

Answer 1

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

另外，为了避免阻塞字符串字面量，我们可以给这个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.