Введение в интегрированную среду разработки Eclipse CDT
реклама
МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ УКРАИНЫ
Севастопольский национальный технический университет
Введение в интегрированную среду разработки Eclipse CDT
Методические указания к лабораторным работам по дисциплине
«Основы программирования и алгоритмические языки»
для студентов дневной и заочной форм обучения
направления 050101 – «Компьютерные науки»
Севастополь
2011
2
УДК 004.42 (075.8)
Введение в интегрированную среду разработки Eclipse CDT: методические
указания к лабораторным работам по дисциплине «Основы программирования и
алгоритмические языки» для студ. дневной и заочной форм обучения направления
050101 ― «Компьютерные науки» / СевНТУ ; сост. В. Н. Бондарев. ― Севастополь : Изд-во СевНТУ, 2011. ― 59 с.
Цель указаний: оказать методическую помощь студентам дневной и заочной
форм обучения направления 050101 ― «Компьютерные науки» при выполнении
лабораторных работ по дисциплине «Основы программирования и алгоритмические языки» в интегрированной среде разработки Eclipse CDT (C/C++ Development Tooling ―CDT).
Методические указания составлены в соответствии с требованиями программы дисциплины «Основы программирования и алгоритмические языки» для студентов дневной и заочной форм обучения направления 6.050101 ― «Компьютерные науки» и утверждены на заседании кафедры Информационных систем (протокол № 5 от 10 января 2011 г.)
Допущено учебно-методическим центром СевНТУ в качестве методических
указаний.
Рецензент:
Кожаев Е.А., канд. техн. наук, доцент кафедры кибернетики и вычислительной техники.
3
СОДЕРЖАНИЕ
Введение…………………………………………………………………………...
1. Платформа разработки приложений Eclipse………………………………….
1.1. Проект Eclipse……………………………………………………………..
1.2. Архитектура платформы Eclipse …………………………..…………….
2. Установка компиляторов и среды Eclipse …….……………………………..
2.1. Установка компиляторов С/С++…………………………………………
2.2. Установка исполняющей среды Java ……………...................................
2.3. Установка Eclipse IDE for C/C++ Developers……………………………
3. Практическая работа в среде Eclipse СDT……………………………………
3.1. Интерфейс пользователя Eclipse………………………………………...
3.2. Элементы проекции C/С++………………………………………………
3.3. Простейший проект………………………………………………………
3.4. Отладка программы………………………………………………………
3.5. Настройки проекта……………………………………………………….
3.6. Дополнительные возможности редактора C/C++………………………
4. Лабораторные работы …………………………………………………………
4.1. Лабораторная работа №1. Создание проекта и ввод исходного кода…
4.2. Лабораторная работа №2. Компоновка и выполнение программы……
4.3. Лабораторная работа №3. Простейшие приемы отладки программы…
Библиографический список………………………………………………………
Приложение А. Опции компилятора, устанавливаемые в Eclipse CDT
Приложение Б. Функции для взаимного преобразования ANSI и ASCII символов ..........................................................................................
Приложение В. Установка Cygwin и настройка Eclipse CDT…………………
4
5
5
7
10
10
13
14
15
15
17
19
23
31
35
38
38
42
46
50
51
54
56
4
ВВЕДЕНИЕ
Предлагаемые методические указания следует рассматривать как краткое
введение в Eclipse CDT — современную среду разработки приложений на языке
С/С++.
Платформа Eclipse широко применяется не только при разработке приложений (программ) на языках С и С++, но и на многих других языках. «Родным» для
платформы Eclipse является язык программирования Java, что обеспечивает возможность её работы под управлением самых различных операционных систем.
Сочетание промышленного качества, кросс-платформенность, возможность расширения различными дополнениями (например: разработки баз данных, вебсервисов и пр.), поддержка крупнейшими компаниями IT-индустрии (IBM, Oracle,
Nokia и др.), открытость кода и бесплатность (что немаловажно) делают платформу Eclipse стандартом для выполнения разработок во многих компаниях.
В этой связи весьма актуальна задача внедрения этой платформы в учебный
процесс подготовки бакалавров и магистров в области информационных технологий. Предлагаемые методические указания как раз и нацелены на решение этой
задачи. Дополнительное преимущество применения среды Eclipse CDT в учебном
процессе заключается в том, что она работает совместно со свободно распространяемым комплектом GCC компиляторов, которые используются при компиляции
любого программного обеспечения с открытым исходным кодом, включая Linux,
FreeBCD, GNOME, StarOffice, OpenOffice, Apache Web Server и любых приложений для них. Это дает возможность студентам освоить мощный инструмент,
обеспечивающий перенос программ на любую операционную среду и десятки аппаратных платформ.
Логически методические указания состоят из двух частей. Первая часть
представляет собой введение в среду Eclipse CDT, изложенное в последовательной (систематической) форме, и предназначена не только для студентов младших
курсов, которые изучают дисциплину ОПиАЯ в соответствии с учебным планом,
но и для студентов старших курсов, которые уже имеют опыт программирования и желают освоить новую среду самостоятельно с целью профессионального
совершенствования. Вторая часть указаний посвящена описанию лабораторных
работ, закрепляющих знания и вырабатывающих необходимые навыки практической работы в среде Eclipse CDT.
Каждая лабораторная работа выполняется в течение двух академических
часов. Предлагаемые лабораторные работы выполняются вместо лабораторной
работы N1 из методических указаний, посвященных изучению собственно языка
С с элементами С++[6]. Таким образом, изучение среды программирования отделяется от изучения самого языка, что методически обоснованно. Дальнейшее
практическое освоение программирования на языке С/С++ выполняется с использованием ранее подготовленных методических указаний [6,7] .
Студентам, которые только начинают осваивать программирование,
рекомендуется сначала ознакомиться с первым и вторым разделом данных указаний, а затем приступить к выполнению самих лабораторных работ, следуя
методическим рекомендациям, которые там изложены.
5
1. ПЛАТФОРМА РАЗРАБОТКИ ПРИЛОЖЕНИЙ ECLIPSE
1.1. Проект Eclipse
Eclipse ([i’klips] от англ. затмение) представляет собой основанную на языке Java интегрированную инструментальную платформу с открытым исходным
кодом (OpenSource), предназначенную для разработки кроссплатформенных приложений. По сути, платформа Eclipse ― это расширяемая среда разработки и набор сервисов для создания программного обеспечения (ПО) на основе встраиваемых компонентов (плагинов). Eclipse также включает в себя среду разработки
плагинов (PDE), что дает разработчикам инструментариев возможность предложить свои расширения к Eclipse.
Изначально проект разрабатывался в IBM как корпоративный стандарт интегрированной среды разработки (IDE) для различных платформ. Исходный код
стоимостью 40 миллионов долларов был полностью открыт компанией IBM и
сделан доступным в 2001г. Тогда же был образован совет управляющих Eclipse,
призванный обеспечить развитие проекта и создать вокруг него сообщество разработчиков. С 2004г. проект разрабатывается и поддерживается независимой некоммерческой организацией Eclipse Foundation (www.eclipse.org). Среди участников Eclipse Foundation следует назвать компании IBM, Nokia, Oracle, SAP,
OBEO, Ericsson, Intel, QNX, Sybase и др.
Хотя платформа Eclipse и написана на Java, её возможности не ограничиваются разработками на этом языке. Помимо Java, в Eclipse имеются расширения,
поддерживающие разработку ПО на языках C/C++, FORTRAN ,COBOL, PHP,
Perl, Python, Groovy, Erlang, Ruby и др. Множество расширений дополняет
Eclipse средствами для работы с базами данных, моделирования, разработки графических приложений, серверов приложений и др. В настоящее время имеется
более
1000
плагинов,
расширяющих
возможности
Eclipse
(http://marketplace.eclipse.org/). Eclipse поставляется для работы на следующих
платформах: Windows, Linux, Solaris, HP-UX, IBM-AIX, Mac OS X и др.
Распространяется Eclipse в рамках лицензии EPL ― Eclipse Public License
(Открытая лицензия Eclipse), одобренной организацией Open Software Initiative
(OSI). В соответствии с этой лицензией разработчики, создающие плагины к
Eclipse или использующие Eclipse как базу для разработки ПО, обязаны публиковать любой код Eclipse, который они используют либо модифицируют в рамках
лицензии EPL. Однако при этом они имеют право лицензировать свои собственные дополнения по своему усмотрению.
В силу бесплатности и промышленного качества Eclipse постепенно завоевывает позиции корпоративного стандарта для разработки самых различных приложений во многих организациях.
Последние версии Eclipse: Eclipse 3.3.2 (Europa), Eclipse 3.4 (Ganymede,
2008 г.), Eclipse 3.5 (Galileo, 2009г.), Eclipse 3.6 (Helios, 2010г.). В рамках проекта
Eclipse разрабатывается более 100 подпроектов. Версия Eclipse Helios, представленная в июне 2010 года, включает в себя 58 подпроектов, некоторые из которых
указаны в таблице 1.1.
6
Таблица 1.1 ― Подпроекты, входящие в Eclipse Helios
Название подпроекта
Назначение
Eclipse Platform
Equinox
Mylyn
Test and Performance Tools Platform
Project (TPTP)
Java Development Tools (JDT)
C/C++ Development Tooling (CDT)
PHP Development Tools (PDT)
Eclipse Modeling Framework (EMF)
Graphical Editor Framework (GEF)
Graphical Modeling Framework
(GMP GMF)
Data Tools Platform (DTP)
Web Tools Platform (WTP)
Mobile Tools for Java (MTJ)
Swordfish
Accessibility Tools Framework
(ACTF)
Business Intelligence and Reporting
Tools (BIRT)
Eclipse Packaging Project (EPP)
Java™ Workflow Tooling (JWT)
Java Emitter Templates (M2T JET)
Memory Analyzer
SCA Tools
SOA Tools
Target Management
Textual Modeling Framework
(Xtext)
Tools for mobile Linux (TmL)
Ядро среды Eclipse
Реализация ядра спецификации OSGi R4
Подсистема управления заданиями
Инструментарий для профилировки и тестирования
приложений
Инструментарий для разработки приложений на Java
Инструментарий разработки приложений на C/C++
Инструментарий для разработки приложений на
PHP
Моделирование и генерация кода для приложений,
использующих структурированную модель данных
Среда для разработки графических приложений
Инструментарий для разработки графических редакторов
Разработка систем, управляемых данными, в частности, данными в реляционных базах
Средства для разработки веб-приложений JEE
Поддержка разработки мобильных устройств на Java
Платформа для построения распределённых корпоративных информационных систем.
Разработка приложений для людей с ограниченными
физическими возможностями
Генерация отчетов (Web- и PDF-отчёты)
Создание, загрузка и инсталляция пакетов
Инструментарий для проектирования и анализа потоков и процессов
Генерация шаблонов текстовых структур
Поиск утечек памяти и уменьшение объемов занимаемой памяти
Инструментарий для сервисной компонентной архитектуры
Инструментарий для сервисно-ориетированной архитектуры
Конфигурация и управление удаленными системами
Инструментарий для разработки доменноспецифических языков, включая генерацию синтаксических анализаторов
Инструментарий для разработки и диагностики
приложений на мобильных телефонах и эмуляторах
Реализации подпроектов Еclipse сгруппированы в пакеты (рис.1.1) в соответствии с основными потребностями разработчиков и размещены по адресу:
www.eclipse.org/downloads/packages/
7
Eclipse IDE for Java Developers, (99 MB)
Eclipse IDE for Java EE Developers, (206 MB)
Eclipse Classic 3.6.1, (170 MB)
Eclipse IDE for C/C++ Developers, (88 MB)
Eclipse for PHP Developers, (141 MB)
Eclipse IDE for JavaScript Web Developers, (108 MB)
Eclipse Modeling Tools (includes Incubating components), (249 MB)
Pulsar for Mobile Developers, (122 MB)
Eclipse IDE for Java and Report Developers, (241 MB)
Eclipse for RCP and RAP Developers, (188 MB)
Eclipse SOA Platform for Java and SOA Developers , (188 MB)
Eclipse IDE for C/C++ Linux Developers
Рисунок 1.1 – Пакеты, распространяемые в рамках проекта Еclipse Helios
Выход следующей версии Eclipse 3.7 (Indigo) запланирован на июнь 2011г.
В настоящих методических указаниях рассматривается архитектура Eclipse,
общие принципы организации интерфейса пользователя и инструментарий разработки приложений на языке С/С++ (C/C++ Development Tooling (CDT)).
1.2. Архитектура платформы Eclipse
Платформа Eclipse обеспечивает реализацию следующих возможностей
[2,8]:
- поддержку конструирования разнообразных инструментов для разработки приложений;
- поддержку неограниченного числа поставщиков инструментариев,
включая независимых поставщиков ПО;
- поддержку инструментов манипулирования данными произвольных типов (т.е., HTML, Java, C, JSP, EJB, XML и GIF).
- обеспечение "бесшовной" интеграции инструментов разных поставщиков для работы c содержимым различных типов;
- поддержку сред разработки приложений как с графическим интерфейсом
пользователя (GUI), так и без него;
8
- поддержку широкого спектра операционных систем, включая Windows ,
Linux, Mac OC и др.;
- использование кроссплатформенного языка Java для написания инструментария.
Для интеграции необходимых пользователю инструментов в единую систему в Eclipse используется идея сборки платформы из модулей с унифицированными интерфейсами подключения (плагинов). Для этого в плагинах имеются специальные точки расширений (extension point). Благодаря этому платформа реализуется в виде слоев плагинов, в каждом из которых определяются расширения
для подключения плагинов нижних уровней, а также определяются свои точки
расширений для подключения плагинов верхних уровней. Такая модель позволяет
разработчикам плагинов легко добавлять новые инструменты к платформе.
В качестве примера на рис.1.2 изображены основные компоненты платформы Eclipse, распространяемой в виде пакета Eclipse Classic [8]. Платформа построена в виде набора расширяемых подсистем, а не как единое приложение. Каждая из подсистем реализуется с помощью одного или нескольких плагинов.
В пакет Eclipse Classic входят три подсистемы, разрабатываемые более или
менее независимо друг от друга ― собственно платформа (Eclipse Platform),
Java-инструменты (JDT ― Java development tools) и среда разработки плагинов
(PDE ― Plug-in development environment). Платформа предоставляет базовые сервисы, JDT позволяет разрабатывать приложения Java, а PDE ― новые компоненты Eclipse. Указанные подсистемы являются надстройкой над средой выполнения платформы (Platform runtime).
Платформа является ядром Eclipse. Возможности, которые обеспечивает
платформа, позволяют определять основные объекты, с которыми будет работать
пользователь, создавать пользовательские интерфейсы, поддерживать коллективную (командную) работу с сохранением версий разрабатываемого ПО, поддерживать работу с отладчиками, получать справочную информацию. Соответствующими компонентами платформы, реализующими эти возможности, являются: рабочее пространство (Workspace), рабочий стол (Workbench ― базовый пользовательский интерфейс Eclipse), средства поддержки версий (CVS― Concurrent
Versions Systems), подсистема помощи (Help).
Среда выполнения платформы (Platform runtime) определяет основные
плагины (org.eclipse.osgi и org.eclipse.core.runtime), которые используются всеми
другими плагинами. Она динамически обнаруживает плагины и собирает информацию о плагинах и их точках расширения в реестре платформы. Она также отвечает за поиск и выполнение основного приложения.
Рабочее пространство (Workspace ) определяет основные объекты, с которыми могут работать пользователи и приложения Eclipse, структурирует эти объекты и предоставляет возможность управления ими. Объекты, о которых идет
речь — это проект (project), папка (folder) и файл (file). В терминологии Eclipse
все эти объекты называются ресурсами. В техническом плане компонент
Workspace обеспечивает унифицированный доступ ко всем указанным ресурсам.
9
Рисунок 1.2― Основные компоненты платформы Eclipse
Рабочий стол (Workbench) обеспечивает базовый пользовательский интерфейс (UI), а также определяет точки расширений для добавления собственных
компонентов пользовательского интерфейса. Основные объекты интерфейса, с
которыми работает Workbench, это редакторы (editors), представления (views)
и перспективы (perspectives).
Фундаментом, на котором построены все графические средства Eclipse, является входящий в Workbench, компонент SWT (Standard Widget Toolkit). SWT
является основным средством создания пользовательского интерфейса для приложений на основе Eclipse. Для прорисовки графических элементов он использует
средства оконного интерфейса соответствующей операционной системы (например, Win 32 API). Поэтому приложения, построенные на базе SWT, визуально не
отличаются от “родных” приложений используемой операционной системы. На
основе SWT построен компонент JFace, который решает задачи построения пользовательского интерфейса более высокого уровня. JFace содержит средства для
создания диалогов, страниц свойств, управления шрифтами и др.
JDT — интегрированная среда разработки для Java , содержащая компилятор Java, редакторы, средства для отладки, тестирования, навигации и рефакторинга исходного кода.
PDE обеспечивает поддержку разработки разнообразных плагинов, редакторов, представлений и страниц настроек. Именно PDE позволяет расширять сам
Eclipse.
Рассматриваемая ниже интегрированная среда разработки приложений на
языке С/С++ представляет собой одно из дополнений платформы Eclipse. Инструменты разработки для С/С++, обозначаемые как CDT (C/C++ Development
Tools), обеспечивают:
10
- поддержку процесса создания и компоновки проектов с помощью различных комплектов компиляторов;
- навигацию в пространстве исходных кодов (просмотр иерархии типов и дерева вызовов, просмотр схемы заголовочных файлов, просмотр макроопределений);
- редактирование исходных кодов, включая возможности подсветки и сворачивания различных частей кода, гиперссылки и рефакторинг;
- визуализацию процесса отладки с возможностью контроля состояния памяти и регистров, просмотра дизассемблерного кода.
2. УСТАНОВКА КОМПИЛЯТОРОВ И СРЕДЫ ECLIPSE
2.1. Установка компиляторов С/С++
Для того чтобы выполнять компиляцию и отладку программ, написанных на
С/С++, необходимо установить соответствующие программные инструменты, так
как они не входят в состав Eclipse. Базовый вариант CDT Eclipse поддерживает
интеграцию с GNU1-коллекцией (цепочкой — toolchain) инструментов для разработки С/С++ приложений. GNU-коллекция инструментов содержит: средства
управления процессом компиляции и компоновки (GNU-make утилита), непосредственно компиляторы и редактор связей (GNU Compiler Collection — GCC),
отладчик (GNU Debbuger — GDB). В GCC входят компиляторы для нескольких
языков программирования: C, C++, Objective-C, Java, FORTRAN, ADA [1]. Исторически аббревиатура GCC сначала означала “GNU C Compiler”, поэтому имя gcc
часто используют для обозначения основной драйверной программы GNUколлекции при работе с С-компилятором. Для компилятора С++ в качестве имени по умолчанию используют либо g++, либо с++.
Все дистрибутивы
Linux изначально содержат необходимые GNUколлекции инструментов. Для Windows имеются две GNU-коллекции инструментов: Cygwin (GNU+Cygnus+Windows) и MinGW (Minimalist GNU for Windows).
Cygwin — это порт Linux для Windows. Он содержит библиотеку
cygwin1.dll, которая эмулирует Linux и тем самым обеспечивает основную функциональность программных интерфейсов приложений (API) Linux, а также набор
средств, обеспечивающих Linux-стиль отображения графических компонентов
приложений (Linux look and feel). В случае установки Cygwin пользователь получает доступ ко многим стандартным unix-утилитам. Имеются средства, позволяющие создавать динамические библиотеки под Windows (dlltool), и компилятор
ресурсов (windres). В дополнение к сказанному следует отметить, что Cygwin использует GNU libc в качестве библиотеки времени выполнения и его использование требует соблюдения лицензии GPL (General public license) для открытых программных продуктов.
1
Проект GNU был открыт в 1984г. Его целью являлась разработка свободно распространяемой Unix-подобной
операционной системы — GNU-системы. Сокращение GNU представляет собой рекурсивный акроним от “GNU’s
Not Unix”. Примерами таких систем являются системы, использующие ядро Linux.
11
MinGW — это порт GNU-коллекции инструментов для Windows. Его основное отличие от Cygwin состоит в том, что он использует Windows Си библиотеку времени выполнения mscvrt. Поэтому MinGW взаимодействует с Windows
напрямую и обладает лучшей интегрируемостью с Eclipse. Поэтому ниже будем
использовать именно эту коллекцию инструментов, хотя она уступает Cygwin в
отношении переносимости создаваемых приложений на другие платформы1.
Для установки MinGW необходимо выполнить следующее:
1. Загрузить со страницы Интернет
http://sourceforge.net/projects/mingw/files/Automated MinGW Installer/
автоматический инсталлятор mingw-get-inst (796.0 KB).
2. Выполнить программу mingw-get-inst, используя предлагаемые по умолчанию
опции установки, при этом выбрать для загрузки компоненты, указанные на рисунке 2.1 .
Рисунок 2.1 — Окно выбора компонентов загрузки MinGW
3. В результате на диске С: будет создана папка MinGW, содержащая все необходимые компоненты для разработки программ на языках С/С++ с помощью комплекта инструментов MinGW.
4. Добавить путь с:\ MinGW \bin в переменную среды Path. Для этого выполнить
следующие действия:
- выбрать в Windows «Пуск > Панель Управления»;
- дважды кликнуть на иконке «Система»;
- выбрать вкладку «Дополнительно», а затем кликнуть на кнопке «Переменные среды» (рис. 2.2);
- выделить в разделе «Системные переменные» переменную Path и кликнуть «Изменить» (рис.2.2). Добавить в конец поля «Значение переменной» следующую строку (рис. 2.3):
;C:\MinGW\bin
1
Рекомендуется на компьютере установить оба комплекта: как MinGW, так и Cygwin. Установка Cygwin описана
в приложении В.
12
Рисунок 2.2 — Окна свойства системы и переменные среды
Обратите внимание, что пути разделяют знаком «;» и после него не должно быть
пробела.
Рисунок 2.3 — Окно изменения значений системной переменной
6. Проверить версию GCC и работоспособность сделанных установок, выполнив в
командной строке команду:
gcc –v
Сравнить полученный результат с содержимым окна на рис.2.4.
В результате выполненных загрузок в состав MinGW будут включены следующие основные модули:
а) binutils — содержит ассемблер и редактор связей, которые преобразуют
выходные (объектные) файлы компиляторов в двоичные исполняемые файлы;
13
б) mingw-runtime — содержит головные файлы и импортируемые библиотеки для используемой по умолчанию С-библиотеки времени выполнения
(msvcrt);
в) w32api — содержит головные файлы и импортируемые библиотеки, которые обеспечивает доступ посредством программного интерфейса приложений (Application Programming Interface — API) к функциям операционной системы MS Windows;
г) gcc-core — C компилятор с дополнительными пакетами для других языков (версия 4.5.0);
д) gcc-g++ — C++ компилятор;
е) mingw-gdb — порт GNU отладчика для MS Windows;
ж) mingw32-make — порт анализатора make файлов.
Рисунок 2.4 — Проверка версии GCC
Если рассмотренные выше установки покажутся сложными, то можно использовать проект Wascana. В этом случае помимо указанных выше модулей автоматически загружается сама интегрированная среда Eclipse Helios C/C++ IDE,
виртуальная Java-машина, а также дополнительные библиотеки для создания
приложений Windows. Установочный файл проекта Wascana можно скачать по
адресу:
http://wascana.eclipselabs.org.codespot.com/files/wascana-1.0-setup.exe
В результате будет загружен файл wascana-1.0-setup.exe (148 Mb). Для того чтобы установить модули проекта необходимо просто выполнить этот файл. Следует
отметить, что в состав Wascana-1.0 входит более ранняя версия компиляторов
С/С++ — gcc 4.4.1. В случае установки Wascana дальнейшие установки Javaмашины и интегрированной среды Eclipse IDE for C/C++ Developers не требуются.
2.2. Установка исполняющей среды Java
Перед тем как устанавливать Eclipse, необходимо убедиться, что на компьютере установлена виртуальная Java-машина (Java Virtual Machine — JVM), которую часто называют исполняющей средой JRE (Java Runtime Environment).
JRE может быть установлена либо отдельно, либо в составе комплекта разработки
14
программного обеспечения на языке Java (Java Development Kit — JDK). Комплекты последних версий JRE и JDK Standard Edition (Java SE) можно свободно
загружать с сайта:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Следует отметить, что комплект JDK дополнительно содержит средства,
предназначенные для специальных отладочных режимов работы с Java-машиной.
Чтобы проверить версию исполняющей среды JRE, установленной на компьютере, введите в командной строке команду:
java -version
Рекомендуется установить последнюю из имеющихся версий. На момент
написания данных методических указаний такой версия была JRE 1.6.0_23.
2.3. Установка Eclipse IDE for C/C++ Developers
Чтобы установить пакет Eclipse IDE для разработки приложений на языке
С/С++ необходимо:
1) открыть веб-страницу www.eclipse.org/downloads/packages/ и выбрать
для загрузки пакет Eclipse IDE for C/C++ Developers (88 MB). В результате будет загружен архив eclipse-cpp-helios-SR1-win32.zip;
2) перейти на страницу проекта Babel Language Packs for Helios:
http://download.eclipse.org/technology/babel/babel_language_packs/R0.8.1/helios.php;
3) найти раздел Language: Russian. Загрузить архивы, частично русифицирующие устанавливаемую среду:
BabelLanguagePack-eclipse-ru_3.6.0.v20101211043401.zip (78.6%);
BabelLanguagePack-rt.equinox-ru_3.6.0.v20101211043401.zip (71.11%);
BabelLanguagePack-rt.equinox.p2-ru_3.6.0.v20101211043401.zip (34.11%);
BabelLanguagePack-tools.cdt-ru_3.6.0.v20101211043401.zip (28.22%);
BabelLanguagePack-tools.mylyn-ru_3.6.0.v20101211043401.zip (28.86%);
4) разархивировать все загруженные zip-архивы на диск с:\ c сохранением
структуры папок архивов.
В итоге будет создана папка с:\eclipse, в которой будут располагаться все
файлы Eclipse. Среда Eclipse готова для запуска.
Возможен альтернативный вариант установки. Можно установить пакет
Eclipse Classic 3.6.1 (170 Mб) c последующей установкой CDT 7.0.1 — Eclipse
C/C++ Development Toolkit. Для установки CDT 7.0.1 необходимо скачать со
страницы http://download.eclipse.org/tools/cdt/releases/helios/ архив cdt-master7.0.1-I201009241320.zip (54,7 Mб). Чтобы корректно установить zip-файл с CDT
следует в среде Eclipse Classic выбрать Help > Install New Software, нажать
кнопку Add и в окне диалога Add Repository, нажав кнопку Archive, указать
путь к этому архиву. Далее необходимо будет выбрать установку всех компонентов CDT и принять условия лицензии. Такой вариант установки среды Eclipse
обеспечивает работу как с инструментами разработки на языке С/С++, так и на
языке Java.
15
3. ПРАКТИЧЕСКАЯ РАБОТА В СРЕДЕ ECLIPSE СDT
3.1. Интерфейс пользователя Eclipse
Выполним первый запуск Eclipse. Для этого в папке с:\Eclipse необходимо
найти файл еclipse.ехе и создать для него на рабочем столе ярлык «Eclipse». Дважды щелкнув по ярлыку, запустим Eclipse.
Рабочая область (workspace)
Первое окно, которое отобразится на экране (рис. 3.1), — это диалоговое
окно выбора рабочей области (workspace). В простейшем случае рабочая область (пространство) — это каталог на диске, в котором хранятся проекты
пользователя. Проект (project) представляет собой набор файлов с исходными и
бинарными кодами, файлов сценариев компоновки и других дополнений. Всё, что
находится внутри этого каталога, считается частью рабочей области. В методических указаниях рабочая область будет
размещаться в каталоге
C:\Eclipse.cppworkspace.
Рисунок 3.1 Выбор рабочей области (пространства)
После ввода имени папки, в которой будут храниться файлы ваших С/С++
проектов, следует установить флажок «Использовать это значение по умолчанию в дальнейшем». Установка флажка позволит использовать выбранную рабочую область по умолчанию. При последующих вызовах данное окно появляться
не будет. В дальнейшем, чтобы сменить рабочую область, указанное окно можно
открыть с помощью команд меню Файл > Сменить рабочую область.
Начальная страница (welcome)
Нажатие кнопки «OK» в окне выбора рабочей области приведёт к появлению начальной страницы (страницы приветствия — welcome), на которой имеется
5 графических кнопок (рис. 3.2):
- Обзор — содержит ссылки на обучающие интернет-ресурсы Eclipse;
- Новое — содержит обзор основных нововведений пакета;
- Примеры — в данной версии этот раздел пустой;
- Учебники — содержит ссылки на справочную систему и интернет ресурсы, в частности, на руководство по разработке С/С++ проектов;
16
- Рабочая среда — это рабочий стол с основными инструментами среды
программиста.
Рисунок 3.2 — Начальная страница
Рабочий стол (workbench)
Для того чтобы приступить к работе, нажмите на странице приветствия
кнопку Рабочая среда. По умолчанию откроется рабочий стол (workbench), изображенный на рисунке 3.3.
Рисунок 3.3 — Рабочий стол, открываемой по умолчанию проекцией C/C++
На рис. 3.3 в правом верхнем углу овалом выделена метка, которая отображает текущий режим рабочего стола (проекцию). Рабочий стол — это, по существу, сама платформа с набором инструментов. К инструментам рабочего стола от-
17
носится набор соответствующих редакторов (editors) и панелей (views), размещенных на нём.
Проекции (perspectives)
Для конкретной задачи набор определенных редакторов и панелей, расположенных на рабочем столе в определенном порядке, называют проекцией (перспективой — perspective) [2].
В каждой проекции присутствует свой набор инструментов. Некоторые
проекции могут иметь общие наборы инструментов. В определенный момент
времени активной может быть только одна проекция. Быстрое переключение между различными проекциями осуществляется нажатием клавиш <Ctrl+F8>.
Используя проекции можно настроить свой рабочий стол под определенный
тип выполняемой задачи. При разработке С/С++ проектов используют следующие основные проекции: С/С++ (рис. 3.4, при установке русифицирующих плагинов отображается литерой С) , Отладка (рис. 3.12), Информация (Recourses).
В Eclipse имеется возможность создавать свои проекции. Открыть соответствующую проекцию можно командой меню Окно > Открыть проекцию (Window > Open Perspective).
Редакторы (editors)
Редакторы позволяют создавать, открывать, редактировать, сохранять
файлы различных типов.
Панели (views)
Панели (представления — views) являются дополнениями к редакторам и
обеспечивают вывод дополнительной информации о файлах и проекте в целом.
Открыть панель можно командой меню Окно > Показать панель (Window >
Show View).
3.2. Элементы проекции C/С++
На рис. 3.4. изображена проекция С/С++ с открытым проектом. В этой проекции рабочего стола можно выделить несколько основных составляющих интерфейса пользователя, которые на рисунке заключены в прямоугольники (окна) и
обозначены цифрами.
Прежде всего, это основные элементы управления средой:
- Строка меню (окно 1) — содержит пункты меню платформы Eclipse с
набором функций для работы с проектами;
- Панель инструментов (окно 2) — содержит набор кнопок, которые обеспечивают быстрый выбор того или иного инструмента;
- Открытие проекции (окно 3) — кнопка, позволяющая выбрать необходимую проекцию (перспективу) из списка имеющихся проекций;
- Текущая проекция (окно 4) — отображает имя текущей активной проекции;
18
- Показать панель как быструю панель (окно 9) — кнопка, которая позволяет осуществить быстрое открытие одной из панелей (представлений), указанных ниже. В дальнейшем будем называть эту кнопку просто «Быстрая панель».
Рисунок 3.4 — Проекция “С/С++”
В окнах, обозначенных номерами 5,6,7и 8 (рис. 3.4), отображаются различные панели (представления), расположение которых, при необходимости, можно
менять:
- Структура проекта (Project Explorer) (окно 5) — отображает структуру
рабочей области в виде каталогов и файлов, входящих в проект;
- Редактор (Editor) (окно 6) — обеспечивает ввод и редактирование файлов С/С++ проектов;
- Схема (Outline) (окно 7) — обеспечивает отображения структуры файла
С/С++, который в данный момент открыт в окне редактора;
- Make targets (окно 7) — позволяет выбрать цели при выполнении компоновки проектов рабочей области;
- Неполадки (Problems) (окно 8) — отображает ошибки компиляции;
- Задачи (Tasks) (окно 8) — отображает список задач, которые вы хотите
прослеживать в соответствии с расписанием или в соответствии с историей выполнения;
- Консоль (Console) (окно 8) — системная консоль, используемая для вывода данных программы, а также для вывода результатов работы компоновщика и
внешних коллекций компиляторов;
19
- Свойства (Properties) (окно 8) — показывает атрибуты элементов, которые в данный момент выделены на других панелях или в редакторе.
Кнопка «Быстрая панель», находящаяся в левом нижнем углу рабочего
стола, открывает список доступных панелей и добавляет выбранную панель в окно 5 (рис 3.4). При этом вновь открытая панель помещается поверх существующих элементов представления, закрывая собой некоторую часть рабочего стола.
Имеется возможность добавить открываемую панель в любое из окон 5,6,7 или 8.
Для этого необходимо нажать мышью на закладке заголовка панели и перетащить
её в необходимое окно. В процессе перетаскивания панели на рабочем столе будет появляться прямоугольная рамка, показывающая новое расположение панели.
3.3. Простейший проект
Приступим к созданию и выполнению простейшей программы (приложения)
«Hello World» с использованием CDT. Эта программа будет выводить в консоль
Eclipse фразу «Здравствуй мир». Для того чтобы создать проект с такой программой, необходимо выполнить несколько шагов.
Шаг1. Создание проекта
Выбрать Файл > Создать > С++ Project или нажать на панели инструментов стрелку рядом с кнопкой
— New C/C++ Project и в выпадающем списке
выбрать C++ Project. В результате откроется окно создания проекта (рис. 3.5).
Рисунок 3.5 — Окно создания С++ проекта
В окне следует ввести имя проекта, например, MyHelloWorld, а затем в поле Project type (тип проекта) выбрать: Executable > Empty Project (Исполняемый
> Пустой проект). Тип Executable обеспечивает создание исполняемого приложе-
20
ния (т.е. файла с расширением .ехе ). При этом файл сценария построения проекта (make-файл) генерируется средой CDT автоматически.
Затем следует выбрать цепочку инструментов Toolchains: MinGW . Это набор инструментов, используемых при построении (компоновке) проекта, состоящий из компилятора (соmpiler), компоновщика (linker), ассемблера (assembler). С
выбранной цепочкой инструментов могут быть связаны и другие дополнительные
инструменты, например, отладчик. При установке флажка, находящегося в нижней части окна (рис. 3.5), в поле Toolchains будут отображаться только те цепочки
инструментов, которые установлены на компьютере.
Нажатие кнопки Далее (рис. 3.5) открывает окно Select configurations (выбор конфигурации). В этом окне отображается список конфигураций, зависящий
от выбранного типа проекта, и отображается название ранее выбранной цепочки
инструментов. Если есть необходимость изменить установки проекта, выбранные
по умолчанию, то в окне выбора конфигурации можно нажать кнопку Advanced
Setting (Дополнительные установки). Откроется диалоговое окно Свойств проекта, которое позволит изменить любую установку проекта, включая пути к папкам Include, параметры компилятора и компоновщика. Однако для этого проекта
изменять настройки, используемые по умолчанию, нет необходимости.
Поэтому вернитесь с помощью кнопки Назад к исходному окну, изображенному на рис. 3.5, и нажмите кнопку Готово. Если текущая проекция рабочего
стола будет не С/С++, то среда предложит сделать переход к этой проекции. В таком случае подтвердите Да. В результате будет создан пустой проект. При этом в
рабочей области создаётся папка проекта, которая отобразится на панели Структура проекта.
Шаг2. Редактирование исходного кода
Для добавления файла с исходным кодом в проект сначала выполним создание папки, где будет храниться исходный файл. Для этого следует нажать
стрелку рядом с кнопкой
— New C/C++ source folder и в выпадающем списке выбрать Исходная папка (Source folder) . Эти же операции можно выполнить
с помощью пунктов меню: Файл > Создать > Исходная папка. В открывшемся
окне в поле Folder name напечатать имя папки src и нажать внизу окна кнопку
Готово.
Добавим в папку src файл с исходным кодом. Для этого выделим мышью
папку src на панели Структура проекта, нажмем стрелку рядом с кнопкой
— New C/C++ source file и в выпадающем списке выберем Source file (эти же
операции можно выполнить с помощью пунктов меню: Файл > Создать > Source
file). В открывшемся окне в поле Source file напечатать имя файла, например,
main.cpp и нажать внизу окна кнопку Готово. В результате будет создан файл
main.cpp. Его имя появится в папке src, а сам файл будет отрыт в окне редактора.
Добавим в файл main.cpp текст простейшей программы на языке С++,
обеспечивающей вывод в консоль фразы "Здравствуй мир":
21
#include <iostream>
int main(){
cout<<"Здравствуй мир"<<endl; //вывод в консоль"Здравствуй мир"
return 0;
}
Сохраните файл, нажав Ctrl+S (или выбрав Файл > Cохранить или щелкнув правой кнопкой мыши на панели с открытым файлом и выбрав пункт меню
Сохранить). Обратите внимание, что на панели Схема появились основные объекты программы.
Шаг3. Компоновка проекта
Теперь нам нужно выполнить компоновку (компиляция и объединение программных модулей) проекта. Для этого следует нажать кнопку
— Скомпоновать все на панели инструментов или сочетание клавиш Сtrl+B (или выбрать
пункт меню Проект > Скомпоновать все). Начнется процесс компоновки проекта. Когда он завершится, то на панели консоли будет выведено сообщение:
**** Internal Builder is used for build
****
g++ -O0 -g3 -Wall -c -fmessage-length=0 -osrc\main.o ..\src\main.cpp
..\src\main.cpp: In function 'int main()':
..\src\main.cpp:9:2: error: 'cout' was not declared in this scope
..\src\main.cpp:9:26: error: 'endl' was not declared in this scope
Build error occurred, build is stopped
Time consumed: 390 ms.
Это сообщение говорит о том, что произошли ошибки, и процесс построения приложения был остановлен. Щелкнув мышью по закладке Неполадки, мы
увидим сообщения о проблемах, которые произошли во время компоновки (рис.
3.6). Обнаружены две ошибки в строке 9 нашей программы: не объявлены имена
“cout” и “endl”. Сама строка, в которой обнаружены ошибки, в окне редактора
выделяется красной меткой с крестиком. Аналогичные метки получают: файл
main.cpp, папка src и сам проект MуHelloWorld.
Проблема решается весьма просто. В тексте программы после строки #include <iostream> следует добавить строку:
using namespace std;
и заново выполнить компоновку. Теперь процесс компоновки завершится успешно (рис. 3.7), но c предупреждением:
warning:
auto-importing has been activated
specified on the command line.
without
--enable-auto-import
Это предупреждение не является ошибкой. Как его исключить укажем позже.
Обратите внимание, что в процессе компоновки был создан целевой файл
нашего приложения MуHelloWorld.exe. На панели Схема отображаются основ-
22
ные объекты программы. Если щелкнуть мышью по любому из объектов в окне
Схема, то происходит подсвечивание соответствующего текста в окне редактора.
Рисунок 3.6 — Сообщения об ошибках
Рисунок 3.7 — Сообщение об успешной компоновке проекта
Шаг 4. Выполнение приложения
Для этого следует сначала щелкнуть мышью на имени проекта в панели
Структура проекта, а затем нажать на панели инструментов стрелку рядом с
23
кнопкой
— Выполнить и в выпадающем списке выбрать Выполнить Configurations.
Откроется окно создания конфигураций (рис. 3.8). В этом окне необходимо
слева выбрать С/С++ Application и нажать кнопку
— Создать (или просто
дважды щелкнуть мышью в строке С/С++ Application). В итоге будет создана
конфигурация выполнения, изображенная на рис. 3.8, которая будет иметь своё
имя (MyHelloWorld Debug) и указывать путь к исполняемому файлу (.ехе) проекта.
Если необходимо, то в поле Имя можно изменить имя конфигурации на другое, а
поля Project и C/C++ Application заполнить так, как указано на рис. 3.8, используя соответственно кнопки Brose (Просмотр) и Search Project (Поиск проекта).
Рисунок 3.8 — Окно создания конфигурации выполнения
Теперь для запуска приложения остается просто нажать внизу кнопку Запуск. Результаты работы приложения будут представлены в консоли (рис. 3.9). В
дальнейшем приложение можно также вызывать, используя имя конфигурации,
которое появляется в выпадающем списке при нажатии кнопки
, или просто
нажимая кнопку
— Выполнить на панели инструментов.
Рисунок 3.9 — Результаты работы приложения
3.4. Отладка программы
Отладка программы — это процесс пошагового выполнения программы с
целью её проверки и выявления ошибок. Отладку выполняют с помощью специ-
24
альной программы, называемой отладчиком. Отладчик позволяет контролировать
выполнение отлаживаемой программы путём пошагового выполнения программы
и установки точек прерываний, приостановки выполнения программы, анализа
значений переменных. Основным отладчиком GNU-коллекции инструментов является утилита gdb.
Следует отметить, что отладчик работает с двоичным кодом программы, т.е.
с программой, которая уже скомпилирована. Поэтому, чтобы отладчик мог сопоставить двоичный код его исходному тексту и предоставить разработчику сведения
в удобной форме, компиляция должна выполняться в режиме, обеспечивающем
включение в объектные файлы необходимой дополнительной информации о программе. Без этой дополнительной информации всё, что будет известно отладчику,— это двоичные адреса и машинные коды выполняемых операций. Такие сведения не позволяют ссылаться на исходный код и отлаживать программу.
Для задания объёма и типа включаемых дополнительных сведений о программе в двоичный код компилятор должен вызываться с использованием специальных опций, например,
g++ –g3 …
Здесь g++ — команда вызова компилятора, -g3 — специальная опция, которая определяет объем включаемых дополнительных сведений в создаваемый
компилятором выходной файл. После флага -g в опции записывается цифра, определяющая уровень дополнительных сведений. Существует три уровня: 1 — минимальный объем информации, достаточный для трассировки вызовов функций и
исследования глобальных переменных; 2 — помимо отладочной информации
уровня 1, добавляются сведения для сопоставления двоичного и исходного кодов,
имена и расположение локальных переменных; 3 — помимо сведений уровней 1 и
2, включает определения макросов препроцессора.
Очевидно, вы заметили (см. рис 3.7), что бинарный код нашей программы
на панели Структура проекта обозначен в виде жучка
. Это как раз и означает, что он был скомпилирован с автоматическим использованием соответствующей опции компилятора, обеспечивающей включение в него дополнительной информации, необходимой для работы отладчика (в данном случае –g3). Включение
этой информации увеличивает размер исполняемого файла. В среде Eclipse изначально имеются две конфигурации компоновки (build configuration), используемые
при вызове компилятора и обозначаемые Debug и Release. По умолчанию активной является конфигурация Debug (см. рис. 3.8, поле Вuild configuration), которая
обычно используется на этапе разработки проекта и обеспечивает подстановку
опции –g3 в момент вызова компилятора. Если требуется выполнить окончательную компиляцию и исключить добавление отладочной информации в исполняемый файл, то следует выбирать для компоновки конфигурацию Release (выпуск –
релиз). Смену активной конфигурации компоновки можно выполнить, нажав на
панели инструментов стрелку рядом с кнопкой
и выбрав в появившемся
списке необходимый вариант Debug или Release.
В качестве упражнения установите активной конфигурацию Release и выполните заново компоновку проекта MyHelloWorld (Проект > Скомпоновать
25
все). Теперь на панели Структура проекта наряду с папкой Debug, появится
папка Release (рис 3.10). Кроме этого, в папке Binaries будут два исполняемых
файла. Щелкнув мышью по очереди на каждом из файлов, на панели Свойства
(рис. 3.10) можно прочитать сведения о каждом из файлов, в частности, определить их размеры (25,9 Кбайт и 60,9 Кбайт). Удалите папку Release из проекта (для
этого нужно щелкнуть мышью на папке, а затем, щелкнув правой кнопкой мыши,
выбрать Удалить).
В дальнейшем будем использовать конфигурацию Debug. Поэтому сделайте
необходимые переключения, используя кнопку
управления конфигурацией
компоновки проекта.
Рисунок 3.10 — Свойства исполняемых файлов
Для того чтобы продемонстрировать работу отладчика, усложним немного
программу. Пусть требуется, чтобы программа 10 раз выводила в консоль фразу
“Здравствуй мир” и печатала в начале очередной строки её номер. Для этого добавим в текст программы цикл for:
#include <iostream>
using namespace std;
int main(){
for (int i=1;i<11;++i){
cout<<i<<’\t’;
cout<<"Здравствуй мир"<<endl;//вывод в консоль "Здравствуй мир"
}
return 0;
}
Сохраним файл main.cpp, нажав Ctrl+S, и заново его скомпонуем, нажав
кнопку
— Скомпоновать все или
— скомпоновать проект MyHelloWorld
на основе конфигурации Debug (аналогично Проект > Скомпоновать проект).
Чтобы продемонстрировать работу программы по шагам, запустим её в режиме отладки. Для этого нажмем кнопку
— Отладка на панели инструментов.
Возможно, при первом запуске среда попросит уточнить способ запуска отладчика (рис. 3.11). Тогда необходимо выбрать GDB (DSF) Create Process
Launcher и нажать ОК. Это обеспечит вывод результатов работы отлаживаемой
программы в консоли среды Eclipse.
26
Рисунок 3.11 — Выбор способа запуска отладчика
Затем откроется окно с сообщением о переходе к проекции Отладка (Debug
Perspective), подтвердите «Да». На экране появится проекция Отладка (рис. 3.12).
С помощью этой проекции вы можете контролировать выполнение программы,
устанавливая точки прерывания, выполняя программу по шагам, контролируя
значения переменных. По умолчанию она содержит окно редактора и панель
Схема, которые поменяли свое расположение на рабочем столе, и основные панели (рис. 3.12), описание которых приводится ниже.
Панель Отладка (Debug) — служит для показа стека приостановленных
подпроцессов (threads — нитей) приложения, отображаемых в виде узлов дерева,
и управления вариантами пошагового выполнения (для этого на панели имеются
специальные командные кнопки). Анализ содержимого этой панели (рис. 3.12)
показывает, что под управлением конфигурации MyHelloWorld Debug было запущено приложение MyHelloWorld.exe. Это приложение представлено одной нитью исполняемых инструкций – Thread [1], выполнение которой было остановлено внутри функции main в точке, которая соответствует строке 12 исходного файла main.cpp.
Панель Переменные (Variables) — обеспечивает контроль и изменение значений переменных программы. Значения переменных, которые изменились во
время очередного шага выполнения программы, выделяются цветом в момент
приостановки её выполнения.
Панель Точки прерывания (Breakpoints) — обеспечивает отображение
сведений о точках прерываний и предоставляет средства для управления ими.
Панель Выражения (Expressions) — предоставляет возможность ввода выражений и вычисления их значений.
Панель Регистры (Registers) — служит для отображения информации о регистрах выделенного подпроцесса.
27
Панель Память (Memory) — позволяет отслеживать и изменять состояние
памяти подпроцесса.
Панель Модули (Modules) — отображает информацию о модулях (исполняемых и разделяемых библиотеках), загруженных в память.
Рисунок 3.12 — Проекция «Отладка»
Основными средствами, используемыми для отладки, являются точки прерываний и команды пошагового выполнения. Точка прерываний служит для остановки выполнения в том месте программы, где она установлена. Для того чтобы
установить точку прерывания, в окне редактора исходного кода следует дважды
щелкнуть мышью в столбце слева от строки программы, в которой желательна
остановка. При этом напротив выбранной строки программы появится значок
(см. рис. 3.12, строка 14), обозначающий точку прерывания, а в списке точек прерывания на панели Точки прерывания появится запись: main.cpp [line: 14].
Будучи установленной, точка прерываний может быть действующей (enabled) и недействующей (disabled). Чтобы изменить статус точки прерывания следует щелкнуть правой кнопкой на ёё значке и выбрать одно из двух: Enable
Breakpoint/Disable Breakpoint. Недействующая точка прерываний обозначается
белым кружочком.
Для того чтобы удалить точку прерывания, необходимо дважды щелкнуть
мышью на её значке. Управлять свойствами точек прерываний можно также с помощью панели Точки прерывания.
В режиме отладки программа, дойдя до точки прерывания, прерывает
обычный режим работы и останавливается, переходя в режим пошагового выпол-
28
нения. При этом появляется возможность выполнять операторы по одному (или
группой) с остановкой после выполнения очередного оператора (или группы
операторов). Во время остановки в редакторе исходного кода виден указатель текущего оператора — стрелка слева, указывающая на строку исходного кода, где
произошла остановка (см. рис. 3.12, строка 12). Кроме этого, такая строка выделяется светло-зеленым цветом. Нажатие кнопки
на панели Отладка (или клавиши F6) осуществляет переход к следующему оператору.
При старте процесса отладки по умолчанию устанавливается точка остановки на входе в функцию main (в случае необходимости эту остановку можно отменить). Нажимая кнопку пошагового выполнения
(F6), проследите порядок
циклического выполнения операторов. Обратите внимание на то, что переменная
цикла “i” меняет свои значения после прохождения заголовка цикла for, её новые
значения отображаются при этом на панели Переменные и выделяются желтым
цветом. Также обратите внимание на то, что значение этой переменной при выполнении строки 13 не выводятся сразу в панели Консоль. Вывод происходит
только после выполнения строки 14. При этом выводится как значение “i”, так и
фраза «Здравствуй мир».
Во время отладки имеется возможность не только контролировать значения
переменных, но и присваивать им новые значения. Чтобы изменить значение переменной (например, для проверки поведения программы при конкретном значении переменной), необходимо щелкнуть мышью на панели Переменные в поле
Value (значение переменной) и ввести новое значение переменной и нажать Enter.
Имеется также возможность вычислять выражения во время отладки. Щелкнув на кнопке Быстрая панель (см. рис. 3.4), откройте панель Выражения (Expressions) и перетащите её в окно рядом с панелью Точки прерывания (см. рис.
3.12). Для ввода выражения щелкните правой кнопкой мыши на панели Выражения и выберете Add new expression (Добавить новое выражение). Откроется окно,
в котором можно будет ввести выражение, например 10-i. Выражение будет автоматически вычисляться при каждой смене значений переменных, входящих в него.
Для рассматриваемого примера значение введенного выражения будет показывать,
сколько итераций цикла предстоит выполнить до завершения программы. Если
панель Выражения случайно будет закрыта, то её можно открыть, выбрав Окно
> Показать панель > Выражения (аналогично можно открыть и любую другую
панель).
На панели Отладка, кроме кнопки
— Пропустить функцию (F6), имеются и другие кнопки, определяющие команды управления процессом отладки.
Назначение основных командных кнопок указано в табл. 3.2 в порядке их изображения на панели Отладка.
С точкой прерывания можно связать определенные условия, при которых
будет происходить остановка, а также действия, например, внесение сообщений в
журнал отладки или проигрывание звуковых сигналов.
29
Таблица 3.2 — Назначение кнопок панели Отладка
Иконка Название кнопки
Описание выполняемых действий
Удалить все завершенные
запуски (Remove All
Terminated Launches )
Очищает панель Отладка от всех завершенных процессов
Рестарт (Restart)
Открывает новую сессию отладки для выбранного процесса.
Продолжить (F8) (Resume)
Выход из пошагового режима и продолжение выполнения в обычном режиме до очередной точки прерывания.
Приоставновить (Suspend)
Кнопка активна только в обычном режиме выполнения
отлаживаемого приложения. Приостанавливает выполнение в обычном режиме и переводит его в пошаговый
режим. При этом в окне редактора указатель текущего
оператора указывает на место, где произошла остановка.
Завершить (Ctrl+F2)
(Terminate)
Завершение сессии отладки выбранного приложения
(процесса). Отлаживаемое приложение (процесс) снимается с исполнения.
Отсоединить (Disconnect)
Отсоединяет отладчик от выбранного процесса
Трассировать функцию
(F5) (Step Into)
Шаг вперед с заходом внутрь каждой выполняемой
функции (метода). С помощью этой команды можно
зайти внутрь интересующей функции и проследить, что
происходит при её выполнении.
Пропустить функцию (F6)
Step Over
Шаг вперед на один оператор без захода в вызываемые
функции (методы).
Пропустить до оператора
Выход наружу из текущей функции (метода). После
возврата (F7) (Step Return ) выхода указатель текущего оператора остается в той
строке, из которой был осуществлен вызов функции
или метода.
Сбросить во фрейм (Drop
to Frame)
Команда применяется для повторного ввода выбранного подпроцесса в стек.
Режим покомандного выполнения (Instruction
Stepping Mode)
Активизирует режим покомандного выполнения дизассемблерного кода. Позволяет прослеживать покомандное выполнение операторов отлаживаемой программы на уровне дизассемблерного кода на панели
Disassembly.
Включить/Выключить
пошаговые фильтры (Use
Step Filters)
Позволяет включать и отключать пошаговые фильтры.
30
Чтобы связать с точкой прерывания условия или действия, следует щелкнуть правой кнопкой мыши на значке точки прерываний
в окне редактора
(или выделить на панели Точки прерывания необходимую точку и щелкнуть
правой кнопкой мыши) и выбрать Breakpoint Properties (Свойства точки прерываний). Откроется окно свойств точки прерываний (рис. 3.13).
Рисунок 3.13 — Свойства точки прерываний
На странице Общая (Common) в поле Condition введем условие, при котором будет происходить останов в данной точке, например логическое выражение
i%2. Подтвердим ввод, нажав внизу кнопку Ok. Введенное выражение будет
принимать значение «истина» каждый раз, когда остаток от деления переменной i
на 2 будет отличен от нуля, т.е. для всех нечетных значений. Запустим процесс
отладки заново и убедимся, что остановка программы будет теперь происходить
каждые два прохода цикла.
Обратите внимание, что в графическом обозначении точки прерывания появился знак вопроса, а в её описании на панели Точки прерываний добавилось
условие:
main.cpp [line: 14] [condition: i%2]
Аналогично можно связать с точкой прерывания и действия. Для этого в
окне свойств точки прерываний следует выбрать страницу Action (действие). Если с точкой прерывания связано действие, то в её графическом обозначении появится знак плюс.
Кроме точек прерывания (breakpoints), можно устанавливать и точки наблюдения (watchpoints). Эти точки приостанавливают выполнение, если изменяется значение заданного выражения (использующего глобальные переменные), без
привязки к какому-либо оператору программы. Добавить точку наблюдений можно, щелкнув в панели Точки прерываний правой кнопкой мыши на кнопке
— View menu и выбрав Add watchpoint.
31
Непосредственно протокол текущего сеанса работы gdb-отладчика можно
просмотреть в консоли Eclipse, выбрав консоль трассировки (gdb traces) с помощью кнопки
— Показать выбранную консоль.
3.5. Настройки проекта
При работе с проектами в среде Eclipse имеется возможность эффективного
управления их самыми различными свойствами. Для того чтобы просмотреть
свойства проекта и изменить их значения, следует выделить имя проекта на панели Структура проекта, щелкнуть правой кнопкой мыши и в появившемся списке
внизу выбрать Свойства (либо выбрать Файл > Свойства). Откроется окно
свойств выделенного проекта. В левой части окна свойств отображаются категории (группы) свойств и названия страниц, в правой части — содержимое выбранной страницы. На рис. 3.14 открыта страница Параметры (Settings) категории
C/C++ Build (C/C++ компоновщика).
Рисунок 3.14 — Страница Параметры (Settings) окна свойств проекта
В категории С/С++ Вuild вы имеете возможность установить свойства проекта, которые будут использоваться на этапе его компоновки, т.е. компиляции и
объединения модулей проекта в единое приложение. В частности, на общей
странице этой категории вы можете выяснить, какой компоновщик будет использоваться для создания приложения — внутренний (CDT internal builder) или внешний (GNU make builder). На странице Параметры с активной закладкой Tool Settings, которая как раз и изображена на рис. 3.14, вы имеете возможность задать
команды вызова компиляторов и редактора связей (Linker), а также определить
все необходимые параметры (опции) этих команд. По умолчанию, как следует из
рис. 3.14, для вызова С++ компилятора будет использоваться команда g++ (а для
32
компилятора Си — gcc). При запуске она выполняет все необходимые этапы преобразования входного исходного файла в выходной исполняемый (executable)
файл приложения. В нашем случае файл main.cpp будет преобразован в приложение MyHelloWorld.exe. Команда g++ (gcc), в общем случае, может компилировать
несколько входных исходных файлов в несколько (или один) файлов ассемблера.
Затем каждый ассемблерный входной файл преобразуется в объектный файл, а
редактор связей компонует все эти файлы в один исполняемый файл. Можно остановить процесс преобразования на любом из указанных этапов. Например, если
при вызове g++ (gcc) установить опцию “-c”, то редактирование связей выполняться не будет. В таком случае процесс преобразований заканчивается созданием
объектного файла.
Ранее при компоновке наших примеров использовался внутренний компоновщик (CDT Internal Builder), в котором команда g++ вызывалась два раза (см.
сообщения консоли на рис. 3.7) с опциями компоновки, указанными в поле All options (см. рис. 3.14):
g++ -O0 -g3 -Wall -c -fmessage-length=0 -omain.o main.cpp
g++ -oMyHelloWorld.exe main.o
Здесь имя команды g++ обеспечивает вызов исполняемого файла g++.exe,
который в данном случае находится в папке с:\MinGW\bin. В результате первого
вызова программа g++ выполнит преобразование исходного входного файла
main.cpp в выходной объектный файл main.o (опция -omain.o). Второй вызов
g++ обеспечивает преобразование созданного объектного файла с помощью редактора связей в исполняемый файл MyHelloWorld.exe. Опции, подставляемые в
командную строку вызова g++, определяются выбранной конфигурацией компоновки (Debug/Release) и имеют следующий смысл:
-O0 — опция предписывает не выполнять оптимизацию кода (уровень оптимизации 0,1,2 или 3 можно изменить, выбрав Optimization (см. рис. 3.14));
-g3 — обеспечивает запись максимального объема отладочной информации
в выходной файл (можно изменить, выбрав Отладка (Debugging));
-Wall — предписывает выводить все предупреждения компиляции (можно
изменить, выбрав Warnings (см. рис. 3.14)):
-c — выполнять только компиляцию, редактирование связей не выполнять;
-fmessage-length=0 — определяет режим форматирования выводимых сообщений об ошибках, нулевое значение обеспечивает вывод каждого сообщения в
отдельной строке (можно изменить, выбрав Miscellaneous).
Существует огромное число опций, которые вы можете использовать на
этапе компоновки проекта. При этом компилятор автоматически определяет, какие действия следует выполнять с файлами по расширению (суффиксу) файла.
Например:
.c — исходный файл на языке С, который подлежит предобработке (препроцессингу);
.срр, .сс, .с++, .ср, .срх — исходный файл на языке С++, который подлежит
предобработке;
33
.h — заголовочный файл С/С++;
.i, .ii — исходные файлы соответственно на языках С и С++, для которых не
требуется предобработка;
.о — файл с объектным кодом соответствующего формата, обрабатываемый
редактором связей (Linker);
.s — файл с кодом на языке ассемблера;
.а — файл статической библиотеки, который содержит один или более объектных файлов (такую библиотеку также называют архивом);
.so — файл разделяемой (Shared Objects под Linux) или динамической библиотеки (DLL — Dynamic Link Library под Windows). Такой файл содержит объектные файлы “.о” с перемещаемой внутренней адресацией, которые подключаются к программе во время её загрузки и выполнения.
Полный перечень опций компилятора вы найдете в документации к GCC. В
приложении A в алфавитном порядке приведены описания опций [1], которые вам
предлагает для выбора среда Eclipse CDT. Эти опции вы сможете устанавливать
на странице Параметры для обозначенных там компиляторов и редактора связей,
выбирая соответствующие группы опций: Preprocessor, Includes, Miscellaneous и
др.
В частности, для того чтобы исключить вывод в окне консоли предупреждения, показанного на рис. 3.7 , в группе опций MinGW C++ Linker > Miscellaneous в поле Linker flags введите опцию
-Wl,--enable-auto-import
и нажмите внизу кнопку Применить. В таком случае редактор связей будет вызываться командой со следующими параметрами:
g++ -Wl,--enable-auto-import -oMyHelloWorld.exe main.o
На странице Параметры, кроме закладки Tool Settings, имеются и другие
закладки (см. рис. 3.14). В частности, Вinary Parsers и Error Parsers. В случае
открытия закладки Вinary Parsers вам предоставляется возможность выбора корректного анализатора двоичного (бинарного) объектного файла для среды разработки. При правильном выборе такого анализатора (PE Windows Parser) вы сможете увидеть на панели Структура проекта структуру файла main.o в виде раскрывающегося поддерева. Если открыть закладку Error Parsers, то здесь для рассматриваемого примера следует установить флажки напротив следующих анализаторов ошибок: CDT GNU C/C++ Error Parser, CDT GNU Assembler Error
Parser и CDT GNU Linker Error Parser. Установка этих флажков обеспечивает
выбор соответствующих фильтров для обнаружения ошибок компоновки, возникающих на разных её этапах при использовании GNU-инструментария.
Страница ToolChain Editor категории С/С++ Вuild (см. рис.3.14) предназначена для выбора комплекта инструментов компоновки (MinGW GCC, Cygwin
GCC и др.) из предлагаемого списка. Кроме этого, в этой категории можно вы-
34
брать внутренний (СDT Internal Builder) или внешний компоновщик (например,
GNU Make Builder).
В категории С/С++ General (см. рис.3.14) на различных закладках страницы
Path and Symbols можно изменять и добавлять пути к каталогам Include выбранных компиляторов, управлять порядком в котором эти пути будут просматриваться, редактировать список символов препроцессора, добавлять и изменять пути к
библиотекам, указывать расположение исходных файлов для заданной конфигурации, определять ссылки проекта на другие проекты.
Категория Настройки запуска/отладки (Run/Debug Settings, см. рис. 3.14)
позволяет редактировать и создавать конфигурации запуска, ассоциированные с
проектом (см. рис. 3.8).
В категории Компоновщики (см. рис. 3.14) можно создать внешний компоновщик и определить его параметры.
В заключение отметим, что некоторые настройки общие для всех проектов
С/С++ можно также устанавливать и изменять в параметрах среды CDT Eclipse.
Для этого следует выбрать Окно > Параметры (рис. 3.15). Ниже будет рассмотрен пример настройки дополнительных возможностей редактора С/С++.
Рисунок 3.15 Окно настроек параметров среды Eclipse CDT
35
3.6. Дополнительные возможности редактора C/C++
С/С++ редактор, используемый в среде Eclipse, наряду со стандартными
функциями, свойственными многим современным текстовым редакторам, предоставляет следующие дополнительные возможности:
- обеспечивает «подсветку» (выделение цветом) синтаксически различных
участков исходного кода, а также автоматическое его форматирование для улучшения восприятия;
- выделяет метками строки кода с ошибками для ускорения поиска ошибок;
- предоставляет возможность контекстной справки и вставки шаблонов исходного кода для сокращения числа операций при вводе текста программы;
- может сворачивать некоторые участки кода для улучшения его обозримости.
Большинство свойств редактора устанавливаются на страницах редактора в
окне параметров (см. рис. 3.15): Окно > Параметры > С/С++ > Редактор (Editor).
Возможности редактора, связанные с подсветкой участков кода и выделением ошибок метками, демонстрировались ранее на рис. 3.4 и рис. 3.6, соответственно. Для выполнения автоматического форматирования исходного кода, следует нажать клавиши Ctrl+Shift+F.
Помощь при вводе комментариев. Чтобы быстро «закомментировать»
строку программы в стиле языка С++, достаточно в любом месте строки нажать
клавиши Ctrl+/. В итоге строка будет «закомментирована» символами “//”. Также
можно «закомментировать» и блок исходного кода. Для этого необходимо выделить блок и нажать Ctrl+/. Удаление символов комментария “//” выполняется
выделением комментированной строки (строк) и нажатием Ctrl+/.
Чтобы вставить комментарий из нескольких строк, например перед определением функции, следует напечатать “com” и нажать Ctrl+Space (пробел). В исходный код будет добавлен следующий шаблон комментария:
/*
* author user
*
* To change this generated comment edit the template variable "comment":
* Window > Preferences > C/C++ > Editor > Templates.
*/
Шаблон этого комментария можно изменить, отредактировав переменную “comment” в окне изменения свойств шаблонов (см. ниже).
Контекстная помощь. Этот вид помощи базируется на том, что редактор
предугадывает исходный код, который собирается вводить пользователь, анализируя контекст. Чтобы получить такую помощь, следует ввести первые литеры
кода и нажать Ctrl+Space (при вводе символов “.”, “->” или “::” вызов контекстной помощи может активироваться автоматически). Например, напечатав литеры
“fo” и нажав Ctrl+Space, получим список конструкций, которые начинаются этими литерами (рис.3.16). Если выбрать элемент из появившегося списка одним
щелчком мыши, то справа от списка можно увидеть текст шаблона соответствующего кода (если он имеется в памяти). Если выбрать необходимый элемент
36
списка двойным щелком мыши, то текст, соответствующий выбранной конструкции языка, будет вставлен в программу.
Рисунок 3.16 Контекстная помощь, получаемая при нажатии Ctrl+Space
Так, при выборе “for – for loop” будет вставлен текст, изображенный на рис. 3.16
справа. При этом переменная var будет выделена цветом (три раза). Если заменить var другим именем, то новое имя будет введено всюду вместо var. Т.е. заменив, например, первое вхождение var на i, получим: for (i = 0; i < max; ++i).
Если в памяти для вводимых литер будет найден только один шаблон, то
при нажатии Ctrl+Space список шаблонов не отображается, а шаблон по умолчанию сразу добавляется в текст программы. Так, если напечатать в окне редактора
“mai” и нажать Ctrl+Space, то будет введен текст заголовка основной функции:
int main(int argc, char **argv) { }.
Тексты шаблонов можно создавать и сохранять. Для этого следует открыть
окно изменения свойств шаблонов (рис. 3.17): Окно > Параметры >С/С++ > Редактор >Шаблоны (Templates).
Рисунок 3.17 — Создание и изменение шаблонов
37
Свертывание участков кода. С целью улучшения обозримости текста программы редактор позволяет свертывать некоторые участки исходного кода. Для
активизации режима свертывания кода следует в окне Параметры открыть страницу редактора Свертывание (Folding) (см. рис. 3.17) и установить флаг Enable
folding when opening a new editor (разрешить свертывание при открытии нового
редактора) и нажать кнопку Применить. Если после этого заново открыть в окне
редактора файл с исходным кодом, то напротив участков кода, которые можно
свернуть или развернуть, будут видны специальные метки в виде кружочков со
знаками плюс или минус (рис.3.18).
Рисунок 3.18 Пример свертывания исходного кода
Для того чтобы свернуть участок кода, отмеченный знаком минус следует
щелкнуть мышью на этом знаке. И наоборот, чтобы его развернуть, следует
щелкнуть мышью на знаке плюс.
В настройках редактора можно определить участки кода, которые следует
сворачивать. Для этого на странице Свертывание имеются флаги, с помощью которых можно отметить следующие участки кода, которые будут сворачиваться:
ветви препроцессора (#if/#endif), управляющие конструкции (if/else, do/while, for,
switch), макросы, функции, структуры, методы, комментарии.
38
4. ЛАБОРАТОРНЫЕ РАБОТЫ
4.1. Лабораторная работа №1. Создание проекта и ввод исходного кода
4.1.1. Цель работы
Освоение основных понятий интерфейса среды Eclipse и приобретение элементарных навыков редактирования текста программ.
4.1.2. Основные теоретические сведения и методические указания
Цель данной лабораторной работы ― первоначальное знакомство со средой
Eclipse CDT. Основные сведения о проекте Eclipse и архитектуре среды Eclipse
изложены в разделе 1 настоящих методических указаний. Поэтому внимательно
прочтите материал раздела 1.
При первоначальном знакомстве со средой Eclipse она может показаться несколько сложной для неподготовленного пользователя. Чтобы понять, как работать в этой среде, необходимо уяснить основные понятия интерфейса пользователя среды Eclipse: рабочее пространство, проекции (перспективы), редакторы,
панели (представления). Для этого изучите эти понятия по материалам, изложенным в п. 3.1. Чтобы начать работу в среде Eclipse СDT, необходимо также знать и
понимать расположение основных элементов проекции C/C+ (см. п.3.2).
Основное задание данной лабораторной работы будет сводиться к подготовке текста (исходного кода) программы с помощью редактора программ С/С++,
входящего в состав Eclipse CDT. Этот редактор обладает многими функциями,
свойственными обычным текстовым редакторам (например, стандартной программе «Блокнот» операционной системы Windows). В тоже время ему свойственны дополнительные возможности, которые упрощают процесс ввода программ
на языках С и С++. В настоящей лабораторной работе будут использоваться возможности, связанные с вводом комментариев, вставкой шаблонов и свертыванием исходного кода. Поэтому ознакомьтесь с ними, прочитав материал п. 3.6 данных методических указаний.
4.1.3. Порядок выполнения работы
4.1.3.1. Знакомство с интерфейсом пользователя и получение справочных данных.
1. Выполните первый запуск Eclipse так, как указано в п. 3.1.
2. Познакомьтесь с начальной страницей Welcome и нажмите кнопку Рабочая среда (рис. 3.2). Начальную страницу можно повторно отобразить на экране,
выбрав Справка > Начальная страница.
3. В открывшейся по умолчанию проекции рабочего стола определите вид
проекции и расположение основных панелей в соответствии с рис. 3.3 и 3.4. За-
39
фиксируйте для отчета в виде схематического рисунка относительное расположение панелей открытой проекции C/C++.
4. Откройте проекцию «Отладка». Для этого нажмите в правом верхнем углу кнопку — «Открыть проекцию» и выберите проекцию
Отладка щелчком мыши (либо пункт меню Окнo > Открыть проекцию >
Отладка). Зафиксируйте в виде схематического рисунка относительное расположение панелей
проекции Отладка.
5. Нажмите внизу справа кнопку
— Показать панель как быструю панель и в списке Прочие найдите папку Справка и в ней щелкните мышью на
панели Справка и потвердите ОК. Откроется панель Cправка, которая разместится поверх панели Структура проекта. Перетащите мышью эту панель в нижнюю половину панели Схема. Для этого нужно навести указатель мыши на закладку панели Справка и, удерживая мышь, перетащить панель на новое место.
В процессе перетаскивания будут отображаться прямоугольные области, показывающие новое месторасположение перемещаемой панели.
Аналогичным образом можно менять и расположение других панелей.
6. Познакомитесь со справочной системой Eclipse. Для этого на панели
Справка внизу в разделе «Перейти к:» нужно выбрать Оглавление (или выберите пункт меню Справка > Оглавление справки). Раскройте руководство пользователя С/С++ Development User Guide и познакомьтесь с его содержанием.
7. Познакомьтесь с основными сведениями о программе Eclipse. Для этого
выберите пункт меню Справка > О программе Eclipse. В открывшемся окне нажмите кнопку Installation Details. Откроется новое окно, которое содержит полные сведения об установленном программном обеспечении. Используя в открывшемся окне закладки Установленное ПО (Installed software) и Комплекты, определите версию установленной платформы Eclipse, а также версию Eclipse IDE
for C/C++ developers. Зафиксируйте эти сведения для отчета.
8. Познакомьтесь с окном справочных данных о назначении клавиш при работе в среде Eclipse CDT. Для этого выберите пункт меню Справка > Помощник
по клавишам и просмотрите в открывшемся окне сведения о клавишах. Зафиксируйте сочетание клавиш, которые обеспечивают копирование, вставку и удаление. Сравните их с клавишами, применяемыми для этих целей в стандартной программе «Блокнот». Определите клавиши, с помощью которых можно выполнить:
быстрый переход к следующей проекции, быстрое переключение в редактор, активирование редактора, быстрый доступ (quick access). В пункте меню Справка
определите сочетание клавиш для быстрого вызова помощника по клавишам.
Оформите полученные данные в виде таблицы и внесите их в отчет.
4.1.3.2. Создание проекта, ввод и редактирование исходного кода.
1. Создайте пустой проект с именем lab1, так как указано в п. 3.3 шаг 1.
2. Добавьте в проект папку src и создайте в этой папке файл main.cpр. Выполнение этих действий описано в п. 3.3 в начале шага 2.
4. Будет создан файл main.cpp, содержащий автоматически сгенерированный комментарий. В окне редактора измените этот комментарий следующим образом:
40
/*
* main.cpp
*
* Создан: дата
* Автор: напечатайте фамилию и инициалы
*/
5. Далее будем вводить в файл main.cpp построчно программу (ставшую
уже классикой благодаря авторам [3]), устанавливающую соответствие температуры, заданной в шкале Фаренгейта, температуре в шкале Цельсия. Для этого в
программе выполняются вычисления в соответствии с формулой:
TC 5 / 9(TF 32) ,
(4.1)
где TC — температура в градусах Цельсия; TF — температура в градусах Фаренгейта. При этом значение температуры по Фаренгейту изменяется от нижней до
верхней границы с заданным шагом и вычисляется соответствующее значение
температуры в шкале Цельсия. Значения температуры по Фаренгейту задаются
целыми числами.
Пошаговое выполнение программы рассмотрим позже. Наша основная задача на данном этапе — это приобретение навыков ввода исходного кода в редакторе. Полный текст программы приведен на рисунке 4.1. Однако вводить его будем поэтапно.
Рисунок 4.1 — Программы печати таблицы температур
41
6. При вводе первой строки программы воспользуйтесь контекстной помощью. Для этого напечатайте первые литеры строки “#in” и нажмите Ctrl+Space.
При этом будет введено все слово “include”. Затем введите знак “<”. Редактор автоматически создаст парный ему знак “>”. Напечатайте между угловыми скобками слово “iostream”. В итоге будет введена строка программы: #include
<iostream>.
7. Редактор позволяет автоматически завершать вводимые слова, если они
уже имеются в тексте программы. Для этого после ввода нескольких букв слова
следует нажать клавиши Alt+/. Используя эту возможность, введите следующую
строку программы: #include <iomanip>.
Напечатайте сначала “#in” и нажмите Alt+/. При этом будет введено слово
“include”.
8.При вводе строки
using namespace std;
воспользуйтесь контекстной помощью. Для этого напечатайте две первые буквы
строки и нажмите Ctrl+Space. В появившемся списке дважды щелкните на строке
“using –using a namespace”. В файл будет добавлена строка “using namespace name”.
Исправьте в ней “name” на “std”.
9. Введите в программу следующий текст:
Программа печати таблицы температур
в градусах Фаренгейта и Цельсия
После этого выделите этот текст и нажмите Ctrl+/. Текст будет «закомментирован». Проверьте возможность удаления знаков комментария повторно, нажав
Ctrl+/. Восстановите знаки комментария, нажав еще раз Ctrl+/.
10. Напечатайте первые буквы названия основной функции программы
“mai” и нажмите Ctrl+Space. В файл будет добавлен шаблон кода
int main(int argc, char **argv) {
}
11. Далее введите между фигурными скобками оставшийся код (см. рис.
4.1). При этом при повторном вводе имен переменных пользуйтесь возможностью
автозавершения слов (Alt+/), а при вводе инструкции цикла “for” воспользуйтесь
шаблоном (Ctrl+Space).
12. Отформатируйте текст программы, нажав клавиши Ctrl+Shift+F.
13. Сохраните введенный текст программы, щелкнув в окне редактора правой кнопкой мыши и выбрав Сохранить (или нажмите Ctrl+S, или нажмите
кнопку
Сохранить на панели инструментов).
14. Включите режим свертывания кода (см. п. 3.6). Для дальнейшей отладки
и выполнения программы нам не нужны комментарии, поэтому сверните их. Это
улучшит обозримость программы.
42
Программа готова для компоновки и выполнения. Однако это цель следующей лабораторий работы.
4.1.4. Содержание отчета
Цель работы, схемы проекций «С/С++» и «Отладка», описание последовательности действий по созданию проекта, версия установленной платформы
Eclipse и CDT, таблица справочных данных по клавишам, описание задачи вычисления температуры, текст программы, описание дополнительных возможностей
редактора, выводы (сравнительный анализ различных способов создания проектов, папок, файлов).
4.1.5. Контрольные вопросы
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
Назначение и структура платформы Eclipse.
Объясните следующие понятия интерфейса пользователя: рабочий стол, проекция (перспектива), панель (представления).
Для чего предназначены проекции “С/C++” и “Отладка”? Назовите основные
панели указанных проекций.
Каким образом можно выполнить быстрое открытие панели и обеспечить её
желаемое расположение на рабочем столе?
Как просмотреть справочные данные о клавишах?
Как просмотреть состав установленного ПО?
Как получить справочные данные о CDT?
Как выполнить создание проекта?
Как выполнить вставку шаблона конструкции в текст программы?
Как выполняется автоматическое завершение слов?
Как быстро закомментировать участок программы?
Как ввести шаблон основной функции?
Как установить режим свертывания участка исходного кода?
Как отформатировать программу?
Как сохранить исходный файл?
4.2. Лабораторная работа №2. Компоновка и выполнение программы
4.2.1. Цель работы
Закрепление на практике основных понятий процесса компоновки программы и приобретение элементарных навыков компоновки программы как с помощью в среды Eclipse CDT, так и с помощью командной строки.
4.2.2. Основные теоретические сведения и методические указания
Для того чтобы выполнить подготовленный на языке С/С++ (или ином языке программирования) исходный код программы, требуется перевести его на язык,
43
понятный компьютеру, т.е. в машинные коды. Процесс такого преобразования
предполагает несколько этапов (рис. 4.2) [4].
Сначала выполняют подготовку текста программы с помощью редактора и
сохраняют на диске в виде исходного файла, который имеет расширение, соответствующее типу файла и языку программирования (.с, .срр). Программа может состоять из нескольких исходных файлов — в больших программах их может насчитываться десятки и сотни.
Транслятор считывает исходные файлы и создает их эквивалент в машинных (двоичных) кодах — объектные файлы. Процесс выполнения программытранслятора называется трансляцией или компиляцией исходного кода. При программировании на языке С/С++ перед трансляцией может выполняться предварительная обработка исходных файлов с помощью препроцессора. Препроцессор
выполняет директивы, содержащиеся в тексте программы, например, включение в
текст программы определений элементов из специальных заголовочных файлов
(.h).
Редактор связей, или компоновщик, собирает (компонует) объектные коды
из разных объектных файлов, в том числе и из библиотечных (содержат коды
библиотечных функций), и создает полный машинный код программы в виде исполняемого файла. Исполняемый файл имеет расширение .exe и может быть загружен в память компьютера для выполнения.
Редактор
Библиотечные файлы
(*.а)
Исходные
файлы
(*.сpp, *.h )
Редактор связей (компоновщик)
Транслятор
(Компилятор)
Исполняемый файл
(*.ехе)
Объектные
файлы (*.o)
Загрузчик
ЭВМ
(оперативная память)
Рисунок 4.2 — Этапы создания исполняемой программы
Из всех указанных инструментов, используемых на разных этапах создания
исполняемой программы, в состав Eclipse CDT входит только редактор. Остальные инструменты являются внешними (подключаемыми).
Основные сведения о подключаемых внешних инструментах изложены в
разделе 2 настоящих методических указаний. Поэтому внимательно прочтите материал п.2.1.
Среда Eclipse CDT позволяет автоматизировать процесс создания (компоновки) исполняемой программы, изображенный на рис. 4.2. Познакомьтесь с по-
44
следовательностью действий, которую необходимо выполнить для компоновки
программы, прочитав содержимое п. 3.3 (шаг 3 и шаг 4). Однако чтобы понимать
процесс компоновки в деталях и избежать ошибок, необходимо разобраться с параметрами компилятора и редактора связей, которые они могут получать при запуске из среды Eclipse CDT. Для этого прочтите материал, изложенный в п.3.5.
Чтобы закрепить прочитанный материал, ниже предлагается выполнить
компоновку программы сначала в среде Eclipse, а затем вручную из командной
строки.
4.2.3. Порядок выполнения работы
4.2.3.1. Компоновка и выполнение программы из среды Eclipse.
1. Выполните компоновку проекта lab1, созданного в предыдущей лабораторной работе. Для этого следует нажать кнопку
— Скомпоновать все на панели инструментов или сочетание клавиш Сtrl+B (или выбрать пункт меню Проект > Скомпоновать все). Начнется процесс компоновки проекта. Если текст
программы был введен правильно, то процесс компоновки должен завершиться
без ошибок и в консольном окне C-Build появится сообщение:
Build complete for project lab1
Если ошибки все таки появились, сравните текст введенной программы с
текстом программы на рис. 4.1. Исправьте ошибки и заново выполните компоновку. После успешной компоновки проект готов к выполнению.
2. Перед первым выполнением проекта следует создать конфигурацию выполнения проекта (см. рис. 3.8). Чтобы её создать выполните рекомендации, указанные в п.3.3 (шаг 3). Завершите создание конфигурации выполнения нажатием
кнопки Применить и закройте окно создания конфигураций, нажав кнопку Закрыть (см. рис. 3.8).
3. Выполните проект, нажав кнопку
— Выполнить на панели инструментов. При запросе программы «Введите начальное значение диапазона температур» щелкните в окне консоли мышью и введите 0 (ноль). При запросе «Введите конечное значение диапазона температур» введите 10. При запросе «Введите
шаг изменения температуры» введите 1. Программа выведет в консоль результаты, полученные в соответствии с формулой (4.1).
Однако результаты выглядят странно. Для всех значений температур Фаренгейта в диапазоне от 0 до 10 мы получили нулевые значения температур
Цельсия. Позже, на этапе отладки, мы выясним, в чем причина такого поведения
программы.
Для завершения работы программы нажмите любую клавишу.
4.2.3.2. Компоновка и выполнение программы из командной строки.
1. Создайте на диске папку lab1.
2. Скопируйте в эту папку исходный файл main.cpp, который находится в
папке с:\ Eclipse.cppworkspace \lab1\src.
45
3. Выполните компиляцию исходного файла main.cpp и создайте объектный файл main.o Для этого откройте командную строку Windows и перейдите в
папку с:\lab1 (используйте для этого команду cd — смена директории). В командной строке введите команду вызова компилятора с опциями (параметрами),
аналогичными тем, которые используются средой Eclipse:
g++ -O0 -g3 -Wall -c -fmessage-length=0 -omain.o main.cpp.
В результате выполнения команды в папке с:\lab1 должен появиться файл main.o.
Проверьте это, напечатав в командной строке команду dir. Так как компилятор
вызывался с опцией -g3, то в объектный файл включается дополнительная информация, необходимая для работы отладчика.
4. Создайте исполняемый файл lab1.exe. Для этого напечатайте в командной
строке команду
g++ -olab1.exe main.o
В результате выполнения команды в папке с:\lab1 должен появиться файл
lab1.exe. Проверьте это, напечатав в командной строке команду dir.
5. Выполните исполняемый файл lab1.exe, напечатав в командной строке
lab1. В командном окне должно появиться приглашение программы «Введите начальное значение диапазона температур». Однако отображаться оно будет не в кодировке Windows, в которой оно было введено в редакторе, а в кодировке ASCII,
принятой в MS DOS, и поэтому на экране мы увидим нечитаемые русские символы. Тем не менее, введите значение 0. В ответ на новый запрос введите число 10,
и на последний запрос — 1. Мы получим те же числовые результаты, которые получили раньше при запуске программы из среды Eclipse. Для завершения работы
программы нажмите любую клавишу.
Поскольку проблема неверного отображения русских символов при запуске консольных приложений из командной строки не имеет непосредственного отношения к изучению языка С/С++, и в дальнейшем мы будем просматривать результаты работы программ в основном из консоли Eclipse (а там русские буквы
отображаются правильно), то не следует обращать на это внимание. Тем не менее,
один из вариантов решения этой проблемы рассмотрен в приложении Б.
4.2.4. Содержание отчета
Цель работы, основные этапы создания исполняемой программы (в виде схемы), копия окна консоли с результатами компоновки программы, описание команд вызова компилятора и основных параметров командной строки, результаты
выполнения программы, выводы (сравнение компоновки программы в среде
Eclipse CDT и компоновки из командной строки)
4.2.5. Контрольные вопросы
1.
2.
Объясните назначение каждого из этапов создания исполняемой программы.
Что понимают под исходным файлом, объектным файлом и исполняемым
файлом?
46
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
Как называется предварительный этап, который выполняется при компиляции программ, написанных на языке С/С++, и для чего он предназначен?
С помощью каких внешних инструментов выполняется компиляция и компоновка программ на языке С/С++ в среде Eclipse CDT? Приведите их общую
характеристику.
Какие преобразования, в общем случае, выполняются над исходным файлом
при вызове команды gcc (g++)?
Сколько раз вызывается команда g++ при использовании внутреннего компоновщика среды Eclipse CDT? Какие преобразования выполняет эта команда
при каждом вызове?
Объясните назначение каждого параметра (опции) при вызове команды g++
из среды Eclipse CDT.
Как компилятор интерпретирует расширения имен (суффиксы) файлов?
Объясните, как можно выполнить основные настройки свойств проекта, которые используются при компоновке программы?
Какие режимы компоновки проекта имеются в среде Eclipse CDT и как их установить?
Как обнаружить ошибки компоновки программы?
Как создать конфигурацию выполнения, и для чего она нужна?
Как выполнить программу в среде Eclipse CDT? Где просмотреть результаты
выполнения программы? Как выполнять ввод исходных данных в программу?
Как выполнить создание объектного файла из командной строки?
Как создать из объектного файла (ов) исполняемую программу, используя
командную строку?
4.3. Лабораторная работа №3. Простейшие приемы отладки программы
4.3.1. Цель работы
Закрепление на практике основных понятий выполнения программы в режиме отладки и приобретение практических навыков работы с отладчиком GDB.
4.3.2. Основные теоретические сведения и методические указания
В данной лабораторной работе мы будем выполнять пошаговую отладку
программы с помощью специальной программы-отладчика, которая является
внешней (подключаемой) по отношению к среде Eclipse.
Сам процесс отладки программы с помощью GDB-отладчика детально описан в п. 3.4. Поэтому внимательно прочтите этот пункт.
4.3.3. Порядок выполнения работы
4.3.3.1. Пошаговое выполнение программы.
1. Нажмите кнопку
— Отладка на панели инструментов. Подтвердите
переход к проекции Отладка.
47
2. Обратите внимание на то, что выполнение программы остановлено на
точке входа в функцию main (см. положение указателя текущего оператора в окне
редактора). На панели Переменные отображаются случайные значения переменных программы.
3. Для пошагового выполнения программы нажимайте кнопку F6 (или
кнопку
на панели отладка). Продвижение по тексту программы контролируйте
по положению указателя текущего оператора в окне редактора. Когда начнёт выполняться оператор ввода (строка программы, содержащая cin), то стрелка в правом поле редактора, указывающая на текущий оператор, исчезнет. Кроме этого,
управляющие кнопки панели отладка станут неактивными. В этот момент необходимо мышью щелкнуть в окне консоли и ввести необходимое значение, подтвердив ввод нажатием клавиши Enter. При запросе программы ввести значения
введите сначала 0 (это значение получит переменная tBegin), потом 10 (значение
для tEnd) и 1 (значение tStep).
Выполняя программу пошагово, остановитесь на строке, следующей после
строки:
tCelsius = 5/9 * (tFahrenheit - 32);
Проконтролируйте значения введенных и основных переменных программы
tFahrenheit и tCelsius (рис. 4.3)
Рисунок 4.3 — Значения переменных на первой итерации цикла
Из рисунка видно, что уже с первых шагов вычисляемая по формуле (4.1) переменная tCelsius получает неправильное значение.
Продолжив пошаговое выполнение, убедимся, что значения переменной
tFahrenheit вычисляются правильно. Её значения на каждой итерации цикла увеличиваются на 1 (от 0 до 10) и когда она принимает значение 11, то происходит
выход из цикла for и управление передаётся на конец программы. А переменная
tCelsius не меняет своих значений и постоянно равна нулю.
4.3.3.2. Выполнение программы до точки прерывания.
1. Чтобы установить, почему формула (4.1) вычисляется неправильно, добавьте на панели Выражения отслеживаемое выражение: tFahrenheit-32 (для
этого щелкните правой кнопкой мыши в панели Выражения и выберите Добавить новое выражение).
48
2. Установите точку прерывания на строке:
cout << setw(5) << tFahrenheit << '\t' << setw(8) << tCelsius << endl;
3. Заново запустите отладку. Нажимая кнопку F8 (или
— Продолжить на
панели Отладка), обеспечивающую выполнение программы до очередной точки
прерывания, проконтролируйте значения введенного выражения.
Вы увидите, что отслеживаемое выражение вычисляется правильно (на первом шаге оно равно -32, затем -31 и т.д.). Но переменная tCelsius, которая вычисляется как произведение выражения tFahrenheit-32 на 5/9, по-прежнему равна
нулю. Очевидно, что при вычислении 5/9 получается ноль. Это действительно так.
Поскольку аргументы операции деления представлены целыми числами, то операция 5/9 интерпретируется как операция целочисленного деления и поэтому результат деления равен только целой части, получаемого частного, а она равна нулю. Ошибка может быть легко исправлена, если изменить порядок вычислений,
т.е. переписать выражение для вычисления переменной tCelsius в виде:
tCelsius = 5 * (tFahrenheit - 32) / 9;
4. Исправьте выражение, сохраните программу и заново её скомпонуйте .
5. Нажмите кнопку
— Отладка на панели инструментов и, используя
кнопку F8, проследите ход выполнения программы.
Теперь переменная tCelsius не равна нулю и при каждом нажатии F8 вычисляется. Однако в окне консоли мы видим повторяющиеся значения tCelsius:
Fahrenheit
Celsius
0
-17
1
-17
2
-16
3
-16
4
-15
5
-15
6
-14
7
-13
8
-13
9
-12
10
-12
Нажмите клавишу Enter
Т.е. для различных значений температур по Фаренгейту мы получаем одни и те
же значения температур по Цельсию. Проблема заключается в том, что выражение 5 * (tFahrenheit - 32) / 9 по-прежнему вычисляется как целочисленное. Это
происходит из-за того, что переменная и константы этого выражения являются
целочисленными (т.е. относятся к типу int). Чтобы исправить эту ошибку достаточно в выражении одну из констант записать в форме вещественного числа, например:
5.0 * (tFahrenheit - 32) / 9
Тогда при вычислении выражения будет автоматически выполняться приведение членов выражения к «старшему» типу. Таким является вещественный
тип double, к которому относится константа «5.0».
49
6. Исправьте выражение, сохраните программу, заново её скомпонуйте и
выполните. Теперь программа работает верно.
4.3.4. Содержание отчета
Цель работы, назначение отладчика и описание опции –gLevel компилятора,
назначение командных кнопок панели «Отладка», результаты пошагового выполнения первого варианта программы, результаты выполнения второго варианта
программы до точки прерывания с указанием значения отслеживаемого выражения, результаты выполнения третьего варианта программы, последние значение
переменной tFahrenheit с пояснениями, выводы (сравнить отладку программы без
отладчика и с отладчиком)
4.3.5. Вопросы для самопроверки
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
Что понимают под отладкой программы?
Что позволяет делать отладчик?
Зачем нужно включать в объектные файлы дополнительную информацию,
если предполагается использование отладчика?
С какой опцией следует вызывать компилятор, чтобы в объектный файл добавлялась информация, необходимая отладчику?
В чем отличие между двумя конфигурациями компоновки — Debug и Release?
Как начать отладку в среде Eclipse CDT уже скомпонованной программы?
Для чего предназначены различные панели проекции «Отладка»?
Что такое точка прерывания? Как её установить? Как изменяется выполнение
программы при достижении точки прерывания?
Как обозначаются активные (действующие) и неактивные (недействующие)
точки прерываний? Где можно изменить свойства точки прерывания?
Где по умолчанию останавливается выполнение программы при запуске её в
режиме отладки?
Каким образом, можно просмотреть и изменить значение переменной во время отладки?
Что понимают под отслеживаемым выражением?
Объясните назначение основных командных кнопок панели «Отладка».
Как назначить точке прерываний условие или действие?
Что такое точка наблюдения?
50
БИБЛИОГРАФИЧЕСКИЙ СПИСОК
1.
2.
3.
4.
5.
6.
7.
8.
Гриффитс Артур GCC. Настольная книга пользователей, программистов и
системных администраторов: Пер. с англ. / Артур Гриффитс . — К.: ООО
«Тид «ДС», 2004. — 624с.
Казарин С.А. Среда разработки Java-приложений Eclipse (ПО для объектноориентированного программирования и разработки приложений на языке
Java): учеб. пособие [Электронный ресурс] / С.А.Казарин, А.П.Клишин. —
М.: Федеральное агентство по образованию, 2008. — 77 с. — Режим доступа: http://window.edu.ru/window_catalog/files/r58397/Eclipse_Java.pdf. — Последний доступ: 20.12.2010. — Название с экрана.
Керниган Б. Язык программирования Си / Б. Керниган, Д. Ритчи ; под ред.
и с предисл. В. С. Штаркмана ; пер. с англ. — 2-е изд., перераб. и доп. —
М. : Финансы и статистика, 1992. — 272 с.
Ковалюк Т. В. Основи программування / Т. В. Ковалюк.—К. : Видавнича
група BHV,2005.—384 с.
Павловская Т.А. С/С++. Структурное программирование: практикум / Т.А.
Павловская, Ю.А. Щупак. — СПб. : Питер, 2004.—239 с.
Структурное программирование на языке С / С++ : методические указания к лабораторным работам по дисциплине «Основы программирования и
алгоритмические языки» для студ. дневной и заочной формы обучения направления 6.0804 — «Компьютерные науки», часть 1 / СевНТУ ; сост. В. Н.
Бондарев, В. Н. Хоролич. — Севастополь : Изд-во СевНТУ, 2007. — 80 с.
Структурное программирование на языке С / С++ : методические указания к лабораторным работам по дисциплине «Основы программирования и
алгоритмические языки» для студ. дневной и заочной формы обучения направления 6.0804 — «Компьютерные науки», часть 2 / СевНТУ ; сост. В. Н.
Бондарев. — Севастополь : Изд-во СевНТУ, 2007. — 75 с.
Rahimberdiev Askar Проект Eclipse [Электронный ресурс] / Askar Rahimberdiev // RSDN Magazine .— №4.— 2004. — Режим доступа:
http://www.rsdn.ru/?article/devtools/eclipse.xml. — Последний доступ:
20.12.2010. — Название с экрана.
51
Приложение A
(справочное)
Опции компилятора, устанавливаемые в Eclipse CDT
Все опции начинаются с дефиса “-“ (некоторые могут начинаться двойного
дефиса). Порядок следования опций в строке команды при вызове компилятора в
большинстве случаев не имеет значения.
Таблица A.1— Опции компилятора
Опция
Назначение опции
Опция сообщает компилятору о соответствии исходного кода
-ansi
стандарту ANSI. Опция допускает применение для языка Си
стандарта ISO C89. При компиляции программ на языке С++ отключается поддержка всех расширений GNU, конфликтующих
со стандартом ISO C++. Тем не менее, некоторые расширения
GNU допускаются. Если требуется строгая проверка на соблюдение стандарту, то дополнительно следует применять опцию
-pedantic.
Компилировать без линковки. Создается объектный файл с рас-c
ширением “.о”.
Позволяет на этапе предобработки определить макрос с именем
Dmacro=[string] macro. Например, опция -Dbool=logic генерирует директиву
макроопределения: #define bool logic. Если string не задано, то
макрос определяется строкой, равной “1”.
Остановка после предобработки (препроцессинга). Вывод на-е
правляется на стандартное устройство вывода, если не задана
опция “ -о ”.
-glevel
Определяет объем дополнительной отладочной информации,
выводимой в выходной файл и используемой затем отладчиком
(level=1,2,3).
-Iname
Добавляет каталог с именем name для поиска заголовочных файлов.
-llibname
Опция задает имя статической библиотеки. При этом к имени
библиотеки автоматически добавляется префикс “lib” и суффикс
“.a”. Например, -lconio автоматически преобразуется в libconio.a и именно эта библиотека будет использоваться при компоновке.
-Ldirectory
Добавляет каталог с именем directory для поиска библиотек,
указанных в опции “-l”.
Обеспечивает применение форматирования при выводе сообще-fmessagelength=size
ний об ошибках. Длина строки не превышает size знаков. Для
языка С++ по умолчанию устанавливается size=72 знака. Если
size=0, то форматирование не применяется и каждое сообщение
выводится в отдельной строке.
52
-fsyntax
-nodefaultlibs
-nostartfiles
-nostdinc
-nostdlib
-Olevel
-оfile
-р, -pg
-pedantic
-pedanticerrors
-s
-S
-shared
Продолжение таблицы А.1
Компилятор проверяет только синтаксис исходной программы.
Никаких других действий не делает.
Редактор связей не будет использовать стандартные системные
библиотеки. Будут использоваться библиотеки, явно заданные в
командной строке. Стандартная библиотека libgcc.a является
частью компилятора и специфична для каждой платформы. Поэтому при отмене использования стандартных библиотек следует указать использование -lgcc.
Редактор связей не будет включать в программу стандартные
объектные файлы, содержащие код инициализации среды выполнения программы.
Предотвращает поиск заголовочных файлов в стандартных каталогах для программ на языке C++. Редактор связей будет использовать только те файлы, которые указаны в командной
строке.
Опция применяет обе опции -nostartfiles и –nodefaultlibs.
Устанавливает уровень оптимизации генерируемого компилятором кода. Level принимает значения 0,1,2,3. O0 означает отказ
от оптимизации, что упрощает работу отладчика. Включение
оптимизации увеличивает время компиляции программы и затрудняет отладку. Во время оптимизации компилятор пытается
сократить как размер генерируемого кода, так и время его выполнения.
Помещает выходной файл соответствующего этапа (-ов) преобразования в файл file. Если “-o” не задавать, то по умолчанию
создается выходной файл “a.out”, готовый к исполнению.
Включает в программу дополнительный код, который выводит
информацию, пригодную для использования профилирующими
программами соответственно prof и gprof.
Выдаёт предупредительные сообщения при любых отступлениях от стандартов ISO, предусмотренных этими стандартами.
Действует как –pedantic, но сообщения выводятся как ошибки,
а не предупреждения.
Удаляет из исполняемого файла таблицу программных символов (symbol table) и информацию об их перемещении.
Предписывает не задействовать ассемблер и редактор связей. В
результате создается выходной файл, имеющий расширение “.s”
(ассемблерный код).
Создает объект модуль, который может затем подключаться к
программе из разделяемой библиотеки (libXX.so) во время выполнения программы.
53
-uname
-Umacro
-v
-w
-W
-Wall
-Werror
-Wl, optionlist
-x language
-XLinker
[оption]
Продолжение таблицы А.1
Передает указанное имя name в таблицу программных символов
(symbol table). Имя будет использоваться редактором связей для
загрузки объектного модуля, содержащего определение символа
с таким именем.
Удаляет ранее сделанное макроопределение с именем macro.
Все опции -U обрабатываются позже опций -D.
Назначает версию gcc, которая должна быть запущена при компиляции. Применяется, когда в системе установлено одновременно несколько версий компилятора.
Подавляет вывод всех предупреждений.
Включает вывод семейства предупреждений относительно кода,
который может вызвать ошибки.
Предписывает выводить все предупреждения компиляции.
Выполняет преобразование всех предупреждений в сообщения
об ошибках.
Список опций optionlist передаётся редактору связей.
Указывает тип содержимого файла, где language = c|c++|java и
др. Отменяет предустановленное действие, определяемое суффиксом файла. Распространяет своё действие на все имена файлов, записанные после неё в строке команды.
Передает опцию option редактору связей.
54
Приложение Б
(справочное)
Функции для взаимного преобразования ANSI и ASCII символов
Так как при подготовке текстов программ в редакторе, являющемся приложением Windows, используется стандарт кодировки ANSI, а в командной строке
— ASCII, и кодовые таблицы этих стандартов совпадают только для английских
символов, то русские символы отображаются консольными приложениями неверно. Чтобы решить эту проблему следует использовать функцию CharToOem() для
преобразования символов из кодировки ANSI в кодировку ASCII и функцию
OemToChar() для обратного преобразования. Вторая функция обычно используется при вводе текста с клавиатуры, когда в дальнейшем необходимо выполнять
запись этого текста в выходные файлы в кодировке ANSI. Чтобы использовать эти
функции к программе следует подключить заголовочный файл <windows.h>. Ниже приведен пример использования функции CharToOem() для корректного отображения русских букв при выводе сообщений в окне консоли Windows. С этой
целью в программе реализована вспомогательная функция rus(), из которой вызывается функция CharToOem() [5]. Дело в том, что функция CharToOem() возвращает результат типа BOOL и имеет два аргумента, один из которых это указатель на преобразуемый текст, а второй — указатель на буфер, в который записывается результат преобразования. Поэтому вызов этой функции нельзя непосредственно подставлять вместо строковых констант при использовании объектов вывода cout.
Формат вызова функции rus следующий: rus(строковая константа). Функция перекодирует строку и помещает её в небольшой литерный массив
bufRus[256], указатель на который и передается в объект cout для вывода. Ниже в
тексте программы строки с вызовами функции rus обозначены номерами.
#include <iostream>
#include <iomanip>
#include <windows.h>
using namespace std;
//Прототип функции перекодировки
char * rus(const char *text);
//Программа печати таблицы температур
//в градусах Фаренгейта и Цельсия
int main(int argc, char **argv) {
float tCelsius;
int tFahrenheit, tBegin, tEnd, tStep;
cout << rus("Введите начальное значения диапазона температур:") << endl; //1
cin >> tBegin;
cout << rus("Введите конечное значение диапазона температур:") << endl; //2
cin >> tEnd;
cout << rus("Введите шаг изменения температуры:") << endl;
//3
55
cin >> tStep;
cout << "Fahrenheit" << " " << "Celsius " << endl;
for (tFahrenheit = tBegin; tFahrenheit <= tEnd; tFahrenheit = tFаhrenheit + tStep) {
tCelsius = 5.0 * (tFahrenheit - 32) /9;
cout << setw(5) << tFahrenheit << '\t' << setw(8) << tCelsius << endl;
}
cout << rus("Нажмите любую клавишу") << endl;
//4
cin.get();
cin.get();
return 0;
}
//Функция, преобразующая символы из кодировки ANSI в кодировку ASCII
char bufRus[256];
char* rus(const char * text){
CharToOem(text,bufRus);
return bufRus;
}
56
Приложение В
(справочное)
Установка Cygwin и настройка Eclipse CDT
Для установки комплекта компиляторов Cygwin необходимо загрузить с
сайта http://www.cygwin.com файл setup.exe (549 К) и выполнить его. В открывшемся окне (рис. В.1) выбрать тип установки Download Without Installing (загрузка без установки) и нажать кнопку Далее. После чего выбрать папку, в которой будут сохраняться файлы дистрибутива (по умолчанию это та папка, откуда
был запущен файл setup.exe).
Рисунок B.1 — Выбор типа установки
Затем вам будет предложено выбрать тип подключения к Интернету. Отметьте Use Internet Explorer Proxy Settings и нажмите кнопку Далее. В новом
окне выберете сайт ftp://ftp.linux.kiev.ua из списка доступных сайтов для скачивания (рис. В.2) и нажмите кнопку Далее. При первой установке Сygwin появляется предупреждение Setup Alert. Проигнорируйте его, нажав кнопку ОК.
Рисунок B.2 — Выбор сайта для загрузки Сygwin
57
Далее в появившейся форме (рис. В.3) необходимо выбрать загружаемые
пакеты. Воспользуйтесь базовыми установками (default — по умолчанию) c добавлением необходимых средств разработки. Для этого выберите в категории Devel (development — разработка) следующие файлы:
gcc-core: C compiler;
gcc-g++: C++ compiler;
gdb: The GNU debugger;
make: The GNU version of ‘make’ utility.
При выборе средств разработки будут автоматически появляться отметки и у
файлов, которые вы не выбирали. Эти отметки не следует снимать. В указанном варианте загружается около 48 Мбайт.
Рисунок В.3 — Выбор загружаемых пакетов
После загрузки вы можете устанавливать файлы дистрибутива без подключения к Интернету. Для этого надо запустить файл setup.exe и в окне, изображенном на рис. В.1, выбрать опцию Install from Local Directory (загружать из локальной папки). После этого повторите описанную выше процедуру выбора папки
установки (следует выбрать с:\cygwin) и устанавливаемых файлов.
После завершения установки добавьте путь с:\cygwin\bin в переменную
среды Path (см. п.2.1)
Для того чтобы использовать Cygwin в качестве инструментария создания
проектов Eclipse CDT, необходимо при создании нового проекта в группе Toolchains: выбрать Cygwin GCC (см. рис. 3.5).
Дальнейшие действия, связанные с вводом исходного кода, редактированием, выполнением компоновки проекта, аналогичны действиям при работе с комплектом инструментов MinGW.
58
Чтобы выполнять отладку приложений, полученных с помощью Cygwin,
лучше использовать «родной» отладчик GDB, который находится в папке
с:\Сygwin\bin. Для этого сначала следует отредактировать конфигурацию отладки,
которая обеспечивает задание необходимых значений параметров среды. Нажмите стрелку рядом с кнопкой
— Отладка и выберете Отладка Configurations.
Откроется окно создания конфигураций отладки (рис. В.4).
Рисунок В.4 — Создание конфигурации отладки
В этом окне необходимо выбрать С/С++ Application и нажать кнопку
—
Создать (вверху слева). На закладке Main в поле Имя напечатать имя конфигурации, например lab1_cygwin. Поля Project и C/C++ Application заполнить аналогично рис. B.4, используя соответственно кнопки Brose (Просмотр) и Search
Project (Поиск проекта).
Перейти на закладку Debugger. Сначала внизу в конце строки Using GDB
(DSF) Create Process Launcher щелкнуть мышью на подчеркнутой строке Select
other. Откроется окно Select Preferred Launcher (см. рис. 3.11), в котором следует выбрать Standard Create Process Launcher и нажать ОК. Затем в поле Debugger (рис. В.5) выбрать из списка gdb/mi. В группе Debugger options в поле GDB
debugger с помощью кнопки Browse указать путь к файлу отладчика
C:\Cygwin\bin\gdb.exe и нажать кнопку Применить.
59
Рисунок В.5 —Конфигурации отладки, закладка Debugger
В дальнейшем к данной конфигурации можно будет обращаться по имени
lab1_cygwin. После этого нажать внизу кнопку Отладка. Дальнейшая работа с
отладчиком аналогична работе с отладчиком GDB MinGW.
Заказ № _____ от «_____» ______2011г. Тираж ______экз.
Изд-во СевНТУ
60
