Когда я могу использовать предварительную декларацию?

Главное правило состоит в том, что вы можете только forward-declare классы, чей макет памяти (и, следовательно, функции-члены и члены данных) не обязательно должны быть известны в файле, который вы пересылаете, объявите его.

Это исключает базовые классы и все, кроме классов, используемых с помощью ссылок и указателей.

Lakos различает использование класса

• in-name-only (для которого достаточно прямого объявления) и
• in-size (для которого требуется определение класса).

Я никогда не видел, чтобы это произносилось более кратко:)

Помимо указателей и ссылок на неполные типы, вы также можете объявить прототипы функций, которые указывают параметры и/или возвращаемые значения, которые являются неполными. Тем не менее, вы не можете определить функцию с неполным параметром или возвращаемым типом, если это не указатель или ссылка.

Примеры:

struct X;              // Forward declaration of X

void f1(X* px) {}      // Legal: can always use a pointer
void f2(X&  x) {}      // Legal: can always use a reference
X f3(int);             // Legal: return value in function prototype
void f4(X);            // Legal: parameter in function prototype
void f5(X) {}          // ILLEGAL: *definitions* require complete types

Ни один из ответов до сих пор не описывает, когда можно использовать форвардное объявление шаблона класса. Итак, вот оно.

Шаблон класса может быть перенаправлен как:

template <typename> struct X;

Следуя структуре принятого ответа,

Здесь то, что вы можете и чего не можете сделать.

Что вы можете сделать с неполным типом:

• Объявите элемент как указатель или ссылку на неполный тип в другом шаблоне класса:

  template <typename T>
  class Foo {
      X<T>* ptr;
      X<T>& ref;
  };
  

• Объявить элемент как указатель или ссылку на одно из своих неполных экземпляров:

  class Foo {
      X<int>* ptr;
      X<int>& ref;
  };
  

• Объявлять шаблоны функций или шаблоны функций-членов, которые принимают/возвращают неполные типы:

  template <typename T>
     void      f1(X<T>);
  template <typename T>
     X<T>    f2();
  

• Объявлять функции или функции-члены, которые принимают/возвращают одно из своих неполных экземпляров:

  void      f1(X<int>);
  X<int>    f2();
  

• Определить шаблоны функций или шаблоны функций-членов, которые принимают/возвращают указатели/ссылки на неполный тип (но не используют его элементы):

  template <typename T>
     void      f3(X<T>*, X<T>&) {}
  template <typename T>
     X<T>&   f4(X<T>& in) { return in; }
  template <typename T>
     X<T>*   f5(X<T>* in) { return in; }
  

• Определите функции или методы, которые принимают/возвращают указатели/ссылки на одну из своих неполных экземпляров (но не используют ее элементы):

  void      f3(X<int>*, X<int>&) {}
  X<int>&   f4(X<int>& in) { return in; }
  X<int>*   f5(X<int>* in) { return in; }
  

• Используйте его как базовый класс другого класса шаблонов

  template <typename T>
  class Foo : X<T> {} // OK as long as X is defined before
                      // Foo is instantiated.
  
  Foo<int> a1; // Compiler error.
  
  template <typename T> struct X {};
  Foo<int> a2; // OK since X is now defined.
  

• Используйте его для объявления члена другого шаблона класса:

  template <typename T>
  class Foo {
      X<T> m; // OK as long as X is defined before
              // Foo is instantiated. 
  };
  
  Foo<int> a1; // Compiler error.
  
  template <typename T> struct X {};
  Foo<int> a2; // OK since X is now defined.
  

• Определение шаблонов функций или методов с использованием этого типа

  template <typename T>
    void    f1(X<T> x) {}    // OK if X is defined before calling f1
  template <typename T>
    X<T>    f2(){return X<T>(); }  // OK if X is defined before calling f2
  
  void test1()
  {
     f1(X<int>());  // Compiler error
     f2<int>();     // Compiler error
  }
  
  template <typename T> struct X {};
  
  void test2()
  {
     f1(X<int>());  // OK since X is defined now
     f2<int>();     // OK since X is defined now
  }
  

Что вы не можете сделать с неполным типом:

• Используйте один из своих экземпляров как базовый класс

  class Foo : X<int> {} // compiler error!
  

• Используйте одно из своих экземпляров, чтобы объявить участника:

  class Foo {
      X<int> m; // compiler error!
  };
  

• Определять функции или методы с использованием одного из его экземпляров

  void      f1(X<int> x) {}            // compiler error!
  X<int>    f2() {return X<int>(); }   // compiler error!
  

• Используйте методы или поля одного из его экземпляров, на самом деле пытается разыменовать переменную с неполным типом

  class Foo {
      X<int>* m;            
      void method()            
      {
          m->someMethod();      // compiler error!
          int i = m->someField; // compiler error!
      }
  };
  

• Создание явных экземпляров шаблона класса

  template struct X<int>;
  

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

с class Foo;//forward declare

Мы можем объявлять элементы данных типа Foo * или Foo &.

Мы можем объявлять (но не определять) функции с аргументами и/или возвращаемыми значениями типа Foo.

Мы можем объявлять статические элементы данных типа Foo. Это связано с тем, что статические члены данных определяются вне определения класса.

До тех пор, пока вам не нужно определение (мыслители и ссылки), вы можете уйти с передовыми объявлениями. Вот почему в большинстве случаев вы увидите их в заголовках, в то время как файлы реализации обычно вытягивают заголовок для соответствующих определений.

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

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

Если вы возвращаете или принимаете ссылочные типы, то вы просто говорите, что они могут пройти через указатель или ссылку, которую они могут в свою очередь знать только через декларацию вперед.

Когда вы возвращаете неполный тип X f2();, вы говорите, что ваш вызывающий должен иметь полную спецификацию типа X. Они нуждаются в ней для создания LHS или временного объекта при вызове сайт.

Аналогично, если вы принимаете неполный тип, вызывающий должен построить объект, являющийся параметром. Даже если этот объект был возвращен как еще один неполный тип из функции, сайту вызова требуется полное объявление. то есть:.

class X;  // forward for two legal declarations 
X returnsX();
void XAcceptor(X);

XAcepptor( returnsX() );  // X declaration needs to be known here

Я думаю, что существует важный принцип, согласно которому заголовок должен предоставлять достаточную информацию для использования без зависимостей, требующих других заголовков. Это означает, что заголовок должен быть включен в блок компиляции, не вызывая ошибки компилятора при использовании любых функций, которые он объявляет.

За исключением

• Если эта внешняя зависимость является желаемой. Вместо использования условной компиляции у вас может быть хорошо документированное требование для их подачи собственного заголовка, объявляющего X. Это альтернатива использованию #ifdefs и может быть полезным способом введения mocks или других вариантов.

• Важным отличием является то, что некоторые шаблонные методы, в которых вы явно НЕ должны их создавать, упомянули просто так, что кто-то не смущает меня.

Общее правило, которое я придерживаюсь, - это не включать заголовочный файл, если только не нужно. Поэтому, если я не храню объект класса в качестве переменной-члена моего класса, я его не буду включать, я просто буду использовать декларацию forward.

Я просто хочу добавить одну важную вещь, которую вы можете сделать с переадресованным классом, не упомянутым в ответе Люка Торайля.

Что вы можете сделать с неполным типом:

Определить функции или методы, которые принимают/возвращают указатели/ссылки на неполный тип и пересылать указатели/ссылки к другой функции.

void  f6(X*)       {}
void  f7(X&)       {}
void  f8(X* x_ptr, X& x_ref) { f6(x_ptr); f7(x_ref); }

Модуль может проходить через объект прямого объявленного класса другому модулю.

Возьмите его, чтобы форвардное объявление получило ваш код для компиляции (создается объект obj). Однако связывание (создание exe) не будет успешным, если определения не найдены.

Обычно вы хотите использовать форвардное объявление в заголовочном файле классов, если хотите использовать другой тип (класс) в качестве члена класса. Вы не можете использовать методы, объявленные вперед, в заголовочном файле, потому что С++ пока не знает определения этого класса. Эта логика вам нужно переместить в .cpp файлы, но если вы используете шаблонные функции, вы должны уменьшить их только до той части, которая использует шаблон, и переместить эту функцию в заголовок.