Основы компиляции


Содержание

Этапы компиляции

Компиляция исходных текстов на Си в исполняемый файл происходит в три этапа.

Препроцессинг

Эту операцию осуществляет текстовый препроцессор.

Исходный текст частично обрабатывается — производятся:

  • Замена комментариев пустыми строками
  • Текстовое включение файлов — #include
  • Макроподстановки — #define
  • Обработка директив условной компиляции — #if , #ifdef , #elif , #else , #endif

Компиляция

Процесс компиляции состоит из следующих этапов:

  1. Лексический анализ. Последовательность символов исходного файла преобразуется в последовательность лексем.
  2. Синтаксический анализ. Последовательность лексем преобразуется в дерево разбора.
  3. Семантический анализ . Дерево разбора обрабатывается с целью установления его семантики (смысла) — например, привязка идентификаторов к их декларациям, типам, проверка совместимости, определение типов выражений и т. д.
  4. Оптимизация . Выполняется удаление излишних конструкций и упрощение кода с сохранением его смысла.
  5. Генерация кода . Из промежуточного представления порождается объектный код.

Результатом компиляции является объектный код.

Объектный код — это программа на языке машинных кодов с частичным сохранением символьной информации, необходимой в процессе сборки.

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

Компоновка

Также называется связывание, сборка или линковка.

Это последний этап процесса получения исполняемого файла , состоящий из связывания воедино всех объектных файлов проекта.

При этом возможны ошибки связывания.

Если, допустим, функция была объявлена, но не определена, ошибка обнаружится только на этом этапе.

Особенность подключения пользовательских библиотек в Си

Подключение пользовательской библиотеки в Си на самом деле не так просто, как кажется.

Рассмотрим пример: есть желание вынести часть кода в отдельный файл — пользовательскую библиотеку.

program.c

#include «mylib.h»
const int MAX_DIVISORS_NUMBER = 10000;

int main()
<
int number = read_number();

int Divisor[MAX_DIVISORS_NUMBER];
size_t Divisor_top = 0;
factorize(number, Divisor, &Divisor_top);

print_array(Divisor, Divisor_top);
return 0;
>

Сама библиотека должна состоять из двух файлов: mylib.h и mylib.c.

mylib.h

#ifndef MY_LIBRARY_H_INCLUDED
#define MY_LIBRARY_H_INCLUDED

//считываем число
int read_number();

//получаем простые делители числа
// сохраняем их в массив, чей адрес нам передан
void factorize(int number, int *Divisor, int *Divisor_top);

//выводим число
void print_number(int number);

//распечатывает массив размера A_size в одной строке через TAB
void print_array(int A[], size_t A_size);

mylib.c

//считываем число
int read_number()
<
int number;
scanf(«%d», &number);
return number;
>

//получаем простые делители числа
// сохраняем их в массив, чей адрес нам передан
void factorize(int x, int *Divisor, int *Divisor_top)
<
for (int d = 2; d = 0; i—)
<
printf(«%d\t», A[i]);
>
printf(«\n»);
>

Препроцессор Си, встречая #include «mylib.h», полностью копирует содержимое указанного файла (как текст) в место вызова директивы. Благодаря этому на этапе компиляции не возникает ошибок типа Unknown identifier при использовании функций из библиотеки.

Файл mylib.c компилируется отдельно.

А на этапе компоновки полученный файл mylib.o должен быть включен в исполняемый файл program.exe.

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

Основы компиляторов

Основные задачи компиляторов

Компьютеры сами по себе способны выполнять только очень ограниченный набор операций, называемых машинными кодами. В старые времена, когда появились первые компьютеры, программы писались в машинных кодах, представляющих собой последовательности двоичных чисел, однозначно воспринимаемых компьютером. В конце 50-х кодов прошлого века появились первые языки программирования, такие как язык ассемблера и Фортран. Для того, чтобы компьютер мог понять программу, написанную на каком-то языке программирования, необходим переводчик ( транслятор ) такой программы в машинные коды. Отметим, что, если оператор языка ассемблера отображается при трансляции чаще всего 1 Некоторые операторы языка ассемблера, например, такие, как операторы ввода/вывода, отображаются в несколько машинных команд. в одну машинную инструкцию, предложения языков более высокого уровня отображаются, вообще говоря, в несколько машинных инструкций.

Трансляторы бывают двух типов: компиляторы ( compiler ) и интерпретаторы ( interpreter ). Процесс компиляции состоит из двух частей: анализа ( analysis ) и синтеза ( synthesis ). Анализирующая часть компилятора разбивает исходную программу на составляющие ее элементы (конструкции языка) и создает промежуточное представление исходной программы. Синтезирующая часть из промежуточного представления создает новую программу, которую компьютер в состоянии понять. Такая программа называется объектной программой. Объектная программа может в дальнейшем выполняться без перетрансляции. В качестве промежуточного представления обычно используются деревья, в частности, так называемые деревья разбора. Под деревом разбора понимается дерево , каждый узел которого соответствует некоторой операции , а сыновья этого узла — операндам.

Интерпретатор

В отличие от компилятора, интерпретатор не создает никакой новой программы, а просто выполняет каждое предложение языка программирования. Можно сказать, что результатом работы интерпретатора является «число».

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

В том случае, если исходный язык достаточно прост (например, если это язык ассемблера или Basic ), то никакое промежуточное представление не нужно, и тогда интерпретатор — это простой цикл . Он выбирает очередную инструкцию языка из входного потока, анализирует и выполняет ее. Затем выбирается следующая инструкция . Этот процесс продолжается до тех пор, пока не будут выполнены все инструкции, либо пока не встретится инструкция , означающая окончание процесса интерпретации.

Компилятор

Компилятор переводит программы с одного языка на другой. Входом компилятора служит цепочка символов , составляющая исходную программу на языке программирования . Выход компилятора (объектная программа ) также представляет собой цепочку символов, но принадлежащую другому языку , например, языку некоторого компьютера. При этом сам компилятор написан на языке , возможно, отличающемся от первых двух. Будем называть язык исходным языком, язык — целевым языком, а язык — языком реализации. Таким образом, можно говорить о компиляторе как об отображении множества в множество , т.е. .

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

Существует огромное количество различных языков программирования, начиная с таких традиционных языков программирования как Fortran и Pascal и кончая современными объектно-ориентированными языками такими, как C# и Java . Практически каждый язык программирования имеет какие-то особенности с точки зрения создателя транслятора. Однако мы начнем с рассмотрения разнообразных целевых языков компиляторов.

Национальная библиотека им. Н. Э. Баумана
Bauman National Library

Персональные инструменты

Компилятор

Компиля́тор — программа или техническое средство, выполняющее компиляцию [1] [2] [3] .

Компиля́ция — трансляция программы, составленной на исходном языке высокого уровня, в эквивалентную программу на низкоуровневом языке, близком машинному коду (абсолютный код, объектный модуль, иногда на язык ассемблера) [2] [3] [4] . Входной информацией для компилятора (исходный код) является описание алгоритма или программа на предметно-ориентированном языке, а на выходе компилятора — эквивалентное описание алгоритма на машинно-ориентированном языке (объектный код) [5] .

Компили́ровать — проводить трансляцию машинной программы с предметно-ориентированного языка на машинно-ориентированный язык [3] .

Содержание

Виды компиляторов

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

Виды компиляции

  • Пакетная. Компиляция нескольких исходных модулей в одном пункте задания.
  • Построчная. Машинный код порождается и затем исполняется для каждой завершённой грамматической конструкции языка. Внешне воспринимается как интерпретация, но устройство иное.
  • Условная. Компиляция, при которой транслируемый текст зависит от условий, заданных в исходной программе директивами компилятора. Так, в зависимости от значения некоторой константы, можно включать или выключать трансляцию части текста программы.

Структура компилятора

Процесс компиляции состоит из следующих этапов:

  1. Лексический анализ. На этом этапе последовательность символов исходного файла преобразуется в последовательность лексем.
  2. Синтаксический (грамматический) анализ. Последовательность лексем преобразуется в дерево разбора.
  3. Семантический анализ. Дерево разбора обрабатывается с целью установления его семантики (смысла) — например, привязка идентификаторов к их декларациям, типам, проверка совместимости, определение типов выражений и т. д. Результат обычно называется «промежуточным представлением/кодом», и может быть дополненным деревом разбора, новым деревом, абстрактным набором команд или чем-то ещё, удобным для дальнейшей обработки.
  4. Оптимизация. Выполняется удаление излишних конструкций и упрощение кода с сохранением его смысла. Оптимизация может быть на разных уровнях и этапах — например, над промежуточным кодом или над конечным машинным кодом.
  5. Генерация кода. Из промежуточного представления порождается код на целевом языке.

В конкретных реализациях компиляторов эти этапы могут быть разделены или, наоборот, совмещены в том или ином виде.

Генерация кода

Генерация машинного кода

Большинство компиляторов переводит программу с некоторого высокоуровневого языка программирования в машинный код, который может быть непосредственно выполнен процессором. Как правило, этот код также ориентирован на исполнение в среде конкретной операционной системы, поскольку использует предоставляемые ею возможности (системные вызовы, библиотеки функций). Архитектура (набор программно-аппаратных средств), для которой производится компиляция, называется целевой машиной.

Результат компиляции — исполнимый модуль — обладает максимальной возможной производительностью, однако привязан к определённой операционной системе и процессору (и не будет работать на других).

Для каждой целевой машины (IBM, Apple, Sun и т. д.) и каждой операционной системы или семейства операционных систем, работающих на целевой машине, требуется написание своего компилятора. Существуют также так называемые кросс-компиляторы, позволяющие на одной машине и в среде одной ОС генерировать код, предназначенный для выполнения на другой целевой машине и/или в среде другой ОС. Кроме того, компиляторы могут оптимизировать код под разные модели из одного семейства процессоров (путём поддержки специфичных для этих моделей особенностей или расширений наборов инструкций). Например, код, скомпилированный под процессоры семейства Pentium, может учитывать особенности распараллеливания инструкций и использовать их специфичные расширения — MMX, SSE и т. п.

Некоторые компиляторы переводят программу с языка высокого уровня не прямо в машинный код, а на язык ассемблера (примером может служить PureBasic, транслирующий бейсик-код в ассемблер FASM). Это делается для упрощения части компилятора, отвечающей за кодогенерацию, и повышения его переносимости (задача окончательной генерации кода и привязки его к требуемой целевой платформе перекладывается на ассемблер), либо для возможности контроля и исправления результата компиляции программистом.

Генерация байт-кода

Результатом работы компилятора может быть программа на специально созданном низкоуровневом языке, подлежащем интерпретации виртуальной машиной. Такой язык называется псевдокодом или байт-кодом. Как правило, он не является машинным кодом какого-либо компьютера и программы на нём могут исполняться на различных архитектурах, где имеется соответствующая виртуальная машина, но в некоторых случаях создаются аппаратные платформы, напрямую поддерживающие псевдокод какого-либо языка. Например, псевдокод языка Java называется байт-кодом Java и выполняется в Java Virtual Machine, для его прямого исполнения была создана спецификация процессора picoJava. Для платформы .NET Framework псевдокод называется Common Intermediate Language (CIL), а среда исполнения — Common Language Runtime (CLR).

Некоторые реализации интерпретируемых языков высокого уровня (например, Perl) используют байт-код для оптимизации исполнения: затратные этапы синтаксического анализа и преобразование текста программы в байт-код выполняются один раз при загрузке, затем соответствующий код может многократно использоваться без промежуточных этапов.

Динамическая компиляция

Из-за необходимости интерпретации байт-код выполняется значительно медленнее машинного кода сравнимой функциональности, однако он более переносим (не зависит от операционной системы и модели процессора). Чтобы ускорить выполнение байт-кода, используется динамическая компиляция, когда виртуальная машина транслирует псевдокод в машинный код непосредственно перед его первым исполнением (и при повторных обращениях к коду исполняется уже скомпилированный вариант).

Наиболее популярной разновидностью динамической компиляции является JIT-компиляция. Другой разновидностью является. CIL-код также компилируется в код целевой машины JIT-компилятором, а библиотеки .NET Framework компилируются заранее.

Декомпиляция

Существуют программы, которые решают обратную задачу — перевод программы с низкоуровневого языка на высокоуровневый. Этот процесс называют декомпиляцией, а такие программы — декомпиляторами. Но поскольку компиляция — это процесс с потерями, точно восстановить исходный код, скажем, на C++, в общем случае невозможно. Более эффективно декомпилируются программы в байт-кодах — например, существует довольно надёжный декомпилятор для Adobe Flash. Разновидностью декомпилирования является дизассемблирование машинного кода в код на языке ассемблера, который почти всегда выполняется успешно (при этом сложность может представлять самомодифицирующийся код или код, в котором собственно код и данные не разделены). Связано это с тем, что между кодами машинных команд и командами ассемблера имеется практически взаимно-однозначное соответствие.

Раздельная компиляция

Раздельная компиляция (англ. separate compilation ) — трансляция частей программы по отдельности с последующим объединением их компоновщиком в единый загрузочный модуль.

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

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

Интересные факты

На заре развития компьютеров первые компиляторы (трансляторы) называли «программирующими программами» [6] (так как в тот момент программой считался только машинный код, а «программирующая программа» была способна из человеческого текста сделать машинный код, то есть запрограммировать ЭВМ).

Основы компиляции программ в ОС Linux.

Основы использования утилиты MAKE.

Утилита ‘make’ автоматически определяет, какие части составной программы (программы, состоящей из нескольких файлов) необходимо перекомпилировать, и выполняет их команды для перекомпиляции.

Далее использование ‘make’ будет показано на С программах, так как они наиболее часто используются в Linux, но вы можете испльзовать ‘make’ с любым другим языком программирования, чей компилятор может работать с командами интерпретатора. Конечно ‘make’ неограничена программированием. Вы можете ее использовать для описания любой задачи, в которой некоторые файлы должны обновляться автоматически , всякий раз когда изменяютя файлы, от которых они зависят.

Для подготовки использования ‘make’, необходимо создать файл, называемый “makefile” или “Makefile” , который описывает зависимости среди файлов, составляющих вашу программу и задает команды для обновления каждого файла. При создании программы на любом языке программирования, обычно, исполнимый файл обновляется ( или создается) из объектных файлов, которые в свою очередь обновляются (создаются) посредством компиляции файлов исходных текстов программы.

Если существует подходящий makefile , при каждом изменении некоторых исходных файлов, составляющих программу, команда оболочки

Make

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

Далее будет рассмотрен простой makefile , который описывает как компилировать и линковать текстовый редактор, который состоит из восьми файлов исходных текстов на языке С и трех заголовочных файлов.

Когда ‘make’ перекомпилирует редактор, каждый измененный файл исходных текстов должен быть перекомпилирован. Если заголовочный файл был изменен, каждый файл исходных текстов, включающий этот зоголовочный файл должен быть перекомпилирован. Каждая процедура компиляции создает объектный файл соответствующий исходному. Наконец, если любой файл исходных текстов был перекомпилирован, все объектные файлы, и вновь созданные и осташиеся от предыдущей компиляции, должны быть собраны вместе линковщиком для создания нового исполнимого файла текстового редактора.

Простой makefile состоит из правил следующего вида:

ЦЕЛЬ . : ЗАВИСИМОСТИ .

КОМАНДЫ

ЦЕЛЬ – это обычно имя файла, который создается программой; примерами ЦЕЛИ являются исполнимые и объектные файлы. ЦЕЛЬ также может быть именем действия , которое необходимо выполнить, такое как ‘clean’ (очистка от ненужных файлов).

ЗАВИСИМОСТИ – это файлы, кторые используются как исходные для создания файла цели. ЦЕЛЬ обычно зависит от нескольких файлов.

КОМАНДЫ – это действия которые выполняет ‘make’. Правило может иметь более одной кманды, каждая из которых должна пиписаться с новой строки. Заметим, что вначале каждой строки команд необходимо использовать символ табуляции.

Обычно КОМАНДЫ используются в правиле с ЗАВИСИМОСТЯМИ и служат для создания файла ЦЕЛИ если изменится какая нибудь ЗАВИСИМОСТЬ. Однако есть правила, которые определяют КОМАНДЫ для ЦЕЛИ не имея ЗАВИСИМОСТЕЙ. Например, правило ,содержащее КОМАНДЫ удаления и ассоциированное с целью ‘clean’ не имеет ЗАВИСИМОСТЕЙ.

Принцип работы make следующий — после запуска, make начинает сначала просматривать содержимое файла makefile. Найдя первую ЦЕЛЬ, make смотрит по порядку написания ЗАВИСИМОСТИ. Если ЗАВИСИМОСТЬ является файлом, но не является ЦЕЛЬЮ какого нибудь другого правила, то сравниваются времена последней модификации этой ЗАВИСИМОСТИ и ЦЕЛИ. Если время последней модификации ЦЕЛИ более раннее, чем ЗАВИСИМОСТИ, то make отмечает,что необходимо выполнение КОМАНД данного правила и переходит к следующей ЗАВИСИМОСТИ. Если ЗАВИСИМОСТЬ является ЦЕЛЬЮ какого нибудь другого правила, то make вначале переходит к выполнению этого зависимого правила. Затем make возвращается к исходному правилу и смотрит времена последней модификации ЦЕЛИ и данной ЗАВИСИМОСТИ. После прохождения всех ЗАВИСИМОСТЕЙ make выполняет КОМАНДЫ. В случае, если после прохождения всех ЗАВИСИМОСТЕЙ правила выяснится, что времена последней модификации ЗАВИСИМОСТЕЙ и ЦЕЛИ совпадают, то make выполнять КОМАНДЫ не будет и прекратит работу. Замтим, что выполняется по умолчанию только одно первое встретившееся правило. Если есть правила, не являющееся ЗАВИСИМОСТЬЮ первого, то для его выполнения необходимо указать его имя в качестве аргумента make. Например ,если нам необходимо удалить ненужные файлы, и в makefile присутствует ЦЕЛЬ clean, то для ее выполнения необходимо ввести команду

Илон Маск рекомендует:  Что такое код bessel

Make clean

Main.o : main.c defs.h

Cc -c main.c

Cc -c kbd.c

Cc -c command.c

Cc -c display.c

Cc -c insert.c

Cc -c search.c

Cc -c files.c

Utils.o : utils.c defs.h

Cc -c utils.c

clean :

rm edit main.o kbd.o command.o display.o \

Main.o : main.c defs.h

Cc -c main.c

то make временно приостанавливает выполнение предыдущего и переходит к выполнению этого правила. main.o зависит от main.c defs.h (т.е для полученияобъектого файла main.o необходимо откомпилировать файл исходных текстов main.c в который включен заголовочный файл defs.h ). Далее make опять просматривает ЗАВИСИМОСТИ на предмет их совпадения с акой либо целью другого правила. Т.к в нашем примере совпадения нет, то сравниваются времена последней модификации файлов main.o и main.c defs.h .Если время последней модификации хотябы одного из файлов main.o и main.c более позднее, чем main.o , то make выполняет КОМАНДЫ cc -c main.c (т.е осуществляет компиляцию изменивщегося файла ЗАВИСИМОСТИ) и переходит к следующей ЗАВИСИМОСТИ предыдущей цели. При этом время последней модификации файла main.o изменится ( это время будет необходимо в предыдущей цели). Если эти времена совпадают, то КОМАНДЫ не выполняются , а происходит возврат к предыдущей цели. По приведенной аналогии make просматривает все ЗАВИСИМОСТИ цели edit. После этого сравниваютя времена последней модификации файлов ЦЕЛИ edit и ЗАВИСИМОСТЕЙ main.o kbd.o command.o display.o insert.o search.o files.o utils.o . Если время последней модификации хотябы одного из файлов ЗАВИСИМОСТИ будет более поздним чем у ЦЕЛИ , то make ваполнит КОМАНДЫ cc -o edit main.o kbd.o command.o display.o insert.o search.o files.o utils.o для получения нового исполнимого файла редактора.

Заметим, т.к цель clean не является ЗАВИСИМОСТЬЮ ни в первой ни в подчиненных целях, то это правило простым введением команды ‘make’ никогда не выполнится. Для его выолнения необходимо, как было сказано выше ввести команду ‘make clean’. Т.к. ЦЕЛЬ clean не имеет ЗАВИСИМОСТЕЙ, то выполнится только она, и никакие другие правила выполнены не будут.

Основы компиляции программ в ОС Linux.

Компилятор превращает код программы на «человеческом» языке в объектный код понятный компьютеру. Компиляторов под Linux существует много, практически для каждого распространенного языка. Большинство самых востребованных компиляторов входит в набор GNU Compiler Collection, известных под названием GCC.

Изначально аббревиатура GCC имела смысл GNU C Compiler, но в апреле 1999 года сообщество GNU решило взять на себя более сложную миссию и начать создание компиляторов для новых языков с новыми методами оптимизации, поддержкой новых платформ, улучшенных runtime-библиотек и других изменений. Поэтому сегодня коллекция содержит в себе компиляторы для языков C, C++, Objective C, Chill, Fortran, Ada и Java, как библиотеки для этих языков (libstdc++, libgcj, . ).

Компиляция программ производится командой:

После этого, если процесс компиляции пройдет успешно, то вы получите загружаемый файл a.out, запустить который можно командой:

Для примера давайте напишем маленькую простейшую программку:

Любой компилятор по умолчанию снабжает объектный файл отладочной информацией. Компилятор gcc также снабжает файл такой информацией и на результат вы можете посмотреть сами. При компиляции проекта из предыдущего шага у нас появился файл a.out размером 11817 байт (возможно у вас он может быть другого размера).

Вся эта отладочная информация предназначается для отладки программы отладчиком GNU Debugger. Запустить его вы можете командой:

При этом запустится отладчик и наша скомпилированная программа. Об отладке мы с вами поговорим отдельно и более подробно.

Компилятор gcc может создавать отладочную информацию в различных объемах и форматах, контролировать которые можно специальными ключами. Посмотреть их подробное описание можно командой man gcc:

Debugging Options -a -dletters -fpretend-float -g -glevel -gcoff -gxcoff -gxcoff+ -gdwarf -gdwarf+ -gstabs -gstabs+ -ggdb -p -pg -save-temps -print-file-name=library -print-libgcc-file-name -print-prog-name=program

Ключ -g создает отладочню информацию в родном для операционной системы виде, он выбирает между несколькими форматами: stabs, COFF, XCOFF или DWARF. На многих системах данный ключ позволяет использовать специальную информацию, которую умеет использовать только отладчик gdb. Другие ключи позволяют более тонко контролировать процесс встраивания отладочной информации.

Ключ -ggdb включает в исполняемый файл отладочную информацию в родном для ОС виде и дополняет ее специализированной информацией для отладчика gdb.

Ключ -gstabs создает отладочную информацию в формате stabs без дополнительных расширений gdb. Данный формат используется отладчиком DBX на большинстве BSD систем. Ключ -gstabs+ дополняет отладочную информацию расширенниями понятными отладчику gdb.

Ключ -gcoff создает отладочную информацию в формате COFF, которая используется отладчиком SDB на большинстве систем System V до версии System V R4.

Ключ -gxcoff снабжает файл информацией в формате XCOFF, который используется отладчиком DBX на системах IBM RS/6000. Использование -gxcoff+ влкючает использование дополнительной информации для gdb.

Ключ -gdwarf добавляет инфомацию в формате DWARF приняотм в системе System V Release 4. Соответственно ключ -gdwarf+ прибавляет возможностей отладчику gdb.

Добавление к этим ключам в конце цифры позволяет увеличить или уменьшить уровень отладки, т.е. управлять размером требуемой отладочной информации. Например ключ:

Увеличит уровень отладки до 3, по умолчанию он равен 2. При первом уровне отладки компилятор включает в файл минимальное количество отладочной информации достаточное для отладки частей программы, которые вы не планировли отлаживать. В эту информацию входит описание функций и внешних переменных, но не включается информация об локальных переменных и номерах строк исходного текста. Второй уровень — это уровень по умолчанию, включает в файл большинство нужной отладочной информации. Третий уровень позволяет добавить экстра-информацию, такую как определения присутствующих в программе макросов.

Отладочная информация может значительно увеличить объем вашего файла (в три-четыре раза). Для создания программ «релизов» существует отдельная программа, позволяющая удалить отладочную информацию из запускаемого файла. Называется эта программа strip. Для того, чтобы полностью очистить файл от отладочной информации, требуется вызвать ее с ключом -s:

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

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

· Если над программой работает много человек, то практически невозможно отследить сделанные изменения.

· Процесс правки и само ориентирование при большом исходном тексте становится сложным и поиск небольшой ошибки может повлечь за собой вынужденное «изучение» кода заново.

Это далеко не все пробемы, которые могут возникнуть при наличии программы «монстра». Поэтому при разработке программ рекомендуется их разбивать на куски, которые функционально ограничены и закончены. В этом значительно помогает сам язык C++, предоставляя свой богатый синтаксис.

Для того, чтобы вынести функцию или переменную в отдельный файл надо перед ней поставить зарезервированное слово extern. Давайте для примера создадим программу из нескольких файлов. Сначала создадим главную программу, в которой будут две внешние процедуры. Назовем этот файл main.c:

#include // описываем функцию f1() как внешнююextern int f1(); // описываем функцию f2() как внешнююextern int f2(); int main()

Теперь создаем два файла, каждый из которых будет содержать полное определение внешней функции из главной программы. Файлы назовем f1.c и f2.c:

// файл f1.cint f1() < return 2;>// файл f2.cint f2()

После этого процесс компиляции программы с помощью gcc будет выглядеть несколько иначе от описанного при компиляции одного файла. Компилировать можно все файлы одновременно одной командой, перечисляя составные файлы через пробел после ключа -c:

gcc -c main.c f1.c f2.c

Или каждый файл в отдельности:

gcc -c f1.cgcc -c f2.cgcc -c main.c

В результате работы компилятора мы получим три отдельных объектных файла:

Чтобы их собрать в один файл с помощью gcc надо использовать ключ -o, при этом линкер соберет все файлы в один:

gcc main.o f1.o f2.o -o rezult

В результате вызова полученной программы rezult командой:

На экране появится результат работы:

# ./rezultf1() = 2f2() = 10dron:

Теперь, если мы изменим какую-то из процедур, например f1():

То компилировать заново все файлы не придется, а понадобится лишь скомпилировать измененный файл и собрать результирующий файл из кусков:

# gcc main.o f1.o f2.o -o rezult2dron:

# ./rezult2f1() = 25f2() = 10dron:

Таким образом можно создавать большие проекты, которые больше не будут отнимать много времени на компиляцию и поиск ошибок. Однако помните, не стоит также чересчур разбивать программу, иначе у Вас получится несколько десятков файлов, в которых Вы сами рано или поздно запутаетесь. Найдите «золотую середину», например в отдельные файлы помещайте те функции или классы, с которыми Вам приходится больше всего работать при отладке. После того, как функция будет окончательно отлажена, ее вполне можно перенести в более крупный файл.

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

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

Объектные библиотеки по способу использования разделяются на два вида:

Статическая библиотека — это коллекция объектных файлов, которые присоединяются к программе во время линковки программы. Таким образом статические библиотеки используются только при создании программы. Потом в работе самой программы они не принимают участие, в отличие от динамических библиотек.

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

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

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

Для начала стоит сказать, что объектный файл создаваемый нашим проверенным способом вовсе не подходит для динамических библиотек. Связано это с тем, что все объектные файлы создаваемые обычным образом не имеют представления о том в какие адреса памяти будет загружена использующая их программа. Несколько различных программ могут использовать одну библиотеку, и каждая из них располагается в различном адресном пространстве. Поэтому требуется, чтобы переходы в функциях библиотеки (операции goto на ассемблере) использовали не абсолютную адресацию, а относительную. То есть генерируемый компилятором код должен быть независимым от адресов, такая технология получила название PIC — Position Independent Code. В компиляторе gcc данная возможность включается ключом -fPIC.

Теперь компилирование наших файлов будет иметь вид:

# gcc -fPIC -c f1.cdron:

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

# gcc -shared -o libfsdyn.so f1.o f2.o

В результате получим динамическую библиотеку libfsdyn.so: Теперь, чтобы компилировать результирующий файл с использованием динамической библиотеки нам надо собрать файл командой:

# gcc -с main.сdron:

# gcc main.o -L. -lfsdyn -o rezultdyn

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

Если Вы сейчас попробуете запустить файл rezultdyn, то получите ошибку:

# ./rezultdyn./rezultdyn: error in loading shared libraries: libfsdyn.so: cannot open shared object file: No such file or directorydron:

Это сообщение выдает загрузчик динамических библиотек (динамический линковщик — dynamic linker), который в нашем случае не может обнаружить библиотеку libfsdyn.so. Для настройки динамического линковщика существует ряд программ.

Первая программа называется ldd. Она выдает на экран список динамических библиотек используемых в программе и их местоположение. В качестве параметра ей сообщается название обследуемой программы. Давайте попробуем использовать ее для нашей программы rezultdyn:

# ldd rezultdyn libfsdyn.so => not found libc.so.6 => /lib/libc.so.6 (0x40016000) /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)dron:

Как видите все правильно. Программа использует три библиотеки:

· libc.so.6 — стандартную библиотеку функций языка C++.

· ld-linux.so.2 — библиотеку динамической линковки программ ELF формата.

· libfsdyn.so — нашу динамическую библиотеку функций.

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

Для того, чтобы добавить нашу директорию с библиотекой в список известных директорий надо подредактировать файл /etc/ld.so.conf. Например, пусть этот файл состоит из таких строк:

Во всех этих директории хранятся всеми используемые библиотеки. В этом списке нет лишь одной директории — /lib, которая сама по себе не нуждается в описании, так как она является главной. Получается, что наша библиотека станет «заметной», если поместить ее в один их этих каталогов, либо отдельно описать в отдельном каталоге. Давайте для теста опишем, добавим строку в конец файла ld.so.conf:

Для примера, этот файл находится в домашнем каталога пользователя root, у Вас он может быть в другом месте. Теперь после этого динамический линковщик будет знать где можно найти наш файл, но после изменения конфигурационного файла ld.so.conf необходимо, чтобы система перечитала настройки заново. Это делает программа ldconfig. Пробуем запустить нашу программу:

# ./rezultdynf1() = 25f2() = 10dron:

Как видите все заработало :) Если теперь Вы удалите добавленную нами строку и снова запустите ldconfig, то данные о расположении нашей библиотеки исчезнут и будет появляться таже самая ошибка.

Но описанный метод влияет на всю систему в целом и требует доступа администратора системы, т.е. root. А если Вы простой пользователь без сверх возможностей ?!

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


Если в ответ выводится пустая строка, то эт означает, что такой переменной среды нет. Устанавливается она следующим образом:

После этого программа rezultdyn будет прекрасно работать. В случае, если у Вас в системе эта переменная среды уже установлена, то, чтобы не испортить ее значение, надо новый каталог прибавить к старому значению. Делается это другой командой:

Если Вы обнулите эту переменную, то снова библиотека перестанет работать:

# ./rezultdyn./rezultdyn: error in loading shared libraries: libfsdyn.so: cannot open shared object file: No such file or directorydron:

Вы также параллельно можете зайти в систему под другим пользователем или даже тем же самым, но если Вы захотите просмотреть значение LD_LIBRARY_PATH, то увидите ее прежнее значение. Это означает, что два разных пользователя Linux не могут влиять на работу друг друга, а это и есть самое главное хорошее отличие систем Unix от большинства других систем.

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

Опора деревянной одностоечной и способы укрепление угловых опор: Опоры ВЛ — конструкции, предназначен­ные для поддерживания проводов на необходимой высоте над землей, водой.

Организация стока поверхностных вод: Наибольшее количество влаги на земном шаре испаряется с поверхности морей и океанов (88‰).

Системы программирования.

Системы программирования

Системой программирования будем называть комплекс программных средств, предназначенных для кодирования, тестирования и отладки программного обеспечения.

Другими словами, это набор специализированных программных продуктов, которые являются инструментальными средствами разработчика.

Система программирования, как правило, включает следующие программные компоненты:

· транслятор с соответствующего языка;

· компоновщик (редактор связей);

Заметим, что любая система программирования может работать только в соответствующей ОС, под которую она и создана, однако при этом она может позволять разрабатывать программное обеспечение и под другие ОС.

Илон Маск рекомендует:  Ошибки при работе с Ajax

Редактор текста — это программа для ввода и модификации текста.

Программа, подготовленная на каком-либо языке программирования, называется исходным модулем и представляет собой текстовый файл с соответствующим расширением.

Например, в системе программирования Borland Pascal редактор сохраняет тексты программ в файлах с расширением pas .

Трансляторы предназначены для преобразования программ, написанных на языках программирования, в программы на машинном языке.

В качестве входной информации трансляторы применяют исходные модули и формируют в результате своей работы объектные модули, являющиеся входной информацией для редактора связей.

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

Объектный модуль, как правило, имеет расширение obj .

Трансляторы делятся на два класса: компиляторы и интерпретаторы.

Компилятор переводит весь исходный модуль на машинный язык.

При компиляции одна и та же программа имеет несколько представлений — в виде текста и в виде выполняемого файла.

Интерпретатор последовательно переводит на машинный язык каждый оператор исходного модуля и сразу же выполняет его.

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

Соответственно говорят о компилируемых и интерпретируемых языках программирования.

Языки программирования Pascal , Object Pascal и С-подобные языки (С, С ++ , С#) являются компилируемыми.

Язык Java — ; пример интерпретируемого языка программирования.

Компоновщик, или редактор связей — системная обрабатывающая программа, редактирующая и объединяющая объектные (ранее оттраслированные) модули в единые загрузочные, готовые к выполнению программные модули.

Загрузочный модуль может быть помещен операционной системой в оперативную память и выполнен.

Загрузочный модуль, подготовленный системой программирования Borland Pascal , имеет расширение exe .

Отладчик — системная программа, которая позволяет управлять процессом исполнения пользовательской программы, является инструментом для поиска и исправления ошибок в программе.

Базовый набор функций отладчика включает:

· пошаговое выполнение программы (режим трассировки) с отображением результатов,

· остановка в заранее определенных точках,

· возможность остановки в некотором месте программы при выполнении некоторого условия;

· изображение и изменение значений переменных.

В системе программирования Borland Pascal отладчик запускается с помощью режима меню Debug .

Загрузчик — системная обрабатывающая программа.

Загрузчик помещает находящиеся в его входном наборе данных объектные и загрузочные модули в оперативную память, объединяет их в единую программу, корректирует перемещаемые адресные константы с учетом фактического адреса загрузки и передает управление в точку входа созданной программы.

В системе программирования Borland Pascal загрузчик начинает свою работу после выполнения команды Run . Эта команда объединяет функции редактора связей и загрузчика.

Примерами современных систем программирования являются системы программирования

Borland C++ Builder,

Microsoft Visual Basic,

Microsoft Visual C ++

и многие-многие другие.

Современными системами программирования являются система, построенная на базе языка С# и системы, ориентированные на концепцию . NET .

Основные сведения о компиляции

Основным модулем системы программирования всегда является компилятор .

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

Кроме основного компилятора, большинство систем программирования могут содержать в своем составе целый ряд других компиляторов. Так, большинство систем содержат компилятор с языка Assembler и компилятор с входного языка описания ресурсов. Но они редко непосредственно взаимодействуют с пользователем.

Основные термины и понятия.

Транслятор – это программа, которая переводит входную программу на исходном (входном) языке в эквивалентную ей выходную программу на результирующем (выходном) языке.

Близко по смыслу к этому понятию понятие компилятор.

Компилятор – это транслятор, который осуществляет перевод исходной программы в эквивалентную ей объектную программу на языке машинных команд или языке ассемблера.

Таким образом, компилятор отличается от транслятора тем, что его результирующая программа написана обязательно на языке машинных команд или языке ассемблера. Результирующая программа транслятора в общем случае может быть написана на любом языке (например, транслятор с языка Pascal на язык С).

Таким образом, компиляторы – это вид трансляторов.

Повторим еще раз принципиально отличное понятие «интерпретатор».

Интерпретатор – это программа, которая воспринимает входную программу на исходном языке и выполняет ее. (Интерпретатор не порождает результирующую программу и никакого результирующего кода.)

Основные блоки (фазы) компилятора, их функции

Исходная программа, написанная на некотором языке программирования, есть цепочка знаков. Компилятор в конечном итоге превращает эту цепочку знаков в цепочку битов – объектный код.

В процессе компиляции обычно выделяют следующие подпроцессы (блоки, этапы).

1. Лексический анализ.

2. Работа с таблицами.

3. Синтаксический анализ, или разбор.

4. Генерация кода, или трансляция в промежуточный код (например, языка ассемблер).

5. Оптимизация кода.

6. Генерация объектного кода.

Замечание. В конкретных компиляторах порядок может несколько отличаться, а некоторые блоки могут объединяться в один. В реальном компиляторе блоки не обязательно разделены.

Лексический анализ

Входом является цепочка символов некоторого алфавита.

Некоторые комбинации символов в программе рассматриваются как единые объекты – лексемы (например, зарезервированные слова, идентификаторы, числовые константы).

Работа лексического анализатора состоит в том, чтобы сгруппировать определенные символы в единые синтаксические объекты – лексемы.

Выходом является последовательность лексем.

Например, в результате лексического анализа следующей цепочки символов

с ost:= (price + tax) * 0.98

будет обнаружено, что

cost , price , tax являются лексемами типа идентификатор;

0.98 — лексема типа константа;

Работа с таблицами

Информация о лексемах собирается и записывается в одну или несколько таблиц, например, в виде списка лексем и соответствующей информации о них.

Синтаксический анализ

Вход – цепочка лексем.

На этом этапе исследуется цепочка лексем и устанавливается, удовлетворяет ли она структурным условиям, явно сформулированным в определении синтаксиса языка.

Выходом анализатора является дерево, которое представляет синтаксическую структуру, присущую исходной программе.

Генерация кода

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

Замечание. На практике чаще одновременно строится и дерево, и код.

Существует несколько методов построения промежуточного кода по синтаксическому дереву. Основным из них является синтаксически управляемый перевод (трансляция).

На двух этапах – синтаксического анализа и в начале этапа подготовки к генерации кода – выполняется семантический анализ. Семантический анализатор проверяет семантические соглашения входного языка, проверяет элементарные семантические (смысловые) нормы языков программирования, напрямую не связанных с входным языком; дополняет внутреннее представление программы в компиляторе операторами и действиями, неявно предусмотренными семантикой входного языка.

Оптимизация кода

На этом этапе производится попытка сделать объектные программы более эффективными (т.е. быстрее работающими или более компактными).

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

Еще одним методом оптимизации кода является оптимизация вычисления логических выражений (не всегда полностью надо выполнять вычисление всего выражения, чтобы знать его результат, иногда по значению одного операнда можно определить значение всего выражения).

Оптимизация передачи параметров в процедуры и функции через стек не является эффективным, если выполняются несложные вычисления над небольшим количеством параметров (всякий раз при вызове процедуры компилятор создает объектный код для размещения фактических параметров в стеке, а при выходе – код для освобождения ячеек). Эффективность результирующей программы повышается при передаче параметров через регистры либо подстановкой кода функции в вызывающий объектный код.

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

Генерация объектного кода

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

В системе программирования Borland Pascal компиляция запускается с помощью режима меню Compile .

В случае отсутствия синтаксических ошибок (перевод осуществлен успешно) система программирования сообщает об этом пользователю и предлагает нажать любую клавишу для продолжения работы:

Compile successful. Press any key.

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

KNZSOFT Разработка ПО, консультации, учебные материалы

Князев Алексей Александрович. Независимый программист и консультант.

С++ для начинающих. Урок 1. Компиляция

    Содержание

Обзор компиляторов

Существует множество компиляторов с языка C++, которые можно использовать для создания исполняемого кода под разные платформы. Проекты компиляторов можно классифицировать по следующим критериям.

  1. Коммерческие и некоммерческие проекты
  2. Уровень поддержки современных тенденций и стандартов языка
  3. Эффективность результирующего кода

Если на использование коммерческих компиляторов нет особых причин, то имеет смысл использовать компилятор с языка C++ из GNU коллекции компиляторов (GNU Compiler Collection). Этот компилятор есть в любом дистрибутиве Linux, и, он, также, доступен для платформы Windows как часть проекта MinGW (Minumum GNU for Windows). Для работы с компилятором удобнее всего использовать какой-нибудь дистрибутив Linux, но если вы твердо решили учиться программировать под Windows, то удобнее всего будет установить некоммерческую версию среды разработки QtCreator вместе с QtSDK ориентированную на MinGW. Обычно, на сайте производителя Qt можно найти инсталлятор под Windows, который сразу включает в себя среду разработки QtCreator и QtSDK. Следует только быть внимательным и выбрать ту версию, которая ориентирована на MinGW. Мы, возможно, за исключением особо оговариваемых случаев, будем использовать компилятор из дистрибутива Linux.

GNU коллекция компиляторов включает в себя несколько языков. Из них, группу языков Си составляет три компилятора.

  1. g++ — компилятор с языка C++.
  2. gcc — компилятор с языка C (GNU C Compiler).
  3. gcc -lobjc — Objective-C — это, фактически, язык C с некоторой макро-магией, которая доступна в объектной библиотеке objc. Ее следует поставить и указать через ключ компиляции -l.

Этапы компиляции

Процесс обработки текстовых файлов с кодом на языке C++, который упрощенно называют «компиляцией», на самом деле, состоит из четырех этапов.

  1. Препроцессинг — обработка текстовых файлов утилитой препроцессора, который производит замены текстов согласно правилам языка препроцессора C/C++. После препроцессора, тексты компилируемых файлов, обычно, значительно вырастают в размерах, но теперь в них содержится все, что потребуется компилятору для создания объектного файла.
  2. Ассемблирование — процесс превращения текста на языке C++ в текст на языке Ассемблера. Для компиляторов GNU используется синтаксис ассебмлера AT&T.
  3. Компилирование — процесс превращения текстов на языке Ассемблера в объектные файлы. Это файлы состоящие из кодов целевого процессора, но в которых еще не проставлены адреса объектов, которые находятся в других объектных файлах или библиотеках.
  4. Линковка — процесс объединения объектных файлов проекта и используемых библиотек в единую целевую сущность для целевой платформы. Это может быть исполняемая программа или библиотека статического или динамического типа.

Рассмотрим подробнее упомянутые выше стадии обработки текстовых файлов на языке C++.

Препроцессинг

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

Основными элементами языка препроцессора являются директивы и макросимволы. Директивы вводятся с помощью символа «решетка» (#) в начале строки. Все, что следует за символом решетки и до конца строки считается директивой препроцессора. Директива препроцессора define вводит специальные макросимволы, которые могут быть использованы в следующих выражениях языка препроцессора.

На входе препроцессора мы имеем исходный файл с текстом на языке C++ включающим в себя элементы языка препроцессора.

На выходе препроцессора получаются так называемые компиляционные листы, состоящие исключительно из выражений языка C++, которых должно быть достаточно для создания объектных файлов на следующих этапах обработки. Последнее означает, что на момент использования каких-либо символов языка из других файлов, объявления этих символов должны присутствовать в компиляционном листе выше. Именно такие подстановки и призван осуществлять препроцессор. Часто, на вход препроцессора поступает файл размером в несколько десятков строк, а на выходе получается компиляционный лист из десятков тысяч строк.

Ассемблирование

Процесс ассемблирования с одной стороны достаточно прост для понимания и с другой стороны является наиболее сложным в реализации. По своей сути это процесс трансляции выражений одного языка в другой. Более конкретно, в данном случае, мы имеем на входе утилиты ассемблера файл с текстом на языке C++ (компиляционный лист), а на выходе мы получаем файл с текстом на языке Ассемблера. Язык Ассемблера это низкоуровневый язык который практически напрямую отображается на коды инструкций процессора целевой системы. Отличие только в том, что вместо числовых кодов инструкций используется англоязычная мнемоника и кроме непосредственно кодов инструкций присутствуют еще директивы описания сегментов и низкоуровневых данных, описываемых в терминологии байтов.

Ассемблирование не является обязательным процессом обработки файлов на языке C++. В данном случае, мы наблюдаем лишь общий подход в архитектуре проекта коллекции компиляторов GNU. Чтобы максимально объеденить разные языки в одну коллекцию, для каждого из языков реализуется свой транслятор на язык ассемблера и, при необходимости, препроцессор, а компилятор с языка ассемблера и линковщик делаются общими для всех языков коллекции.

Компиляция

В данном случае, мы имеем компилятор с языка ассемблера. Результатом его работы является объектный файл полученный на основе всего того текста, что был предоставлен в компиляционном листе. Поэтому можно говорить, что каждый объектный файл проекта соответствует одному компиляционному листу проекта.

Объектный файл — это бинарный файл, фактически состоящий из набора функций. Однако в исходном компиляционном листе не все вызываемые функции имели реализацию (или определение — definition). Не путайте с объявлением (declaration). Чтобы компиляционный лист можно было скомпилировать, необходимо, чтобы объявления всех вызываемых функций присутствовали в компиляционном листе до момента их использования. Однако, объявление, это не более чем имя функции и параметры ее вызова, которые позволяют во время компиляции правильно сформировать стек (передать переменные для вызова функции) и отметить, что тут надо вызвать функцию с указанным именем, адрес реализации которой пока не известен. Таким образом, объектные файлы сплошь состоят из таких «дыр» в которые надо прописать адреса из функций, которые реализованы в других объектных файлах или даже во внешних библиотеках.

Вообще, разница между объявлением (declaration) и определением (definition) состоит в том, что объявление (declaration) говорит об имени сущности и описывает ее внешний вид — например, тип объекта или параметры функции, в то время как определение (definition) описывает внутреннее устройство сущности: класс памяти и начальное значение объекта, тело функции и пр.

Исходя из этих определений, в компиляционном листе перед компиляцией должны существовать все объявления (declaration) всех тех сущностей, что используются в этом компиляционном листе. Причем их объявления должны находится до момента использования этих сущностей. Иначе, компилятор не сможет подготовить обращение к соответствующей сущности. Например, не сможет оформить передачу параметров через стек вызова функции и подготовиться к приему возвращаемого функцией значения.

Линковка

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

Средства сборки проекта

Традиционно, программа на языке C++ собирается средствами утилиты make исполняющей сценарий из файла Makefile. Сценарий сборки можно писать самостоятельно,
а можно создавать его автоматически с помощью всевозможных средств организации проекта. Среди наиболее известных средств организации проекта можно указать следующие.

  1. GNU Toolchain — Старейшая система сборки проектов известная еще по сочетанию команд configure-make-«make install».
  2. CMake — Кроссплатформенная система сборки, которая позволяет не только создать кроссплатформенный проект но и создать сценарий компиляции под любые известные среды разработки, для которых написаны соответствующие генераторы сценариев.
  3. QMake — Достаточно простая система сборки, специально реализованная для фреймворка Qt и широко используемая именно для сборки Qt-проектов. Может быть использована и просто для сборки проектов на языке C++. Имеет некоторые проблемы с выявлением сложных зависимостей метакомпиляции, специфической для Qt, поэтому, даже в проектах Qt, рекомендуется использование системы сборки CMake.

Современные версии QtCreator могут работать с проектами, которые используют как систему сборки QMake, так и систему сборки CMake.

Простой пример компиляции

Рассмотрим простейший проект «Hello world» на языке C++. Для его компиляции мы будет использовать консоль, в которой будем писать прямые команды компиляции. Это позволит нам максимально прочувствовать описанные выше этапы компиляции. Создадим файл с именем main.cpp и поместим в него следующий текст программы.

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

В первой строке кода записана директива включения файла с именем iostream в текст проекта. Как уже говорилось, все строки, которые начинаются со знака решетки (#) интерпретируются в языках C/C++ как директивы препроцессора. В данном случае, препроцессор, обнаружив директиву включения файла в текст программы, директиву include, выполнит включение всех строк указанного в директиве файла в то место программы, где стоит инструкция include. В результате этого у нас получится большой компиляционный лист, в котором будут присутствовать множество символов объявленных (declaration) в указанном файле. Включаемые файлы, содержащие объявления (declaration) называют заголовочными файлами. На языке жаргона можно услышать термины «header-файлы» или «хидеры».

Чтобы увидеть результат препроцессинга можно воспользоваться опцией -E компилятора g++. По умолчанию, в этом случае, результат препроцессинга будет выведен в стандартный поток вывода. Чтобы можно было удобно рассмотреть его, следует перенаправить стандартный поток вывода в какой-нибудь текстовый файл. В представленном ниже примере это будет файл main.E.

Илон Маск рекомендует:  Что такое код ncurses_resetty

В третьей строке программы описана функция main(). В контексте операционной системы, каждое приложение должно иметь точку входа. Такой точкой входа в операционных системах *nix является функция main(). Именно с нее начинается исполнение приложения после его загрузки в память вычислительной системы. Так как операционная система Windows имеет корни тесно переплетенные с историей *nix, и, фактически, является далеким проприентарным клоном *nix, то и для нее справедливо данное правило. Поэтому, если вы пишете приложение, то начинается оно всегда с функции main().

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

В пятой строке мы обращаемся к предопределенному объекту cout из пространства имен std, который связан с потоком вывода приложения. Используя синтаксис операций, определенных для указанного объекта, мы передаем в него строку «Hello world» и символ возврата каретки и переноса строки.

В седьмой строке мы возвращаем код 0, как код возврата функции main(). В организации процессов в операционной системы, это число будет восприниматься как код возврата приложения.

Следующим шагом проведения эксперимента выполним останов компиляции файла main.cpp после этапа ассемблирования. Для этого воспользуемся ключом -S для компилятора g++. Здесь и далее, знак доллара ($) обозначает стандартное приглашение к вводу команды в консоли *nix. Писать знак доллара не требуется.

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

Для остановки компиляции после, собственно, компиляции следует воспользоваться ключом -c для компилятора g++.

Наконец, если нас не интересуют эксперименты с остановками компиляции на разных этапах и если мы просто хотим получить из нашего файла на языке C++ исполняемую программу, то следует выполнить следующую команду.

В результате исполнения этой команды появится файл a.out который и представляет собой результат компиляции — исполняемый файл программы. Запустим его и посмотрим на результат выполнения. При работе в операционной системе Windows, результатом компиляции будет файл с расширением exe. Возможно, он будет называться main.exe.

Добавить комментарий Отменить ответ

Для отправки комментария вам необходимо авторизоваться.

Основы Just In Time компиляции, используемой в динамических языках, на примере программы на C

Я был сильно вдохновлен, когда узнал о динамической компиляции (JIT — Just In Time) из различных виртуальных машин Ruby и JavaScript. Я мог бы рассказать вам все о том, как работает «компиляция на лету» и как она может дать прирост в производительности для вашего интерпретируемого языка. Это было бы здорово. Но проблема в том, что я никогда не мог понять и, тем более, предположить, как работает JIT-компиляция.

Как вообще возможно компилировать код во время его выполнения? Я спросил Бенджамина Петерсона о том, где он так много узнал о технологии JIT. В ответ он меня направил к проекту pypy (это исходники Python JIT). Но изучение проекта заняло бы довольно много времени, а я всего лишь хотел простой пример для понимания работы технологии.

К счастью, у меня есть отличная работа, где я могу встретиться лицом к лицу с теми людьми, которые занимаются производством JIT-компиляторов. Часть прошедшей недели я провел на конференции GDC (Game Developers Conference), где увидел демку игры, разработанную на движке Unreal Engine 3 и запущенную в браузере. Ребята сделали большую работу, создавая эту демку, и я обязательно напишу о ней более подробно чуть позже. Однако Люк Вагнер (Luke Wagner) — JavaScript-программист из Mozilla — оптимизировал asm.js, добавив OdinMonkeys в SpiderMonkeys.

Люк очень дружелюбный человек. Сначала я слушал его разговоры с Дейвом Херманом и Алоном Закаи, но потом задал ему интересующий меня вопрос. Люк очень доступно все мне объяснил. Скомпилировать простой объектный файл, использовать objdump для получения специфичной для конкретной платформы сборки, использовать системный вызов mmap для выделения памяти, которую вы можете прочитать И выполнить, скопировать инструкции в этот буфер, привести его к типу указателя на функцию и, в конце концов, вызвать его.

21 ноября в 19:00, Москва, беcплатно

Итак, я написал простейшую функцию перемножения двух целых чисел. Первое, что я делаю, это создаю простой .c файл, затем компилирую его с флагами -c и -o для получения объектного файла.

Кстати, я работаю на 64-битной OS X. Таким образом, моя сборка может отличаться от вашей. Очевидно, что JIT-компиляция абстрагируется от платформозависимости, но, как бы то ни было, все инструкции в этой статье работают как на x86, так и на x64. Дальше нужно будет воспользоваться утилитами по работе с бинарными файлами . У меня ее не было, поэтому я установил эту утилиту при помощи команды brew install binutils .

Если у вас уже есть необходимые утилиты (в том числе [g]objdump), переходим к следующему шагу: чтение машинного кода из объектного файла, представленный в шестнадцатеричном формате. При запуске gobjdump -j .text -d mul.o -M intel вы должны получить приблизительно такое (приблизительно, потому что у нас могут быть разные платформы):

Итак, эти инструкции различаются по размеру. Я не знаю, как это будет выглядеть на платформе x86, поэтому не могу подробно комментировать эти строки. Однако очевидно, что это пары шестнадцатеричных цифр. 16 2 == 2 8 означает, что каждая пара шестнадцатеричных цифр может быть представлена одним байтом (тип char). Таким образом, мы можем записать все эти числа в массив unsigned char [].

Справочник man подробно описывает все забавные флаги функции mmap(). Примечательно, что такой способ выделения памяти может делать ее исполняемой. Таким свойством не обладает выделение памяти при помощи функции alloc(). Наверняка разработчики JavaScript каким-то образом пользуются такой возможностью.

После того, как данные скопированы, приведем память к типу указателя на функцию. А затем вызываем нашу функцию. Вот как все это будет выглядеть:

Вуаля! Получилось очень аккуратно, а главное — оно работает! Помощь Люка Вагнера, час работы и эта статья в частности — вот то, что понадобилось для реализации технологии JIT.

Опять же, это всего лишь простой пример, причем супер непортативный. Более того, те операции, которые мы выполняем над памятью, они небезопасные. Но самое главное — теперь я знаю основы JIT-компиляции. И вы тоже!

Как происходит компиляция. Часть 1.

В этой статье я подробно объясню ход процесса компиляции исходного текста в исполняемую программу. Я не буду заострять внимание на таких моментах, как окружение Make, или Revision Control, хотя это было обязательно на тех университетских занятиях. Здесь будет лишь разобрано, что происходит после отдачи команды gcc test.c.

Вообще говоря, процесс компиляции можно разбить на 4 этапа: обработка препроцессором, компиляция, ассемблирование и связывание (линковка). Обсудим подробнее каждый этап.

Перед тем как обсуждать компиляцию программы, нужно иметь собственно программу. Наша программа должна быть простой, но не настолько, чтобы лишить нас удовольствия обсудить все интересующие нас детали компиляции. К примеру, вот такая программа:
#include

#define STRING «This is a test»
#define COUNT (5)

Процесс компиляции

Вопрос из лички перетащу на форум, т.к. другим, возможно, тоже будет интересно

1. Препроцессор ничего в «исполнительный» файл не вставляет. Препроцессор делает только текстовую подстановку и всё. Т.е. из 10 текстовых файлов делает один. И больше ничего
2. В любом случае я может неправильно понимаю, что означает «исполнительный»
3. Если под «линком» подразумевается линковка при помощи линкера (в русских книгах обычно это называют «связывание» и «редактор связей»), то препроцессор к этому отношения не имеет. Весь код функций находится в библиотеках. В языках Си и Си++ любая библиотека предоставляется в виде файла с бинарным кодом и набором инклюдов. Автор библиотеки должен гарантировать, что инклюды соответствуют бинарному файлу. Т.е. когда ты вызываешь printf, то в файле stdio.h есть только описание прототипа и больше ничего. Сам код функции printf находится в библиотеке в уже скомпилированном виде, а эта библиотека поставляется в комплекте вместе с компилятором. Компилятор по умолчанию линкуется с библиотекой, пользователю дополнительных действий делать не надо.
4. Что такое «ссылки» не понял

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

18.06.2012, 10:32

Открыть процесс процесс на полный доступ, и запретить для других
Всем доброго времени суток. Друзья, HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE.

Процесс А инициализирует массив случайными значениями и записывает их в файл, а затем запускает процесс Б
В универ нужно сделать лабу по выше указанной теме. Мне не нужно чтобы за меня делали — нужен.

Процесс компиляции Java
Здравствуйте форумчане . Помогите разобраться в сборке Hello World’a. .

18.06.2012, 12:21 2 19.06.2012, 13:24 [ТС] 3

Решение

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

Рассмотрим на простеньком примере

Конкретные действия буду объяснять на примере компилятора gcc. Просто потому, что с ним я умею работать из консоли. Наверняка все эти действия можно выполнять и из-под IDE, но я с ними не работаю, а потому не знаю, как это делается

*** UPDATE ***
Пока писал, понял, что пример выбрал неудачно и методику изложения следует немного поменять. Но для этого нужно в очередной раз найти время и уже в законченном виде с нормальными пояснениями выложить в блог, где можно спокойно редактировать и исправлять

1 этап. Препроцессирование

На данном этапе работа идёт только с текстовыми файлами. Здесь препроцессор объединит наш исходник и все include-файлы в один большой текстовый файл. Для нашего случая это будет что-то типа:

Во время работы препроцессора идёт работа со всякими внешними файлами (include’ами) и путями (каталоги, в которых компилятор ищет include-файлы)

Результат работы препроцессора можно посмотреть так:

Итоговый препроцессированный текст будет в файле t.i

2 этап. Трансляция

Полученный после препроцессирования единый текстовый файл скармливается транслятору. В процессе работы транслятора уже нет никакой работы со внешними файлами, путями поиска и т.п. На вход транслятору подаётся один файл с исходником, на выходе транслятора получается один файл, содержащий ассемблерный текст. А сам транслятор занимается преобразованием исходника на языке программирования в ассемблерный текст, содержащий код целевой машины на языке ассемблера.

В нашем случае на выходе транслятора мы получим ассемблерный текст. Я привожу тот текст, который получен в результате работы компилятора gcc. Некоторые интересные места я отметил стрелочками и пронумеровал. О них пойдёт речь ниже.

Ассемблерный текст является не просто образом будущего кода, но ещё и образом будущего объектного файла, в котором будут символьные имена меток, которые в свою очередь будут использоваться при линковке.

В нашем случае мы видим, что в коде имеются две метки. Метка «.LC0» (стрелка 1), описывающая набор символов от строкового литерала и метка «main» (стрелка 3), описывающая начало функции main. У каждой метки есть так называемая область видимости: локальная или глобальная. Локальные метки видны только внутри данного модуля, глобальные метки видны из других модулей. Метка «.LC0» является локальной, т.к. строковой литерал — это внутренние данные нашего модуля. Метка main является глобальной, т.к. эта функция должна быть видна извне (в исходнике у main’а нет модификатора static), а потому этот факт подсвечивается специальной директивой (стрелка 2).

Помимо вхождения меток мы видим ещё и обращения к меткам: обращение к строковому литералу «.LC0» (стрелка 4) и обращение к внешней метке «printf» (стрелка 5).

Результат работы препроцессора можно посмотреть так:

Итоговый ассемблерный текст будет в файле t.s

3 этап. Ассемблирование

Полученный ассемблерный текст далее передаётся программе-ассемблеру, которая преобразует его в объектный файл. Объектный файл представляет собой бинарные коды целевой машины плюс дополнительная информация о метках и их использовании. Информация, содержащаяся в объектном файле принципиально ничем не отличается от информации, содержащейся в ассемблерном тексте. Только весь код вместо мнемоник, понятных человеку, содержит двоичный код, понятный машине. А вместо меток, расставленных по ассемблерному тексту, объектный файл содержит специальную таблицу символов (symbol table), описывающую все метки из нашего ассемблерного текста и таблицу перемещений (relocations table), описывающую точки, где метки использовались. Эти таблицы спроектированы таким образом, чтобы с ними было удобно работать линкеру и дизассемблеру.

Конкретно в нашем случае эти таблицы будут выглядеть примерно таким образом. В объектном файле определена локальная метка «.LC0», глобальная метка «main» и внешняя метка «printf», к которой в данном файле есть обращения (но определения метки нет). В объектном файле есть использование метки «.LC0» и использования метки «printf»

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

Объектный файл можно получить так:

В итоге создастся объектный файл с именем t.o. Просто так в него заглянуть уже не получится, т.к. это бинарный файл, но при помощи воспомогательных утилит можно выудить любую информацию.

Таблица символов (меток) — symbol table:

Здесь удалил целую портянку служебных фиктивных символов, о которых на данном этапе можно и не вспоминать. Обратите внимание, что среди таблицы символов отсутствует метка «.LC0». Для процесса линковки метка как таковая не нужна (ибо она локальная внутри модуля), а все обращения к метке ассемблер заменил на смещения внутри объектного файла (см. далее). Это некая оптимизация. При желании можно попросить ассемблер эту метку сохранить (но это надо почитать документацию)

Таблица перемещений (использований) — relocation table:

Место, помеченное стрелкой — это есть обращение к метке «.LC0», которое ассемблер заменил на обращение к секции данных с заданным смещением (правда для данного примера смещение оказалось нулевым)

4 этап. Линковка

Полученный объектный файл (а их может быть несколько) отдаётся линкеру. Линкер склеивает между собой все поданные ему файлы и формирует один большой исполняемый файл. Помимо объектных файлов компилятор подаёт в линкер ещё и библиотеки. Какие-то библиотеки компилятор подаёт невидимым для пользователя образом (т.е. пользователь непосредственно в этом процессе не участвует). Какие-то библиотеки пользователь сам просит компилятор передать линкеру. В первую группу, как правило, относятся библиотеки, отвечающие за run-time поддержку языка программирования и библиотеки, входящие в состав стандарта языка программирования или входящие в состав стандартной библиотечной поддержки на данной операционной системе. Библиотека, содержащая реализацию функции printf относится именно к этой группе. Ко второй группе относятся все пользовательские библиотеки (графические библиотеки, библиотеки для работы с криптографией и прочее)

В контексте данной статьи к библиотекам нужно относиться следующим образом. Где-то кто-то написал реализации всех стандартных функций, в том числе и printf. Далее все эти реализации откомпилированы до объектного файла. Дальше каким-то образом склеили эти объектные файлы в единый файл (или в небольшое количество раздельных файлов) и назвали эти файлы словом «библиотека». Т.е. библиотека — это набор уже откомпилированных кодов. Далее эту библиотеку и include-файлы к ним включили в состав компилятора или в состав операционной системы

Помимо склеивания файлов линкер ещё и занимается настройкой адресов. Поскольку весь набор кодов, требуемых для формирования программы-бинарника, уже имеется на руках у линкера, то линкер после склеивания уже однозначно может сказать, по какому адресу будет располагаться та или иная функция или переменная. Для каждого файла, поступившего на ликновку, линкер заглянет в таблицу перемещений (использований), из которой поймёт, в какое место кода какой адрес нужно прописать. Конкретно в нашем случае в объектном файле у нас две перемещения: для бывшей метки «.LC0» (которая превратилась в обращение к секции с данными) и для метки printf. В итоге в функцию main в те места, которые засвечены в таблице перемещений, будут воткнуты итоговые адреса в исполняемом файле, соответствующие местоположению метки «.LC0» и функции «printf»

В общем, пояснение было несколько сумбурным, а потому лучше будет, если ты задашь конкретные вопросы по непонятным местам, чтобы было ясно, каким образом в дальнейшем аккуратно это дело переписать

Язык Си в примерах/Компиляция программ

Программа на языке Си — один или несколько текстовых файлов, которые также называются исходными.

Исполнить исходные файлы нельзя, их необходимо скомпилировать, т.е. создать исполняемый файл, содержащий в себе инструкции процессора и пригодный для запуска на компьютере.

Процесс преобразования исходных файлов в исполняемый называется компиляцией. Если ваша программа состоит из одного исходного файла hello.c , то для его компиляции компилятором GNU С достаточно выполнить команду:

Если не получается или будете создавать папку для проекта, то разместите её поближе к корневой пользователя /home/username/folder/hello.c и запустите команду:

В результате получится файл hello , имя которого мы указали в опции -o . Этот файл является исполняемым и его можно запускать (execute) при помощи команды:

Пара символов ./ перед hello означает «искать исполняемый файл hello в текущей директории».

соответствует команде: «скомпилировать файлы xxx.c yyy.c в программу zzz; заголовочные файлы находятся в директориях ./common и ..; подключить библиотеку libm»

Библиотека libm (подключаемая с помощью опции -lm ) содержит откомпилированные математические функции, которые объявляются в заголовочном файле math.h . Если вы используете функции из этой библиотеки (такие как log , sin , cos , exp ), то не забывайте подключать её при компиляции.

Подробную информацию об опциях компилятора gcc можно получить, если набрать

Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL