Заголовочные файлы в Си нужны только для интерфейса?

Question

[AslanPAPA]

Приветствую! В начале хочу написать что, скорее всего я задал этот вопрос т.к у меня мало опыта в этом. И да такой вопрос может быть где-то задавали и я повторяюсь.

Вопрос:
Есть файлы math_functions.c и main.c. Я же могу просто в main.c использовать функции из файла math_functions.c? Но нет нужно ещё объявить этот самый math_functions.h в котором нужно определить функции, вот этого я не понимаю зачем ? Что-то там чтобы в файле main.c компилятор знал про типы функций, зачем ему знать это из заголовочного файла math_functions.h если это есть в файле math_functions.c.
Знаю ещё про то что в заголовочном файле используются #ifndef чтобы не использовать к примеру одну переменную два раз в одном файле, но это же можно и в main.c сделать.

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

Comments

[Vitaliy Ivanov]

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

spoiler

В целом, это просто стандарты Си требуют сначала объявлять функции и переменные, только потом их использовать

[Эдуард Емельянов]

1. header-guards вида "#ifndef __HEADER_H__ ..." устарели сто лет назад. Сейчас достаточно в самом начале, после комментария с лицензией, воткнуть "#pragma once".
2. Если у тебя всего-то 2 файла, ты, конечно, можешь в начале main.c написать прототипы всех фунцкий и глобальных переменных (для переменных, соответственно, нужно будет указать "extern ...").
3. Прочитай сначала Kernigan&Ritchie, а потом уже пытайся что-то на С писать! А то, подозреваю, следующий вопрос будет про указатели…
Кстати, в заголовочных файлах не только прототипы и объявления глобальных переменных, но и определения enum'ов, структур, да и просто часто используемых макросов.

[AslanPAPA]

Эдуард Емельянов, сейчас почти дочитал Стивена Прата, потом k&r начну. Указатели, их я люблю, с ним проблем пока нет)

[Эдуард Емельянов]

AslanPAPA, в gcc, например, есть забавный баг.
Вот такой код:

static void *procthread(void* v){
    typedef void (*procfn_t)(Image*);
    void (*process)(Image*) = (procfn_t)v;

считается неправильным при включении "-pedantic-errors"!
То бишь, официально не хочет преобразовывать void* в указатель на функцию…

// как же задолбала эта убогая капча! Вообще все желание сюда писать отбивает! Твари!

Answer 1

[Wataru]

Для того, чтобы использовать в main.c функцию, определенную в math_functions.c, вам надо иметь ее объявление в main.c

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

Можно просто в main.c написать то, что вы бы написали в math_functions.h. Но это быстро становится сложно, если у вас проект большой и функции используются в разных файлах. Надо будет эти объявления копировать в кучу мест. А если вам еще и поменять что-то надо потом, вы офигеете. Для этого и придумали заголовочные файлы - вы пишите объявление один раз и потом его везде используете.

Вообще, сейчас не обязательно math_functions.h включать и в math_functions.c. Раньше надо было определять функцию даже если ее объявления нигде нет. В современных стандартах это не так. Но все равно хедеры включают в соответствующий файл, чтобы ловить ошибки. Если вы поменяете функцию в .c но не поменяете в хедере, компилятор заметит несоответствие объявления и определения и сообщит об ошибке.

Comments

[AslanPAPA]

Для того, чтобы использовать в main.c функцию, определенную в math_functions.c, вам надо иметь ее объявление в main.c

Вот тут тоже кое что я не понимаю, зачем ? в main.c иметь объявления функций из math_functions.с? Чисто для того чтобы компилятор понимал что есть такая та функция с такими то параметрами ? Но зачем если ей известно уже вся функция и заголовок и тело. Или это просто так надо ?
Это почти похоже на то что к примеру в одном файле к примеру test1.c

#include <stdio.h>

double sqr(double a);

int main(void)
{
     return 0;
}

double sqr(double a)
{
       return a*a;
}

Вот простите конечно, но как же меня бесит, почему писать определение функции на верху, если можно сразу написать её объявление ?

[AslanPAPA]

Что-то я думаю какой-то одной детали, не хватает чтобы мне понять это, и я думаю это практика)

[Wataru]

AslanPAPA, Можно сразу написать определение сверху, не надо объявлений:

#include <stdio.h>

double sqr(double a)
{
       return a*a;
}
int main(void)
{
     return 0;
}

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

Но, если у вас тело sqr в другой единице трансляции, то без объявления никак.

[Wataru]

AslanPAPA,

Но зачем если ей известно уже вся функция и заголовок и тело. Или это просто так надо ?

Вот в примере выше компилятору известно. А если функция в другом файле - то нет. Компилятор, когда комплиирует main.c вообще ничего не знает про файл math_function.c. В Си каждый файл компилируется отдельно независимо от остальных, создает объектый файл. Уже потом линкер из нескольких объектных файлов собирает один исполнительный.

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

[AslanPAPA]

Wataru, Хорошо, в современном стандарте уже в одной единице трансляции определение функции является сразу и объявлением. А на счет того что функция нужно определить первее чем её использовать, ну да это так.
Блин что, то я вроде и понятно. Ноо...

И ещё иногда странно когда говорят, компилятору достаточно того что он знает тип функции и параметры, а то что она делает не важно ? (или это уже имеется ввиду что компилятор знаю тип и параметры уже знает где её тело ?).

Ну это мы больше про один файл говорили. Но вот опять же почему чтобы в main.c использовать функции из math_functions.c нужны определения функций ? Ну хорошо нужны эти определения, так давайте я их определю в самом math_fanctions.c. И все компилятор будет знать определения функций? Или что тут против этого выступает, какое-то другое правило ? Что-то типа плохо включать через #include "math_function.c" нужно именно ".h" или что?

Потом ещё начинает путать немного путает переменные, структуры и enum. Их тоже вот в headers нужно определить как ссылку на то что они существуют. Ну ладно про это потом.

[Wataru]

AslanPAPA,

странно когда говорят, компилятору достаточно того что он знает тип функции и параметры, а то что она делает не важно ?

Тут бы помогло знание ассемблера и того как работают процессоры. Идея такая: чтобы вызвать функцию, компилятору надо сгенерировать код, который параметры и адрес возврата положит в нужное место (стек), а потом перейдет в код функции. Код функции берет параметры из стека, выполняется,а потом возвращает исполнение в место вызова. Тело функции не знает, где оно будет вызвано, оно отдельно где-то есть, ему важно только что вызывающий код правильно положит в стек параметры. Чтобы это правильно сделать надо лишь знать сигнатуру функции - сколько и каких у нее параметров и что она возвращает. Ну и имя, конечно, чтобы знать, что вообще вызывать.

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

Ну хорошо нужны эти определения, так давайте я их определю в самом math_fanctions.c. И все компилятор будет знать определения функций?

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

Что-то типа плохо включать через #include "math_function.c" нужно именно ".h" или что?

Дело в том, что определение - тело - у функции может быть только одно. Теоретически вы можете включить math_function.c в main.c и скомпилировать только main.c. И все даже сработает в этом простейшем случае. Но если у вас в проекте несколько разных файлов, использующих math_function.c у вас опредения функций появятся в разных обхъектных файлах и линкер выдаст ошибку. Компилятор при этом даже все скомпилирует, но исполнительный файл вы собрать не сможете. Теоретически всякими прагмами once и очень аккуратной расстановкой можно даже заставить сложные проекты заработать, но у вас может все сломаться. Вот есть файл a.c он использует функции из b.c. А b.c использует из a.c. Что куда включать и как?

Вторая причина никогда не включать никуда .c файлы - это скорость компиляции. Когда у вас определение функции в отдельной единице трансляции (.с файле) и компилируется отдельно, у вас тело скомпилируется ровно один раз. Если же оно включается в кучу файло, оно будет компилировано в каждом файле. Потом, если вы измените код функции не меняя ее сигнатуру, вам можно не перекомпилировать main.c. Код там только лишь вызывает функцию, он не содержит ее тело. Можно взять уже готовый объектный файл main.o и слинковать его с обновленным math_functions.o.

Answer 2

[Mercury13]

Хедеры служат, чтобы два c-файла — они называются «единицы трансляции» — компилировались по отдельности. Это основное назначение той разновидности include-файлов, которые называются хедерами.

Можно в h-файлы посадить и тела функций, только убедиться, что каждое тело ровно в одной единице трансляции — есть такой подход под названием «одна единица трансляции», и он существует у больших редко перекомпилируемых библиотек, чтобы перекомпиляция была покороче.

Подключение main.c←math_functions.h служит, чтобы сказать компилятору: а где-то в другом месте есть эти функции.

Подключение math_functions.c←math_functions.h — частично для подключения прочего общего вроде типов, частично для проверки на ошибки. Дело в том, что Си традиционно не козявит (does not mangle) имена функций, и если в хедере sin(int), а в реализации sin(double) — будут трудноуловимые ошибки.

Да, деление на единицы компиляции решает и другую задачу — декомпизицию программы на меньшие элементы, и есть противоречие одного с другим (особенно в языке Си++, где хедеры огромны)

В хедере находится только то, что не производит кода. Если говорить про Си++, то…
• inline-объекты (код производят вызовы объекта)
• определения типов, функций и прочего; extern-определения переменных (код производят тела функций и окончательные определения переменных)
• шаблоны, если те нужны более чем в одной единице компиляции (код производит специализация)
Но полные специализации шаблонов производят код и находятся в cpp-файле!

Answer 3

[VoidVolker]

Ну есть же всё в гугле и в манах, где очень подробно всё расписано и даже с примерами: https://ru.wikipedia.org/wiki/Заголовочный_файл

Comments

[AslanPAPA]

Вы правы! Я то привык задавать вопросы в форумах и ждать ответы, когда вы скинули крутой справочник про заголовочный файл. Сейчас МАКСИМАЛЬНО внимательно и подробно прочитаю.

[VoidVolker]

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

[historydev]

VoidVolker, ECMAScript то ещё чтиво)

Answer 4

[Кот Абсолютный]

Ничего не мешает вообще использовать только main.c. Но по мере роста программы и ее сложности ты опухнешь каждый раз рыться в исходнике.

Answer 5

[ImagineTables]

Есть файлы math_functions.c и main.c. Я же могу просто в main.c использовать функции из файла math_functions.c? Но нет нужно ещё объявить этот самый math_functions.h в котором нужно определить функции, вот этого я не понимаю зачем ?

1. В отличие от других ЯП, Си плотно привязан к обработке текста. И это хорошо. Встроенный текстовой препроцессинг это его фишка, которой в других ЯП часто не хватает. Так вот, #include это не using из других языков (когда мы говорим компилятору, что хотим пользоваться таким-то модулем). Это копирование сырого текста из файла в заданное место.

2. Каждый файл .c/.cpp компилируется по отдельности. И компилятор работает с текстом этого файла, а не рассматривает его как модуль какого-то проекта. Если в main.c написать вызов функции из math_functions.c, компилятор эту функцию тупо не найдёт (её же в main.c нет). Значит, компилятору надо сказать перед вызовом каждой функции, что ГДЕ-ТО есть функция с такой сигнатурой (с таким именем и параметрами). Для этого перед первым вызовом функции должно идти её объявление без реализации, заканчивающееся вместо тела символом ;. Раз перед первым вызовом — самое удобное место это начало файла.

3. Чтобы не копипастить эти объявления без реализации руками, их выносят в файл math_functions.h, который при помощи #include подставляется в начало КАЖДОГО файла, где планируется их использовать, и таким образом эти объявления появляются в каждом файле .c/.cpp в виде текста.

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