C++ require 没有隐式转换的函数

Question

我使用 boost::variant 来模仿具有值语义的继承。

有一个类可以被打印：

struct Printable { /* ... */ };

void print(const Printable &) { /* ... */ }

和类可能不会：

struct NotPrintable { /* ... */ };

最后，有一个带有隐式强制转换的“Base”类：

struct Base : boost::variant<Printable, NotPrintable>
{
    Base(const Printable &) {}    // constructor for implicit cast
    Base(const NotPrintable &) {} // constructor for implicit cast
};

// Print, if printable, throw exception, if not
void print(const Base &base) 
{ 
    Printer printer{};
    base.apply_visitor(printer);
}

问题是如何检查访问者内部是否可打印：

struct Printer
{
   using result_type = void;

   // If printable 
   template<typename PrintableType> requires 
   requires(const PrintableType &v) { {print(v)}; }  // (1)
   void operator()(const PrintableType &v) { print(v); }

   // If not printable
   void operator()(const auto &v) { throw /*...*/; }
}; 

要求 由于隐式转换为 const Base &，(1) 始终为 true。如何避免只在那个确切的地方进行转换？

Answer 1

正如@Jarod42在评论中所说，为了保证不发生隐式转换，需要定义一个模板print()函数来“吸收”其他类型(NotPrintable 在您的示例中）并将其设置为删除

void print(const auto&) = delete;

然后可以将 printable 概念定义为

template<class T>
concept printable = requires (const T& x) { print(x); };

要求表达式 print(x) 格式良好。

当 T 的类型为 Printable 或 Base 时，表达式 print(x) 有效，因为您已定义相应的 print() 函数。当T的类型为NotPrintable或其他类型时，将调用删除的print()，这使得表达式格式错误，因此约束条件不满足。

然后你可以使用这个概念来约束 Printer::operator()

struct Printer {
  using result_type = void;

  // If printable 
  template<printable PrintableType>
  void operator()(const PrintableType& v) { print(v); }

  // If not printable
  void operator()(const auto&) { throw /*...*/; }
};

请注意，由于 print(const auto&) 可以实例化为任何类型，这将禁止所有隐式转换，但我们仍然可以通过添加约束来允许某些隐式转换

#include <concepts>

struct Boolean { };
struct Integer {
  Integer();
  Integer(Boolean);
  friend Integer operator+(Integer, Integer);
};
struct String { };

template<class T, class U>
  requires (!std::convertible_to<U, T>)
void operator+(T, U) = delete;

int main() {
  Integer{} + Integer{}; // OK
  Integer{} + String{};  // ERROR (as expected)
  Integer{} + Boolean{}; // OK
};

Answer 2

我找到了一个基于内联好友定义的完美解决方案。

根据标准：

这样的函数隐式是内联函数 (10.1.6)。 类中定义的友元函数位于（词法）中
定义它的类的范围。在类外部定义的友元函数不是 (6.4.1)。

---

其他一些可能有用的东西：

1. 删除的模板功能

   void print(auto) = 删除;
   

缺点：

• 每个函数都有样板

• 禁止所有隐式转换

  结构布尔值；
  
  结构字符串；
  
  结构体整数
  {
    整数（布尔值）；
  
    朋友 整数运算符+(整数, 整数);
  }
  
  模板
  需要 (!std::convertible_to)
  void 运算符+(T, U) = 删除；
  
  整数 + 整数 // 确定
  整数 + 字符串 // 错误（如预期）
  整数 + 布尔值 // 确定
  

2. 更改接口

   结构基础：/* ... */
   {
     /* ... */
   
     静态无效打印（基础）；
   }
   

缺点：

• 没有运算符支持 (Base + Base -> Base::add(Base, Base))
• 接口有点差

3. 添加特征

   模板<类型名称 T>结构特征{
     静态 constexpr bool is_printable = true;
   }
   

缺点：

• 每个类和方法的样板
• 如何处理隐式转换（Boolean + Integer）？
• 因延期而关闭