Что такое предварительные объявления в C ++?

215

По адресу : http://www.learncpp.com/cpp-tutorial/19-header-files/

Упоминается следующее:

add.cpp:

int add(int x, int y)
{
    return x + y;
}

main.cpp:

#include <iostream>

int add(int x, int y); // forward declaration using function prototype

int main()
{
    using namespace std;
    cout << "The sum of 3 and 4 is " << add(3, 4) << endl;
    return 0;
}

Мы использовали предварительное объявление, чтобы компилятор знал, что " add" было при компиляции main.cpp. Как уже упоминалось ранее, написание предварительных объявлений для каждой функции, которую вы хотите использовать и которая находится в другом файле, может быстро утомить.

Можете ли вы объяснить « предварительную декларацию » дальше? В чем проблема, если мы используем его в main()функции?

Простота
источник
1
«Предварительная декларация» на самом деле просто декларация. См. (Конец) этого ответа: stackoverflow.com/questions/1410563/…
sbi

Ответы:

381

Почему форвард-декларирование необходимо в C ++

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

Это на самом деле просто позволяет компилятору лучше выполнять проверку кода и позволяет ему убирать свободные концы, чтобы он мог создавать аккуратный объектный файл. Если вам не нужно пересылать объявленные вещи, компилятор создаст объектный файл, который должен будет содержать информацию обо всех возможных предположениях относительно того, какой может быть функция add. И компоновщик должен был бы содержать очень умную логику, чтобы попытаться определить, какое «add» вы на самом деле намеревались вызвать, когда функция «add» может находиться в другом объектном файле, который компоновщик объединяет с тем, который использует add для создания DLL или Exe. Возможно, что компоновщик может получить неправильное добавление. Скажем, вы хотели использовать int add (int a, float b), но случайно забыли написать его, но компоновщик нашел уже существующий int add (int a, б) и подумал, что это правильно, и использовал это вместо этого. Ваш код будет компилироваться, но не будет делать то, что вы ожидали.

Таким образом, просто для того, чтобы все было ясно, чтобы не было догадок и т. Д., Компилятор настаивает на том, чтобы вы объявляли все перед использованием.

Разница между декларацией и определением

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

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

Вы можете получить объявление функции в вашем текущем файле .cpp или .h, # включив заголовок, который уже содержит объявление функции. Тем не менее, это может замедлить компиляцию, особенно если вы #include заголовка в .h вместо .cpp вашей программы, так как все, что включает в себя #inch .h вы пишете, в конечном итоге # include'ing все заголовки Вы тоже написали #includes для. Внезапно, компилятор имеет включенные # страницы и страницы кода, которые ему нужно скомпилировать, даже если вы хотите использовать только одну или две функции. Чтобы избежать этого, вы можете использовать предварительное объявление и просто ввести объявление функции в верхней части файла. Если вы используете только несколько функций, это действительно может сделать ваши компиляции быстрее, чем всегда, включая заголовок. Для действительно больших проектов,

Разорвать циклические ссылки, где два определения оба используют друг друга

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

Например:

Файл Car.h

#include "Wheel.h"  // Include Wheel's definition so it can be used in Car.
#include <vector>

class Car
{
    std::vector<Wheel> wheels;
};

Файл Wheel.h

Хм ... здесь требуется объявление Car, так как в Wheel есть указатель на Car, но Car.h не может быть здесь включен, так как это приведет к ошибке компилятора. Если был включен Car.h, то он попытался бы включить Wheel.h, который включал бы Car.h, который включал бы Wheel.h, и это продолжалось бы вечно, поэтому вместо этого компилятор вызывает ошибку. Решение состоит в том, чтобы направить объявление об автомобиле вместо:

class Car;     // forward declaration

class Wheel
{
    Car* car;
};

Если бы у класса Wheel были методы, которые должны вызывать методы car, эти методы можно было бы определить в Wheel.cpp, и теперь Wheel.cpp может включать Car.h без вызова цикла.

Скотт Лэнгхэм
источник
4
предварительное объявление также необходимо, когда функция дружественна двум или нескольким классам
Barun
1
Привет, Скотт, что касается времени сборки: скажете ли вы, что это обычная / лучшая практика - всегда пересылать объявления и включать заголовки по мере необходимости в файл .cpp? После прочтения вашего ответа может показаться, что так и должно быть, но мне интересно, есть ли какие-то предостережения?
Zepee
5
@Zepee Это баланс. Для быстрой сборки я бы сказал, что это хорошая практика, и я рекомендую попробовать ее. Однако это может потребовать некоторых усилий и дополнительных строк кода, которые, возможно, потребуется поддерживать и обновлять, если имена типов и т. Д. Все еще изменяются (хотя инструменты становятся лучше в переименовании вещей автоматически). Таким образом, есть компромисс. Я видел кодовые базы, где никто не беспокоится. Если вы обнаружите, что повторяете одни и те же форвардные определения, вы всегда можете поместить их в отдельный заголовочный файл и включить в него что-то вроде: stackoverflow.com/questions/4300696/what-is-the-iosfwd-header
Скотт Лэнгхем,
предварительные объявления требуются, когда заголовочные файлы ссылаются друг на друга: т.е. stackoverflow.com/questions/396084/…
Николас Гамильтон
1
Я вижу, что это позволяет другим разработчикам в моей команде быть действительно плохими гражданами кодовой базы. Если вам не требуется комментарий с предварительным объявлением, например, // From Car.hвы можете создать некоторые опасные ситуации, пытаясь найти определение в будущем, гарантировано.
Dagrooms
25

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

//foo.h
class bar;    // This is useful
class foo
{
    bar* obj; // Pointer or even a reference.
};

// foo.cpp
#include "bar.h"
#include "foo.h"

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

Махеш
источник
12

Поскольку C ++ анализируется сверху вниз, компилятор должен знать о вещах, прежде чем они будут использованы. Итак, когда вы ссылаетесь:

int add( int x, int y )

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

Итак, « Предварительная декларация » - это то, что написано на банке. Он объявляет что-то перед его использованием.

Обычно вы включаете предварительные объявления в заголовочный файл, а затем включаете этот заголовочный файл так же, как и iostream .

Ник
источник
12

Термин « предварительное объявление » в C ++ в основном используется только для объявлений классов . См. (Конец) этого ответа, чтобы узнать, почему «предварительное объявление» класса действительно является простым объявлением класса с причудливым именем.

Другими словами, «вперед» просто добавляет балласт к термину, так как любое объявление можно рассматривать как forward, поскольку оно объявляет некоторый идентификатор перед его использованием.

(Относительно того, что такое декларация в отличие от определения , снова см. Какова разница между определением и декларацией? )

SBI
источник
2

Когда компилятор видит, add(3, 4)он должен знать, что это значит. С помощью предварительного объявления вы в основном сообщаете компилятору, чтоadd это функция, которая принимает два целых числа и возвращает int. Это важная информация для компилятора, потому что он должен поместить 4 и 5 в правильном представлении в стек и должен знать, что это за тип, возвращаемый add.

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

Рене Ниффенеггер
источник
1
int add(int x, int y); // forward declaration using function prototype

Можете ли вы объяснить «предварительную декларацию» более подробно? В чем проблема, если мы используем ее в функции main ()?

Это так же, как #include"add.h". Если вы знаете, препроцессор разворачивает файл, в котором вы упоминаете #include, в файл .cpp, где вы пишете #includeдирективу. Это означает, что если вы напишите#include"add.h" , вы получаете то же самое, как если бы вы делали «предварительное объявление».

Я предполагаю, что add.hимеет эту строку:

int add(int x, int y); 
Наваз
источник
1

Одно быстрое дополнение, касающееся: обычно вы помещаете эти прямые ссылки в заголовочный файл, принадлежащий файлу .c (pp), где реализована функция / переменная и т. д. в вашем примере это будет выглядеть так: add.h:

extern int add (int a, int b);

ключевое слово extern указывает, что функция фактически объявлена ​​во внешнем файле (также может быть библиотекой и т. д.). ваш main.c будет выглядеть так:

#включают 
#include "add.h"

int main ()
{
,
,
,

разъем
источник
Но разве мы не помещаем объявления только в заголовочный файл? Я думаю, именно поэтому функция определена в "add.cpp", и, следовательно, с использованием предварительных объявлений? Спасибо.
Простота
0

Одна проблема заключается в том, что компилятор не знает, какое значение доставляет ваша функция; is предполагает, что функция возвращает intв этом случае, но это может быть как правильно, так и неправильно. Другая проблема заключается в том, что компилятор не знает, какого рода аргументы ожидает ваша функция, и не может предупредить вас, если вы передаете значения неправильного типа. Существуют специальные правила «продвижения», которые применяются при передаче, скажем, значений с плавающей запятой в необъявленную функцию (компилятор должен расширить их до типа double), что часто не соответствует ожиданиям функции, что приводит к трудным поискам ошибок. во время выполнения.

кортик
источник