1
00:00:07,200 --> 00:00:09,100
[Powered by Google Translate] ROB Боуден: Давайте поговорим о компиляторах.

2
00:00:09,100 --> 00:00:11,490
До этого момента, вы только что ввели ваш исходный код в

3
00:00:11,490 --> 00:00:14,260
некоторые файлы, послал их через этот большой черный ящик, который является

4
00:00:14,260 --> 00:00:16,890
Clang, и из приходит на ваш исполняемый файл, что делает

5
00:00:16,890 --> 00:00:19,430
именно то, что вы написали в вашем исходном коде.

6
00:00:19,430 --> 00:00:22,170
Как магический, как и было, мы собираемся, чтобы поближе

7
00:00:22,170 --> 00:00:23,590
посмотрим, что происходит на самом деле

8
00:00:23,590 --> 00:00:25,220
Когда мы компиляции файла.

9
00:00:25,220 --> 00:00:28,580
Так что же это значит для компиляции что-то?

10
00:00:28,580 --> 00:00:31,150
>> Ну, в самом общем смысле, это просто означает,

11
00:00:31,150 --> 00:00:32,580
преобразованию кода, написанного в одном

12
00:00:32,580 --> 00:00:34,680
языка программирования на другой.

13
00:00:34,680 --> 00:00:37,550
Но обычно, когда люди говорят, что они компилировать что-нибудь, они

14
00:00:37,550 --> 00:00:39,660
значит, они берут его от более высокого уровня программирования

15
00:00:39,660 --> 00:00:42,460
языка на более низкую язык программирования высокого уровня.

16
00:00:42,460 --> 00:00:44,960
Это может показаться очень субъективным условиях.

17
00:00:44,960 --> 00:00:48,090
Например, вы, вероятно, не думают о С, как высокая

18
00:00:48,090 --> 00:00:51,440
уровне языка программирования, но Вы его компиляции.

19
00:00:51,440 --> 00:00:52,730
Но это все относительно.

20
00:00:52,730 --> 00:00:55,790
Как мы увидим, код сборки и в конечном итоге машина

21
00:00:55,790 --> 00:00:59,270
кода, который мы собираем до, несомненно, более низкого уровня

22
00:00:59,270 --> 00:01:00,700
чем C.

23
00:01:00,700 --> 00:01:03,310
Хотя мы будем использовать Clang в сегодняшней демонстрации,

24
00:01:03,310 --> 00:01:06,360
Много идей здесь переносятся на другие компиляторы.

25
00:01:06,360 --> 00:01:09,160
>> Для Clang, существуют четыре основных этапа в общем

26
00:01:09,160 --> 00:01:10,200
компиляцию.

27
00:01:10,200 --> 00:01:15,430
Это один, предварительная обработка сделать препроцессором, два,

28
00:01:15,430 --> 00:01:19,530
компиляция делается компилятором, три, монтаж

29
00:01:19,530 --> 00:01:22,010
сделано ассемблере, и четыре,

30
00:01:22,010 --> 00:01:24,640
связывающий сделано компоновщика.

31
00:01:24,640 --> 00:01:27,600
Это может ввести в заблуждение, что одним из подшагов общего

32
00:01:27,600 --> 00:01:30,980
Clang компиляторы называют компилятором, но

33
00:01:30,980 --> 00:01:32,530
Мы вернемся к этому.

34
00:01:32,530 --> 00:01:35,050
Мы будем использовать простую программу привет мир, как наш пример

35
00:01:35,050 --> 00:01:36,270
на протяжении всего этого видео.

36
00:01:36,270 --> 00:01:38,380
Давайте посмотрим.

37
00:01:38,380 --> 00:01:40,330
>> На первом этапе предварительной обработки.

38
00:01:40,330 --> 00:01:42,520
Что препроцессор делать?

39
00:01:42,520 --> 00:01:45,560
В значительной степени каждая программа C вы когда-либо читали или письменной форме,

40
00:01:45,560 --> 00:01:48,310
Вы использовали строк кода, которые начинаются с хэш.

41
00:01:48,310 --> 00:01:51,730
Я буду называть его хэш, но вы также можете называть это фунтах, количество

42
00:01:51,730 --> 00:01:53,280
подписаться, или острым.

43
00:01:53,280 --> 00:01:56,840
Любая такая строка является директивой препроцессора.

44
00:01:56,840 --> 00:02:00,650
Вы, наверное, видели # # определять и включать раньше, но

45
00:02:00,650 --> 00:02:03,690
несколько больше, что препроцессор признает.

46
00:02:03,690 --> 00:02:07,340
Давайте добавим # определить нашему примеру привет всем мире.

47
00:02:07,340 --> 00:02:11,690
Теперь давайте запустим просто препроцессор на этот файл.

48
00:02:11,690 --> 00:02:16,150
По мимо clage флага-E, вы поручив ему работать

49
00:02:16,150 --> 00:02:17,880
просто препроцессор.

50
00:02:17,880 --> 00:02:19,130
Давайте посмотрим, что происходит.

51
00:02:22,250 --> 00:02:24,020
Похоже, Clang просто выплевывает все

52
00:02:24,020 --> 00:02:25,200
в командной строке.

53
00:02:25,200 --> 00:02:27,800
Для того, чтобы сохранить все это вывод в новый файл с именем

54
00:02:27,800 --> 00:02:33,850
hello2.c, мы будем добавлять> hello2.c на нашу команду.

55
00:02:33,850 --> 00:02:37,800
Теперь давайте взглянем на нашу предварительно обработанного файла.

56
00:02:37,800 --> 00:02:40,810
>> Эй, что произошло с нашей коротенькой программы?

57
00:02:40,810 --> 00:02:43,890
Если пройти весь путь до дна этот файл, мы увидим,

58
00:02:43,890 --> 00:02:46,070
часть кода, что мы на самом деле написал.

59
00:02:46,070 --> 00:02:49,800
Обратите внимание, что # определить ушел, и все экземпляры имя

60
00:02:49,800 --> 00:02:51,950
были заменены именно то, что мы указали в

61
00:02:51,950 --> 00:02:53,590
# определить линию.

62
00:02:53,590 --> 00:02:56,530
Так что все эти определения типов и описания функций

63
00:02:56,530 --> 00:02:58,140
в верхней части файла?

64
00:02:58,140 --> 00:03:00,820
Обратите внимание, что # определить не только препроцессор

65
00:03:00,820 --> 00:03:02,390
директивы, которые мы указали.

66
00:03:02,390 --> 00:03:05,280
Мы также включает stdio.h #.

67
00:03:05,280 --> 00:03:09,560
Так что все сумасшедшие линии на самом деле просто скопировал stdio.h

68
00:03:09,560 --> 00:03:11,810
и вставлены в верхней части этого файла.

69
00:03:11,810 --> 00:03:14,110
Именно поэтому файлы заголовков так полезны для функции

70
00:03:14,110 --> 00:03:15,160
декларациями.

71
00:03:15,160 --> 00:03:17,740
Вместо того, чтобы копировать и вставлять все функции

72
00:03:17,740 --> 00:03:21,050
декларациях вы планируете использовать в верхней части вашего файла,

73
00:03:21,050 --> 00:03:22,990
препроцессор скопируйте и вставьте их из заголовка

74
00:03:22,990 --> 00:03:24,140
файл для вас.

75
00:03:24,140 --> 00:03:26,480
>> Теперь, когда мы закончили первичную обработку, мы перейдем к

76
00:03:26,480 --> 00:03:27,680
компиляцию.

77
00:03:27,680 --> 00:03:30,725
Поэтому мы называем этот шаг компиляции, потому что это

78
00:03:30,725 --> 00:03:34,130
этап, на котором Clang на самом деле его составления от С до

79
00:03:34,130 --> 00:03:35,370
ассемблере.

80
00:03:35,370 --> 00:03:38,280
Для того чтобы иметь Clang компиляции файла до сборки, но

81
00:03:38,280 --> 00:03:42,030
продолжать дальше, передайте его-S флаг

82
00:03:42,030 --> 00:03:43,560
в командной строке.

83
00:03:43,560 --> 00:03:44,790
Давайте взглянем на сборку

84
00:03:44,790 --> 00:03:47,390
файл, который был сигнал.

85
00:03:47,390 --> 00:03:49,740
Похоже, совсем другой язык.

86
00:03:49,740 --> 00:03:52,660
Ассамблея код очень конкретного процессора.

87
00:03:52,660 --> 00:03:55,440
В этом случае, поскольку CS50 прибор работает на

88
00:03:55,440 --> 00:04:00,470
виртуальным x86-процессор, это x86-код сборки.

89
00:04:00,470 --> 00:04:03,450
Очень немногие люди пишут прямо на ассемблере в эти дни,

90
00:04:03,450 --> 00:04:06,490
но каждая программа C Вы когда-нибудь написать преобразуется вниз

91
00:04:06,490 --> 00:04:07,940
в сборке.

92
00:04:07,940 --> 00:04:11,440
Опять же, мы называем этот шаг компиляции C в сборке

93
00:04:11,440 --> 00:04:14,170
поскольку мы собираемся с более высокого уровня на более низкий уровень

94
00:04:14,170 --> 00:04:15,480
язык программирования.

95
00:04:15,480 --> 00:04:17,880
>> То, что делает сборку более низком уровне, чем C?

96
00:04:17,880 --> 00:04:21,660
Ну, в сборе, мы очень ограничены в том, что мы можем сделать.

97
00:04:21,660 --> 00:04:25,120
Есть нет, если, в то время, ибо, или петли любого рода.

98
00:04:25,120 --> 00:04:27,560
Но вы можете сделать то же самое, что эти контролем

99
00:04:27,560 --> 00:04:30,270
структуры предлагают использование ограниченных операций,

100
00:04:30,270 --> 00:04:32,350
сборка не предусматривает.

101
00:04:32,350 --> 00:04:35,960
Но чтобы понять, как низко уровне сборки на самом деле, давайте

102
00:04:35,960 --> 00:04:39,320
еще один шаг вперед в нашей компиляции, сборки.

103
00:04:39,320 --> 00:04:41,890
Это работа сборщиком, чтобы преобразовать код сборки

104
00:04:41,890 --> 00:04:44,740
в объект или машинный код.

105
00:04:44,740 --> 00:04:47,610
Помните, что ассемблер не выводит собраний;

106
00:04:47,610 --> 00:04:51,080
скорее, он принимает в сборке и выходы машинный код.

107
00:04:51,080 --> 00:04:54,040
Машинный код является фактическим 1 и 0, что процессор может

108
00:04:54,040 --> 00:04:57,290
понимаю, хотя у нас еще есть чуть-чуть оставил работу

109
00:04:57,290 --> 00:04:59,380
прежде чем мы сможем выполнить нашу программу.

110
00:04:59,380 --> 00:05:01,400
Давайте собирать наши сборки кода, передав

111
00:05:01,400 --> 00:05:04,080
Флаг Clang-C.

112
00:05:04,080 --> 00:05:06,410
Теперь давайте посмотрим, что находится в собранном файл.

113
00:05:06,410 --> 00:05:09,220
>> Хорошо, что не помогает нам очень многое.

114
00:05:09,220 --> 00:05:11,340
Помните, что машина кода нулей и единиц, что

115
00:05:11,340 --> 00:05:13,240
Ваш компьютер может понять.

116
00:05:13,240 --> 00:05:16,080
Это не значит, что это легко для нас, чтобы понять.

117
00:05:16,080 --> 00:05:19,160
Так как именно низкий уровень сборки?

118
00:05:19,160 --> 00:05:21,480
Это почти идентично объектный код.

119
00:05:21,480 --> 00:05:24,300
Переход от сборки в объектный код намного больше

120
00:05:24,300 --> 00:05:27,540
Перевод, чем преобразование, поэтому

121
00:05:27,540 --> 00:05:29,310
никто не может рассмотреть ассемблеру

122
00:05:29,310 --> 00:05:31,400
делать любые фактические компиляции.

123
00:05:31,400 --> 00:05:34,110
На самом деле, это довольно легко вручную переводить с

124
00:05:34,110 --> 00:05:36,050
сборки в машинный код.

125
00:05:36,050 --> 00:05:39,040
Глядя на сборку для основной функции, что первая линия

126
00:05:39,040 --> 00:05:42,100
бывает, чтобы соответствовать шестнадцатеричное 0x55.

127
00:05:42,100 --> 00:05:45,470
В двоичной, это 1010101.

128
00:05:45,470 --> 00:05:49,300
Во второй строке происходит соответствуют шестнадцатеричной 0x895.

129
00:05:49,300 --> 00:05:51,290
А на следующий, 0x56.

130
00:05:51,290 --> 00:05:53,730
Учитывая сравнительно простую таблицу, вы можете переводить

131
00:05:53,730 --> 00:05:57,130
сборку в коде, что машины могут понять тоже.

132
00:05:57,130 --> 00:05:58,810
>> Так что один оставшийся шаг в

133
00:05:58,810 --> 00:06:01,150
компиляцию, которая связывает.

134
00:06:01,150 --> 00:06:04,530
Образцы сочетает в себе кучу объектных файлов в один большой файл

135
00:06:04,530 --> 00:06:06,380
что вы реально можете выполнить.

136
00:06:06,380 --> 00:06:08,570
Образцы очень зависит от системы.

137
00:06:08,570 --> 00:06:11,030
Таким образом, самый простой способ получить Clang просто связать объект

138
00:06:11,030 --> 00:06:13,920
Файлы Вместе является звонить Clang на всех файлов, которые

139
00:06:13,920 --> 00:06:15,190
Вы хотите, чтобы связать вместе.

140
00:06:15,190 --> 00:06:18,740
Если вы укажете. О файлах, то не нужно будет перерабатывать,

141
00:06:18,740 --> 00:06:21,680
компилировать и собирать все ваши исходным кодом.

142
00:06:21,680 --> 00:06:23,960
Давайте бросать математические функции в нашем файле, так что у нас есть

143
00:06:23,960 --> 00:06:25,210
что-то, чтобы связать дюйма

144
00:06:34,220 --> 00:06:37,010
Теперь давайте собирать его обратно в объектный код и

145
00:06:37,010 --> 00:06:38,260
звоните Clang на нем.

146
00:06:40,560 --> 00:06:41,420
Ой.

147
00:06:41,420 --> 00:06:43,790
Так как мы включали математические функции, нам нужно связать в

148
00:06:43,790 --> 00:06:46,610
математическую библиотеку с-лм.

149
00:06:46,610 --> 00:06:48,990
>> Если мы хотим связать воедино кучу. Вывода файлов, которые мы

150
00:06:48,990 --> 00:06:51,420
написал на наши собственные, мы бы просто указать их все в

151
00:06:51,420 --> 00:06:52,460
командной строки.

152
00:06:52,460 --> 00:06:55,320
Ограничением является то, что только один из этих файлов должны

153
00:06:55,320 --> 00:06:57,790
на самом деле определить основные функции, либо

154
00:06:57,790 --> 00:06:59,930
полученный исполняемый файл не знаете с чего начать

155
00:06:59,930 --> 00:07:00,910
работает ваш код.

156
00:07:00,910 --> 00:07:03,360
В чем разница между указанием файл по ссылке в

157
00:07:03,360 --> 00:07:06,600
с-л, а просто указав файл напрямую?

158
00:07:06,600 --> 00:07:07,440
Ничего.

159
00:07:07,440 --> 00:07:09,850
Это просто, что Clang происходит точно знать, какой файл

160
00:07:09,850 --> 00:07:12,560
что-то вроде-LM происходит относятся.

161
00:07:12,560 --> 00:07:14,700
Если бы вы знали, что файл самостоятельно, вы можете указать его

162
00:07:14,700 --> 00:07:15,930
в явном виде.

163
00:07:15,930 --> 00:07:18,990
Просто помните, что все л флаги должны прийти в конце

164
00:07:18,990 --> 00:07:20,770
Вашего клиента спрос.

165
00:07:20,770 --> 00:07:22,300
>> И это все, что нужно сделать.

166
00:07:22,300 --> 00:07:24,940
Если вы просто запустите Clang на некоторые файлы, это то, что это

167
00:07:24,940 --> 00:07:26,350
на самом деле делает.

168
00:07:26,350 --> 00:07:29,490
Меня зовут Боб Боуден, и это CS50.