3.3. Включение текстов из файлов

Теория

Зачем нужен этот пункт

В языке C программа редко состоит только из одного полностью самостоятельного файла. Даже простая программа, которая выводит текст через printf, обычно подключает заголовочный файл stdio.h.

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

В этом пункте рассматриваются:

Что делает #include

Директива #include говорит препроцессору: взять текст указанного файла и включить его в текущий файл на место этой директивы.

#include <stdio.h>

Упрощённо это можно представить так:

текст до #include

#include <stdio.h>

текст после #include

После препроцессорной обработки:

текст до #include

содержимое файла stdio.h

текст после #include

То есть #include не выполняется во время работы программы. Он обрабатывается до компиляции, на этапе подготовки исходного текста.

Зачем подключать заголовочные файлы

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

Например, функция printf находится в стандартной библиотеке, но чтобы компилятор правильно проверил её вызов, нужно подключить заголовочный файл stdio.h.

#include <stdio.h>

int main(void)
{
    printf("Hello\n");
    return 0;
}

Без #include <stdio.h> компилятор может не знать прототип функции printf. Это может привести к предупреждениям или ошибкам.

Три формы записи #include

Директива #include имеет три основные формы записи.

#include <имя_файла>
#include "имя_файла"
#include имя_макроса

Первая форма обычно используется для стандартных заголовочных файлов:

#include <stdio.h>
#include <math.h>
#include <string.h>

Вторая форма обычно используется для собственных заголовочных файлов проекта:

#include "my_math.h"
#include "student.h"
#include "config.h"

Третья форма используется реже. В ней имя файла получается через макроподстановку:

#define HEADER_FILE "config.h"

#include HEADER_FILE

Форма с угловыми скобками

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

#include <stdio.h>

Эта форма используется для стандартных библиотечных заголовков.

#include <stdlib.h>
#include <math.h>
#include <limits.h>
#include <float.h>

Например, stdio.h содержит объявления средств стандартного ввода-вывода, math.h — объявления математических функций, а limits.h — предельные значения целочисленных типов.

Форма с кавычками

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

#include "my_header.h"

Такая форма используется для собственных заголовочных файлов проекта.

Например, если проект состоит из файлов:

main.c
math_utils.c
math_utils.h

то в main.c можно подключить собственный заголовок так:

#include "math_utils.h"

Это означает: найти файл math_utils.h в проекте и включить его текст в текущий файл.

Разница между <...> и "..."

Форма Обычно используется для Где ищется файл
#include <stdio.h> стандартных заголовков в системных каталогах компилятора
#include "my_header.h" собственных заголовков проекта сначала в каталоге проекта, затем в стандартных путях

Практическое правило:

#include <...>   /* стандартная библиотека */
#include "..."   /* файлы своего проекта */

Так код становится понятнее: по форме подключения сразу видно, стандартный это заголовок или собственный файл проекта.

Форма через макрос

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

#define HEADER <stdio.h>

#include HEADER

После макроподстановки получится:

#include <stdio.h>

Другой вариант:

#define PROJECT_HEADER "config.h"

#include PROJECT_HEADER

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

Что такое заголовочный файл

Заголовочный файл — это файл, который обычно содержит объявления, необходимые другим исходным файлам.

По соглашению заголовочные файлы в C часто имеют расширение .h.

stdio.h
math.h
string.h
my_math.h
student.h

В заголовочный файл обычно помещают:

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

Что обычно не помещают в заголовочный файл

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

Плохая идея для обычного заголовка:

int counter = 0;

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

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

Обычно в заголовке пишут объявление:

extern int counter;

int sum(int a, int b);

А настоящее определение помещают в один .c файл:

int counter = 0;

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

Стандартные заголовочные файлы

Стандартная библиотека C предоставляет набор заголовочных файлов. Каждый из них связан с определённой группой возможностей.

Заголовок Назначение
assert.h диагностика программ, проверочные утверждения
ctype.h проверка и преобразование символов
errno.h коды ошибок
float.h характеристики вещественных типов
limits.h предельные значения целочисленных типов
locale.h настройки локали и национальной среды
math.h математические функции
setjmp.h нелокальные переходы
signal.h обработка сигналов
stdarg.h функции с переменным числом аргументов
stddef.h стандартные определения и типы
stdio.h стандартный ввод-вывод
stdlib.h функции общего назначения, память, преобразования, завершение программы
string.h работа со строками и блоками памяти
time.h дата и время

Для большинства начальных программ чаще всего используются stdio.h, stdlib.h, math.h, string.h, limits.h и float.h.

Примеры подключения стандартных заголовков

stdio.h

#include <stdio.h>

int main(void)
{
    printf("Hello\n");
    return 0;
}

Заголовок stdio.h нужен для функций стандартного ввода-вывода, например printf, scanf, fopen, fclose.

math.h

#include <stdio.h>
#include <math.h>

int main(void)
{
    double x = 16.0;

    printf("%f\n", sqrt(x));

    return 0;
}

Заголовок math.h нужен для математических функций: sqrt, sin, cos, pow и других.

limits.h

#include <stdio.h>
#include <limits.h>

int main(void)
{
    printf("INT_MAX = %d\n", INT_MAX);
    return 0;
}

Заголовок limits.h содержит предельные значения целочисленных типов.

Имена из стандартных заголовков

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

Примеры:

Не стоит создавать собственные имена, совпадающие с именами стандартной библиотеки. Это может привести к конфликтам и непонятным ошибкам.

Порядок подключения заголовков

Заголовочные файлы обычно подключают в начале исходного файла.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "my_math.h"
#include "student.h"

Часто сначала подключают стандартные заголовки, затем собственные заголовки проекта. Это не жёсткое правило языка, но такой порядок хорошо читается.

Действие подключённого файла распространяется на текст, который идёт после директивы #include.

printf("Hello\n");       /* здесь stdio.h ещё не подключён */

#include <stdio.h>

printf("Hello\n");       /* здесь объявление printf уже известно */

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

Повторное подключение стандартных заголовков

Стандартные заголовочные файлы обычно можно подключать несколько раз без вредных последствий.

#include <stdio.h>
#include <stdio.h>

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

Для собственных заголовков такую защиту нужно добавлять самостоятельно. Это будет рассмотрено ниже в этом пункте.

Собственный заголовочный файл

Допустим, в проекте есть функция сложения двух чисел. Её можно вынести в отдельный исходный файл, а прототип поместить в заголовочный файл.

Структура проекта:

project/
├── main.c
├── math_utils.c
└── math_utils.h

Файл math_utils.h:

#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int sum(int a, int b);

#endif

Файл math_utils.c:

#include "math_utils.h"

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

Файл main.c:

#include <stdio.h>
#include "math_utils.h"

int main(void)
{
    int result = sum(10, 20);

    printf("result = %d\n", result);

    return 0;
}

В таком проекте заголовочный файл сообщает main.c, что функция sum существует, принимает два int и возвращает int.

Защита от повторного включения

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

#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int sum(int a, int b);
int max2(int a, int b);

#endif

Здесь:

Такой приём называют include guard, или защитой заголовочного файла.

#pragma once

В некоторых компиляторах для защиты от повторного включения используют директиву:

#pragma once

Тогда заголовок может выглядеть так:

#pragma once

int sum(int a, int b);
int max2(int a, int b);

Такая запись короче, но #pragma относится к директивам, зависящим от реализации компилятора. Для учебного классического C полезно знать стандартный вариант через #ifndef, #define и #endif.

Что помещать в собственный .h файл

В собственный заголовочный файл обычно помещают то, что должно быть известно нескольким .c файлам.

Например:

#ifndef STUDENT_H
#define STUDENT_H

#define MAX_NAME_LENGTH 64

struct Student
{
    char name[MAX_NAME_LENGTH];
    int age;
    double averageMark;
};

void printStudent(struct Student student);
int isExcellentStudent(struct Student student);

#endif

Здесь в заголовке находятся:

Любой файл, который подключит student.h, сможет использовать эту структуру и эти функции.

Объявления внешних переменных через extern

Иногда нескольким файлам нужно обращаться к одной глобальной переменной. В этом случае в заголовке размещают объявление через extern, а само определение переменной оставляют только в одном .c файле.

Файл globals.h:

#ifndef GLOBALS_H
#define GLOBALS_H

extern int recordsCount;

#endif

Файл globals.c:

#include "globals.h"

int recordsCount = 0;

Файл main.c:

#include <stdio.h>
#include "globals.h"

int main(void)
{
    recordsCount++;

    printf("%d\n", recordsCount);

    return 0;
}

Ключевое правило: в заголовке — объявление через extern, в одном исходном файле — настоящее определение.

Почему не стоит подключать .c файлы через #include

Технически препроцессор может включить текст любого файла, не только .h. Но в нормальной многофайловой разработке не принято подключать .c файлы через #include.

Плохая практика:

#include "math_utils.c"

Обычно делают так:

Правильная схема:

main.c         подключает math_utils.h
math_utils.c   подключает math_utils.h

оба .c файла компилируются
затем объединяются в одну программу

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

Пример многофайлового проекта

Рассмотрим маленький проект с двумя функциями.

Файл array_utils.h:

#ifndef ARRAY_UTILS_H
#define ARRAY_UTILS_H

int arraySum(int a[], int n);
int arrayMax(int a[], int n);

#endif

Файл array_utils.c:

#include "array_utils.h"

int arraySum(int a[], int n)
{
    int i;
    int sum = 0;

    for (i = 0; i < n; i++)
    {
        sum += a[i];
    }

    return sum;
}

int arrayMax(int a[], int n)
{
    int i;
    int max = a[0];

    for (i = 1; i < n; i++)
    {
        if (a[i] > max)
        {
            max = a[i];
        }
    }

    return max;
}

Файл main.c:

#include <stdio.h>
#include "array_utils.h"

int main(void)
{
    int a[5] = { 4, 8, 1, 9, 3 };

    printf("sum = %d\n", arraySum(a, 5));
    printf("max = %d\n", arrayMax(a, 5));

    return 0;
}

Файл main.c не знает подробностей реализации функций. Ему достаточно прототипов из array_utils.h. Реализация находится в array_utils.c.

Как компилировать такой проект

Если проект состоит из нескольких .c файлов, при сборке нужно передать компилятору все исходные файлы.

gcc main.c array_utils.c -o program

Здесь:

Заголовочный файл array_utils.h не указывается как отдельный файл для компиляции. Он подключается через #include в нужные .c файлы.

Что происходит при include в многофайловом проекте

Важно понимать: #include работает отдельно для каждого исходного файла.

main.c:
#include "array_utils.h"

array_utils.c:
#include "array_utils.h"

Препроцессор обрабатывает main.c и вставляет туда текст array_utils.h. Потом он отдельно обрабатывает array_utils.c и тоже вставляет туда текст array_utils.h.

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

Вложенные подключения

Один заголовочный файл может подключать другой заголовочный файл.

/* student.h */
#ifndef STUDENT_H
#define STUDENT_H

#include <stdio.h>

struct Student
{
    char name[64];
    int age;
};

void printStudent(struct Student student);

#endif

Здесь student.h сам подключает stdio.h. Это может быть нужно, если в заголовке используются типы или объявления из другого заголовочного файла.

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

Минимально необходимые подключения

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

Например, если файл использует printf:

#include <stdio.h>

Если файл использует sqrt:

#include <math.h>

Если файл использует strlen:

#include <string.h>

Не нужно подключать все заголовки «на всякий случай».

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
/* плохо, если большая часть этого не используется */

Лишние подключения ухудшают читаемость и могут приводить к конфликтам имён в больших проектах.

Относительные пути в #include

В собственных проектах заголовочные файлы могут лежать в отдельных каталогах.

project/
├── include/
│   └── array_utils.h
└── src/
    ├── main.c
    └── array_utils.c

Тогда в исходном файле можно написать относительный путь:

#include "../include/array_utils.h"

Но в больших проектах чаще настраивают путь поиска заголовков в параметрах компилятора. Например:

gcc src/main.c src/array_utils.c -Iinclude -o program

После этого можно подключать заголовок проще:

#include "array_utils.h"

Ключ -Iinclude сообщает компилятору, что заголовочные файлы нужно искать ещё и в каталоге include.

Связь #include и прототипов функций

В однофайловой программе прототипы функций можно писать прямо перед main.

int sum(int a, int b);

int main(void)
{
    return sum(1, 2);
}

В многофайловой программе удобнее вынести прототипы в заголовочный файл.

/* math_utils.h */
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int sum(int a, int b);
int max2(int a, int b);

#endif

Тогда любой файл, которому нужны эти функции, подключает один заголовок:

#include "math_utils.h"

Это уменьшает дублирование: прототип функции хранится в одном месте, а используется во многих файлах.

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

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

Например, модуль работы с массивами может иметь такой интерфейс:

#ifndef ARRAY_UTILS_H
#define ARRAY_UTILS_H

void readArray(int a[], int n);
void printArray(int a[], int n);
int arraySum(int a[], int n);
int arrayMax(int a[], int n);

#endif

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

Такое разделение помогает делать программу более аккуратной:

Включение обычного текста из файла

Директива #include технически включает текст из файла. Поэтому в учебных примерах можно встретить включение не только заголовков, но и других текстовых фрагментов.

#include "constants.inc"

Однако в обычном C-проекте лучше придерживаться ясной структуры:

Чем понятнее структура проекта, тем легче его собирать, проверять и объяснять.

Типичные ошибки

Ошибка 1. Забыли подключить нужный заголовок

int main(void)
{
    printf("Hello\n");
    return 0;
}

Для printf нужен stdio.h.

#include <stdio.h>

int main(void)
{
    printf("Hello\n");
    return 0;
}

Ошибка 2. Собственный файл подключён через угловые скобки

#include <math_utils.h>

Если это файл проекта, обычно нужно писать:

#include "math_utils.h"

Ошибка 3. Стандартный заголовок подключён через кавычки

#include "stdio.h"

Для стандартных заголовков обычно пишут:

#include <stdio.h>

Ошибка 4. Нет защиты от повторного включения

/* math_utils.h */
int sum(int a, int b);

Лучше:

#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int sum(int a, int b);

#endif

Ошибка 5. Определение глобальной переменной в заголовке

/* globals.h */
int counter = 0;

Если такой заголовок подключить в несколько файлов, появятся несколько определений. Лучше:

/* globals.h */
extern int counter;

А в одном .c файле:

int counter = 0;

Ошибка 6. Подключение .c файла

#include "array_utils.c"

Обычно нужно подключать заголовок:

#include "array_utils.h"

А файл array_utils.c передавать компилятору при сборке:

gcc main.c array_utils.c -o program

Практические рекомендации

Мини-разбор проекта

Рассмотрим маленький проект:

project/
├── main.c
├── geometry.c
└── geometry.h

Файл geometry.h:

#ifndef GEOMETRY_H
#define GEOMETRY_H

double rectangleArea(double width, double height);
double circleArea(double radius);

#endif

Файл geometry.c:

#include "geometry.h"

#define PI 3.14159

double rectangleArea(double width, double height)
{
    return width * height;
}

double circleArea(double radius)
{
    return PI * radius * radius;
}

Файл main.c:

#include <stdio.h>
#include "geometry.h"

int main(void)
{
    double width = 5.0;
    double height = 3.0;
    double radius = 2.0;

    printf("Rectangle area = %.2f\n", rectangleArea(width, height));
    printf("Circle area = %.2f\n", circleArea(radius));

    return 0;
}

Сборка:

gcc main.c geometry.c -o program

В этом проекте:

Что нужно запомнить

Самопроверка перед переходом дальше

  1. Для чего используется директива #include?
  2. Когда выполняется включение текста из файла: до компиляции или во время работы программы?
  3. Какие три формы записи имеет #include?
  4. Чем отличается #include <stdio.h> от #include "stdio.h"?
  5. Для каких файлов обычно используют угловые скобки?
  6. Для каких файлов обычно используют двойные кавычки?
  7. Что такое заголовочный файл?
  8. Что обычно помещают в .h файл?
  9. Почему не стоит помещать обычные определения функций в заголовочный файл?
  10. Для чего нужна защита от повторного включения?
  11. Как записать include guard для файла math_utils.h?
  12. Почему в заголовке для глобальной переменной используют extern?
  13. Почему обычно не подключают .c файлы через #include?
  14. Как собрать проект из файлов main.c и utils.c через gcc?