Перейти к содержимому

Препроцессор

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

Для этих примеров используйте g++ (драйвер GCC для C++) и сохраняйте каждую программу как main.cpp. Каждый пронумерованный пример — самостоятельный, если явно не указано, что он переиспользует файлы из другого. Запускайте команды из каталога, в котором лежат эти файлы.

Окно терминала
g++ -std=c++20 -E main.cpp

Флаг -E останавливает работу сразу после препроцессинга и выводит результат. Обязательно запустите команду и посмотрите на вывод, прежде чем открывать ответ. Строки, начинающиеся с # в этом выводе, лишь отмечают, откуда взят код — это уже не ваши исходные директивы. Добавьте -P, чтобы скрыть эти отметки в коротких примерах:

Окно терминала
g++ -std=c++20 -E -P main.cpp

Чтобы скомпилировать и запустить корректный пример:

Окно терминала
g++ -std=c++20 main.cpp -o app
./app

Если в задании не спрашивается о чём-то другом, предскажите код после препроцессора, скомпилируется ли программа и что она выведет. Помните: успешный запуск с -E ещё ничего не говорит о корректности самого C++-кода.

// A comment before main.
int main()
{
int a = 2 /* another comment */ + 3;
}
Ответ

Комментарии исчезают. Каждый из них заменяется пробельным символом, чтобы соседние токены не слиплись. Компилятор видит инициализацию, эквивалентную int a = 2 + 3;. Программа компилируется и ничего не выводит.

Что выведет -E -P? Добавляет ли определение макроса что-либо в main?

#define NUMBER 5
int main()
{
}
Ответ

После препроцессора остаётся только пустая функция main. #define сообщает препроцессору, что нужно подставить, если дальше встретится NUMBER. Здесь NUMBER нигде не используется, поэтому подставлять нечего. Само определение не создаёт переменную и ничего не выполняет. Программа компилируется и ничего не выводит.

#define NUMBER 5
int main()
{
auto a = NUMBER;
}
Ответ

NUMBER заменяется на 5, поэтому инициализация превращается в auto a = 5;. Переменная a получает тип int и инициализируется значением 5. Программа ничего не выводит. Сама строка #define исчезает и не превращается в объявление C++.

#include <iostream>
#define NUMBER 5
constexpr double number = 5;
int main()
{
auto a = NUMBER;
auto b = number;
std::cout << a / 2 << std::endl;
std::cout << b / 2 << std::endl;
}
Ответ

Программа выведет 2 и 2.5. NUMBER превращается в целочисленный литерал 5, поэтому a имеет тип int. Имя number остаётся в коде после препроцессора, и благодаря объявленному типу b получает тип double. Целочисленное деление отбрасывает дробную часть, а деление с плавающей точкой её сохраняет. Макрос — это просто набор токенов для подстановки без собственного типа C++. Переменная constexpr, напротив, — настоящий объект C++ со своим типом, инициализатор которого является константным выражением.

Что именно выведет -E -P?

#define MAKE_A int a = 5
int main()
{
MAKE_A;
}
Ответ

MAKE_A; превращается в int a = 5; внутри main. Здесь ничего не вызывается — компилятор просто получает обычное определение переменной. Программа компилируется и ничего не выводит.

#define MAKE_A int a = 5
int main()
{
MAKE_A;
MAKE_A;
}
Ответ

Препроцессинг проходит успешно, но компиляция падает с ошибкой: строка int a = 5; появляется дважды в одной области видимости. Вторая строка определяет a повторно. Если поместить каждое использование в отдельный вложенный блок, этой ошибки можно избежать.

void makeA()
{
int a = 5;
}
int main()
{
makeA();
makeA();
}
Ответ

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

8. Изменение переменной после раскрытия макроса

Заголовок раздела «8. Изменение переменной после раскрытия макроса»
#define MAKE_A int a = 5
int main()
{
MAKE_A;
a = 8;
}
Ответ

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

struct Point
{
int x;
int y;
};
#define START Point{ 2, 3 }
int main()
{
Point p = START;
}
Ответ

p.x равно 2, а p.y равно 3. Инициализация превращается в Point p = Point{ 2, 3 };. Заменяющим текстом может быть любая последовательность токенов, в том числе целая инициализация структуры.

#define NUMBER (5)
int main()
{
[[maybe_unused]] int b = NUMBER;
}
Ответ

b инициализируется значением 5. NUMBER раскрывается в (5). Круглые скобки здесь — просто часть текста подстановки. Они не делают макрос вызываемым.

11. У макроса нет блочной области видимости

Заголовок раздела «11. У макроса нет блочной области видимости»
int main()
{
{
#define NUMBER 5
int a = NUMBER;
}
[[maybe_unused]] int b = NUMBER;
}
Ответ

b инициализируется значением 5. Препроцессор ничего не знает о блоках C++. Макрос действует на весь код после своего определения вплоть до директивы #undef или до конца единицы трансляции. Локальная переменная a принадлежит внутреннему блоку, а макрос NUMBER — нет.

#define NUMBER 5
#define NUMBER 8
int main()
{
int a = NUMBER;
}
Ответ

Такое переопределение некорректно, так как новая подстановка отличается от старой. GCC обычно лишь выдаёт предупреждение и продолжает со значением 8, но полагаться на это не стоит. Повторять абсолютно идентичное определение допустимо. Чтобы намеренно заменить определение, пишут так:

#undef NUMBER
#define NUMBER 8

Директива #undef удаляет макрос. Переменные, которые уже были им инициализированы, не меняются. См. правила переопределения макросов в GCC.

#define NUMBER() 5
int main()
{
[[maybe_unused]] int a = NUMBER();
}
Ответ

a инициализируется значением 5. NUMBER() — это функционально-подобный макрос без параметров. В определении открывающая скобка должна идти сразу за именем, без пробела. В месте использования именно скобки запускают раскрытие. Если написать в main просто NUMBER, имя не раскроется, и компиляция завершится ошибкой.

14. То же объявление через функционально-подобный макрос

Заголовок раздела «14. То же объявление через функционально-подобный макрос»
#define MAKE_A() int a = 5
int main()
{
MAKE_A();
}
Ответ

a инициализируется значением 5. MAKE_A(); раскрывается в int a = 5;. Внешнее сходство с вызовом функции не даёт макросу собственной локальной области видимости. Если использовать его в этом блоке дважды, a по-прежнему определится два раза.

15. Замена ключевого слова: опасный эксперимент

Заголовок раздела «15. Замена ключевого слова: опасный эксперимент»
#define true false
int main()
{
bool a = true;
}
Ответ

При запуске GCC с -E -P получается bool a = false;, то есть заменяется даже ключевое слово. Однако стандарт C++ запрещает определять макрос с именем ключевого слова вроде true. Это намеренно некорректный эксперимент, а не приём для работы. Такое определение незаметно меняет весь последующий код, включая подключённые заголовочные файлы. Никогда не делайте так в реальном коде и удалите это определение перед тем, как идти дальше.

#include <iostream>
#define COMBINE(a, b) a + b
int main()
{
std::cout << COMBINE(2, 3) << std::endl;
}
Ответ

Строка превращается в std::cout << 2 + 3 << std::endl; и выводит 5. Аргументы подставляются в текст замены как есть. Скобки вокруг списка аргументов не переносятся вокруг результата.

#include <iostream>
#define COMBINE(a, b) a + b
int main()
{
std::cout << COMBINE(2 * 3, 4 * 5) << std::endl;
}
Ответ

Макрос раскрывается в 2 * 3 + 4 * 5, поэтому программа выводит 26. Умножение имеет более высокий приоритет, чем сложение, так что здесь отсутствие скобок случайно не мешает.

18. Использование результата в другом выражении

Заголовок раздела «18. Использование результата в другом выражении»
#include <iostream>
#define COMBINE(a, b) a + b
#define TRANSFORM(a, b) a * b
int main()
{
std::cout << 2 * COMBINE(3, 4) << std::endl;
std::cout << TRANSFORM(2 + 3, 4 + 5) << std::endl;
}
Ответ

Программа выведет 10 и 19. Первое выражение превращается в 2 * 3 + 4, а не в 2 * (3 + 4). Второе превращается в 2 + 3 * 4 + 5, а не в (2 + 3) * (4 + 5). Собственные скобки нужны как для всего результата подстановки, так и для каждого аргумента.

#include <iostream>
#define COMBINE(a, b) ((a) + (b))
#define TRANSFORM(a, b) ((a) * (b))
int main()
{
std::cout << 2 * COMBINE(3, 4) << std::endl;
std::cout << TRANSFORM(2 + 3, 4 + 5) << std::endl;
}
Ответ

Программа выведет 14 и 45. Выражения раскрываются в 2 * ((3) + (4)) и ((2 + 3) * (4 + 5)). Внутренние скобки защищают аргументы, а внешние — результат целиком.

#include <iostream>
int combine(int a, int b)
{
return a + b;
}
int transform(int a, int b)
{
return a * b;
}
int main()
{
std::cout << 2 * combine(3, 4) << std::endl;
std::cout << transform(2 + 3, 4 + 5) << std::endl;
}
Ответ

Этот код тоже выводит 14 и 45. Аргументы функции сначала вычисляются, и их значения инициализируют параметры. Тело функции работает с этими параметрами, а не с токенами, вклеенными в выражение вызывающего кода. Если вам нужно поведение функции — пишите функцию.

int main()
{
#if false
this is not valid C++;
#endif
int a = 5;
}
Ответ

Код компилируется, и a инициализируется значением 5. #if false выбрасывает секцию ещё до того, как компилятор начнёт проверять её синтаксис. Некорректной инструкции просто нет в выводе после препроцессора. В C++ директива #if распознаёт false и true; #if 0 и #if 1 тоже работают.

int main()
{
#if 2 + 3 == 5
int a = 5;
#else
int a = 8;
#endif
}
Ответ

Препроцессор оставляет int a = 5; и отбрасывает int a = 8;. Он сам вычисляет условие и сохраняет только первую ветку. Никакого if для проверки во время выполнения программы не остаётся.

#define LEVEL 2
int main()
{
#if LEVEL >= 2
int a = 5;
#else
int a = 8;
#endif
}
Ответ

После препроцессора остаётся int a = 5;. LEVEL раскрывается в 2 до вычисления условия. Если изменить определение на 1 и снова запустить препроцессор, останется другая ветка.

24. Условие на основе константной переменной

Заголовок раздела «24. Условие на основе константной переменной»
constexpr int level = 2;
int main()
{
#if level >= 2
int a = 5;
#else
int a = 8;
#endif
}
Ответ

После препроцессора остаётся int a = 8;, хотя level равен 2. Препроцессор не видит переменные C++ — даже constexpr. Внутри #if любой нераскрытый идентификатор вроде level считается равным 0, поэтому проверяется условие 0 >= 2. Для проверки переменной C++ используйте обычный C++-ный if. Флаг GCC -Wundef предупреждает о подобных ошибках.

#define FEATURE 0
int main()
{
#ifdef FEATURE
int a = 5;
#else
int a = 8;
#endif
}
Ответ

После препроцессора остаётся int a = 5;. #ifdef FEATURE проверяет только то, что макрос существует, а не его значение. Эта директива означает то же самое, что #if defined(FEATURE). Напротив, #if FEATURE проверял бы значение 0.

#ifndef LIMIT
#define LIMIT 10
#endif
int main()
{
int a = LIMIT;
}
Ответ

Инициализация превращается в int a = 10;. LIMIT ещё не был определён, поэтому определение внутри секции сохраняется. #ifndef LIMIT означает #if !defined(LIMIT). Если бы LIMIT уже был определён как 20, эта секция оставила бы его без изменений, и инициализация превратилась бы в int a = 20;.

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

empty.h:

// Nothing here yet.

main.cpp:

#include "empty.h"
int main()
{
}
Ответ

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

number.h:

int number()
{
return 7;
}

main.cpp:

int main()
{
[[maybe_unused]] int a = number();
}
Ответ

Компиляция завершается ошибкой, потому что number нигде не объявлена в main.cpp. Никто не ищет недостающие объявления по соседним файлам. Само по себе сохранение number.h рядом с main.cpp не делает его частью программы.

3. Включение файла с функцией до её использования

Заголовок раздела «3. Включение файла с функцией до её использования»

number.h:

int number()
{
return 7;
}

main.cpp:

#include "number.h"
int main()
{
[[maybe_unused]] int a = number();
}
Ответ

Код компилируется, и a инициализируется значением 7. В файле после препроцессора определение number оказывается перед main. Для небольшой программы с одним исходным файлом держать определение в заголовке вполне нормально. Общий код для нескольких исходных файлов — тема лабораторной о компоновщике.

4. Включение файла с функцией после её использования

Заголовок раздела «4. Включение файла с функцией после её использования»

number.h:

int number()
{
return 7;
}

main.cpp:

int main()
{
[[maybe_unused]] int a = number();
}
#include "number.h"
Ответ

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

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

Заголовок раздела «5. Выбор, какие функции предоставляет заголовочный файл»

Определения каких функций останутся в выводе -E? Скомпилируется ли программа?

first.h:

#ifdef ENABLE_FIRST
int firstNumber()
{
return 7;
}
#endif

second.h:

#ifdef ENABLE_SECOND
int secondNumber()
{
return 11;
}
#endif

main.cpp:

#define ENABLE_FIRST
#include "first.h"
#include "second.h"
int main()
{
[[maybe_unused]] int a = firstNumber();
}
Ответ

Остаётся только firstNumber. Программа компилируется, и a инициализируется значением 7. Когда препроцессор заходит в first.h, макрос ENABLE_FIRST уже определён, поэтому он сохраняет функцию внутри этого #ifdef. ENABLE_SECOND не определён, так что функция в second.h отбрасывается. Вызов secondNumber из main не скомпилировался бы: её объявления не остаётся.

У определения ENABLE_FIRST нет текста подстановки, но для #ifdef это не важно — директива проверяет только само существование макроса. Таким образом, макрос, определённый перед #include, может управлять тем, что предоставит заголовочный файл.

Оставьте те же два заголовочных файла, но замените main.cpp на эту версию. Какие определения функций останутся теперь?

main.cpp:

#include "first.h"
#define ENABLE_FIRST
#include "second.h"
int main()
{
[[maybe_unused]] int a = firstNumber();
}
Ответ

Не остаётся ни одного определения функции, и компиляция падает на вызове firstNumber. Когда обрабатывается first.h, макрос ENABLE_FIRST ещё не определён, поэтому его функция отбрасывается. Определение макроса позже не заставит препроцессор вернуться и пересмотреть этот заголовочный файл. ENABLE_SECOND по-прежнему отсутствует, так что функция из второго заголовка тоже выбрасывается.

Порядок имеет значение: ставьте конфигурационные макросы до директивы #include, которая ими пользуется.

7. Макрос, определённый в более раннем заголовочном файле

Заголовок раздела «7. Макрос, определённый в более раннем заголовочном файле»

Замените файлы на варианты ниже. В этот раз в main.cpp нет ни одного #define. Повлияет ли макрос из first.h на second.h?

first.h:

#define ENABLE_SECOND
int firstNumber()
{
return 7;
}

second.h:

#ifdef ENABLE_SECOND
int secondNumber()
{
return 11;
}
#endif

main.cpp:

#include "first.h"
#include "second.h"
int main()
{
[[maybe_unused]] int a = firstNumber();
[[maybe_unused]] int b = secondNumber();
}
Ответ

Остаются обе функции. Программа компилируется, a инициализируется значением 7, а b — 11. Препроцессор встречает #define ENABLE_SECOND во время обработки first.h. Завершение этого файла не удаляет макрос: он остаётся определённым, когда начинается обработка second.h. Он также остаётся определённым и во всём остальном main.cpp, если что-нибудь не удалит его через #undef.

Поменяйте две директивы #include местами — и secondNumber исчезнет, так что её вызов не скомпилируется. Препроцессор дойдёт до #ifdef раньше, чем встретит определение в first.h. Включения не создают для макросов собственной области видимости: они обрабатываются по порядку как части одного исходного файла. При этом макросы не передаются автоматически другим исходным файлам, которые компилируются отдельно.

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

#include <iostream>
int main()
{
std::cout << 7 << std::endl;
}
Ответ

Программа выведет 7. <iostream> даёт объявления, нужные для работы с потоками. Посмотрите на вывод -E: одно это включение обычно подтягивает множество других заголовочных файлов. Это не значит, что весь этот текст превратится в машинные инструкции вашей программы.

9. Средства библиотеки C через заголовочный файл C++

Заголовок раздела «9. Средства библиотеки C через заголовочный файл C++»
#include <cstdio>
int main()
{
std::printf("%d\n", 7);
}
Ответ

Программа выведет 7. <cstdio> — это C++-заголовок для ввода-вывода в стиле C, и он помещает printf в пространство имён std.

#include <stdio.h>
int main()
{
printf("%d\n", 7);
}
Ответ

Программа выведет 7. Заголовочный файл совместимости <stdio.h> помещает printf в глобальное пространство имён. В C++ принято писать <cstdio> и std::printf. Не рассчитывайте, что один из этих заголовков заодно сделает имя доступным и в другом пространстве имён.

11. Использование функции без её заголовочного файла

Заголовок раздела «11. Использование функции без её заголовочного файла»
int main()
{
printf("%d\n", 7);
}
Ответ

C++ требует объявления функции перед таким вызовом, поэтому GCC отклоняет код: printf не объявлена. Подключите <cstdio> и используйте std::printf, либо подключите <stdio.h>. То, что библиотека установлена в системе, само по себе не делает её объявления видимыми.

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

settings.h:

constexpr int number = 7;

main.cpp:

#include <settings.h>
int main()
{
return number;
}
Ответ

При запуске g++ -std=c++20 -E main.cpp поиск завершается ошибкой: файл settings.h не найден. Угловые скобки не начинают поиск с каталога того файла, в котором стоит #include. Они всё же смогут найти проектные заголовки, если добавить этот каталог в путь поиска — например, с помощью -I .. См. правила путей поиска GCC.

13. Стандартный заголовочный файл в кавычках

Заголовок раздела «13. Стандартный заголовочный файл в кавычках»
#include "iostream"
int main()
{
std::cout << 7 << std::endl;
}
Ответ

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

Скомпилируйте командой g++ -std=c++20 -I config main.cpp -o app. Какое значение инициализирует a?

config/settings.h:

constexpr int number = 11;

main.cpp:

#include <settings.h>
int main()
{
[[maybe_unused]] int a = number;
}
Ответ

a инициализируется значением 11. -I config добавляет каталог config в путь поиска заголовочных файлов, поэтому препроцессор находит config/settings.h. number остаётся именем переменной C++ в выводе, а её определение приходит из этого заголовка.

15. Кавычки: соседний файл или каталог включения?

Заголовок раздела «15. Кавычки: соседний файл или каталог включения?»

Скомпилируйте командой g++ -std=c++20 -I config main.cpp -o app. Какой заголовочный файл победит?

settings.h:

constexpr int number = 7;

config/settings.h:

constexpr int number = 11;

main.cpp:

#include "settings.h"
int main()
{
[[maybe_unused]] int a = number;
}
Ответ

a инициализируется значением 7, потому что каталог файла main.cpp просматривается раньше, чем -I config. Замените включение на <settings.h>, и победит копия из config: a инициализируется значением 11. Вариант с угловыми скобками вообще не заглядывает в соседний файл.

Сравните g++ -std=c++20 -I first -I second main.cpp -o app с обратным порядком флагов.

first/settings.h:

constexpr int number = 11;

second/settings.h:

constexpr int number = 22;

main.cpp:

#include <settings.h>
int main()
{
[[maybe_unused]] int a = number;
}
Ответ

При -I first -I second переменная a инициализируется значением 11. Поменяйте флаги местами — и она инициализируется значением 22. GCC просматривает каталоги -I слева направо и останавливается на первом совпадении. Он не объединяет два заголовка только из-за того, что у них одинаковое имя.

Запустите g++ -std=c++20 -I config -E main.cpp. Пройдёт ли -E успешно?

config/settings.h:

constexpr int number = 11;

main.cpp:

#include <missing.h>
int main()
{
}
Ответ

Препроцессинг завершается ошибкой с сообщением вроде missing.h: No such file or directory. -I лишь добавляет места для поиска — он не способен создать файл, которого нет ни в одном из них. Исправьте имя в #include или поместите недостающий заголовок в один из просматриваемых каталогов.

18. Удаление стандартных путей включения C++

Заголовок раздела «18. Удаление стандартных путей включения C++»

Запустите g++ -std=c++20 -nostdinc++ -E main.cpp. На чём возникнет ошибка?

#include <iostream>
int main()
{
std::cout << 7 << std::endl;
}
Ответ

В типичной установке GCC препроцессинг падает, потому что не удаётся найти iostream. Флаг -nostdinc++ убирает стандартные каталоги заголовков C++, но оставляет прочие системные пути. Некоторые пакетные обёртки над компилятором добавляют свои пути; проверьте вывод с -v, если у вас заголовок всё ещё находится. Не путайте этот флаг с -nostdinc, который убирает вообще все стандартные системные каталоги включения.

Возьмите предыдущий main.cpp. Как с помощью -I снова сделать препроцессинг успешным?

Ответ

Сначала запустите препроцессор как обычно с флагом -v и выпишите пути, напечатанные между #include <...> search starts here: и End of search list.:

Окно терминала
g++ -std=c++20 -E -v main.cpp -o normal.ii

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

Окно терминала
g++ -std=c++20 -nostdinc++ \
-I /usr/include/c++/VERSION \
-I /usr/include/TARGET/c++/VERSION \
-I /usr/include/c++/VERSION/backward \
-E main.cpp -o restored.ii

Когда все нужные каталоги возвращены, препроцессинг снова проходит успешно. Добавить только каталог с iostream может быть недостаточно: этот заголовок подключает внутренние файлы вроде bits/c++config.h, которые могут лежать в отдельном каталоге под конкретную целевую платформу. Точная структура зависит от установки, поэтому не копируйте номера версий с чужой машины. См. описание опций каталогов GCC.

Возьмите программу с <iostream>. Сравните команды:

Окно терминала
gcc -std=c++20 -E main.cpp -o main.ii
gcc -std=c++20 -c main.cpp -o main.o
gcc main.o -o app

Какой этап завершится ошибкой? Действительно ли gcc не подключает пути заголовков C++ для файла .cpp?

Ответ

В типичной установке GCC первые две команды выполняются успешно. Расширение .cpp говорит gcc обрабатывать файл как C++ с обычными путями заголовков C++. Последняя команда падает на этапе компоновки, жалуясь на неопределённые символы библиотеки C++. gcc не линкует стандартную библиотеку C++ автоматически, в отличие от g++. Поэтому для всей сборки C++ используйте g++. См. пояснение GCC о драйвере C++.

Чтобы вместо этого увидеть ошибку выбора языка, попробуйте:

Окно терминала
gcc -x c -E main.cpp

Здесь -x c принудительно задаёт язык C, а стандартные пути поиска C обычно не содержат заголовков C++ вроде iostream. Обычный вызов gcc main.cpp так не делает. Обёртки над компилятором могут менять пути поиска; используйте -v, чтобы увидеть свои.