Что такое предварительные объявления в C++?
По адресу: 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() функционировать?
8 ответов
Почему форвард-декларирование необходимо в C++
Компилятор хочет убедиться, что вы не допустили орфографических ошибок или передали неверное количество аргументов функции. Таким образом, он настаивает на том, что сначала видит объявление 'add' (или любых других типов, классов или функций) перед его использованием.
Это на самом деле просто позволяет компилятору лучше выполнять валидацию кода и позволяет ему убирать свободные концы, чтобы он мог создавать аккуратный объектный файл. Если вам не нужно пересылать объявленные вещи, компилятор создаст объектный файл, который должен будет содержать информацию обо всех возможных предположениях относительно того, какой может быть функция add. И компоновщик должен был бы содержать очень умную логику, чтобы попытаться выяснить, какое "add" вы на самом деле намеревались вызвать, когда функция "add" может находиться в другом объектном файле, который компоновщик объединяет с тем, который использует add для создания DLL или Exe. Возможно, что компоновщик может получить неправильное добавление. Скажем, вы хотели использовать int add(int a, float b), но случайно забыли написать его, но компоновщик нашел уже существующий int add(int a, int b) и подумал, что он правильный, и использовал его вместо этого. Ваш код будет компилироваться, но не будет делать то, что вы ожидали.
Таким образом, просто для того, чтобы все было ясно и избегать догадок и т. Д., Компилятор настаивает на том, чтобы вы объявляли все перед использованием.
Разница между декларацией и определением
Кроме того, важно знать разницу между декларацией и определением. Объявление просто дает достаточно кода, чтобы показать, как что-то выглядит, поэтому для функции это тип возвращаемого значения, соглашение о вызове, имя метода, аргументы и их типы. Но код для метода не требуется. Для определения вам нужно объявление, а затем и код для функции.
Как предварительные декларации могут значительно сократить время сборки
Вы можете получить объявление функции в вашем текущем файле.cpp или.h, # включив заголовок, который уже содержит объявление функции. Тем не менее, это может замедлить компиляцию, особенно если вы #include заголовка в.h вместо.cpp вашей программы, так как все, что #include.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, не вызывая цикл.
Компилятор ищет каждый символ, используемый в текущей единице перевода, ранее объявленной или нет в текущей единице. Это просто вопрос стиля, обеспечивающий все сигнатуры методов в начале исходного файла, а определения будут предоставлены позже. Значительное использование этого происходит, когда вы используете указатель на класс как переменную-член другого класса.
//foo.h
class bar; // This is useful
class foo
{
bar* obj; // Pointer or even a reference.
};
// foo.cpp
#include "bar.h"
#include "foo.h"
Поэтому, когда это возможно, используйте forward-объявления в классах. Если ваша программа просто имеет функции (с заголовочными файлами), то предоставление прототипов в начале - это просто вопрос стиля. Это было бы так или иначе, если бы файл заголовка присутствовал в обычной программе с заголовком, который имеет только функции.
Поскольку C++ анализируется сверху вниз, компилятор должен знать о вещах, прежде чем они будут использованы. Итак, когда вы ссылаетесь:
int add( int x, int y )
в основной функции компилятор должен знать, что он существует. Чтобы доказать это, попробуйте переместить его ниже основной функции, и вы получите ошибку компилятора.
Так что "Предварительная декларация" - это то, что написано на банке. Он объявляет что-то перед его использованием.
Обычно вы включаете предварительные объявления в заголовочный файл, а затем включаете этот заголовочный файл так же, как и iostream.
Термин "прямое объявление" в C++ в основном используется только для объявлений классов. См. (Конец) этого ответа, чтобы узнать, почему "предварительное объявление" класса действительно является простым объявлением класса с причудливым именем.
Другими словами, "forward" просто добавляет балласт к термину, поскольку любое объявление может рассматриваться как прямое, поскольку оно объявляет некоторый идентификатор перед его использованием.
(Относительно того, что является декларацией в отличие от определения, снова см. Какова разница между определением и декларацией?)
Когда компилятор видит add(3, 4) это должно знать, что это значит. С помощью предварительного объявления вы в основном сообщаете компилятору, что add это функция, которая принимает два целых числа и возвращает целое число Это важная информация для компилятора, потому что он должен поместить 4 и 5 в правильном представлении в стек и должен знать, что это за тип, возвращаемый add.
В то время компилятор не беспокоился о фактической реализации add, т.е. где это (или если даже есть один), и если это компилируется. Это становится понятным позже, после компиляции исходных файлов при вызове компоновщика.
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);
Одно быстрое дополнение, касающееся: обычно вы помещаете эти прямые ссылки в заголовочный файл, принадлежащий файлу.c(pp), где реализована функция / переменная и т. д. в вашем примере это будет выглядеть так: add.h:
extern int add (int a, int b);
ключевое слово extern указывает, что функция фактически объявлена во внешнем файле (также может быть библиотекой и т. д.). ваш main.c будет выглядеть так:
#включают
#include "add.h"
int main()
{,,,
Одна проблема заключается в том, что компилятор не знает, какое значение доставляет ваша функция; is предполагает, что функция возвращает int в этом случае, но это может быть как правильно, так и неправильно. Другая проблема состоит в том, что компилятор не знает, какого рода аргументы ожидает ваша функция, и не может предупредить вас, если вы передаете значения неправильного типа. Существуют специальные правила "продвижения", которые применяются при передаче, скажем, значений с плавающей запятой в необъявленную функцию (компилятор должен расширить их до типа double), что часто не соответствует ожиданиям функции, что приводит к трудностям в поиске ошибок. во время выполнения.