Перейти к содержанию
Предметы
  • 1 Основы C
    1.1

    main, printf & функции

    Каждая программа на C начинается с main. #include <stdio.h> подключает заголовок, чтобы вы могли использовать printf для вывода текста. Функция — это именованный блок кода, который можно вызвать; \n начинает новую строку. main возвращает 0, чтобы означать «успех».

    #include <stdio.h>
    
    void greet(void) {
        printf("Hello, world!\n");
    }
    
    int main(void) {
        greet();
        printf("I am learning C.\n");
        return 0;
    }
    
    Каждая программа на C выполняется из main после подключения заголовков
    Каждая программа на C выполняется из main после подключения заголовков
    1.2

    Переменные, типы и арифметика

    C требует тип для каждой переменной: int (целочисленный), double (с плавающей запятой), char (один символ). printf использует спецификатор формата — %d, %f, %c — для каждого значения. / между двумя int — это целочисленное деление; % — это остаток.

    #include <stdio.h>
    
    int main(void) {
        int n = 17;
        double pi = 3.14;
        char grade = 'A';
        printf("%d %.2f %c\n", n, pi, grade);   // 17 3.14 A
        printf("%d %d\n", 7 / 2, 7 % 2);        // 3 1
        return 0;
    }
    

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

    Specifier Type Пример вывода
    %d int 17
    %f double (%.2f = 2 знака после десятичной точки) 3.14
    %c char A
    %s строка Mei
    %zu размер (от sizeof / strlen) 3
    %x unsigned int, напечатанное в системе счисления 16 ff

    scanf("%d", &n) reads an int through its address (note the &). Input and output formats are not identical: printf("%f", x) prints a double, but scanf("%lf", &x) reads a double; input %f needs a float *. Check the returned count of successfully assigned items. Its sibling sscanf parses values out of a string:

    #include <stdio.h>
    
    int main(void) {
        char line[] = "Mei 88";
        char name[20];
        int score;
        if (sscanf(line, "%19s %d", name, &score) != 2) return 1;
        printf("%s scored %d\n", name, score);   // Mei scored 88
        return 0;
    }
    
    1.3

    Комментарии и стиль

    Комментарий — это заметка для людей; компилятор игнорирует его. Используйте // для одной строки и /* ... */ для блока. Хорошие отступы и понятные имена делают код легким для чтения.

    #include <stdio.h>
    
    int main(void) {
        // a single-line comment
        /* a block
           comment */
        int total = 3 + 4;       // clear names help
        printf("%d\n", total);   // 7
        return 0;
    }
    

    Распространенные ошибки

    • Объявления и операторы выражений завершаются ;; составной блок { ... } не требует дополнительной точки с запятой. main должен возвращать int (return 0;).
    • printf требует форматную строку: %d для int, %f для double, и \n для новой строки.
    • Неправильный формат, например %d для типа double, вызывает неопределённое поведение; он не гарантирует просто вывод мусора. Сопоставляйте тип аргумента.
  • 2 Выбор
    2.1

    if / else

    Инструкция if выполняет блок, когда условие истинно. В C нет настоящего типа boolean по умолчанию: 0 означает ложь, а любое ненулевое значение — истину. Цепочку выборов можно строить с помощью else if и else. Сравнивайте с ==, !=, <, >, <=, >=.

    #include <stdio.h>
    
    int main(void) {
        int score = 72;
        if (score >= 90) {
            printf("A\n");
        } else if (score >= 60) {
            printf("Pass\n");
        } else {
            printf("Fail\n");
        }
        return 0;
    }
    
    if выбирает истинную ветку; else — ложную ветку
    if выбирает истинную ветку; else — ложную ветку
    2.2

    выключатель

    Конструкция switch выбирает один case по целочисленному значению. Каждый case требует break для выхода — без него C «перетекает» (falls through) в следующий case. default выполняется, если ничего не совпадает.

    #include <stdio.h>
    
    int main(void) {
        int day = 3;
        switch (day) {
            case 1: printf("Mon\n"); break;
            case 2: printf("Tue\n"); break;
            case 3: printf("Wed\n"); break;
            default: printf("Other\n");
        }
        return 0;
    }
    

    Распространенные ошибки

    • if (x = 5) присваивает значение и всегда истинно; используйте == для сравнения.
    • Для каждого случая switch требуется break;, иначе выполнение перейдет к следующему.
    • В условии 0 является ложным, а любое ненулевое значение — истинным.
  • 3 Циклы
    3.1

    Циклы while & for

    Цикл повторяет блок кода. Цикл while выполняется, пока условие истинно. Цикл for объединяет инициализацию, проверку условия и инкремент (i++) в одну строку — это удобно, когда заранее известно количество повторений.

    #include <stdio.h>
    
    int main(void) {
        int i = 1;
        while (i <= 3) {
            printf("%d ", i);
            i++;
        }
        printf("\n");                    // 1 2 3
        for (int j = 0; j < 5; j++) {
            printf("%d ", j);
        }
        printf("\n");                    // 0 1 2 3 4
        return 0;
    }
    
    while проверяет условие; for считает с шагом
    while проверяет условие; for считает с шагом
    3.2

    Накопление

    Распространенный шаблон: начать аккумулятор со значения 0, затем прибавлять к нему внутри цикла. Та же идея используется для подсчета элементов или вычисления накопительной суммы.

    #include <stdio.h>
    
    int main(void) {
        int total = 0;
        for (int i = 1; i <= 5; i++) {
            total += i;            // 1 + 2 + 3 + 4 + 5
        }
        printf("%d\n", total);     // 15
        return 0;
    }
    
    3.3

    Вложенные циклы и паттерны

    Цикл внутри другого цикла называется вложенным. Внутренний цикл полностью завершается на каждом шаге внешнего цикла — идеально подходит для создания сеток и узоров.

    #include <stdio.h>
    
    int main(void) {
        for (int row = 0; row < 3; row++) {
            for (int col = 0; col < 3; col++) {
                printf("*");
            }
            printf("\n");
        }
        return 0;
    }
    

    Распространенные ошибки

    • for (i = 0; i < n; i++) выполняется n раз; точка с запятой сразу после for (...) образует пустой цикл.
    • Цикл while, у которого условие никогда не становится ложным, будет выполняться бесконечно.
    • Объявите счётчик (int i) до или внутри заголовка for.
  • 4 Функции
    4.1

    Параметры и возвращаемые значения

    Функция принимает параметры (входные данные) и возвращает результат. Тип возвращаемого значения указывается первым (int, double, …); ключевое слово void означает, что функция ничего не возвращает.

    #include <stdio.h>
    
    int square(int x) {        // x is a parameter
        return x * x;          // hand back a value
    }
    
    int main(void) {
        int r = square(5);
        printf("%d\n", r);     // 25
        return 0;
    }
    
    Параметры входят; возвращаемое значение выходит
    Параметры входят; возвращаемое значение выходит
    4.2

    Прототипы и области видимости

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

    #include <stdio.h>
    
    int add(int a, int b);     // prototype: declared before use
    
    int main(void) {
        printf("%d\n", add(3, 4));   // 7
        return 0;
    }
    
    int add(int a, int b) {    // definition comes later
        int sum = a + b;       // sum is local to add
        return sum;
    }
    

    Распространенные ошибки

    • Если функция используется до своего определения, над ней должна быть прототип main.
    • Аргументы передаются ПО ЗНАЧЕНИЮ — изменения внутри функции не влияют на вызывающий код, если только не передан указатель.
    • Переменная, объявленная внутри функции, является ее локальной.
  • 5 Массивы
    5.1

    Массивы 1-мерные

    Массив хранит несколько значений одного типа. Индексация начинается с 0. C не хранит длину массива, поэтому распространенный трюк — вычислить количество элементов: sizeof(a) / sizeof(a[0]).

    #include <stdio.h>
    
    int main(void) {
        int scores[3] = {88, 71, 95};
        printf("%d\n", scores[0]);     // 88
        scores[1] = 100;
        printf("%d\n", scores[1]);     // 100
        int n = sizeof(scores) / sizeof(scores[0]);
        printf("%d\n", n);             // 3
        return 0;
    }
    
    Ячейки массива нумеруются от 0
    Ячейки массива нумеруются от 0
    5.2

    Алгоритмы работы с массивами

    Обойдите массив с помощью цикла for, чтобы найти максимум, сумму или количество элементов. Всегда начинайте цикл со значения 0 и заканчивайте значением n - 1.

    #include <stdio.h>
    
    int main(void) {
        int a[] = {3, 9, 2, 7};
        int n = sizeof(a) / sizeof(a[0]);
        int max = a[0], total = 0;
        for (int i = 0; i < n; i++) {
            if (a[i] > max) max = a[i];
            total += a[i];
        }
        printf("%d %d\n", max, total);   // 9 21
        return 0;
    }
    
    5.3

    Массивы 2-мерные

    Массив размером 2-D представляет собой сетку строк и столбцов: grid[row][col]. Используйте два вложенных цикла для посещения каждой ячейки.

    #include <stdio.h>
    
    int main(void) {
        int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
        printf("%d\n", grid[1][2]);    // 6
        for (int r = 0; r < 2; r++) {
            for (int c = 0; c < 3; c++) {
                printf("%d ", grid[r][c]);
            }
        }
        printf("\n");                  // 1 2 3 4 5 6
        return 0;
    }
    

    Распространенные ошибки

    • C НЕ проверяет границы массива: запись по индексу a[n] в массиве размером n является Undefined Behavior (неопределенное поведение).
    • Допустимые индексы находятся в диапазоне от 0 до n - 1.
    • В большинстве выражений массив преобразуется в указатель на свой первый элемент, но сам массив не является указателем. sizeof(a) даёт полный размер байтов для фактического массива; параметр массива приводится к указателю, поэтому функция требует отдельно передаваемой длины.
  • 6 Указатели
    6.1

    &, * и передача по указателю

    Указатель хранит адрес переменной. Оператор &x дает адрес переменной x; оператор *p разыменовывает указатель — он читает или записывает значение, хранящееся по этому адресу. Передача указателя позволяет функции изменить переменную вызывающего кода (передача по указателю).

    Указатель хранит адрес; разыменование следует по стрелке к значению
    Указатель хранит адрес; разыменование следует по стрелке к значению
    #include <stdio.h>
    
    void addOne(int *p) {     // p holds an address
        *p = *p + 1;          // change the value at that address
    }
    
    int main(void) {
        int x = 10;
        int *ptr = &x;        // & takes the address of x
        printf("%d\n", *ptr); // * reads the value: 10
        addOne(&x);
        printf("%d\n", x);    // 11 — changed through the pointer
        return 0;
    }
    

    Классическое применение — функция обмена (swap). Передача значений лишь копирует их — обмен теряется. Передача указателей позволяет функции получить доступ к переменным вызывающего кода:

    #include <stdio.h>
    
    void swap_values(int a, int b) {      // copies: the caller sees nothing
        int t = a; a = b; b = t;
    }
    
    void swap_pointers(int *a, int *b) {  // addresses: the swap is real
        int t = *a; *a = *b; *b = t;
    }
    
    int main(void) {
        int x = 1, y = 2;
        swap_values(x, y);
        printf("%d %d\n", x, y);   // 1 2  (unchanged!)
        swap_pointers(&x, &y);
        printf("%d %d\n", x, y);   // 2 1  (swapped)
        return 0;
    }
    

    Имя массива действует как указатель на его первый элемент, а арифметика указателей сдвигается на целые элементы:

    #include <stdio.h>
    
    int main(void) {
        int a[] = {10, 20, 30};
        int *p = a;                 // same as &a[0]
        printf("%d\n", *p);         // 10
        printf("%d\n", *(p + 2));   // 30 — same as a[2]
        return 0;
    }
    
    • NULL — это указатель, который ни на что не указывает — проверяйте его на NULL перед разыменованием.

    Распространенные ошибки

    • &x — это адрес x; *p — значение, хранящееся по адресу p.
    • Никогда не используйте *p на неинициализированном или NULL указателе — это приведет к сбою или повреждению памяти.
    • Чтобы изменить переменную вызывающего кода, передайте её адрес и запишите значение через указатель.
  • 7 Строки
    7.1

    Массивы символов и нулевой терминатор

    Строка C — это массив символов char. Каждая строка заканчивается скрытым нуль-терминатором '\0', обозначающим конец. Функция strlen (из библиотеки <string.h>) подсчитывает символы до этого '\0'. Выведите всю строку с помощью %s, а один символ — с помощью %c.

    #include <stdio.h>
    #include <string.h>
    
    int main(void) {
        char name[] = "Mei";            // 'M', 'e', 'i', '\0'
        printf("%s\n", name);           // Mei
        printf("%zu\n", strlen(name));  // 3 (stops at '\0')
        printf("%c\n", name[0]);        // M
        return 0;
    }
    
    Строка в C — это массив char, заканчивающийся скрытым нулевым терминатором
    Строка в C — это массив char, заканчивающийся скрытым нулевым терминатором

    Вы можете проходить по строке, выполняя цикл, пока не достигнете терминатора '\0'.

    #include <stdio.h>
    
    int main(void) {
        char word[] = "banana";
        int count = 0;
        for (int i = 0; word[i] != '\0'; i++) {
            if (word[i] == 'a') count++;
        }
        printf("%d\n", count);   // 3
        return 0;
    }
    
    7.2

    Библиотека string.h

    Библиотека #include <string.h> предоставляет базовые инструменты для работы со строками:

    Функция Назначение
    strlen(s) длина строки, без учета терминатора
    strcpy(dst, src) копирование — буфер dst должен быть достаточно большим
    strcat(dst, src) добавление строки src в конец строки dst
    strcmp(a, b) сравнение: возвращает 0 при равенстве, иначе отрицательное / положительное число
    #include <stdio.h>
    #include <string.h>
    
    int main(void) {
        char full[40];
        strcpy(full, "Mei");           // full is now "Mei"
        strcat(full, " Chen");         // append -> "Mei Chen"
        printf("%s (%zu)\n", full, strlen(full));       // Mei Chen (8)
        printf("%d\n", strcmp("apple", "apple") == 0);  // 1 (equal)
        return 0;
    }
    
    • strcmp возвращает 0 при совпадении, поэтому проверка должна выглядеть как strcmp(a, b) == 0 — никогда не используйте a == b.
    • Целевой массив должен иметь место для результата плюс терминатор.

    Распространенные ошибки

    • Для строки C требуется один дополнительный байт для завершающего символа \0: слово из 5 буквы требует char[6].
    • Копировать и сравнивать строки с strcpy / strcmp, а не с = / ==.
    • Забытый терминатор \0 заставляет работу printf("%s", ...) выйти за пределы текста.
  • 8 Структуры
    8.1

    struct, typedef, . vs ->

    Структура (struct) группирует связанные значения в один тип. Каждое значение является членом структуры. Конструкция typedef присваивает структуре короткое имя, позволяя писать Dog вместо длинного имени struct Dog. Используйте точку . для значений структур, но стрелку -> для указателей на структуры.

    #include <stdio.h>
    
    typedef struct {
        char name[20];
        int age;
    } Dog;
    
    int main(void) {
        Dog d = {"Rex", 3};
        printf("%s is %d\n", d.name, d.age);   // Rex is 3   (. on a value)
    
        Dog *p = &d;
        p->age = 4;                            // -> on a pointer
        printf("%s is %d\n", d.name, d.age);   // Rex is 4
        return 0;
    }
    

    Распространенные ошибки

    • Используйте . для значения структуры и -> для указателя на структуру.
    • Конструкция typedef позволяет опускать слово struct при объявлении; без нее нужно писать полное имя struct Point p;.
    • Присвоение одной структуры другой копирует все её поля.
    Точка для значений структур; стрелка для указателей на структуры
    . Точка для значений структур; стрелка для указателей на структуры
  • 9 Динамическая память
    9.1

    malloc, free & realloc

    Функция malloc выделяет память в куче во время выполнения и возвращает указатель на неё. Функция realloc изменяет размер этого блока; функция free освобождает его. На каждый вызов malloc нужен соответствующий вызов free, иначе возникнет утечка памяти. Эти функции определены в заголовочном файле <stdlib.h>.

    Локальные переменные находятся в стеке; память, выделенная через malloc, находится в куче, пока вы не освободите её
    Локальные переменные находятся в стеке; память, выделенная через malloc, находится в куче, пока вы не освободите её
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(void) {
        int n = 3;
        int *a = malloc(n * sizeof(int));    // room for 3 ints
        if (a == NULL) return EXIT_FAILURE;
        for (int i = 0; i < n; i++) a[i] = i * 10;
    
        int *grown = realloc(a, 4 * sizeof *a); // positive size
        if (grown == NULL) {
            free(a);
            return EXIT_FAILURE;
        }
        a = grown;
        a[3] = 30;
    
        for (int i = 0; i < 4; i++) printf("%d ", a[i]);
        printf("\n");                        // 0 10 20 30
    
        free(a);                             // hand the memory back
        return 0;
    }
    
    • calloc(n, size) выделяет массив, подобно malloc, И заполняет его нулями.

    Распространенные ошибки

    • Каждый malloc требует соответствующего free; если забыть освободить, произойдет утечка памяти.
    • Использование памяти после free (так называемое "использование после освобождения", use-after-free) — это серьезная ошибка.
    • Проверьте, что malloc не вернул NULL, прежде чем использовать память.

    Для положительных размеров при неудачном realloc возвращается NULL, а старая область выделения остаётся нетронутой: проверяйте временный результат перед заменой единственного указателя. Успех сохраняет меньшее из старых/новых значений количества байтов; добавленные ячейки не инициализированы. Этот пример избегает запросов нулевого размера и переполнения разрядности. Обычные локальные переменные без ключевых слов статичности имеют автоматическое время жизни и обычно реализуются в стеке; C не требует такого расположения.

  • 10 Структуры данных
    10.1

    Связные списки

    Связный список — это цепочка узлов. Каждый узел хранит значение и указатель на следующий next; последний указывает на NULL. В отличие от массива он увеличивается по одному узлу с каждым malloc. Обязательно free каждый узел после завершения работы.

    Связный список: каждый узел хранит значение и указатель на следующий, заканчивая NULL
    Связный список: каждый узел хранит значение и указатель на следующий, заканчивая NULL
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct Node {
        int value;
        struct Node *next;
    } Node;
    
    int main(void) {
        Node *head = NULL;
        for (int v = 10; v <= 30; v += 10) {   // prepend 10, 20, 30
            Node *n = malloc(sizeof(Node));
            n->value = v;
            n->next = head;
            head = n;
        }
        for (Node *p = head; p != NULL; p = p->next) {
            printf("%d ", p->value);           // 30 20 10
        }
        printf("\n");
    
        while (head != NULL) {                 // free the whole list
            Node *t = head;
            head = head->next;
            free(t);
        }
        return 0;
    }
    
    10.2

    Стек и очередь

    Стек работает по принципу LIFO (последним пришел — первым ушел): push и pop выполняются с одного конца. Очередь работает по принципу FIFO (первым пришел — первым ушел): элементы добавляются сзади, удаляются спереди. Оба структуры легко реализовать на массиве с использованием индексных переменных.

    #include <stdio.h>
    
    int main(void) {
        int stack[10];
        int top = 0;                       // next free slot
        stack[top++] = 1;                  // push
        stack[top++] = 2;
        stack[top++] = 3;
        while (top > 0) {
            printf("%d ", stack[--top]);   // pop: 3 2 1
        }
        printf("\n");
        return 0;
    }
    
    #include <stdio.h>
    
    int main(void) {
        int queue[10];
        int front = 0, back = 0;
        queue[back++] = 1;                       // enqueue
        queue[back++] = 2;
        queue[back++] = 3;
        while (front < back) {
            printf("%d ", queue[front++]);       // dequeue: 1 2 3
        }
        printf("\n");
        return 0;
    }
    

    Распространенные ошибки

    • В связном списке никогда не теряйте указатель на head, иначе весь список станет недоступным.
    • Освобождайте каждый узел по завершении, проходя по списку перед разрывом связей.
    • Проверяйте пустой список (пустую голову/NULL head), прежде чем выполнять pop.
  • 11 Поиск, сортировка & рекурсия
    11.1

    Линейный и бинарный поиск

    Линейный поиск последовательно проверяет каждый элемент — он работает с любым массивом. Бинарный поиск намного быстрее, но требует отсортированного массива: он проверяет середину и отбрасывает половину на каждом шаге. Оба возвращают индекс или -1, если элемент отсутствует.

    #include <stdio.h>
    
    int linear(int a[], int n, int target) {
        for (int i = 0; i < n; i++)
            if (a[i] == target) return i;
        return -1;
    }
    
    int binary(int a[], int n, int target) {
        int lo = 0, hi = n - 1;
        while (lo <= hi) {
            int mid = (lo + hi) / 2;
            if (a[mid] == target) return mid;
            else if (a[mid] < target) lo = mid + 1;
            else hi = mid - 1;
        }
        return -1;
    }
    
    int main(void) {
        int a[] = {2, 5, 8, 12, 16, 23};
        int n = sizeof(a) / sizeof(a[0]);
        printf("%d %d %d\n", linear(a, n, 12), binary(a, n, 12), binary(a, n, 9));
        return 0;   // 3 3 -1
    }
    
    Линейный перебирает всё; бинарный делит отсортированный диапазон пополам
    Линейный перебирает всё; бинарный делит отсортированный диапазон пополам
    11.2

    Сортировка

    Пузырьковая сортировка (bubble sort) многократно сравнивает соседние элементы и меняет местами любую пару, которая стоит в неправильном порядке. После каждого прохода максимальное значение «всплывает» в конец.

    #include <stdio.h>
    
    int main(void) {
        int a[] = {5, 2, 9, 1, 7};
        int n = sizeof(a) / sizeof(a[0]);
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
                }
            }
        }
        for (int i = 0; i < n; i++) printf("%d ", a[i]);
        printf("\n");   // 1 2 5 7 9
        return 0;
    }
    
    11.3

    Рекурсия

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

    #include <stdio.h>
    
    int factorial(int n) {
        if (n <= 1) return 1;          // base case
        return n * factorial(n - 1);   // recursive call
    }
    
    int main(void) {
        printf("%d\n", factorial(5));  // 120
        return 0;
    }
    

    Распространенные ошибки

    • Бинарный поиск требует отсортированного массива; рекурсия требует базового случая.
    • Каждый рекурсивный вызов должен приближаться к базовому случаю, иначе произойдет переполнение стека.
    • Пузырьковая и сортировка вставками имеют сложность O(n²) — отлично подходят для изучения, но медленны при больших объемах данных.
  • 12 Файлы & ошибки
    12.1

    Текстовые файлы

    fopen возвращает указатель на файл; строка режима указывает действие — "w" запись, "r" чтение, "a" дописывание. Записывайте с помощью fprintf, читайте с помощью fscanf, и всегда fclose по завершении.

    #include <stdio.h>
    
    int main(void) {
        FILE *out = fopen("scores.txt", "w");   // open for writing
        fprintf(out, "Alice 80\nBob 95\n");
        fclose(out);
    
        FILE *in = fopen("scores.txt", "r");    // open for reading
        char name[20];
        int score;
        while (fscanf(in, "%19s %d", name, &score) == 2) {   // %19s leaves room for '\0'
            printf("%s -> %d\n", name, score);
        }
        fclose(in);
        return 0;
    }
    
    fopen → чтение/запись → fclose
    fopen → чтение/запись → fclose
    12.2

    Обработка ошибок через коды возврата

    В C нет исключений. Вместо этого функция сигнализирует об ошибке через код возврата — по соглашению 0 означает успех, а ненулевое значение — ошибку. Вызывающий код проверяет код, прежде чем доверять результату. (fopen следует той же идее: он возвращает NULL при неудаче.)

    #include <stdio.h>
    
    // returns 0 on success, -1 if the divisor is 0
    int safe_divide(int a, int b, int *result) {
        if (b == 0) return -1;          // error code
        *result = a / b;
        return 0;                       // success
    }
    
    int main(void) {
        int r;
        if (safe_divide(10, 2, &r) == 0)
            printf("10 / 2 = %d\n", r);          // 10 / 2 = 5
        if (safe_divide(10, 0, &r) != 0)
            printf("cannot divide by zero\n");   // error reported
        return 0;
    }
    

    Распространенные ошибки

    • Проверяйте, что fopen не вернул NULL, перед чтением или записью.
    • Всегда fclose файл по завершении работы.
    • Возвращайте ненулевой код из main, чтобы сообщить об ошибке вызывающему коду.
  • 13 Биты & данные
    13.1

    Биты, двоичная система и побитовые операторы

    Бит — это одиночный 0 или 1; числа хранятся в двоичной системе. Побитовые операторы работают непосредственно с битами: & AND (И), | OR (ИЛИ), ^ XOR (ИСКЛЮЧАЮЩЕЕ ИЛИ), << сдвиг влево (×2 на каждом шаге), >> сдвиг вправо (÷2).

    #include <stdio.h>
    
    int main(void) {
        int a = 12;              // 1100
        int b = 10;              // 1010
        printf("%d\n", a & b);   // 8   AND  -> 1000
        printf("%d\n", a | b);   // 14  OR   -> 1110
        printf("%d\n", a ^ b);   // 6   XOR  -> 0110
        printf("%d\n", a << 1);  // 24  left shift
        printf("%d\n", a >> 1);  // 6   right shift
        return 0;
    }
    

    Шестнадцатеричная система (основание 16) компактно записывает двоичные данные: одна шестнадцатеричная цифра ровно равна четырем битам. Записывайте шестнадцатеричные литералы с помощью 0x; выводите с помощью %x:

    #include <stdio.h>
    
    int main(void) {
        printf("%d\n", 0xFF);   // 255  (0x marks a hex literal)
        printf("%x\n", 255);    // ff
        printf("%x\n", 12);     // c
        return 0;
    }
    
    Побитовые операторы работают с битами целых чисел
    Побитовые операторы работают с битами целых чисел
    13.2

    Кодирование длин серий (RLE)

    Кодирование длин серий (RLE) — простой метод сжатия: заменяет каждую серию повторяющихся символов счетчиком и самим символом. Это сжатие без потерь — исходные данные полностью восстанавливаемы.

    #include <stdio.h>
    #include <string.h>
    
    int main(void) {
        char *s = "aaabbc";
        int n = strlen(s);
        for (int i = 0; i < n; ) {
            char c = s[i];
            int run = 0;
            while (i < n && s[i] == c) { run++; i++; }
            printf("%d%c", run, c);     // 3a2b1c
        }
        printf("\n");
        return 0;
    }
    

    Распространенные ошибки

    • & — это побитовое AND, а && — логическое AND; не путайте их.
    • Сдвиг влево << 1 удваивает значение; сдвиг вправо >> 1 делит его пополам.
    • Бит n имеет значение 1 << n (в C отсутствует оператор возведения в степень **); проверьте бит с помощью выражения (x >> n) & 1.
  • 14 Предпроцессор & модификаторы
    14.1

    Предпроцессор, const, static, enum

    Препроцессор выполняется перед компиляцией. #define создает макрос — простой текст, заменяемый повсюду. const создает константу, которую нельзя изменить. static внутри функции сохраняет значение переменной между вызовами. Перечисление (enumeration) enum задает набор целых чисел, начинающихся со значения 0.

    #include <stdio.h>
    
    #define MAX 100                     // macro: text replaced before compiling
    
    enum Color { RED, GREEN, BLUE };    // named integers 0, 1, 2
    
    int next_id(void) {
        static int count = 0;           // keeps its value between calls
        count++;
        return count;
    }
    
    int main(void) {
        const double PI = 3.14;         // cannot be changed
        printf("%d %.2f\n", MAX, PI);            // 100 3.14
        printf("%d %d %d\n", RED, GREEN, BLUE);  // 0 1 2
        int a = next_id();
        int b = next_id();
        printf("%d %d\n", a, b);                 // 1 2
        return 0;
    }
    

    Большие программы разбиваются на файлы: объявления помещают в заголовочный файл (mine.h), который подключают через #include "mine.h" — кавычки означают ваш собственный файл, угловые скобки (< >) — стандартную библиотеку. Предупреждение о включении (#ifndef MINE_H / #define MINE_H / #endif) предотвращает повторное подключение заголовочного файла.

    Распространенные ошибки

    • #define выполняет простую замену текста без проверки типов; оборачивайте тела макросов и аргументы в скобки.
    • Значение константы const нельзя изменить после присвоения.
    • Статическая локальная переменная (static) сохраняет свое значение между вызовами функции.
    #define, const, enum и static делают код понятным
    #define, const, enum и static делают код понятным

Войти или создать аккаунт

IGCSE, A-Level & AP