Заголовочный файл в языках программирования

заголовочный файл (header file) — это файл, содержащий объявления (например, функций, классов, констант, макросов) и предназначенный для повторного использования в нескольких исходных файлах. Обычно используется для разделения интерфейса и реализации кода. В программировании заголовочный файл (англ. header file) или подключаемый файл — файл, содержимое которого автоматически добавляется препроцессором в исходный текст в том месте, где располагается некоторая директива ({$I file.inc} в Паскале, #include в Си).

В языках программирования Си и C++ заголовочные файлы — основной способ подключить к программе типы данных, структуры, прототипы функций, перечисляемые типы и макросы, используемые в другом модуле. По умолчанию используется расширение .h; иногда для заголовочных файлов языка C++ используют расширение .hpp.

Чтобы избежать повторного включения одного и того же кода, используются директивы #ifndef, #define, #endif.

Заголовочный файл в общем случае может содержать любые конструкции языка программирования, но на практике исполняемый код (за исключением inline-функций в C++) в заголовочные файлы не помещают. Например, идентификаторы, которые должны быть объявлены более чем в одном файле, удобно описать в заголовочном файле, а затем его подключать по мере надобности. Подобным же образом работает модульность и в большинстве ассемблеров.

По сложившейся традиции, в заголовочных файлах объявляют функции стандартной библиотеки Си и Си++.

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

В современных языках программирования программы составляются из модулей, компилируемых по отдельности. В связи с этим возникает вопрос: как указать, что подпрограмма или переменная X определена в модуле Y? Для этого существует несколько решений, в Си применено такое.

В одной из единиц компиляции (то есть с-файле) описывается функция, например:

 int add(int a, int b)
 {
     return a + b;
 }

Чтобы на нее можно было ссылаться из других единиц компиляции, требуется объявить ее при помощи прототипа функции, то есть:

 int add(int, int);
 
 int triple(int x)
 {
     return add(x, add(x, x));
 }

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

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

 /* File triple.c */
 #include "add.h"
 
 int triple(int x)
 {
     return add(x, add(x, x));
 }

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

 /* File add.h */
 #ifndef ADD_H
 #define ADD_H
 
 int add(int, int);
 
 #endif /* ADD_H */

Кроме конструкции #ifndef - #endif иногда применяется нестандартная #pragma once:

 /* File add.h */
 #pragma once

 int add(int, int);

Заголовочные файлы облегчают поддержку — при изменении определения должно быть обновлено лишь одно объявление (то, которое находится в заголовочном файле). К исходному файлу также можно подключать заголовочный файл, содержащий определения, используемые в исходниках. Это позволяет компилятору сверять, совпадает ли объявление в h-файле с определением в c-файле:

 /* File add.c */
 #include "add.h"
 
 int add(int a, int b)
 {
     return a + b;
 }

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

Использование заголовочных файлов в разных языках

1. C и C++

• Расширение: .h (в C и C++), .hpp (в C++).
• Хранит объявления функций, структур, классов и макросов.
• Подключается с помощью #include.

Пример :
math_utils.h

#ifndef MATH_UTILS_H 
#define MATH_UTILS_H 
int add(int a, int b); 
double multiply(double x, double y); 
#endif 

math_utils.c

#include "math_utils.h" 

int add(int a, int b) { 
   return a + b; 
}

 double multiply(double x, double y) {
   return x * y; 
} 

main.c

#include  
#include "math_utils.h" 
int main() { 
   printf("Sum: %d\n", add(3, 4)); 
   return 0; 
} 

2. Java

В Java нет традиционных заголовочных файлов, но интерфейсы выполняют схожую функцию.

// Интерфейс (аналог заголовочного файла) 
public interface MathUtils {
  int add(int a, int b); 
} 

3. C#

C# не использует заголовочные файлы, но можно разделять код через namespace и using.

4. Python

В Python роль заголовочных файлов выполняют модули (.py файлы), которые импортируются с помощью import.

math_utils.py

def add(a, b): 
  return a + b 

main.py

import math_utils 
print(math_utils.add(3, 4)) 

5. JavaScript & TypeScript

В TypeScript используются файлы .d.ts для объявления типов.

Пример:

math_utils.d.ts

declare function add(a: number, b: number): number; 

math_utils.js

function add(a, b) { 
  return a + b; 
}

Альтернатива заголовочным файлам — получение информации об объявленных типах, функциях и т. д. напрямую из откомпилированного модуля. Так поступают языки Паскаль, Java и другие.

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

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

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

Если программист исправил реализацию функции в c-файле, не тронув заголовка, это не вызовет каскадной перекомпиляции всех модулей, которые используют данный заголовок.

Заголовочный файл позволяет задать то, что невозможно задать с помощью модулей — подстановки с помощью #define, директивы компилятора, незаконченные синтаксические конструкции…

Упрощается взаимодействие между модулями, написанными на разных языках. Компилятору и компоновщику вообще безразлично, написан вызываемый модуль на том же языке или на другом. К тому же разные языки могут скомпилировать свои модули в одинаковые объектные файлы — в таком случае получается один компоновщик на несколько языков. Точно так же просто сделать библиотеку, которая по выбору пользователя включается в проект в виде CPP-файлов, хранится заранее откомпилированной и прикомпоновывается статически, или прикомпоновывается как DLL.

Заголовочные файлы намного медленнее — чтобы откомпилировать 10 c-файлов, к каждому из которых подключен длинный h-файл, компилятору придется пройти по заголовку 10 раз. Чтобы справиться с этой проблемой, во многих компиляторах используют предварительно откомпилированные заголовки.

Заголовочные файлы вместе с некоторыми объектами языка C++ (константы, inline-функции, шаблоны, static-переменные) образуют тяжеловесные конструкции.

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

Проектам из языков семейства Си свойственны сложные схемы сборки проекта. Ведь (как минимум в стандартном C++) надо включить в проект библиотеку — либо в виде CPP-файлов, либо в откомпилированном виде. Даже если (например, в Visual C++) для этого есть директивы препроцессора, библиотеку все равно придется собрать.

Выводы

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

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

Хотя не во всех языках программирования есть традиционные заголовочные файлы (например, в Java и Python), их функциональность реализуется через интерфейсы, модули и пространства имен.

• include ,
• Стандартная библиотека языка Си — стандартные заголовочные файлы языка Си
• Стандартная библиотека языка C++ — стандартные заголовочные файлы языка Си++
• java объектно-ориентированное программирование с интерфейсами ,