Блог

Я наткнулся на это:

 #include <type_traits>
#include <concepts>

template<class T>
concept IsFoo = requires(T a)
{
    {a.a} -> std::same_as<int>;
};

#if 1
// Will not compile, because Foo currently has incomplete type
template<IsFoo AFoo>
struct AcceptsFoo
{};
#else
template<class AFoo>
struct AcceptsFoo
{};
#endif

struct Foo
{
    int a;
    int b;

    AcceptsFoo<Foo> obj;
};
  

https://gcc.godbolt.org/z/j43s4z

Другой вариант (crtp) https://gcc.godbolt.org/z/GoWfhq

Foo является неполным, потому что он должен создать экземпляр AcceptsFoo , но для этого Foo должен быть полным, иначе он не сможет проверить IsFoo . Это ошибка в GCC, или так сказано в стандарте? Последнее было бы печально, потому что это предотвращает совместное использование концепций с некоторыми хорошо известными шаблонами, такими как CRTP.

Я заметил, что clang выдает аналогичную ошибку:https://gcc.godbolt.org/z/d5bEez

Вы можете проверить концепцию на соответствие неполному типу, но если для этой проверки концепции фактически требуется что-либо сделать с типом, который требует ее завершения, это приведет к провалу проверки концепции.

И даже там вы должны быть осторожны, поскольку реализациям разрешено (и они будут) кэшировать проверки концепции для более быстрой компиляции — поэтому, если вы попытаетесь, C<T> пока T не завершено, и повторите попытку, когда T станет полным, и они должны дать разные ответы, вы напрашиваетесь на неприятности.

Foo на момент проверки она не завершена, поэтому, естественно, у нее нет имени элемента a . Это действительно не может сработать.

потому что это предотвращает совместное использование концепций с некоторыми хорошо известными шаблонами, такими как CRTP.

Используется вместе таким образом, да. Точно так же, как с CRTP вы также не можете получить доступ ни к чему непосредственно из параметра шаблона, переданного в базовый класс, вы всегда должны быть осторожны, чтобы отложить любое создание экземпляра этого типа до его завершения.

В конечном счете, это одна и та же причина:

 template <typename Derived>
struct B { 
    typename Derived::type x;
};

struct D : B<D> {
    using type = int;
};
  

не работает.

[РЕДАКТИРОВАТЬ] Это работает, как и ожидалось, на g 10.3, 11.2 и текущем clang. Некоторые комментарии указывают, что это неопределенное поведение, поэтому остерегайтесь возможных неожиданных изменений для будущих компиляторов.

Оригинальное решение:

Я также только что наткнулся на это, и мне удалось заставить мой CRTP с концепциями работать, позволяя type быть либо неполным, либо полным с желаемыми ограничениями.

Помимо defined IsFoo , я также определяю IsComplete helper (используя sizeof трюк) и, наконец, IsFooIncomplete следующим образом:

 template<class T> 
concept IsFooIncomplete = !IsComplete<T> || IsFoo<T>;
  

Таким образом, я могу гарантировать, что во время обработки Foo она является неполной, и сразу после завершения класса она является полной и соответствует желаемым IsFoo ограничениям.

 #include <concepts>
#include <type_traits>

template<class T>
concept IsFoo = requires(T self)
{
   {
      self.a
      } -> std::same_as<intamp;>;
};

template<class T>
concept IsComplete = requires(T self)
{
   {
      // You can't apply sizeof to an incomplete type
      sizeof(self)
   };
};

template<class T>
concept IsFooIncomplete = !IsComplete<T> || IsFoo<T>;

#if 0
// Will not compile, because Foo currently has incomplete type
template<IsFoo AFoo>
struct AcceptsFoo
{};
#else
// will compile with IsFooIncomplete
template<IsFooIncomplete AFoo> // no need to use 'class AFoo' here...
struct AcceptsFoo
{};
#endif

struct Foo
{
   int a;
   int b;

   // Foo is incomplete here, but that's fine!
   static_assert(!IsComplete<Foo>);
   AcceptsFoo<Foo> obj;
};

// Foo is now complete, and that's also fine!
static_assert(IsFoo<Foo>);
  

Отлично работает на g версии 10.3.0 (с флагом --std=c 20 ), и я надеюсь, что это сработает и на других компиляторах.

[РЕДАКТИРОВАТЬ] как указано в комментариях, это допускает любой неполный тип, но так и задумано. Только внешнее статическое утверждение будет фильтровать полные варианты типов. Спасибо @David Herring за пример в Bar, я написал его здесь для тестирования:https://godbolt.org/z/sqc75qqMv

[EDIT2] теперь это касается варианта CRTP, без какого-либо неопределенного поведения и без обходного пути IsComplete, просто сохраняя тип для проверки после завершения класса.

 // Will not compile, because Foo currently has incomplete type
template<IsFoo AFoo>
struct AcceptsFoo
{};
#else
template<class AFoo> // will not check IsFoo directly here...
struct AcceptsFoo
{
    using IsFooType = AFoo; // will store type on IsFootType for later checks
};
#endif

struct Foo : public AcceptsFoo<Foo> // will check only when complete
{
    int a;
    int b;
};

// Foo is now complete, and that's also fine!
static_assert(IsFoo<Foo::IsFooType>);

struct FooBar : public AcceptsFoo<FooBar> // will fail once it is complete
{
    //int a;
    int b;
};
// will fail here
static_assert(IsFoo<FooBar::IsFooType>);
  

Это также работает на основных компиляторах: https://godbolt.org/z/e1Gc4Kj5n