Ваши вопросы на самом деле не о компиляторе, а о том, как ваша среда разработки обрабатывает всю систему сборки. Системы сборки для большинства проектов C/C++ компилируют каждый файл .c или .cpp отдельно, а затем связывают полученные объектные файлы вместе в окончательный исполняемый файл. В вашем случае ваша IDE компилирует любой файл, который у вас есть в проекте, с расширением имени файла .cpp, а затем связывает полученные объекты. Поведение, которое вы видите, можно объяснить следующим образом:

1. a1.cpp отсутствует ;, поэтому, когда IDE пытается скомпилировать этот файл, вы получаете сообщение об ошибке «неожиданный конец файла».

2. b нигде не объявлено в модуле компиляции main.cpp, поэтому вы получаете ошибку о неопределенном идентификаторе.

3. b существует как в модулях компиляции main.cpp, так и в a1.cpp (очевидно, в a1.cpp и через ваш #include для main.cpp). Ваша IDE компилирует оба этих файла — теперь каждый из a1.o и main.o содержит объект с именем b. При связывании вы получаете ошибку повторяющегося символа.

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

Я рекомендую настроить тестовый проект командной строки с make-файлом, который вы создадите сами, — это научит вас всему внутреннему устройству систем сборки, а затем вы сможете применить эти знания к внутреннему устройству вашей IDE.

1. заголовочные файлы не компилируются
2. директива #include буквально вставляет содержимое включаемого файла вместо строки #include
3. Все исходные файлы (независимо от основного) компилируются в файлы .o или .obj.
4. Все файлы obj связаны между собой вместе с внешними файлами .lib, если таковые имеются.
5. Вы получаете исполняемый файл.

По пункту 2:

example
//a.h
int

//b.h
x = 

//c.h
5

//main.cpp
#include <iostream>
int main()
{
#include "a.h"
#include "b.h"
#include "c.h"
;

std::cout << x << std::endl; //prints 5 :) 
}

Это не полный ответ, но hth, my2c и т. д. :)

Поскольку кажется, что есть два способа понять ваш вопрос, я отвечу на часть понимания компиляции С++.

Я предлагаю вам начать с чтения определения «компилятор» в Википедии. После этого попробуйте поискать в Google учебники по компиляторам, чтобы улучшить свое понимание компиляторов. Если говорить более конкретно о C++, вы можете прочитать о директивах #include и препроцессора (попробуйте поискать эти термины в Google).

Если вы все еще хотите глубже понять компиляторы, я предлагаю книгу по компиляторам. Вы найдете хороший список книг на StackOverflow.

Оператор #include вставляет этот файл в файл, создающий #include. Таким образом, ваш фрагмент 3 main.cpp становится следующим перед компиляцией.

    // main.cpp    
    // All sorts of stuff from iostream
    //a1.cpp
    int b = 4;
    void main()
    {
        cout << b;
    }

Причина, по которой вы получаете ошибку компоновщика, заключается в том, что вы определяете b дважды. Он определен в файлах a.cpp и main.cpp.

Вы можете прочитать об объявлении и определении.

Вы указываете системе сборки, какие файлы компилировать. В случае Visual C++ он автоматически компилирует любой файл с именем "*.cpp", который вы добавляете в проект. Хотя вы можете зайти в настройки проекта и запретить это делать.

Он не компилирует файлы с именами *.h (хотя может, если вы прямо укажете это).

Директива #include обрабатывается компилятором до какой-либо компиляции (она называется препроцессором). По сути, он берет файл, на который указывает, и вставляет его в компилируемый исходный файл в тот момент, когда в файле появляется директива #include. Затем компилятор компилирует все это как единое целое.

Итак, в ваших примерах:

Фрагмент 1

Bote a1.cpp и main.cpp компилируются системой сборки отдельно. ТАК, когда он сталкивается с ошибкой a1.cpp, он сообщает об этом.

Фрагмент 2

Обратите внимание, что он компилирует эти файлы отдельно, не зная друг друга, поэтому, когда вы указываете b в main.cpp, он не знает, что b определен в a1.cpp.

Фрагмент 3

Теперь вы включили a1.cpp в main.cpp, поэтому он компилирует main.cpp, видит определение для b и говорит: «Хорошо, у меня есть b в глобальной области видимости». Затем он компилирует a1.cpp и говорит: «ОК, у меня есть b в глобальной области видимости».

Теперь компоновщик вмешивается и = пытается соединить a1 и main вместе, теперь он говорит вам, эй, у меня есть 2 b ate глобальной области видимости. Не хорошо.

Компилятор берет исходные файлы оттуда, где вы ему говорите. В случае Visual C++ есть IDE, сообщающая компилятору, что делать, и разные папки существуют, потому что именно так IDE упорядочивает файлы.

Кроме того, ошибка во фрагменте 2 связана с компоновщиком, а не с компилятором. Компилятор скомпилировал main.cpp и a1.cpp в объектные файлы main.obj и a1.obj, а затем компоновщик пытается создать исполняемый файл, объединяющий эти объектные файлы, но переменная b находится как в a1.obj (напрямую), так и в main.obj (через включение a1.cpp), поэтому вы получаете «уже определенную» ошибку.

Проблемы, которые вы видите в случае 1 и 3, специфичны для VS. VS, по-видимому, пытается скомпилировать как main.cpp, так и a1.cpp.

Случай 1: когда VS пытается скомпилировать a1.cpp, в котором есть синтаксическая ошибка (отсутствует точка с запятой), компиляция завершается неудачно.

Случай 2: Вы не объявили переменную b в файле main.cpp или во включенных файлах. Таким образом, компиляция не выполняется.

Случай 3: Это ошибка компоновщика. Из-за включения int b было объявлено как в main.cpp, так и в a1.cpp. Поскольку ни одна из них не является ни статической, ни внешней, две глобальные переменные с одинаковым идентификатором были объявлены в одной области видимости. Это не разрешено.