Как скомпилировать программу в linux
Скомпилируйте и запустите программу на C в Linux и Windows
Вступление
В этом документе мы увидим, как мы можем скомпилировать и выполнить программу на C в Linux и Windows. Документ также содержит список доступных компиляторов Си.
Содержание:
Установите, скомпилируйте и выполните программу на языке C с помощью Visual C ++ 2008 Express Edition с пакетом обновления 1 в Windows
Загрузить и установить
Для загрузки укажите в браузере http://www.microsoft.com/visualstudio/en-us/products/2008-editions/express и выберите «Язык» и нажмите «Скачать бесплатно». После завершения загрузки запустите исполняемый файл, он попросит вас выбрать, хотите ли вы установить некоторые другие дополнительные продукты, снимите флажки с этих параметров, чтобы можно было установить только необходимый продукт. Процесс установки начнет загружать другие файлы с сайта Microsoft, и, в зависимости от скорости вашего соединения, установка займет некоторое время.
После завершения установки в Windows 7 запустите командную строку Visual Studio 2008 в меню «Все программы»> «Microsoft Visual C ++ 2008 Express Edition»> «Инструменты Visual Studio»> «Командная строка Visual Studio 2008».
Напишите, скомпилируйте и выполните свою первую программу
Шаг 1: введите notepad demo.c (вы можете заменить имя файла своим собственным) и нажмите Enter, когда вас спросят, хотите ли вы создать новый файл, скажите «да».
Шаг 2: введите следующий код и нажмите Файл> Сохранить. Когда вас спросят, где сохранить файл, выберите подходящее место.
Шаг 3: Введите cl sample.c и нажмите ввод. Это скомпилирует программу для создания исполняемого файла (.exe).
Шаг 4: Теперь просто введите имя образца файла и введите. Это покажет вам результат.
Установить, скомпилировать и выполнить программу на C с Turbo C ++ в Windows
Получить и установить
Запустите Turbo C ++ на весь экран в Windows 7
Написать, скомпилировать и запустить C программу
Откройте новый файл из меню «Файл»> «Создать» в Turbo C ++ IDE. Напишите небольшую программу в IDE.
Нажмите на Опции и перейдите в Каталоги. Нажмите «Каталоги» и установите «Выходной каталог», как вам нужно, и «Исходный каталог», где вы сохранили файл программы «Си».
Теперь перейдите к компиляции и нажмите на Компиляция. А затем нажмите на Run. Вы увидите вывод вашей программы на Си.
Писать, компилировать и запускать программу на C, используя wxDev-C ++ в Windows
После загрузки установщика запустите exe-файл, дважды щелкнув по нему, и мастер установки поможет вам выполнить установку. После завершения установки вы запускаете ее из «Программы», и при первом запуске она занимает некоторое время для разбора заголовочных файлов. Окно IDe выглядит следующим образом:
Вы можете начать программирование, нажав Файл> Создать> Исходный файл в окне. Обратите внимание, что при сохранении файла вы должны выбрать тип файла как C, так как эта IDE также поддерживает C ++.
Вы можете использовать F9 или как показано ниже для компиляции и запуска программы.
Когда компиляция завершена, она открывает новое окно, чтобы показать вам вывод.
Если у вас есть ошибки, он показывает вас на панели ниже, как показано ниже.
Хотя мы немного устарели, мы находим wxDev-C ++ отличной IDE для программирования C. Вы можете попробовать его, если используете Windows.
Установить, скомпилировать и запустить C программу в Linux
Если компилятор C уже установлен, он покажет вам сообщение, как указано выше. Если нет, то будут установлены все необходимые пакеты.
Теперь откройте текстовый редактор и напишите небольшую программу на C, например, следующую и сохраните ее как demo.c:
Теперь выполните команду, как показано ниже, чтобы скомпилировать и выполнить файл:
Вот как вы можете установить GNU Gcc компилятор, написать программу на C и запустить ее под Linux.
Список компиляторов C
В следующей таблице приведен список доступных компиляторов Си. Это не полный список, но он даст вам четкое представление о различных компиляторах C, о том, какую ОС / платформу они поддерживают, и имеет ли она среду программирования.
Предыдущий: C учебник
Далее: C Basic
Как скомпилировать программу в linux
Чтобы сразу начать программировать, создадим еще один клон известной программы «Hello World». Что делает эта программа, вы знаете. Откройте свой любимый текстовый редактор и наберите в нем следующий текст:
Наш исходный код написан на языке программирования C. Языки программирования были придуманы для того, чтобы программист мог объяснить компьютеру, что делать. Но вот беда, компьютер не понимает ни одного языка программирования. У компьютера есть свой язык, который называют машинным кодом или исполняемым кодом (‘executable code’). Написать Hello World в машинном коде можно, но серьезные программы на нем не пишутся. Исполняемый код не только сложный по своей сути, но и очень неудобный для человека. Программа, которую можно написать за один день на языке программирования будет писаться целый год в машинном коде. Потом программист сойдет с ума. Чтобы этого не случилось, был придуман компилятор (‘compiler’), который переводит исходный код программы в исполняемый код. Процесс перевода исходного кода программы в исполняемый код называют компиляцией.
Осталось только запустить полученный бинарник. Для этого набираем в командной строке следующую команду:
Когда мы набираем в командной строке путь к бинарнику, мы, в реальности сообщаем оболочке, что надо выполнить программу. Оболочка «передает» бинарник ядру операционной системе, а ядро системы особым шаманским способом отдает программу на выполнение процессору. Затем, если программа не была запущена в фоновом режиме, то оболочка ждет от ядра сообщения о том, что программа выполнилась. Получив такое сообщение, оболочка выдает приглашение на ввод новой команды. Вы можете еще раз набрать ./hello и процедура повторится. В нашем случае программа выполняется очень быстро, и новое приглашение командной строки «вылетает» практически сразу.
Мы рассмотрели идеальный случай, когда программа написана без синтаксических ошибок. Попробуем намеренно испортить программу таким образом, чтобы она не отвечала канонам языка C. Для этого достаточно убрать точку с запятой в конце вызова функции printf(): Теперь, если попытаться откомпилировать программу, то компилятор выругается, указав нам на то, что он считает неправильным: В первой строке говорится, что в файле hello.c (у нас он единственный) в теле функции main() что-то произошло. Вторая строка сообщает, что именно произошло: седьмая строка файла hello.c вызвала ошибку (error). Далее идет расшифровка: синтаксическая ошибка перед закрывающейся фигурной скобкой.
Заглянув в файл hello.c мы с удивлением обнаружим, что нахулиганили мы не в седьмой, а в шестой строке. Дело в том, что компилятор обнаружил нелады только в седьмой строке, но написал ‘before’ (до), что означает «прокручивай назад».
Естественно, пока мы не исправим ошибку, ни о каком бинарнике не может идти и речи. Если мы удалим старый бинарник hello, доставшийся нам от прошлой компиляции, то увидим, что компиляция испорченного файла не даст никакого результата. Однако иногда компилятор может лишь «заподозрить» что-то неладное, потенциально опасное для нормального существования программы. Тогда вместо ‘error’ пишется ‘warning’ (предупреждение), и бинарник все-таки появляется на свет (если в другом месте нет явных ошибок). Не следует игнорировать предупреждения, за исключением тех случаев, когда вы на 100% знаете, что делаете.
2.2. Мультифайловое программирование
Как я уже говорил, если исходный код сколько-нибудь серьезной программы уместить в одном файле, то такой код станет просто нечитаемым. К тому же если программа компилируется достаточно долго (особенно это относится к языку C++), то после исправления одной ошибки, нужно перекомпилировать весь код.
Куда лучше разбросать исходный код по нескольким файлам (осмысленно, по какому-нибудь критерию), и компилировать каждый такой файл отдельно. Как вы вскоре узнаете, это очень даже просто.
Давайте сначала разберемся, как из исходного файла получается бинарник. Подобно тому как гусеница не сразу превращается в бабочку, так и исходный файл не сразу превращается в бинарник. После компиляции создается объектный код. Это исполняемый код с некоторыми «вкраплениями», из-за которых объектный код еще не способен к выполнению. Сразу в голову приходит стиральная машина: вы ее только что купили и она стоит у вас дома в коробке. В таком состоянии она стирать не будет, но вы все равно рады, потому что осталось только вытащить из коробки и подключить.
Итак, чтобы откомпилировать мультифайловую программу, надо сначала добыть объектный код из каждого исходного файла в отдельности. Каждый такой код будет представлять собой объектный модуль. Каждый объектный модуль записывается в отдельный объектный файл. Затем объектные модули надо скомпоновать в один бинарник.
В Linux в качестве линковщика используется программа ld, обладающая приличным арсеналом опций. К счастью gcc самостоятельно вызывает компоновщик с нужными опциями, избавляя нас от «ручной» линковки.
Попробуем теперь, вооружившись запасом знаний, написать мультифайловый Hello World. Создадим первый файл с именем main.c: Теперь создадим еще один файл hello.c со следующим содержимым:
Давайте разберемся, что же все-таки произошло. В этом нам поможет утилита nm. Я уже оговорился, что объектные файлы содержат таблицу символов. Утилита nm как раз позволяет посмотреть эту таблицу в читаемом виде. Те, кто пробовал программировать на ассемблере знают, что в исполняемом файле буквально все (функции, переменные) стоит на своей позиции: стоит только вставить или убрать из программы один байт, как программа тут же превратиться в груду мусора из-за смещенных позиций (адресов). У объектных файлов особая роль: они хранят в таблице символов имена некоторых позиций (глобально объявленных функций, например). В процессе линковки происходит стыковка имен и пересчет позиций, что позволяет нескольким объектным файлам объединиться в один бинарник. Если вызвать nm для файла hello.o, то увидим следующую картину: О смысловой нагрузке нулей и литер U,T мы будем говорить при изучении библиотек. Сейчас же важным является то, что в объектном файле сохранилась информация об использованных именах. Своя информация есть и в файле main.o: Таблицы символов объектных файлов содержат общее имя print_hello. В процессе линковки высчитываются и подставляются в нужные места адреса, соответствующие именам из таблицы. Вот и весь секрет.
2.3. Автоматическая сборка
В предыдущем разделе для создания бинарника из двух исходных файлов нам пришлось набрать три команды. Если бы программу пришлось отлаживать, то каждый раз надо было бы вводить одни и те же три команды. Казалось бы выход есть: написать сценарий оболочки. Но давайте подумаем, какие в этом случае могут быть недостатки. Во-первых, каждый раз сценарий будет компилировать все файлы проекта, даже если мы исправили только один из них. В нашем случае это не страшно. Но если речь идет о десятках файлов! Во-вторых, сценарий «намертво» привязан к конкретной оболочке. Программа тут же становится менее переносимой. И, наконец, простому скрипту не хватает функциональности (задание аргументов сборки и т. п.), а хороший скрипт (с многофункциональными прибамбасами) плохо модернизируется.
То, что выполняет утилита make, называется сборкой проекта, а сама утилита make относится к разряду сборщиков.
Любой Makefile состоит из трех элементов: комментарии, макроопределения и целевые связки (или просто связки). В свою очередь связки состоят тоже из трех элементов: цель, зависимости и правила.
Сценарии make используют однострочные комментарии, начинающиеся с литеры # (решетка). О том, что такое комментарии и зачем они нужны, объяснять не буду.
Макроопределения позволяют назначить имя практически любой строке, а затем подставлять это имя в любое место сценария, где должна использоваться данная строка. Макросы Makefile схожи с макроконстантами языка C.
Теперь рассмотрим пример. Попробуем составить сценарий сборки для рассмотренного в предыдущем разделе мультифайлового проекта Hello World. Создайте файл с именем Makefile: Обратите внимание, что в каждой строке перед вызовом gcc, а также в строке перед вызовом rm стоят табуляции. Как вы уже догадались, эти строки являются правилами. Формат Makefile требует, чтобы каждое правило начиналось с табуляции. Теперь рассмотрим все по порядку.
Makefile может начинаться как с заглавной так и со строчной буквы. Но рекомендуется все-таки начинать с заглавной, чтобы он не перемешивался с другими файлами проекта, а стоял «в списке первых».
Первая связка имеет цель hello. Цель отделяется от списка зависимостей двоеточием. Список зависимостей отделяется от правил символом новой строки. А каждое правило начинается на новой строке с символа табуляции. В нашем случае каждая связка содержит по одному правилу. В списке зависимостей перечисляются через пробел вещи, необходимые для выполнения правила. В первом случае, чтобы скомпоновать бинарник, нужно иметь два объектных файла, поэтому они оказываются в списке зависимостей. Изначально объектные файлы отсутствуют, поэтому требуется создать целевые связки для их получения. Итак, чтобы получить main.o, нужно откомпилировать main.c. Таким образом файл main.c появляется в списке зависимостей (он там единственный). Аналогичная ситуация с hello.o. Файлы main.c и hello.c изначально существуют (мы их сами создали), поэтому никаких связок для их создания не требуется.
Особую роль играет целевая связка clean с пустым списком зависимостей. Эта связка очищает проект от всех автоматически созданных файлов. В нашем случае удаляются файлы main.o, hello.o и hello. Очистка проекта бывает нужна в нескольких случаях: 1) для очистки готового проекта от всего лишнего; 2) для пересборки проекта (когда в проект добавляются новые файлы или когда изменяется сам Makefile; 3) в любых других случаях, когда требуется полная пересборка (напрмиер, для измерения времени полной сборки).
Теперь осталось запустить сценарий. Формат запуска утилиты make следующий: Опции make нам пока не нужны. Если вызвать make без указания целей, то будет выполнена первая попавшаяся связка (со всеми зависимостями) и сборка завершится. Нам это и требуется: В процессе сборки утилита make пишет все выполняемые правила. Проект собран, все работает.
Теперь давайте немного модернизируем наш проект. Добавим одну строку в файл hello.c: Теперь повторим сборку: Утилита make «пронюхала», что был изменен только hello.c, то есть компилировать нужно только его. Файл main.o остался без изменений. Теперь давайте очистим проект, оставив одни исходники: В данном случае мы указали цель непосредственно в командной строке. Так как целевая связка clean содержит пустой список зависимостей, то выполняется только одно правило. Не забывайте «чистить» проект каждый раз, когда изменяется список исходных файлов или когда изменяется сам Makefile.
2.4. Модель КИС
Итак, сервер предоставляет услуги. В нашем случае это могут быть функции, структуры, перечисления, константы, глобальные переменные и проч. В языке C++ это чаще всего классы или иерархии классов. Любой желающий (клиент) может воспользоваться предоставленными услугами, то есть вызвать функцию со своими фактическими параметрами, создать экземпляр структуры, воспользоваться константой и т. п. В C++, как правило, клиент использует класс как тип данных и использует его члены.
Unix как IDE: Компиляция
Под Unix существует множество компиляторов и интерпретаторов, но здесь мы будем обсуждать лишь gcc как средство компиляции C-кода, и коротко коснемся использования perl в качестве примера интерпретатора.
GCC — это набор компиляторов, обладающий очень почтенным возрастом и распространяемый под лицензией GPL. Он известен как инструмент работы с программами на C и C++. Свободная лицензия и повсеместная распространенность на Unix-подобных системах стали залогом его неизменной популярности, хотя есть и более современные альтернативы, использующие инфраструктуру LLVM, такие как Clang.
Основной исполняемый файл gcc лучше представлять не как компилятор в привычном понимании, а слой абстракции над множеством отдельных инструментов программирования, выполняющих парсинг кода, компиляцию, линковку и другие действия. Это значит, что с его помощью можно не просто получить работающий бинарник из кода на C, но детально исследовать все шаги этого сложного процесса, и при необходимости подстроить его под свои нужды.
Здесь я не буду обсуждать использование make-файлов, хотя они наверняка понадобятся для любого проекта сложнее, чем в один файл. Make-файлов я коснусь в следующей статье о средствах автоматизации сборки.
Компиляция и сборка объектного кода
Объектный код компилируется вот такой командой:
Если код верен, будет создан нелинкованный двоичный объектный файл под именем example.o в текущей папке, или выведены сообщения о проблемах. Заглянуть внутрь полученного файла и увидеть его содержимое на языке ассемблера можно так:
Как вариант, можно попросить gcc сразу показать итоговый ассемблерный код при помощи параметра -S:
Вывод ассемблерного кода может быть полезно совместить с выводом самого исходника, чего можно добиться, набрав:
Препроцессор
Препроцессор C (cpp) обычно используется для подключения заголовочных файлов и определения макросов. Это стандартная часть процесса компиляции gcc, но можно просмотреть генерируемый им код, вызвав cpp напрямую:
Исходный код будет выведен в конечном виде, готовым к компиляции, с замененными макросами и подстановкой включаемых внешних файлов.
Связывание объектов
Один или несколько объектных файлов могут быть связаны в соответствующий исполняемый файл:
Компиляция, сборка и связывание
Все вышеперечисленное может быть выполнено в один шаг при помощи команды:
Этот способ проще, но компиляция объектов по отдельности дает некоторый выигрыш в производительности: не нужно компилировать не изменявшийся код, но об этом мы поговорим в следующей статье.
Включение внешних файлов и связывание
Файлы C и заголовочные файлы могу быть явно включены в компиляцию при помощи параметра -l:
Аналогично, если код нужно динамически связать с уже скомпилированной системной библиотекой, доступной в одной из системных папок ( /lib или /usr/lib ), например, ncurses, этого можно добиться использованием ключа -l:
Если в процессе компиляции внешних связей много, имеет смысл внести их в переменные окружения:
Кстати, Makefile затем и создан, чтобы избавить нас от беспокойства о таких мелочах.
План компиляции
Чтобы посмотреть подробности внутренней кухни gcc, можно добавить ключ -v, и план компиляции будет выведен в стандартный поток вывода ошибок:
Если нет нужды генерировать объектные или исполняемые файлы, то для аккуратности можно использовать -###:
Очень полезно посмотреть, какие действия gcc предпринимает без нашего ведома, кроме того, так мы можем выявить нежелательные шаги при компиляции.
Расширенный вывод сообщений об ошибках
Существует возможность добавить ключи -Wall и/или -pedantic, чтобы gcc предупреждал нас о случаях, которые не обязательно являются ошибками, но могут ими быть:
Удобно включать такие опции в Makefile или в определении makeprg для Vim, так как они отлично сочетаются с окном quickfix, и помогают писать читабельный, совместимый и безошибочный код.
Профилирование процесса компиляции
Вы можете включить опцию -time, чтобы gcc отображал в тексте вывода время выполения каждого из шагов:
Оптимизация
Подобно любой команде Bash, все это можно вызывать прямо из Vim:
Интерпретаторы
Подход к интерпретируемому коду в Unix-системах иной. В своих примерах я буду использовать Perl, но те же принципы применимы для кода, например, на Python или Ruby.
Inline-код
Можно строку Perl-кода прямо на исполнение интерпретатору любым из перечисленных ниже способов Первый, наверное, самый простой и общеупотребительный способ работы с Perl; второй использует синтаксис heredoc, а третий — это классический конвейер Unix.
Конечно, в будничной жизни мы храним код в файле, который можно вызвать прямо вот так:
Можно проверить синтаксис кода без его выполнения с помощью ключа -c:
Порой хочется использовать скрипт подобно любому исполняемому бинарнику, не беспокоясь о том, что он из себя представляет. Для этого в скрипт добавляют первой строкой так называемый «shebang«, указывающий путь к интерпретатору, которому следует передать на исполнение данный файл.
Скрипту после этого можно ставить атрибут исполняемого файла вызовом chmod. Также хорошим тоном считается переименовать файл, убрав расширения, поскольку он теперь считается почти настоящим исполняемым файлом:
Затем файл можно вызывать напрямую, без указания интерпретатора:
Вся эта кухня так здорово работает, что многие стандартные утилиты Linux-систем, такие как adduser, в действительности являются скриптами на Perl или Python.
В следующей публикации я расскажу о методах работы с make для сборки проектов, сравнимых с привычными IDE.
Блог начинающего линуксоида.
советы, руководства, инструкции.
Страницы
четверг, 7 января 2016 г.
Сборка программы из исходного кода в Debian/Ubuntu
В сборке программы из исходного кода нет ничего сложного. Главное помнить одно правило: в пакетном дистрибутиве ни в коем случае нельзя использовать метод make install. Иначе в будущем получите большую такую кучу проблем. Когда поймёте, что хотели удалить программу (поставленную таким образом), а пакетный менеджер о ней не знает. А сама программа состоит из нескольких сотен файлов, разбросанных по разным каталогам. Страшно? Поэтому в пакетных дистрибутивах, программу нужно собирать в, собственно, пакет. Тогда её можно будет без проблем удалить, в случае чего. Я написал это потому что многие руководства по компиляции программ в Linux, которые мне попадались, описывают именно make install. Удалить программу, установленную таким образом можно только в двух случаях:
Отмечу, что не каждую программу можно собрать одним и тем же способом. Поэтому всегда нужно читать инструкцию по сборке, которая есть в архиве с исходным кодом. Бывает что разработчик положил туда скрипт, который при запуске делает всё сам (собирает и устанавливает, но мы помним про make install), или для сборки может не подойти make, а нужна другая система сборки. Также для сборки программы, необходимо будет установить нужные для неё сборочные зависимости (это пакеты с префиксом -dev). Для того чтобы быстро собрать программу в пакет, дабы иметь возможность без проблем её установить или удалить, существует утилита, под названием checkinstall. Она позволит создать родной для системы пакет (deb или rpm), что позволит использовать штатный пакетный менеджер для её установки/удаления
Для сборки программ в GNU/Linux используется (в основном) программа make, которая запускает инструкции из Makefile, но поскольку дистрибутивов GNU/Linux много, и они все разные, то для того чтобы собрать программу, нужно для каждого дистрибутива отдельно прописывать пути, где какие лежат библиотеки и заголовочные файлы. Программисты не могут изучать каждый дистрибутив и для каждого отдельно создавать Makefile. Поэтому придумали конфигураторы, которые «изучают» систему, и в соответствии с полученными знаниями создают Makefile. Для сборки нам нужны компиляторы: они прописаны в зависимостях пакета build-essential, так что достаточно установить его со всеми зависимостями. Ещё нужны autoconf и automake. Если программа написана на Qt, то обычно она собирается либо командой qmake (естественно она должна быть установлена), либо путём открытия файла проекта в какой-нибудь IDE (обычно Qt Creator) и сборки в ней.
Сперва нужно подготовить систему. Для этого установим необходимый набор инструментов:
sudo apt install build-essential gcc devscripts git fakeroot automake autoconf
Получить исходный код можно разными способами. Скачать из интернета (например с сайта разработчика), склонировать репозиторий с исходным кодом и так далее. В первом случае, в общем-то, всё ясно. Во втором: предположим, что программа лежит в git-репозитории (на GitHub, например). Мы можем как зайти в этот репозиторий и скачать оттуда архив с кодом
так и скопировать весь репозиторий себе (как это делают разработчики). Для примера возьмём программу mgba. Это эмулятор игровой консоли Nintendo GameBoy. Адрес репозитория здесь. Копируем его себе:
git clone https://github.com/mgba-emu/mgba.git
В домашнем каталоге у вас появится директория с его исходным кодом. На той же странице программы, есть инструкция по сборке.
Внимательно читаем. Открываем терминал и переходим в каталог с исходным кодом:
И собираем программу:
После выполнения, должен появиться файл configure. Чтобы посмотреть с какими параметрами можно собрать программу, введите:
Просмотрите все доступные параметры. Обычно, это могут быть поддержки различных плагинов, сборка с альтернативным интерфейсом, даже сборка под другую процессорную архитектуру. Допустим программа использует интерфейс, написанный на GTK+ 2, но имеет альтернативный на GTK+ 3. Тогда конфигурация программы будет выглядеть так:
После запуска configure и успешного конфигурирования кода, можно запустить сборку: