Является ли экземпляр шаблона класса неполным типом плохо сформированным, если тип определяется впоследствии?

Ответ 1

Предполагая, что у нас есть только одна единица перевода, [temp.point] исключает вашу цитату как возможный источник плохой формальности

Специализация шаблона класса имеет не более одной точки инстанцирования внутри единицы перевода.

Вместо этого проблема с первым фрагментом - [temp.expl.spec]

Если шаблон, шаблон-член или член шаблона класса явно специализирован, то эта специализация должна быть объявлена до первого использования этой специализации, которая вызовет неявное создание экземпляра, в каждой единицы перевода, в которой такое использование происходит; диагностика не требуется.

Второй фрагмент хорошо сформирован, нет требования, чтобы параметры шаблона имели полный тип.

Третий фрагмент плохо сформирован, new T требует, чтобы T был полным типом. Небольшой улов здесь заключается в том, что определение конструктора неявно создается в Foo<A> foo; , Если, однако, фрагмент изменен на

struct A;

template <typename T>
struct Foo {
    Foo() {
        new T;
    }
};

using FooA = Foo<A>;

struct A {};

Тогда определение конструктора не создается и поэтому будет корректно сформировано. [temp.inst]

Неявное инстанцирование специализации шаблона шаблона вызывает

• неявное создание деклараций, но не определений, функций-не-удаленных членов класса, классов-членов, облачных имен элементов, статических членов данных, шаблонов-членов и друзей; а также [...]

Четвертый фрагмент плохо сформирован, потому что члены должны иметь полный тип. [class.mem]

Тип нестатического элемента данных не должен быть неполным типом [...]

Ответ 2

struct A;
template <typename> class Foo { };
Foo<A> foo; // note A is incomplete here
struct A {};

Foo<A> зависит только от имени A не от его полного типа.

Итак, это хорошо сформировано; однако этот вид вещей все еще может сломаться (стать плохо сформированным), но скомпилировать в каждом тестируемом компиляторе.

Во-первых, мы крадем is_complete. Затем мы делаем следующее:

struct A;
template <class T> class Foo {
  enum{ value = is_complete<T>::value };
};
Foo<A> foo; // note A is incomplete here
struct A {};

Мы в порядке, несмотря на это:

[...] для любой такой специализации, которая имеет точку инстанцирования внутри единицы перевода, конец единицы перевода также считается точкой инстанцирования. [...]

потому что это предложение не относится к классам шаблонов. Здесь единственный экземпляр класса шаблона в порядке.

Теперь, если в другом файле у вас есть:

struct A {};
Foo<A> foo2;

ваша программа плохо сформирована.

Однако в случае с одним файлом:

struct A;
template <class T> class Foo {
  enum{ value = is_complete<T>::value };
};
Foo<A> foo; // note A is incomplete here
struct A {};
Foo<A> foo2; // ill-formed

ваш код в порядке. Существует одна точка инстанцирования для Foo<A> в данной единице компиляции; вторая - это ссылка на первую точку инстанцирования.

И один, и два файла versoins почти наверняка будут компилироваться в компиляторах C++ без ошибок или предупреждений.

Некоторые компиляторы запоминают экземпляры шаблонов даже из одного блока компиляции в пыльник; Foo<A> будет иметь ::value которое является false даже после создания foo2 (с полным A). Другие будут иметь два разных Foo<A> в каждом модуле компиляции; его методы будут отмечены inline (и будут отличаться), размер классов может не совпадать, и вы получите каскады плохо сформированных программных проблем.

Обратите внимание, что многие типы в std требуют, чтобы их аргументы шаблона были завершены в более старых версиях C++ (включая c++11: "17.6.4.8 Другие функции (...) 2. эффекты не определены в следующих случаях: (...) В частности - если неполный тип (3.9) используется в качестве аргумента шаблона при создании экземпляра компонента шаблона, если только это не разрешено для этого компонента "- скопировано из документов с неполным контейнером". Чтобы быть конкретным, std::vector<T> используется для завершения T

По c++17, который изменился для std::vector:

[Vector.overview]/3

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

Теперь, даже до c++17, большинство реализаций std::vector<T> отлично с неполным T пока вы не попытаетесь использовать метод (включая многие его конструкторы или деструктор), но в стандарте указано, что T должен быть полным.

Это фактически мешает некоторому неиспользуемому коду, например, иметь тип функции, который возвращает векторы своего типа ¹. У Boost есть библиотека для решения этой проблемы.

template <typename T>
struct Foo {
  Foo() {
    new T;
  }
};

Тело Foo<T>::Foo() создается только при вызове ". Таким образом, T отсутствие завершения не влияет на Foo::Foo().

Foo<A> foo;

^^ не скомпилируется с неполным A

using foo_t = Foo<A>;

^^ скомпилирует и не вызовет никаких проблем.

using foo_t = Foo<A>;
struct A {};
foo_t foo;

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

¹ Можете ли вы сказать, что функция перехода в состояние машины?

Ответ 3

К счастью, да, это четко определено. По той же причине это четко определено:

struct A;

class Foo { A* value; };

Foo foo; // note A is incomplete here

struct A {};

и это плохо сформировано:

struct A;

template <class T> class Foo { T value; }; // error: 'Foo<T>::value' has incomplete type

Foo<A> foo; // note A is incomplete here

struct A {};