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

Поставьте себя на место компилятора: когда вы пересылаете объявление типа, все, что компилятор знает, - это то, что этот тип существует; он ничего не знает о своем размере, членах или методах. Вот почему он называется неполным типом. Следовательно, вы не можете использовать тип для объявления члена или базового класса, поскольку компилятору необходимо знать макет типа.

Предполагая следующее предварительное объявление.

class X;

Вот что можно и нельзя делать.

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

• Объявите член указателем или ссылкой на неполный тип:

  class Foo {
      X *p;
      X &r;
  };
  

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

  void f1(X);
  X    f2();
  

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

  void f3(X*, X&) {}
  X&   f4()       {}
  X*   f5()       {}
  

Что нельзя сделать с неполным типом:

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

  class Foo : X {} // compiler error!
  

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

  class Foo {
      X m; // compiler error!
  };
  

• Определите функции или методы, использующие этот тип

  void f1(X x) {} // compiler error!
  X    f2()    {} // compiler error!
  

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

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

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

Например, std::vector<T> требует, чтобы его параметр был полного типа, а boost::container::vector<T> - нет. Иногда полный тип требуется только в том случае, если вы используете определенные функции-члены; это относится к std::unique_ptr<T> , Например.

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

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

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

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

1. in-name-only (для которых достаточно предварительного объявления) и
2. 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>;
  

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

с _1 _ // форвардное объявление

Мы можем объявить элементы данных типа 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

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

Кроме

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

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

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

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

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

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

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

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

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

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

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

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

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

Мы должны использовать объявление Forward везде, где это возможно, чтобы избежать нежелательной инъекции зависимостей.

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