这是我的代码的一个 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 条件，如果:

• 我删除了 constexpr的 operator!

或

• 添加一个 Options_proxy<File_options_impl> 类型的对象在接线员调用之前:

像这样:

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

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

至于写这样代码的动机:

我想创建(主要是为了好玩)一个类型安全的标志/选项系统(没有宏):

图书馆黑魔法:

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);

最佳答案

看起来这是一个 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 的相同程序，或者如果您显式实例化 A<0> (例如 template struct A<0>; )在 auto&& a = f((X*)0); 之前.这表明 gcc 的问题在于类模板隐式实例化 [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.

类模板A<0>在 return 处需要constexpr A<0> f(X*)的声明，所以应该在此时隐式实例化。尽管友元函数定义在词法上属于类 A , 该类在友元函数的定义中不应被认为是不完整的；例如以下非模板程序被普遍接受:

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 或使用 template struct C<0>; 显式实例化来修复):

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>;

关于c++ - 友元函数中的类型不完整，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39530837/