友元函数中的类型不完整

Question

这是我的代码的一个 mcve：（如果重要的话，Options_proxy 和 Options 有 constexpr 构造器）。我知道它仍然远非简单，但在仍然显示错误的同时无法进一步简化它：

template <class Impl>
struct Options_proxy : Impl {
  using Flag = typename Impl::Flag;

  friend constexpr auto operator!(Flag f) -> Options_proxy {
    return {}; // <-- error here
  };
};

template <class Impl>
struct Options : Impl {
  using Flag = typename Impl::Flag;
};

struct File_options_impl {
  enum class Flag : unsigned { nullflag, read, write  };

  friend constexpr auto operator!(Flag f) -> Options_proxy<File_options_impl>;
};

using File_options = Options<File_options_impl>;

auto foo()
{
  !File_options::Flag::write; // <-- required from here
}

gcc 6 和 7 给出这个错误：

In instantiation of 'constexpr Options_proxy<File_options_impl> operator!(Options_proxy<File_options_impl>::Flag)':
required from ... etc etc...
error: return type 'struct Options_proxy<File_options_impl>' is incomplete

clang 编译成功。

代码符合 gcc 条件，如果：

我删除了 operator!

constexpr

或

在运算符调用之前添加一个 Options_proxy<File_options_impl> 类型的对象：

像这样：

auto foo()
{
  Options_proxy<File_options_impl> o;
  !File_options::Flag::write; // <-- now OK in gcc also
}

这是 gcc 错误还是代码中的某些未定义行为，例如未指定或不需要诊断？

至于写这样代码的动机：

我想创建（主要是为了好玩）一个类型安全的 flag/options 系统（没有宏）：

图书馆黑魔法：

template <class Impl>
  requires Options_impl<Impl>
struct Options : Impl {
   // go crazy
};

用户代码：

struct File_options_impl {
  // create a system where here the code
  // needs to be as minimal as possible to avoid repetition and user errors

  // this is what the user actually cares about
  enum class Flag : unsigned { nullflag = 0, read = 1, write = 2, create = 4};

  // would like not to need to write this,
  // but can't find a way around it
  friend constexpr auto operator!(Flag f1) -> Options_proxy<File_options_impl>;
  friend constexpr auto operator+(Flag f1, Flag f2) -> Options_proxy<File_options_impl>;
  friend constexpr auto operator+(Flag f1, Options_proxy<File_options_impl> f2) -> Options_proxy<File_options_impl>;
};

using File_options = Options<File_options_impl>;

然后：

auto open(File_options opts);

using F_opt = File_options::Flag;
open(F_opt::write + !F_opt::create);

Answer 1

我在您的代码中看到的一个问题是多个实现可能具有相同的 ::Flag 成员，这意味着您的友元运算符可能会被定义多次，这违反了一次定义规则。

而且Options_proxy没有任何私有成员，所以你不需要让操作员成为朋友（我认为你在滥用朋友内联定义外部函数）。

您需要为您的运算符定义一个明确的定义，我认为当前签名不可能。

如果保证标志是唯一的，您可以尝试将运算符移到 Options_proxy 之外。

template <class Impl>
struct Options_proxy : Impl {
  using Flag = typename Impl::Flag;
};

template <class Impl, typename Flag = Impl::Flag>
constexpr Options_proxy<Impl> operator!(Flag f) {
  return {};
}

template <class Impl>
struct Options : Impl {
  using Flag = typename Impl::Flag;
};

struct File_options_impl {
  enum class Flag : unsigned { nullflag, read, write  };

  friend constexpr Options_proxy<File_options_impl> operator!(Flag f);
  // Or if that doesn't work:
  friend constexpr Options_proxy<File_options_impl> operator!<File_options_impl>(Flag f);
};

Answer 2

看起来这是一个 gcc 错误。这是一个 MCVE（4 行）：

struct X;
template<int> struct A { friend constexpr A f(X*) { return {}; } };
// In instantiation of 'constexpr A<0> f(X*)':
// error: return type 'struct A<0>' is incomplete
struct X { friend constexpr A<0> f(X*); };
auto&& a = f((X*)0);

这被 clang 和 MSVC 接受。

正如您所观察到的，gcc 接受没有 constexpr 的相同程序，或者如果您在 auto&& a = f((X*)0); 之前显式实例化 A<0>（例如使用 template struct A<0>;）。这表明 gcc 的问题在于 class 模板隐式实例化 [temp.inst]:

1 - Unless a class template specialization has been explicitly instantiated (14.7.2) or explicitly specialized (14.7.3), the class template specialization is implicitly instantiated when the specialization is referenced in a context that requires a completely-defined object type or when the completeness of the class type affects the semantics of the program.

class 模板 A<0> 在 constexpr A<0> f(X*) 的 return 语句中是必需的，因此应在该点隐式实例化。尽管友元函数定义在 class A 中，但不应认为 class 在友元函数定义中是不完整的；例如以下非模板程序被普遍接受：

struct Y;
struct B { friend constexpr B f(Y*) { return {}; } };
struct Y { friend constexpr B f(Y*); };
auto&& b = f((Y*)0);

有趣的是，gcc 和 clang（虽然不是 MSVC）在以下程序中都有问题（同样，通过删除 constexpr 或使用 [=23 显式实例化来修复） =]):

struct Z;
template<int> struct C { friend constexpr C* f(Z*) { return 0; } };
struct Z { friend constexpr C<0>* f(Z*); };
// error: inline function 'constexpr C<0>* f(Z*)' used but never defined
auto&& c = f((Z*)0);

我建议使用显式实例化解决方法。在你的情况下是：

template class Options_proxy<File_options_impl>;

友元函数中的类型不完整

Incomplete type in friend function

c++

templates

friend

language-lawyer

incomplete-type