Лабораторная работа 1.

Редакторы и компиляторы языков программирования С и С++

На различных платформах.

Цель работы: отработать умения и навыки работы с базовыми операциями компиляции и компоновки программ написанных на языках программирования С или С++:

Теория:

Редакторы текста программы.

Редактор – это программа, используемая для создания и модификации исходных текстов. В Unix системам доступно множество редакторов, но, очевидно, наиболее популярными и многофункциональными среди них являются KWrite, GNU Emacs, Kate, KEdit.

KWrite – не просто текстовый редактор для среды KDE с открытым исходным кодом. Это очень удобный редактор для программистов, и он может считаться, по крайней мере, частичной заменой более мощным приложениям. Его лучше всего использовать вместе с Konqueror для просмотра файлов с исходными кодами на разных языках. KWrite хорошо выполняет и обычные функции редактора текстов. Одна из его основных особенностей – подсветка синтаксиса, которая настраивается для разных языков программирования: C/C++, Java, Python, Perl, Bash, Modula 2, HTML и Ada. Работа с KWrite очень проста. Если вы хотя бы раз пользовались текстовым редактором, у вас не должно возникнуть проблем.

Для создания нового проекта в домашней директории создайте папку, например, Test. Для этого вызовите контекстное меню правой кнопкой мыши, далее «Создать – Папку» и укажите имя папки. Для создания файла в контекстном меню мыши выберите «Создать – Текстовый файл», и введите имя файла, например, main.cpp. По умолчанию, по клику левой кнопки мыши на этом файле, он открыться должен именно в KWrite. Если это не так, в контекстном меню мыши выберите опцию «Открыть с помощью ...». В появившемся окне в списке «Известные приложения» откройте древообразный список «Редакторы», а в нем KWrite. Отметьте флажок «Запомнить связь с приложением для этого файла».

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

Открытие исходного файла C/C++

Чтобы запустить редактор Emacs, наберите emacs в окне терминала и нажмите <Enter>. Появится окно редактора, в верхней части которого имеется строка меню. Перейдите в меню Files, выберите команду Open Files и наберите имя требуемого файла в строке "мини-буфера" в нижней части экрана. При создании исходного файла на языке C используйте расширения .c или .h. В случае C++ придерживайтесь расширений .cpp, .hpp, .C или .H. Когда файл будет открыт, введите нужный текст и сохраните результат, выбрав команду Save Buffer в меню Files. Чтобы выйти из редактора, воспользуйтесь командой Exit Emacs в меню Files.

Те, кто испытывают раздражение от необходимости постоянно щелкать мышью, могут воспользоваться клавиатурными сокращениями, ускоряющими открытие и сохранение файлов, а также выход из редактора. Операции открытия файла соответствует сокращение C-x C-f. (Запись C-x означает нажатие клавиши <Control> с последующим нажатием клавиши <x>.) Чтобы сохранить файл, введите C-x C-s, а чтобы выйти из Emacs - C-x C-c. Лучше узнать о возможностях редактора можно с помощью встроенного учебника, доступного через команду Emacs Tutorial в меню Help. В нем приведено множество советов, которые помогут пользователям научиться эффективнее работать с Emacs.

Автоматическое форматирование

Программисты, привыкшие работать в интегрированной среде разработки, оценят имеющиеся в Emacs средства автоматического форматирования кода. При открытии исходного файла, написанного на C/C++, редактор самостоятельно определяет наличие в нем программного кода, а не просто текста. Если нажать клавишу <Tab> в пустой строке, редактор переместит курсор в нужную позицию, определяемую положением предыдущей строки. Особенностью редактора является возможность программировать практически любые операции, связанные с автоматическим форматированием. Благодаря этому были реализованы режимы редактирования множества видов документов, разработаны игры и даже СУБД (Введите команду M-x dunnet, если хотите поиграть в старомодную игру).

Синтаксические выделения

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

Чтобы включить режим цветовых выделений, откройте файл ~/.emacs и вставьте в него такую строку:

(global-font-lock-mode t)

Сохраните файл, выйдите из Emacs и перезапустите редактор. Теперь можете открыть нужный исходный файл и наслаждаться!

Вы обратили внимание на то, что строка, вставленная в файл .emacs, выглядит написанной на языке LISP. Это и есть LISP! Большая часть редактора Emacs реализована именно на этом языке. На нем же можно писать расширения к редактору.

Компиляторы GCC

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

Компиляторы, доступные в Unix-системах, являются частью коллекции GNU-компиляторов, известной как GCC (GNU Compiler Collection). В нее входят компиляторы языков C, C++, Java, Objective-C, Fortran и Chill.

В типичной, основанной на UNIX, системе команда компиляции и компоновки программы на C++ обозначается как СС. Чтобы скомпилировать и скомпоновать программу по имени welcom.c, наберите по приглашению UNIX

%СС welcom.c

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

Предположим, имеется проект, в который входят два исходных файла: один написан на C (main.c; листинг 1), а другой – на C++ (reciprocal.cpp; листинг 2).

Листинг 1. (main.c) Исходный файл на языке C

#include <stdio.h>

#include "reciprocal.hpp"

int main(int argc, char **argv)

{

int i;

i = atoi(argv[1]);

printf("The reciprocal of %d is %g\n", i, reciprocal (i));

return 0;

}

Листинг 2. (reciprocal.cpp) исходный файл на языке С++

#include <cassert>

#include "reciprocal.hpp"

double reciprocal(int i) {

// Аргумент не должен быть равен нулю

assert(i != 0);

return 1.0/i;

}

Есть также файл заголовков, который называется reciprocal.hpp (листинг 3).

Листинг 3. (reciprocal.hpp) Файл заголовков

#ifdef __cplusplus

extern "C" {

#endif

extern double reciprocal(int i);

#ifdef __cplusplus

}

#endif

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

Компиляция одного исходного файла

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

%gcc -c main.c.

Полученный объектный файл будет назван main.o.

Компилятором языка C++ является g++. Он работает почти так же, как и gcc. Следующая команда предназначена для компиляции файла reciprocal.cpp:

%g++ -c reciprocal.cpp.

Опция -c говорит компилятору о необходимости получить на выходе объектный файл (он будет называться reciprocal.o). Без нее компилятор g++ попытается скомпоновать программу и создать исполняемый файл a.out.

В процессе написания любой более-менее крупной программы обычно задействуется ряд дополнительных опций. К примеру, опция -I сообщает компилятору о том, где искать файлы заголовков. По умолчанию компиляторы GCC просматривают текущий каталог, а также каталоги, где установлены файлы стандартных библиотек. Предположим, наш проект состоит из двух каталогов: src и include. Следующая команда дает компилятору g++ указание дополнительно искать файл reciprocal.hpp в каталоге ../include:

%g++ -c -I ../include reciprocal.cpp

Компоновка объектных файлов

После того как файлы main.c и reciprocal.cpp скомпилированы, необходимо их скомпоновать. Программы написанные на С/С++ обычно содержат ссылки на функции, определенные где-либо вне самой программы, например, в стандартных библиотеках или в личных библиотеках групп программистов, работающих над данным проектом. Объектный код, созданный компилятором, обычно содержит «дыры» из-за этих отсутствующих частей. Компоновщик связывает объектный код с кодами отсутствующих функций, чтобы создать исполняемый загрузочный модуль (без пропущенных частей).

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

%g++ -o reciprocal main.o reciprocal.o

Опция -o задает имя файла, создаваемого в процессе компоновки.

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

Запуск программы reciprocal осуществляют следующим образом:

%./reciprocal 7

The reciprocal of 7 is 0.142857

Как видите, компилятор g++ автоматически подключил к проекту стандартную библиотеку языка C, содержащую реализацию функции printf().

Автоматизация процесса с помощью GNU-утилиты make

Те, кто программируют в Windows, привыкли работать в той или иной интегрированной среде разработки. Программист добавляет в нее исходные файлы, а среда автоматически создает проект. Аналогичные среды доступны и в Unix системах, но с ними мы будем работать позже. GNU-утилита make позволяет автоматически перекомпилировать программу.

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

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

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

Чтобы передать всю эту информацию утилите make, необходимо создать файл Makefile (touch Makefile). Его содержимое будет таким:

reciprocal: main.o reciprocal.o

g++ $(CFLAGS) -o reciprocal main.o reciprocal.o

main.o: main.с reciprocal.hpp

gcc $(CFLAGS) -c main.c

reciprocal.o: reciprocal.cpp reciprocal.hpp

g++ $(CFLAGS) -c reciprocal.cpp

clean:

rm -f *.o reciprocal

Целевые модули перечислены слева. За именем модуля следует двоеточие и существующие зависимости. В следующей строке указано правило, по которому создается модуль (назначение записи $(CFLAGS) мы пока проигнорируем). Строка правила должна начинаться с символа табуляции, иначе утилита make проинтерпретирует ее неправильно.

Если удалить созданные нами выше объектные файлы и ввести

%make

будет получен следующий результат:

%make

gcc -c main.c

g++ -c reciprocal.cpp

g++ -o reciprocal main.o reciprocal.o

Утилита make автоматически создала объектные файлы и скомпоновала их. Попробуйте теперь внести какое-нибудь простейшее изменение в файл main.с и снова запустить утилиту. Вот что произойдет:

%make

gcc -c main.c

g++ -o reciprocal main.o reciprocal.o

Как видите, утилита make повторно создала файл main.o и перекомпоновала программу, но не стала перекомпилировать файл reciprocal. cpp, так как в этом не было необходимости.

Запись $(CFLAGS) обозначает переменную утилиты make. Ее можно определить либо в файле Makefile, либо в командной строке. Утилита подставит на место переменной реальное значение во время выполнения правила. Вот как, например, можно осуществить перекомпиляцию с включенной оптимизацией:

%make clean

rm -f *.o reciprocal

%make CFLAGS=-02

gcc -02 -c main.c

g++ -02 -c reciprocal.cpp

g++ -02 -o reciprocal main.o reciprocal.o

Обратите внимание на то, что вместо записи $(CFLAGS) в правилах появился флаг -02.

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

%info make

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

GNU-отладчик gdb

Отладчик – это программа, с помощью которой можно узнать, почему написанная вами программа ведет себя не так, как было задумано. Работать с отладчиком приходится очень часто. Большинство Unix-программистов имеет дело с GNU-отладчиком (GNU Debugger, GDB), который позволяет пошагово выполнять программу, создавать точки останова и проверять значения локальных переменных.

Компиляция с включением отладочной информации

Чтобы можно было воспользоваться GNU-отладчиком, необходимо скомпилировать программу с включением в нее отладочной информации. Этой цели служит опция -g компилятора. Если имеется описанный выше файл Makefile, достаточно задать переменную CFLAGS равной -g при запуске утилиты make:

%make CFLAGS=-g

gсс -g -c main.c

g++ -g -c reciprocal.cpp

g++ -g -o reciprocal main.o reciprocal.o

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

Запуск отладчика

Отладчик gdb запускается следующим образом:

%gdb reciprocal

После запуска появится строка приглашения такого вида:

(gdb)

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

(gdb) run

Starting program: reciprocal

Program received signal SIGSEGV, Segmentation fault.

__strtol_internal (nptr=0x0, endptr=0x0, base=10, group=0)

at strtol.c:287

287 strtol.c: No such file or directory.

(gdb)

Проблема заключается в том, что в функции main() не предусмотрены средства контроля ошибок. Программа ожидает наличия аргумента, а в данном случае его нет. Получение сигнала SIGSEGV означает крах программы. Отладчик определяет, что причина краха находится в функции __strtol_internal(). Эта функция является частью стандартной библиотеки, но ее исходный файл отсутствует. Вот почему появляется сообщение "No such file or directory". С помощью команды where можно просмотреть содержимое стека:

(gdb) where

#0 __strtol_internal (nptr=0x0, endptr=0x0, base=10, group=0)

at strtol.c:287

#1 0x40096fb6 in atoi (nptr=0x0) at ../stdlib/stdlib.h:251

#2 0x804863e in main (argc=l, argv=0xbffff5e4) at main.c:8

Как нетрудно заметить, функция main() вызвала функцию atoi(), передав ей нулевой указатель, что и стало причиной ошибки.

С помощью команды up можно подняться по стеку на два уровня, дойдя до функции main():

(gdb) up 2

#2 0х804863е in main (argc=l, argv=0xbffff5e4) at main.c:8

8 i = atoi (argv[l]);

Заметьте, что отладчик нашел исходный файл main.с и отобразил строку, где располагается ошибочный вызов функции. Узнать значение нужной локальной переменной позволяет команда print:

(gdb) print argv[l]

$2 = 0x0

Это подтверждает нашу догадку о том, что причина ошибки - передача функции atoi() указателя NULL.

Установка контрольной точки осуществляется посредством команды break:

(gdb) break main

Breakpoint 1 at 0x804862e: file main.c, line 8.

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

(gdb) run 7

Starting program: reciprocal 7

Breakpoint 1, main (argc=2, argv=0xbffff5e4) at main.c:8

8 i = atoi (argv[l]);

Как видите, отладчик остановился на контрольной точке. Перейти на следующую строку можно с помощью команды next:

(gdb) next

9 printf ("The reciprocal of %d is %g\n", i,

reciprocal(i));

Если требуется узнать, что происходит внутри функции reciprocal(), воспользуйтесь командой step:

(gdb) step

reciprocal (i=7) at reciprocal.cpp:6

6 assert (i != 0);

Иногда удобнее запускать отладчик gdb непосредственно из редактора Emacs, а не из командной строки. Для этого следует ввести в редакторе команду M-x gdb. Когда отладчик останавливается в контрольной точке, редактор Emacs автоматически открывает соответствующий исходный файл. Не правда ли, проще разобраться в происходящем, глядя на весь файл, а не на одну его строку?

Работа с qmake

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

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

Полноценный инструментарий для программирования (контейнеры, протоколы ввода-вывода, протоколы сети, XML, 2D и 3D графика, связка с OpenGL) в среде Unix/Linux предоставляет Qt designer.

Предыдущие версии Qt содержали утилиту tmake, которая позволяла довольно просто создавать make-файлы. Она изначально была реализована на языке Perl, и это накладывало на нее дополнительные ограничения - для использования необходимо было наличие интерпретатора языка Perl на компьютере, что, в свою очередь, снижало способность переносимости данной утилиты. По этой причине и была создана новая утилита qmake, которая вошла в поставку Qt начиная с версии 3.0. Примечательно, что новая утилита так же хорошо переносима, как и сам Qt. Утилита qmake полностью освобождает программиста от использования tmake, перенимая все ее возможности. Благодаря этому старые конфигурационные файлы для tmake могут интерпретироваться ей без проблем. Таким образом, тем, кто уже успел привыкнуть к tmake, вовсе не обязательно изучать новый синтаксис.

Программа qmake интерпретирует файлы проектов, которые имеют расширение .pro и содержат различные параметры. Этот файл создается командой

%qmake -project

Создать из .pro файла make-файл совсем не трудно, для этого нужно просто дать команду

%qmake -o Makefile file.pro

В qmake существует возможность создания файлов с расширением dsp (Developer Studio Project), которые могут быть загружены в Visual Studio. Это можно сделать при помощи команды:

%qmake -o file.dsp -t vcapp file.pro

Опция -t является так называемой шаблонной опцией и заставляет qmake использовать параметр vcapp, невзирая на то, что написано в самом файле проекта. Шаблоны нужны для определения типа проекта. Например, при создании make-файла для приложения нужно задать в файле проекта опцию template = app, а при создании библиотеки template должен быть равен lib. Значения vcapp и vclib имеют смысл только для работы в OC Windows.

Допускается передавать опции в командной строке qmake:

%qmake -o Makefile "TEMPLATE=vcapp" file.pro

Табл. 2 содержит некоторые опции файла проекта. Полный список опций можно получить в официальной документации Qt, поставляемой вместе с самой библиотекой.

Опция	Назначение
HEADERS	Передается список созданных заголовочных файлов
SOURCES	Передается список созданных файлов реализации (с расширением срр)
FORMS	Передается список файлов с расширением .ui. Эти файлы создаются программой QtDesigner и содержат описание интерфейса пользователя в формате XML.
LEXISOURCES	Lex - это программа для синтаксического анализа. Используется для написания компиляторов.
YACCSOURCES	Yacc (Yet another Compiler Compiler) - утилита создания компиляторов
TARGET	Передается имя приложения. Если данное поле не заполнено, то название программы будет соответствовать имени проектного файла
CONFIG	Задает опции, которые должен использовать компилятор
DESTDIR	Задает путь, куда будет помещен готовый исполняемый модуль
DEFINES	Здесь можно передать опции для компилятора. Например, это может быть опция помещения отладочной информации для debuger в исполняемый модуль
INCLUDEPATH	Путь к каталогу,где содержатся заголовочные файлы. Этой опцией можно воспользоваться в случае, если уже есть готовые заголовочные файлы и вы хотите использовать их в текущем проекте
DEPENDPATH	В данном разделе указываются зависимости, необходимые для компиляции
DEF_FILE	Файл определения модуля, указывает, является ли файл DLL библиотекой или EXE файлом. Используется только для OC Windows.
RCFILE	Файл ресурсов в OC Windows. Содержит растровые изображения, меню, диалоговые окна и др. Используется только для OC Windows.
RESFILE	Откомпилированный файл ресурсов (присоединяется к исполняемому коду программы). Используется только для OC Windows.

Проектный файл Qt может выглядеть следующим образом:

TEMPLATE = арр

HEADERS += filel.h \

file2.h

SOURCES += main.cpp \

filel.cpp \

file2.cpp

TARGET = file

CONFIG += qt warn_on release

В первой строке задается тип программы, в данном случае это приложение (template = app). Во второй строке, в опции headers, перечисляются все заголовочные файлы, принадлежащие проекту. В опции sources перечисляются все файлы реализации проекта. Опция target определяет имя программы. config определяет опции, которые должен использовать компилятор в соответствии с подсоединяемыми библиотеками. Например, в нашем случае Qt указывает, что это Qt-приложение и используется библиотека Qt, warn_on означает, что компилятор должен выдавать как можно больше предупреждающих сообщений, release указывает, что приложение должно быть откомпилировано в окончательном варианте, без отладочной информации.

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

Далее создаем исполняемый файл

%make

Метаобъектный компилятор МОС

Метаобъектный компилятор (MOC - Meta Object Compiler). По сути дела, этот инструмент является не компилятором, а препроцессором, который исполняется в процессе компиляции приложения, создавая, в соответствии с определением класса, дополнительный код на C++. Это происходит из-за того, что определение сигналов и слотов в исходном коде программы недостаточно для компиляции. Сигнально-слотный код должен быть преобразован в код, понятный C++-компилятору. Код сохраняется в файле с прототипом moc_<filename>.cpp.

Созданные moc-файлы не стоит включать с помощью команды препроцессора #include "moc_proc.cpp" в конец основного файла. Лучше, если они будут отдельно откомпилированы и подсоединены компоновщиком к основной программе.

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

%mос -о moc_proc.cpp proc.h

После ее исполнения MOC создаст дополнительный файл moc_proc.cpp.

Для каждого класса, унаследованного от QObject, MOC предоставляет объект класса, унаследованного от QMetaObject. Объект этого класса содержит информацию о структуре объекта, например, сигнально-слотные соединения, имя класса, структуру наследования.

Эмулирование среды Unix в ОС Windows

В качестве эмулятора терминала среды Unix в ОС Windows можно использовать среды Cygwin или MinGW. В состав проекта Cygwin входит не только Х-сервер на платформе Windows, но и множество инструментов Unix, портированных на эту платформу. Пакет программ Cygwin можно свободно скачать из сети Интернет.

Правила работа в этой среде ни чем не отличаются описанных выше.

Проект MinGW – это набор средств разработки программ среды Unix, полностью интегрированных в Windows среду. В каталоге С:\MinGW\bin находятся все исполняемые файлы проекта (компиляторы gcc, g++, qmake, отладчик gdb и многое другое). Например, компиляция исходного файла main.c выглядит следующим образом:

Microsoft Windows XP [Версия 5.1.2600]

(С) Корпорация Майкрософт, 1985-2001.

C:\Documents and Settings>D:

D:\>cd First

D:\First>g++ -c main.cpp

In file included from C:/MinGW/bin/../lib/gcc/mingw32/3.4.2/../../../../include/

c++/3.4.2/backward/iostream.h:31,

from main.cpp:1:

C:/MinGW/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/backward/bac

kward_warning.h:32:2: warning: #warning This file includes at least one deprecat

ed or antiquated header. Please consider using one of the 32 headers found in se

ction 17.4.1.2 of the C++ standard. Examples include substituting the <X> header

for the <X.h> header for C++ includes, or <iostream> instead of the deprecated

header <iostream.h>. To disable this warning use -Wno-deprecated.

D:\First>g++ -o test main.o

D:\First>test

3

4

7

D:\First>

Задание.

1. Изучить организацию выполнения базовых операций, связанных с написанием программы на языке C или C++:

• Создать в домашнем каталоге папку ~/First;

• Создать в папке ~/First файлы main.c, first.cpp и first.hpp;

• В текстовом редакторе KWrite описать код созданных файлов;

• Сохраните отредактированные файлы.

• Откройте терминал.

• Перейдите в Вашу рабочую папку. Введите команду: %cd ~/First

• Произвести компиляцию исходного кода и компоновку объектных файлов, как описано в теории;

• Запустить программу;

• Удалить из каталога ~/First созданные компилятором и компоновщиком объектные файлы;

• Создать Makefile;

• Получить исполняемый файл с помощью утилиты make;

• Произвести перекомпиляцию с включенной оптимизацией;

• Произвести перекомпиляцию с включением отладочной информации;

• Получить исполняемый файл с помощью утилиты qmake;

2. В отчете показать запускаемые команды и результат их выполнения

Команды для работы в окне терминала:

сd .. -- перемещение на один каталог вверх по дереву каталогов

cd ~ -- перемещение в домашний каталог (~home)

cd /directory_name -- перемещение в каталог directory_name

cp -- копирование файла

cp old_file new_file

ls -- вывод содержимого текущего каталога

mkdir -- создание нового каталога

rm -- удаление указанных после команды файлов

touch -- обновление времени доступа к файлу. Если указанный файл не существует, он создается с нулевой длиной

Файл main.c и first.hpp для всех вариантов:

//main.c

#include <stdio.h>

#include <stdlib.h>

#include "first.hpp"

int main(int argc, char **argv)

{

double i;

i = atof(argv[1]);

printf("The result of %s is %g\n", argv[1],first(i));

return 0;

}

//first.hpp

#ifdef __cplusplus

extern "C" {

#endif

extern double first(double i);

#ifdef __cplusplus

}

#endif

	first.cpp		first.cpp
1.	#include <cassert> #include <math.h> #include "first.hpp" double first(double i) { assert(i >-1); assert(i <1); return asin(i); }	5.	#include <cassert> #include <math.h> #include "first.hpp" double first(double i) { assert(i >-1); assert(i <1); return acos(i); }
2.	#include <cassert> #include <math.h> #include "first.hpp" double first(double i) { assert(i >0); return sqrt(i); }	6.	#include <cassert> #include "first.hpp" double first(double i) { assert(i !=5); assert(i !=1); return (i-3)*(i+5)/(i-5)/(i-1); }
3.	#include <cassert> #include "first.hpp" double first(double i) { return 180*i/3.14; }	7.	#include <cassert> #include "first.hpp" double first(double i) { return 2*3.14*i; }
4.	#include <cassert> #include "first.hpp" double first(double i) { assert(i >3); return i; }	8.	#include <cassert> #include <math.h> #include "first.hpp" double first(double i) { assert(i >0); assert(i <3.14); return sqrt(sin(i)); }

Вопросы

1. Какие редакторы позволяют создать исходные тексты программ на языке C или C++?

2. Какова организация получения исполняемого файла на языке C и C++?

3. Какие расширения имеют файлы C и C++?

4. Для чего применяют подсвечивание синтаксиса и автоматическое форматирование в текстовых редакторах?

5. Объяснить назначение компилятора, компоновщика и загрузчика файлов.

6. Как задается уровень отладки программы?

7. Каков принцип автоматизации процесса получения исполнительного файла?

8. Какие команды запускают программу в отладчике, задают точку останова, переход на следующую строку, позволяют просмотреть содержимое стека, перемещаться по стеку?

9. Какая команда позволит найти интерактивную документацию по работе с qmake?

10. Какова организация получения исполняемого файла с помощью утилиты qmake?

11. Какая команда создает файл проекта Microsoft Visual Studio (.dsp) с помощью утилиты qmake?

12. Объясните алгоритм работы созданной вами программы.

Лабораторная работа 2