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

Я ищу определение, когда мне разрешено делать предварительное объявление класса в заголовочном файле другого класса:

Могу ли я сделать это для базового класса, для класса, который является членом, для класса, переданного функции-члену по ссылке и т. Д.?

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

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

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> , например.

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

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

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

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

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

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

с class Foo;// предварительным объявлением

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