Основы языка

#include <iostream>

int main() {
    std::cout << "Hello, C++!\n";
    return 0;
}

Сохранить, собрать и запустить

1. Создайте папку и сохраните пример как main.cpp, а не main.cpp.txt.
2. Откройте терминал в этой папке. В GCC или Clang выберите C++20 и предупреждения.
3. После успешной сборки запускайте именно полученный файл. При ошибке сборки исправьте первое сообщение и не запускайте старую программу.

Windows / PowerShell:

> g++ -std=c++20 -Wall -Wextra -Wpedantic main.cpp -o app.exe
> .\app.exe

Linux / macOS: замените имя результата на app и запускайте ./app. В IDE выберите C++20 в настройках проекта. #include <iostream> предоставляет ввод и вывод; std:: уточняет имена стандартной библиотеки.

main — специальное имя, о котором договорились язык и среда запуска. Мы не пишем вызов main() сами: стартовый код вызывает её после необходимой подготовки. Компилятор не выбирает первую функцию в файле и не ищет функцию с «подходящим» смыслом имени. Если переименовать main в start, обычная сборка приложения не получит требуемую точку входа.

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

Почему действия начинаются с main

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

#include <iostream>

void greet() {
    std::cout << "greet: hello\n";
}

int main() {
    std::cout << "main: before call\n";
    greet();
    std::cout << "main: after call\n";
    return 0;
}

В примере функция greet записана выше main, но первой печатается строка main: before call. Затем greet(); передаёт управление в её тело. После возврата выполнение продолжается со следующей инструкции в main. Это и есть вызов функции (временно перейти к описанным действиям и вернуться к месту продолжения).

Что ещё важно знать о main

Для стандартной формы нужен возвращаемый тип int: запись void main() не является стандартным вариантом. Если выполнение дошло до закрывающей скобки main без return, это равнозначно return 0;. У обычных функций, возвращающих значение, такого общего правила нет.

Есть и форма int main(int argc, char* argv[]) для аргументов командной строки: argc сообщает их количество, argv даёт доступ к строкам аргументов. Для первых примеров достаточно int main(). В библиотеках и отдельных средах вроде микроконтроллеров правила запуска могут отличаться; здесь рассматривается обычное приложение под операционную систему.

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

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

Тип переменной определяет, как компилятор интерпретирует данные и какие операции над ними допустимы. Изменение содержимого x не меняет его тип; запись x = 3.14 преобразует значение к int, а не превращает переменную в double.

Разберите присваивание int count = 3;, а затем count = 4.9;: переменная не становится дробной, в неё попадает целое значение 4. При этом компилятор может предупредить о потере дробной части. Если дробь нужна для дальнейшей работы, следует изначально выбрать подходящий тип, например double, а не надеяться, что переменная поменяет его сама.

#include <iostream>

int main() {
    double price = 12.75;
    int whole = static_cast<int>(price);
    double half = whole / 2.0;
    std::cout << whole << ' ' << half << '\n';
}

#include <iostream>

int main() {
    int count{3};
    double price{12.5};
    // int rounded{price}; // Error: narrowing conversion.
    int rounded{static_cast<int>(price)};
    std::cout << count << ' ' << rounded << '\n';
}

int x = 5;         // int
x = 10;            // всё ещё int
x = 3.14;          // станет 3 (преобразование)

Тип, введённое значение и хранимый результат

Предскажите результат 7 / 2, 7.0 / 2 и присваивания int count = 4.9;. Меняется значение, а не тип.

Целые числа подходят для счётчиков, индексов и количества объектов: трёх студентов или пятого элемента, где дробная часть не нужна. Но у каждого целого типа конечное множество значений. Если число слишком велико, память не расширяет переменную автоматически. Поэтому тип выбирают с учётом не только входных данных, но и промежуточных вычислений (того, что получится по пути к окончательному ответу).

Деление и остаток

7 / 2 равно 3: оба операнда целые. 7.0 / 2 равно 3.5. 7 % 2 равно 1 — остаток целочисленного деления. Например, 250 см дают 250 / 100 полных метров и 250 % 100 оставшихся сантиметров. Делитель не должен быть нулевым. Знаковое переполнение недопустимо: выбирайте диапазон до вычисления.

Допустим, два входных числа помещаются в int, а их произведение — уже нет. Если оба операнда имеют тип int, одно лишь присваивание результата в long long не делает предшествующее умножение безопасным. В выражении 1LL * a * b более широкий тип участвует с самого начала. И всё равно нужно проверить, что ответ помещается уже в выбранный long long.

#include <iostream>
#include <limits>

int main() {
    const int maximum = std::numeric_limits<int>::max();
    int value = maximum - 1;
    if (value < maximum) {
        ++value;
    }
    std::cout << std::boolalpha << (value == maximum) << '\n';
}

#include <iostream>
#include <limits>

int main() {
    unsigned int value = std::numeric_limits<unsigned int>::max();
    ++value;
    std::cout << value << '\n';
}

signed, unsigned и char

int a = 42;
long long big = 9'000'000'000LL;
unsigned int n = 10u;
bool flag = (a > 0);
char letter = 'A';

char a = 'A';
char b = 'B';
int sum = a + b; // char → int при арифметике

Логический тип bool

При преобразовании числа к bool: 0 → false, любое ненулевое значение → true. При преобразовании bool в целое: false → 0, true → 1.

bool a = 0;       // false
bool b = -25;     // true
int x = true;     // 1

Целочисленные литералы и суффиксы

42 — целочисленный литерал; 42u — беззнаковый, 42LL — long long. Запись 0xFF использует шестнадцатеричную систему, 0b1010 — двоичную (с C++14), а 1'000'000 разделяет разряды для чтения.

int a = 42;
unsigned int b = 42u;
long long c = 9'000'000'000LL;
int hex = 0xFF;    // 255
int binary = 0b1010; // 10

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

Число 0.5 можно точно представить как половину, а для 0.1 в обычном двоичном формате требуется округление. Поэтому результат 0.1 + 0.2 не стоит бездумно проверять на точное равенство 0.3. Когда задача допускает погрешность, сравнивают близость значений с выбранным допуском (насколько большое расхождение ещё приемлемо). Допуск должен соответствовать масштабу и смыслу задачи.

#include <iomanip>
#include <iostream>

int main() {
    double total = 12.5 * 3;
    std::cout << std::fixed << std::setprecision(2);
    std::cout << total << '\n';
}

#include <cmath>
#include <iostream>

int main() {
    double actual = 0.1 + 0.2;
    double expected = 0.3;
    const double tolerance = 1e-9;
    bool close = std::abs(actual - expected) <= tolerance;
    std::cout << std::boolalpha << close << '\n';
}

float  a = 0.25f;
double b = 0.25;
long double c = 0.25L;
// Не все десятичные дроби кодируются точно в binary64

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

Поток помогает отделить источник данных от правил их чтения. Числа могут приходить с клавиатуры, из файла или из строки в памяти, а извлечение через >> во многих случаях выглядит одинаково. При этом поток не знает, что пользователь «наверняка хотел ввести число»: он разбирает фактические символы. Успешность чтения — отдельный результат, который программа должна проверить.

Что возвращают операторы?

#include <iostream>

int main() {
    int a = 0, b = 0;
    std::cin >> a >> b;            // std::istream&
    std::cout << a << " " << b << '\n'; // std::ostream&
}

Как проверить корректность ввода

#include <iostream>

int main() {
    int a = 0, b = 0;
    if (!(std::cin >> a >> b)) {
        std::cerr << "Ошибка ввода\n";
        return 1;
    }
    std::cout << a + b << '\n';
}

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

#include <iostream>
#include <sstream>

int main() {
    std::istringstream input{"12 30"};
    int first = 0;
    int second = 0;
    if (input >> first >> second) {
        std::cout << first + second << '\n';
    } else {
        std::cout << "Invalid input\n";
    }
}

#include <iostream>
#include <limits>
#include <sstream>

int main() {
    std::istringstream input{"oops\n42\n"};
    int value = 0;
    if (!(input >> value)) {
        input.clear();
        input.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
    if (input >> value) {
        std::cout << value << '\n';
    }
}

Если ввод оказался неправильным

После ошибки обычная повторная операция чтения не поможет: сначала нужно вызвать std::cin.clear(), а затем убрать проблемный остаток строки с помощью ignore(...).

#include <iostream>
#include <limits>

int main() {
    int x = 0;
    if (!(std::cin >> x)) {
        std::cin.clear();
        std::cin.ignore(
            std::numeric_limits<std::streamsize>::max(), '\n'
        );
        return 1;
    }
}

Три небольших задания

1. Прочитайте число и выведите его с подписью.
2. Прочитайте два числа одной проверяемой цепочкой, выведите сумму.
3. Введите слово вместо второго числа: программа должна сообщить об отказе и не выполнять вычисление.

Сначала достаточно прекратить работу при ошибке. Восстановление потока через clear/ignore и строгий разбор всей строки — следующий уровень.

Первые программы удобнее читать не как набор непонятных символов, а как описание объектов и действий над ними. В строке int count = 3; слово int задаёт тип, count становится именем переменной, а 3 — начальным значением. Эти части отвечают на разные вопросы: какие данные допустимы, как к ним обратиться и с чего начать вычисления.

Грамматически это разные понятия: тип определяет, какие значения и операции допустимы; переменная — имя некоторой сущности; оператор участвует в построении выражения; инструкция описывает действие внутри функции.

Прослеживая программу, каждый раз различайте создание переменной и последующее изменение её значения. Сначала int count = 3; создаёт объект с заданным начальным состоянием. Затем count = 8; записывает в тот же объект новое значение. Объявление функции работает иначе: запись void print(int); сообщает, как функцию можно вызвать, но её действия станут понятны только из определения с телом (кода внутри фигурных скобок).

#include <iostream>

int add(int a, int b);    // объявление функции

int main() {               // определение функции
    int x = 5;             // определение и инициализация
    x = add(x, 2);         // выражение + присваивание
    std::cout << x << '\n';
}

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

Что компилятор делает с программой?

Начало файла C++ обычно содержит подключения заголовков и объявления, а действия программы мы записываем внутри функций. Это не означает, что файл выполняется сверху вниз, как сценарий: компилятор сначала разбирает весь исходный текст и строит программу. Место определения функции в файле само по себе не определяет момент её вызова.

Что разрешено писать вне функций

Запись int score = 10; объявляет и определяет глобальную переменную. Определение int twice(int value) { return value * 2; } описывает действия функции, но ещё не вызывает её. А отдельная инструкция std::cout << score; прямо в глобальной области недопустима: там ожидаются объявления, а не последовательность команд для выполнения.

#include <iostream>

int score = 10; // определение глобальной переменной

int twice(int value) { // определение глобальной функции
    return value * 2;
}

// std::cout << score; // ошибка: отдельная инструкция вне функции

int main() {
    std::cout << twice(score) << '\n'; // вызов и вывод — внутри функции
    return 0;
}

Глобальная область и время выполнения — разные понятия. Первая отвечает на вопрос «где объявлено имя и откуда оно видно?», второе — «когда происходят действия?». Обычная вспомогательная функция может быть определена глобально, а исполниться позже, когда её вызовет main или другая функция.

Зачем нужен #include

#include <iostream> — директива препроцессора: она подключает содержимое заголовка, чтобы компилятор увидел необходимые объявления. Например, <iostream> даёт доступ к потокам std::cin и std::cout. Это подготовка исходного текста при сборке; подключение заголовка не означает вызов всех описанных в нём функций.

Системные заголовки стандартной библиотеки обычно подключают через угловые скобки: #include <vector>. Свои заголовки — через кавычки: #include "helpers.hpp". Подключай заголовок, который объявляет используемое средство: случайное косвенное подключение через другой файл может исчезнуть.

Префикс std:: указывает на пространство имён стандартной библиотеки. Запись using namespace std; влияет на поиск имён, но не подключает библиотеку и не заменяет #include. В C++20 есть отдельный механизм модулей с import; в этих начальных примерах используется привычное подключение заголовков.

Когда начинается runtime

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

#include <iostream>

int initial_score() {
    std::cout << "global initialization\n";
    return 10;
}

int score = initial_score(); // вызов нужен для инициализации объекта

int main() {
    std::cout << "main: " << score << '\n';
    return 0;
}

В этом примере вызов initial_score() задаёт начальное значение глобального score. Строка с "global initialization" появится раньше строки из main. Такой порядок не стоит обобщать на все глобальные объекты большого проекта: для объектов из разных файлов действуют дополнительные правила. На старте проще держать основную последовательность действий внутри функций и явно вызывать их из main.

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

C++ вырос из языка C и дополнил его классами, шаблонами, контейнерами стандартной библиотеки и другими возможностями. Большая часть концепций C сохранена, но C++ не является полным надмножеством C.

Поколения стандарта

Версии языка регулируются стандартом ISO. Начиная с C++11 произошёл особенно крупный скачок возможностей.

Обозначение C++20 в примере — это договор о доступных правилах языка, а не название отдельной программы. Один компилятор может поддерживать несколько режимов: например, флаг -std=c++20 выбирает нужный стандарт при сборке в GCC. Если пример не собирается, сначала проверьте выбранный режим и версию инструментов: иногда проблема в неподдерживаемой возможности, а не в самой идее решения.