Вход в программу

Когда операционная система запускает вашу программу, первым кодом, который выполняется, является не main(). До него успевает поработать C++ runtime (CRT): инициализировать память, установить обработчики исключений, вызвать конструкторы всех глобальных объектов. Только после этого управление передаётся вашей функции main.

После того как main возвращает значение, рантайм снова берёт слово: вызывает деструкторы глобальных объектов, запускает функции, зарегистрированные через std::atexit, и только потом сообщает операционной системе код завершения.

Это первое, что нужно понять о точке входа: main() — это ваш код в жизненном цикле процесса, а не сам жизненный цикл.

Жизненный цикл C++ процесса↗

Функция main()

Стандарт C++ допускает две формы сигнатуры main:

int main()                             // без аргументов командной строки
int main(int argc, char* argv[])       // с аргументами командной строки

int main(int argc, char** argv) — это эквивалентная запись второй формы: в параметре функции char*[] и char** означают одно и то же.

Анатомия main()↗

Почему не void main()

void main() — нестандартное расширение, которое некоторые компиляторы исторически допускали (и часть старых учебников до сих пор показывает). По стандарту C++ main обязана возвращать int. Использование void main() — это ill-formed программа; поведение не определено.

// Нестандартно — не используйте
void main() { }

// Правильно
int main() { return 0; }

Возвращаемое значение

main возвращает код завершения процесса. Этот код видит операционная система и любой процесс, который запустил вашу программу (например, shell-скрипт или CI-пайплайн).

EXIT_SUCCESS и EXIT_FAILURE объявлены в <cstdlib>. Используйте их — так код читается как документация.

#include <cstdlib>

int main() {
    if (!initialize()) {
        return EXIT_FAILURE;
    }
    run();
    return EXIT_SUCCESS;
}

Если main завершается без return, стандарт гарантирует неявный return 0 — это единственная функция с таким поведением.

Аргументы командной строки

argv[0] — всегда имя исполняемого файла (или пустая строка в некоторых встроенных средах). argv[1] … argv[argc-1] — аргументы, переданные пользователем. argv[argc] — всегда nullptr (гарантировано стандартом).

#include <iostream>
#include <string_view>

int main(int argc, char* argv[]) {
    std::cout << "Программа: " << argv[0] << "\n";
    std::cout << "Аргументов: " << argc - 1 << "\n";

    for (int i = 1; i < argc; ++i) {
        std::string_view arg = argv[i];
        std::cout << "  [" << i << "] " << arg << "\n";
    }
    return 0;
}

Практический пример — разбор флагов

#include <iostream>
#include <string_view>
#include <cstdlib>

int main(int argc, char* argv[]) {
    bool verbose = false;
    const char* filename = nullptr;

    for (int i = 1; i < argc; ++i) {
        std::string_view arg = argv[i];

        if (arg == "--verbose" || arg == "-v") {
            verbose = true;
        } else if ((arg == "--file" || arg == "-f") && i + 1 < argc) {
            filename = argv[++i];
        } else {
            std::cerr << "Неизвестный аргумент: " << arg << "\n";
            return EXIT_FAILURE;
        }
    }

    if (!filename) {
        std::cerr << "Ошибка: не указан файл (--file <путь>)\n";
        return EXIT_FAILURE;
    }

    if (verbose) {
        std::cout << "Открываем файл: " << filename << "\n";
    }
    // ... дальнейшая логика
    return EXIT_SUCCESS;
}

Запуск:

./myapp --verbose --file data.txt   # OK
./myapp -f data.txt                 # OK
./myapp                             # → ошибка: не указан файл

Переменные окружения

Помимо аргументов командной строки, программа получает доступ к переменным окружения через std::getenv():

#include <cstdlib>
#include <iostream>

int main() {
    if (const char* home = std::getenv("HOME")) {
        std::cout << "Домашняя директория: " << home << "\n";
    }
    return 0;
}

Некоторые платформы предоставляют нестандартную третью форму main(int argc, char* argv[], char* envp[]), где envp — массив строк вида NAME=VALUE. Это расширение, не входящее в стандарт C++, — используйте std::getenv() для переносимости.

Что происходит до main()

Большинство начинающих уверены, что main() — это первая функция, которую выполняет программа. Это не так.

До вызова main() C++ runtime (CRT — C Runtime Library) выполняет ряд действий:

1. Инициализация среды выполнения — настройка стека главного потока, кучи, локальных данных потока (TLS).
2. Конструкторы глобальных и статических объектов — все переменные с static storage duration, объявленные вне функций, инициализируются до main. Порядок инициализации в пределах одной единицы трансляции — сверху вниз; порядок между разными единицами трансляции — не определён стандартом.
3. Регистрация atexit-обработчиков — библиотеки могут заранее зарегистрировать функции очистки.
4. Передача argc/argv — ОС передаёт аргументы командной строки рантайму, а тот упаковывает их в массив argv и передаёт в main.

#include <iostream>

struct Logger {
    Logger()  { std::cout << "Logger создан\n"; }
    ~Logger() { std::cout << "Logger уничтожен\n"; }
};

Logger globalLogger;  // конструктор вызывается до main()

int main() {
    std::cout << "Внутри main()\n";
    return 0;
}

// Вывод:
// Logger создан
// Внутри main()
// Logger уничтожен

Что происходит после main()

После возврата из main() (или вызова std::exit()) рантайм выполняет shutdown-последовательность:

1. Функции, зарегистрированные через std::atexit(), вызываются в обратном порядке регистрации.
2. Деструкторы объектов со static storage duration вызываются в обратном порядке относительно их конструкторов.
3. Буферы стандартных потоков ввода-вывода сбрасываются (std::flush).
4. Код завершения передаётся операционной системе.

#include <cstdlib>
#include <iostream>

void cleanup_network() { std::cout << "Сеть закрыта\n"; }
void cleanup_files()   { std::cout << "Файлы закрыты\n"; }

int main() {
    std::atexit(cleanup_network);  // зарегистрирован первым
    std::atexit(cleanup_files);    // зарегистрирован вторым

    std::cout << "Работаем...\n";
    return 0;
}

// Вывод:
// Работаем...
// Файлы закрыты      ← вызвана последней зарегистрированной первой
// Сеть закрыта

Порядок инициализации глобальных объектов и его подводные камни

Стандарт гарантирует порядок инициализации глобальных объектов только внутри одной единицы трансляции (.cpp-файла) — сверху вниз. Между разными единицами трансляции порядок не определён. Это называется Static Initialization Order Fiasco.

// a.cpp
#include <string>
std::string prefix = "Hello";  // инициализируется в a.cpp

// b.cpp
#include <iostream>
extern std::string prefix;

struct Greeter {
    Greeter() {
        // Опасно: если b.cpp инициализируется раньше a.cpp,
        // prefix ещё не создан — поведение не определено
        std::cout << prefix << ", world!\n";
    }
};

Greeter g;  // конструктор вызывается до main()

Решение: Construct On First Use Idiom

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

// a.cpp
#include <string>

const std::string& get_prefix() {
    static std::string prefix = "Hello";  // инициализируется при первом вызове
    return prefix;
}

// b.cpp
#include <iostream>

const std::string& get_prefix();  // объявление

struct Greeter {
    Greeter() {
        // Безопасно: get_prefix() гарантирует, что prefix создан
        std::cout << get_prefix() << ", world!\n";
    }
};

Greeter g;

В C++11 и новее локальные статические переменные инициализируются потокобезопасно — дополнительные мьютексы не нужны.

Альтернатива — std::call_once из <mutex>, когда требуется явный контроль над одноразовой инициализацией в многопоточном коде:

#include <mutex>
#include <string>

static std::once_flag init_flag;
static std::string* config = nullptr;

void ensure_config() {
    std::call_once(init_flag, []() {
        config = new std::string("production");
    });
}

Способы завершения программы

Помимо return из main(), есть несколько функций завершения — они ведут себя по-разному:

#include <cstdlib>

int main() {
    // std::exit() вызовет atexit и глобальные деструкторы,
    // но деструкторы ЛОКАЛЬНЫХ объектов в этом стеке — нет.
    // Утечки ресурсов, не защищённых RAII, возможны.
    std::exit(EXIT_FAILURE);
}

std::abort() посылает сигнал SIGABRT и немедленно завершает процесс — без каких-либо деструкторов и без сброса буферов. Используется, когда продолжение работы программы опасно (например, внутри обработчика assert).

std::quick_exit() (C++11) — компромисс: нормальное завершение без вызова деструкторов. Функции можно зарегистрировать через std::at_quick_exit().

WinMain на Windows

На Windows консольные программы используют стандартный main(). Но оконные (GUI) приложения традиционно используют нестандартную точку входа WinMain:

#include <windows.h>

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine, int nCmdShow) {
    // Windows GUI startup
    return 0;
}

Это расширение Microsoft — не часть стандарта C++. Современные фреймворки (Qt, wxWidgets) и CMake умеют скрыть эту разницу: в main() вы пишете кроссплатформенный код, а линковщик подставляет нужную точку входа.

Значение для собеседований

Тема точки входа появляется на собеседованиях как проверка глубины: знает ли кандидат, что происходит до и после main(), или думает, что main() — это начало и конец всего.

Что проверяет интервьюер:

• Понимание жизненного цикла процесса (CRT startup → main → CRT shutdown)
• Осознание опасностей глобальных объектов и умение называть решения

Типичные направления вопросов:

1. «Что выполняется до main()?» — ожидают: конструкторы глобальных объектов, инициализация CRT, настройка argc/argv.
2. «В каком порядке инициализируются глобальные объекты из разных .cpp файлов?» — ожидают: порядок не определён стандартом; Static Initialization Order Fiasco; решение — Construct On First Use.
3. «Чем отличается std::exit() от return из main()?» — ожидают: std::exit не вызывает деструкторы локальных объектов в текущем стеке.
4. «Что означает код возврата main()?» — ожидают: передаётся ОС; 0 = успех; EXIT_SUCCESS/EXIT_FAILURE из <cstdlib>.
5. «Что такое WinMain?» — ожидают: нестандартная точка входа для GUI-приложений Windows, не часть стандарта C++.

Самая частая ошибка кандидата: «main() — это первая функция, которая выполняется». Правильный ответ: первой выполняется CRT startup, которая вызывает конструкторы глобальных объектов и только потом передаёт управление main().