Среда разработки и язык программирования Delphi, его графические средства
РЕФЕРАТ
Отчёт к практической работе содержит 23
страницы, 2 рисунка, 7 таблиц, 9 приложений и 3 источника.
Объект исследования - Среда разработки и язык
программирования Delphi,
его графические средства.
Целью данной работы является изучение языка
программирования Delphi, использование синтаксических и графических средств Delphi,
сравнение сред разработки и синтаксиса языков программирования C++
и Delphi. Для сравнения
используются среды программирования Microsoft
Visual C++
и Delphi 7. Сравнение
осуществляется посредством реализации решения девяти определенных задач на
Delphi.
DELPHI 7,
ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ, MICROSOFT
VISUAL C++,
СРЕДА РАЗРАБОТКИ, СРАВНЕНИЕ С++ И DELPHI
СОДЕРЖАНИЕ
Введение
1. Сравнение языков с/с++ и pascal/Delphi
1.1 Простые типы данных
1.2 Структурные типы данных
1.2.1 Строковые переменные
1.2.2 Массивы
.2.3 Множества
.2.4 Файлы
.2.5 Классы
1.3 Указатели
2. Сравнение сред разработки
2.1 Borland
Delphi 7
.2 Microsoft
Visual C++
Заключение
Перечень ссылок
Приложение А
Приложение Б
Приложение В
Приложение Г
Приложение Д
Приложение Е
Приложение Ж
Приложение З
Приложение И
ВВЕДЕНИЕ
На данный момент, значительная часть
программного обеспечения реализуется методами объектно-ориентированного
программирования. Сейчас эта область программирования очень востребована.
Поэтому освоение этого стиля программирования является очень актуальным.
Для изучения данного стиля программирования был
выбран язык Delphi 7, с
помощью которого изучена методика объектно-ориентированного проектирования
программ по формализации и решению задачи, технологическими приемами разработки
объектно-ориентированных программ.
Причина выбора данного языка программирования
также заключается в его графических средствах.- это средства разработки в
программировании, которые имеют место быть в рамках приложений Microsoft
Windows. Delphi представляет собой актуальную и легкую в использовании
программу, которая необходима для генерации автономных программ графического
интерфейса или 32-битовых консольных приложений - программ, которые существуют
вне рамок GUI, вместо этого, в соответствии с так называемым «DOS box».
Delphi является первым языком программирования, который обеспечивает
уничтожение барьера между приложениями комплексного и упрощенного характера в
использовании и низкоуровневыми битовыми программными средствами.
1.
СРАВНЕНИЕ ЯЗЫКОВ С/С++ И PASCAL/DELPHI
1.1 Простые типы
данных
Тип определяет множество значений, которые могут
принимать элементы программы, и совокупность операций, допустимых над этими значениями.
Типы данных можно разделить на следующие группы:
1. Простые;
2. Структурные;
3. Указатели;
4. Процедурные(только
в Delphi);
Простые типы не содержат в себе других типов, и
данные этих типов могут одновременно содержать одно значение. К простым
относятся следующие типы:
1. Целочисленные;
2. Литерные
(Символьные);
3. Логические
(Булевы);
4. Вещественные.
В таблице 1.1 можно увидеть сравнение наиболее
часто встречаемых простых типов в языках программирования C++
и Delphi.
Таблица 1.1 - Сравнение простых типов данных в
С++ и Delphi
|
C/C++
|
Pascal/Delphi
|
|
Типы
данных
|
Тип
|
Диапазон
|
Тип
|
Диапазон
|
|
Целочисленные
|
int
|
От
-32 768 до 32 767
|
Integer
|
от
-2 147 483 648 до 2 147 483 647
|
|
Литерные
(Символьные)
|
char
|
От
-128 до 127
|
Char
|
-//-
|
|
Логические
(Булевы)
|
bool
|
true, false
|
Boolean
|
|
Вещественные
|
float
|
От
3.4e-38 до 3.4e+38
|
Real
|
От
2.9E-39 до 1.7Е38
|
Для каждого типа данных существуют отдельные
функции, упрощающие работу с ними. В таблице 1.2 приведены некоторые функции
для переменных с простыми типами данных в синтаксисе С++ и Delphi.
Таблица 1.2 - Функции для простых типов данных в
С++ и Delphi
|
Операция
|
C/C++
|
Pascal/Delphi
|
|
Конвертация
строки в целый тип данных
|
atoi();
|
StrToInt();
|
|
Конвертация
строки в вещественный тип данных
|
atof();
|
StrToFloat();
|
|
Округление
значения
|
ceil();
|
Round();
|
|
Получение
целой части вещественной переменной
|
Truncate()
|
Trunc();
|
|
Возведение
в степень
|
pow(x, y);
|
Power(x, y);
|
|
Возвращение
абсолютной величины числа
|
abs();
|
abs();
|
|
Вычисление
длины строки
|
Strlen();
|
Length();
|
Различия можно заметить не только в самих типах
данных, но и в работе с переменными. Для создания переменной в C++ нужно
написать тип имя переменной. В Delphi же, создание переменной выглядит так: имя
переменной, двоеточие, имя типа. Более того, в С++ переменную можно объявить в
любом месте программы, а в Delphi
Только в разделе var.
Для присваивания в C++ используется знак =, в Delphi - :=. Операция
присваивания в обоих языках программирования берёт то, что находится справа от
знака и помещает это в переменную, находящуюся слева от знака присваивания.
Рассмотрим же основные операции для работы с
переменными простых типов данных. В таблице 1.3 приведено сравнение их в языках
C++ и Delphi.
Таблица 1.3 - Основные операции
|
Операция
|
C/C++
|
Delphi
|
|
Сложение
|
+
|
+
|
|
Вычитание
|
-
|
-
|
|
Умножение
|
*
|
*
|
|
Деление(целочисленное,
простое)
|
/ (зависит от типа данных)
|
div, /
|
|
Остаток
от деления
|
%
|
mod
|
|
Присваивание
|
=
|
:=
|
|
Проверка
равенства
|
= =
|
=
|
|
Составное
сложение
|
+=
|
Отсутствует
|
|
Составное
вычитание
|
-=
|
Отсутствует
|
|
Составное
умножение
|
*=
|
Отсутствует
|
|
Составное
деление
|
/=
|
Отсутствует
|
%=
|
Отсутствует
|
|
Инкремент
|
++
|
Inc()
|
|
Декремент
|
--
|
Dec()
|
|
Больше
|
>
|
>
|
|
Меньше
|
<
|
<
|
|
Не
равно
|
!=
|
< >
|
|
Логическое
НЕ
|
!
|
not
|
|
Больше
либо равно
|
>=
|
>=
|
|
Меньше
либо равно
|
<=
|
<=
|
|
Логическое
ИЛИ
|
||
|
or
|
|
Логическое
И
|
&&
|
and
|
|
Логическое
исключающее ИЛИ
|
xor
|
xor
|
|
Указатель
|
*
|
^
|
|
Указатель
структуры
|
- >
|
^
|
|
Определение
размера в байтах
|
sizeof();
|
SizeOf();
|
|
Поразрядное
НЕ
|
~
|
not
|
|
Поразрядное
И
|
&
|
and
|
|
Поразрядное
ИЛИ
|
|
|
or
|
|
Поразрядное
исключающее ИЛИ
|
^
|
xor
|
|
Поразрядный
сдвиг влево
|
<<
|
shl
|
|
Поразрядный
сдвиг вправо
|
>>
|
shr
|
При сравнении операторов можно заметить явный
недостаток Delphi, который
проявляется в отсутствии составных операций (>=, <=, +=, -=, *=, /=, %=).
.2 Структурные
типы данных
Теперь перейдем к сравнению структурных типов
данных. Структурные типы имеют в своей основе один или более других типов, в
том числе и структурных. К структурным типам относятся:
1. Строки;
2. Массивы;
3. Множества;
4. Записи;
5. Файлы;
.2.1 Строковые
переменные
В Delphi строки
обеспечивает тип string, который представляет строку с максимальной длиной
около 2х
символов.
Символы строки кодируются в коде ANSI. Так как строки фактически являются
массивами символов, то для обращения к отдельному символу строки можно указать
название строковой переменной и номер (позицию) этого символа в квадратных
скобках, например, strName [i].
В С++ существует 2 типа строк: массив переменных
типа char и специальный класс string. В отличии от типа char, string является
классом. Это объясняет необходимость подключения заголовочного файла <String>
и наличие множества функций для работы с переменной типа String.
Доступ к элементу строки так же можно получить через его номер в строке,
указанном в квадратных скобках. Например, strName [i].
.2.2 Массивы
Массивы в сравниваемых языках схожи. Элементами
массива могут быть данные различных типов, включая структурированные. Каждый
элемент массива однозначно определяется именем массива и индексом (номером
этого элемента в массиве) или индексами, если массив многомерный. Для обращения
к отдельному элементу массива указываются имя этого массива и номер (номера)
элемента, заключенный в квадратные скобки. Однако, в Delphi,
описание массива производится в разделе описания типов данных, тогда как в C++
- в любой точке программы.
.2.3 Множества
Типы данных «множества» аналогичны перечислимым
и интервальным типам данных, однако переменные множественных типов могут иметь
несколько значений из описанного перечисления в каждый момент времени работы
программы, причем каждое значение не может присутствовать в множестве дважды в
одно и то же время. Описание переменной множественного типа на Delphi
выглядит следующим образом:
<Переменная>: Set Of <Тип>;
На C++:
set<Тип>
<Переменная>;
В C++ Set (множество) - это ассоциативный
контейнер STL, хранящий отсортированный набор уникальных объектов. Контейнер
set содержит множество элементов. Строго говоря, set обеспечивает следующую
функциональность:
1. Добавить элемент в рассматриваемое
множество, при этом исключая возможность появления дублей;
2. Удалить элемент из множества;
. Узнать количество (различных) элементов
в контейнере;
. Проверить, присутствует ли в контейнере
некоторый элемент.
1.2.4 Файлы
Файлом называют способ хранения информации на
физическом устройстве. В C++ отсутствуют операторы для работы с файлами. Все
необходимые действия выполняются с помощью функций, включенных в стандартную
библиотеку. Работа с файлами в C++
и в Delphi похожа, и
складывается из трех шагов:
1. Файл
открывается. Это означает, что программа "захватывает" заданный по
имени файл, сообщает Windows, что далее она будет с ним работать. Данный шаг
нужен, чтобы не возникало конфликтов, когда несколько программ одновременно
хотят записывать информацию в один и тот же файл. Правда, считывать данные из
файла, очевидно, допустимо одновременно множеством программ, поэтому в операции
открытия файла обычно уточняется, что файл открывается "на чтение"
(считывание информации, которая не меняется) либо "на запись" (данные
в файле модифицируются).
Операция открытия файла возвращает некий
идентификатор (как правило, целое число), которое идентифицирует в программе в
дальнейшем нужный открытый файл. Этот идентификатор запоминается в переменной;
обычно такая переменная называется файловой переменной.
2. Ведется
работа с файлом. Из него данные либо считываются, либо в него записываются.
3. Файл
закрывается. После этой операции он снова доступен другим программам для
обработки.
В таблице 1.4 показано сравнение работы с
файлами в C++ и в Delphi.
Таблица 1.4 - сравнение работы с файлами в C++
и в Delphi
|
Действие
|
C++
|
Delphi
|
|
Объявление
файла
|
FILE
*идентификатор; Пример: FILE *f;
|
var
идентификатор: File ; Пример: Var F:File;
|
|
Открытие
файла
для
записи
|
fopen(имя
физического файла, “w”) Пример:
fopen(f, “w”);
|
AssignFile(имя
логического файла, название файла); ReWrite(имя
логического файла); Пример: AssignFile(myFile, 'Test.txt');
ReWrite(myFile);
|
|
Запись
в файл
|
fwrite(адрес
записываемой величины, размер одного экземпляра, количество записываемых
величин, имя логического файла); Пример:
fwrite(&dat, sizeof(int), 1, f);
|
WriteLn(имя
логического файла, текст); Пример: WriteLn(myFile, 'Hello
World');
|
|
Закрытие
файла
|
fclose(имя
логического файла); Пример: Fclose(f);
|
CloseFile(имя
логического файла); Пример: CloseFile(myFile);
|
|
Открытие
файла для чтения
|
fopen(имя
физического файла, “r”) Пример: fopen(s,
"r");
|
Reset(myFile);
|
|
Чтение
из файла
|
fread(адрес
величины, размер одного экземпляра, количество считываемых величин, имя
логического файла); Пример: fread(&dat, sizeof(int), 1,
f);
|
ReadLn(имя
логического файла, переменная для считывания); Пример:
ReadLn(myFile, text);
|
|
Проверка
на конец файла
|
eof
|
Eof
|
|
Открытие
текстового файла, для добавления записей в файл (добавляет в конец файла)
|
fopen(имя
физического файла, “a”) Пример: fopen(s,
"a");
|
Append(имя
логического файла); Пример: Append(myFile);
|
1.2.5 Классы
Механизм классов в C++ позволяет пользователям
определять собственные типы данных. По этой причине их часто называют
пользовательскими типами. Класс может наделять дополнительной функциональностью
уже существующий тип.
Определение класса в C++
состоит из двух частей: заголовка, включающего ключевое слово class, за которым
следует имя класса, и тела, заключенного в фигурные скобки. После такого
определения должны стоять точка с запятой:
class
ClassA { /* ... */ };
Внутри тела объявляются данные-члены и
функции-члены и указываются уровни доступа к ним. Таким образом, тело класса
определяет список его членов. Каждое определение вводит новый тип данных. Даже
если два класса имеют одинаковые списки членов, они все равно считаются разными
типами. После того как тип класса определен, на него можно ссылаться двумя
способами:
1. написать ключевое слово class, а после
него - имя класса;
2. указать только имя класса.
Оба способа сослаться на тип класса
эквивалентны. Первый заимствован из языка C и остается корректным методом
задания типа класса, а второй введен в C++ для упрощения объявлений.
Функции-члены класса объявляются в его теле. Это
объявление выглядит точно так же, как объявление функции в области видимости
пространства имен.
Функции-члены отличаются от обычных функций
следующим:
1. Функция-член
объявлена в области видимости своего класса, следовательно, ее имя не видно за
пределами этой области. К функции-члену можно обратиться с помощью одного из
операторов доступа к членам - точки (.) или стрелки (->):
ptrScreen->home();.home();
2. Функции-члены
имеют право доступа как к открытым, так и к закрытым членам класса, тогда как
обычным функциям доступны лишь открытые. Конечно, функции-члены одного класса,
как правило, не имеют доступа к данным-членам другого класса.
В Delphi
описание классов разделено на две части - интерфейсную («заголовочную») и
описательную. В интерфейсной части располагается заголовок класса, в котором
указываются название класса, идентифицирующее его в программе, а также описания
свойств и заголовков методов. В описательной части располагается программный
код (реализация) методов, заголовки которых указаны в интерфейсной части
описания класса. Интерфейсная часть описания класса располагается в разделах
описания типов данных модулей и основных частей программ. Выглядит она
следующим образом:
Туре
<Имя класса> = class {Заголовок описания}
<Имя свойства 1>: <Тип свойства 1>;
{Описание свойства 1}
<Имя свойства М>: <Тип свойства N>;
{Описание свойства N}
<Заголовок метода 1>; {Описание метода 1}
<Заголовок метода М>; {Описание метода М};
<Имя класса>.<Имя метода>(<Список
параметров>);
или для методов-функций:
<Имя класса>.<Имя метода>(<Список
параметров>):
<Тип значения>;
Отличие методов от обычных процедур и функций
состоит в том, что они могут обращаться к свойствам классов по имени без указания
объектов. На этапе выполнения программы такие обращения будут перенаправлены к
свойствам объектов, из которых вызываются соответствующие методы.
В таблице 1.5 показано сравнение парадигм
объектно-ориентированного программирования на языках программирования C++
и Delphi на примерах.
Таблица 1.5 - Сравнение парадигм ООП в C++
и Delphi
|
Наименование
парадигмы
|
C++
|
Delphi
|
|
Инкапсуляция
|
class
A { public: int a, b; //данные открытого интерфейса int ReturnSomething();
//метод открытого интерфейса private: int Aa, Ab; //скрытые данные
void DoSomething(); //скрытый метод };
|
TMyClass = class private FMyField:
Integer; procedure SetMyField(const Value: Integer); function GetMyField:
Integer; protected public property MyField: Integer read GetMyField write
SetMyField; end;
|
|
Наследование
|
class
A{ //базовый класс }; class B : public A{ //public наследование
}; class C : protected A{ //protected наследование
}; class Z : private A{ //private наследование };
|
Предок:
TAncestor = class private protected public // Виртуальная процедура
procedure VirtualProcedure; virtual; abstract; procedure StaticProcedure;
end; Наследник:
TDescendant = class(TAncestor) private protected public // Перекрытие виртуальной процедуры
procedure VirtualProcedure; override; procedure StaticProcedure; end;
|
|
Полиморфизм
|
class A { public: A() { f(); } //Перегруженная
функция virtual
void f()
{
std::cout << "A::f"; } }; class B : public A { public:
//Перегруженная функция void f() { std::cout <<
"B::f"; } };
|
Type // базовый класс
A=class fname:string; constructor Create(name:string); function f: string;
virtual; end;
// производный от базового B=class(A) fgr:integer;
constructor Create(name:string;gr:integer); // Перегруженная функция function
f: string; override; end; // производный от базового C=class(A) fdep:string;
constructor Create(name:string;dep:string); // Перегруженная функция function
f: string; override; end;
|
Подробное описание понятия инкапсуляции связано
с понятием области видимости идентификатора. Область видимости идентификатора
(имени переменной, процедуры, функции или типа данных) - это часть программного
кода, в которой возможен доступ к этому идентификатору. Область видимости
идентификатора компонента, объявленного в описании класса, простирается от его
объявления до конца определения класса, а также распространяется на все потомки
этого класса и на все блоки реализации методов класса. Область видимости
идентификатора компонента зависит от атрибута видимости раздела, в котором
объявлен идентификатор.
В таблице 1.6 приведены атрибуты видимости в Delphi
и в C++.
Таблица 1.6 - Атрибуты видимости
|
Атрибут
видимости
|
C++
|
Delphi
|
|
Private- доступ
открыт самому классу (т.е. функциям-членам данного класса)
|
+
|
+
|
|
Protected - доступ
открыт классам, производным от данного
|
+
|
+
|
|
Public- доступ
открыт всем, кто видит определение данного класса
|
+
|
+
|
|
Published - Поля,
свойства и методы, описанные в данном разделе, называются опубликованными. Их
область видимости эквивалентна области видимости общедоступных описаний.
Отличие состоит в том, что информация о них, за исключением ряда типов,
например real, на этапе проектирования программы помещается в инспектор
объектов. Описания, расположенные сразу после заголовка класса, при
включенной директиве компилятора {$M+}, по умолчанию принимаются
опубликованными.
|
-
|
+
|
1.3 Указатели
Указатель (пойнтер, англ. pointer) - переменная,
диапазон значений которой состоит из адресов ячеек памяти и специального
значения - нулевого адреса. Значение нулевого адреса не является реальным
адресом и используется только для обозначения того, что указатель в данный
момент не может использоваться для обращения ни к какой ячейке памяти.
Указатели применяются в двух различных сферах.
Во-первых, они позволяют использовать некоторые выгоды косвенной адресации,
широко применяемой в программировании на языках ассемблера. Во-вторых,
указатели предлагают метод динамического управления памятью: их можно
использовать для доступа к области с динамическим размещением памяти, обычно
называемой кучей, или динамической памятью.
Переменные, размещаемые в куче, называются
динамическими. Часто они не содержат связанных с ними идентификаторов, и
ссылаться на них можно только с помощью указателей и ссылок.
И C++
и Delphi содержат, две
основные операции над указателями: присваивание и разыменование. Первая из этих
операций присваивает указателю некоторый адрес. Вторая служит для обращения к
значению в памяти, на которое указывает указатель.
При объявлении переменной типа указатель в C++,
необходимо определить тип объекта данных, адрес которых будет содержать
переменная, и имя указателя с предшествующей звездочкой (или группой
звездочек). Формат объявления указателя:
спецификатор-типа [ модификатор ] * описатель .
Спецификатор-типа задает тип объекта и может
быть любого основного типа, типа структуры, смеси (об этом будет сказано ниже).
Задавая вместо спецификатора-типа ключевое слово void, можно своеобразным
образом отсрочить спецификацию типа, на который ссылается указатель.
Переменная, объявляемая как указатель на тип void, может быть использована для
ссылки на объект любого типа. Однако для того, чтобы можно было выполнить
арифметические и логические операции над указателями или над объектами, на
которые они указывают, необходимо при выполнении каждой операции явно
определить тип объектов. Такие определения типов может быть выполнено с помощью
операции приведения типов.
В качестве модификаторов при объявлении
указателя могут выступать ключевые слова const, near, far, huge. Ключевое слово
const указывает, что указатель не может быть изменен в программе. Размер
переменной объявленной как указатель, зависит от архитектуры компьютера и от
используемой модели памяти, для которой будет компилироваться программа.
Указатели на различные типы данных не обязательно должны иметь одинаковую
длину.
Для модификации размера указателя можно
использовать ключевые слова near, far, huge.
Ниже, приведены некоторые примеры объявления
указателей на C++.
unsigned int * a;* x;* fuffer
;nomer;*addres; = & nomer;
(double
*)addres ++;
Переменная addres
объявлена как указатель на объект любого типа. Поэтому ей можно присвоить адрес
любого объекта (& - операция вычисления адреса). Однако, ни одна
арифметическая операция не может быть выполнена над указателем, пока не будет
явно определен тип данных, на которые он указывает. Это можно сделать,
используя операцию приведения типа (double *) для преобразования addres к
указателю на тип double, а затем увеличение адреса.
В Delphi
существует 2 вида указателей: типизированные и нетипизированные.
Нетипизированный указатель представляет собой переменную, в которой хранится
адрес некоторой области памяти некоторого размера, и предназначен для хранения
произвольных данных. Типизированные ссылки указывают на место в памяти, где
хранятся данные определенного типа.
Переменные - нетипизированные указатели
описываются с указанием типа Pointer, а выделение и освобождение памяти под них
осуществляется, соответсвенно, командами GetMem и FreeMem . Использование
нетипизированных указателей ограничено стандартными функциями, принимающими такие
переменные в качестве параметров, а также низкоуровневым программированием.
Для описания типизированной ссылки не
предусмотрен какой-либо специальный тип данных, в отличие от нетипизированных
указателей, имеющих тип Pointer. Поскольку ссылочная переменная такого рода
всегда указывает на данные конкретного типа, то ее описание и строится на
основе этого типа. Для указания на ссылочную природу переменных используется
оператор «^», и описание выглядит следующим
образом:<Переменная>:^<Название типа>;
Или в разделе описания типов данных:
Туре <Новый тип данных> =^<Тип
данных>;
После описания переменной-указателя под нее
выделяется память только для хранения адреса, а под сами данные, на которые
переменная указывает, память не выделяется. Для инициализации переменной
используется процедура New, отличием которой от аналогичной процедуры GetMem,
используемой для работы с нетипизированными указателями, является отсутствие
второго параметра, определяющего размер выделяемой памяти. Это связано с тем,
что типизированная ссылка указывает на данные известного типа, соответственно,
размер этих данных также известен компилятору.
В таблице 1.7 приведены некоторые отличия
синтаксисов C++ и Delphi
в области указателей.
Таблица 1.6 - Отличие указателей в C++ и Delphi
|
Наименование
|
C++
|
Delphi
|
|
Разыменование
|
*
|
^
|
|
Возвращение
адреса
|
&
|
@
|
|
Нулевой
указатель
|
NULL
|
|
Указатель
на указатель
|
**p;
|
P:^Char; F:^P;
|
Как мы видим, есть некоторые отличия в работе с
указателями и адресами в C++
и в Delphi, однако
общая структура работы с ними свойственна обоим языкам.
2. СРАВНЕНИЕ СРЕД РАЗРАБОТКИ
2.1 Borland
Delphi 7
После загрузки среды программирования Delphi
7, на экране появится главное окно.
Верхнюю часть окна занимает меню и панель
инструментов. В левой части окна находятся Object
TreeView и Object
Inspector. В центре
находится форма разрабатываемого приложения и форма для внесения кода.
Object
TreeView - служит для
отображения всех объектов расположенных на текущей форме разрабатываемого
проекта.
Object
Inspector - служит для
отображения и редактирование свойств компонентов расположенных на форме
разрабатываемого приложения.
Проект - это совокупность файлов, которые
используются средой разработки для итоговой генерации программы. Когда мы будем
создавать с вами первый проект, то познакомимся со всеми составляющими проекта
и его структурой.
Теперь рассмотрим состав главного меню. Оно
позволяет вызывать все инструменты, необходимые для работы с проектом. Ниже
приведены назначение раздела меню и связанные с ними функции:
File - содержит набор
команд для работы с файлами, позволяет создавать новые проекты, добавлять новые
файлы в проект на основе различных шаблонов, переименовывать файлы проекта, а
также распечатывать их. Сюда же включена команда закрытия среды разработки;
Edit - здесь, в соответствии
с названием, расположены команды, предназначенные для редактирования текста,
удаления и перемещения его в буфер обмена, вставки текста из буфера и отмены
операций редактировании. Search
- содержит набор команд для работы с текстом, его поиска и замены, причем и то
и другое может производится как в одном файле, так и во всех файлах проекта,
либо в любом каталоге и его подкаталогах;
View - под этим
названием объединены команды вызова инструмента управления проектом, такие как
инспектор объектов, конструктор форм, менеджер проектов и т.д.;
Project
- предназначен для того чтобы добавлять и удалять модули проекта, сохранять
проект, добавлять проекты в группу и убирать их из неё, компилировать как
отдельные проекты, так и все проекты в группе, загружать файл самого проекта в
редактор кода, а также вызывать диалог настройки свойств проекта;
Run - позволяет
запускать проект на выполнение как под отладчиком, так и без него,
конфигурировать строку параметров проекта при запуске, производить отладку,
задать точки останова, осуществлять пошаговое выполнение кода, просматривать
значения переменных и изменять их;
Component
- здесь сосредоточены команды, предназначенные для установки новых компонентов
и пакетов компонентов и создания новых компонентов и шаблонов компонентов;
Database
- здесь сосредоточены команды управления базами дынных;
Tools - позволяет
настраивать свойства рабочей среды Delphi
и отладчика, произвести настройки репозитория, добавлять и удалять
дополнительные утилиты, а так же команды запуска этих самых утилит;
Window - позволяет
переключаться между окнами, если вы отроете какой - либо модуль для
редактирования в новом окне;
Help -
объединяет команды вызова справочной системы Delphi
и её настройки, а так же позволяет обратиться к Web-ресурсам
компании Borland
для получения дополнительной информации.
Можно вручную настроить панель инструментов. Это
было сделано для удобства работы. Для этого нужно вызвать диалоговое окно по
ссылке View-Toolbars-Customize.
Процесс компиляции состоит из двух этапов. На
первом этапе выполняется проверка текста программы на отсутствие ошибок, на
втором - генерируется исполняемая программа (ехе-файл).
После ввода текста функции обработки события и
сохранения проекта можно из меню Project выбрать команду Compile и выполнить
компиляцию. Процесс и результат компиляции отражаются в диалоговом окне
Compiling (РИС. В38). В это окно компилятор выводит ошибки (Errors),
предупреждений (warnings) и подсказок (Hints). Сами сообщения об ошибках,
предупреждения и подсказки отображаются в нижней части окна редактора кода
На рисунке 2.1 изображено главное окно среды
разработки Delphi 7.
Рисунок 2.1 - Главное окно Delpi
7
2.2 Microsoft Visual C++
В семействе продуктов Visual Studio используется
единая интегрированная среда разработки (IDE), состоящая из нескольких
элементов: строки меню, панели инструментов Стандартная, различных закрепленных
или автоматически скрываемых окон инструментов в левой, нижней или правой
областях, а также области редакторов. Набор доступных окон инструментов, меню и
панелей инструментов зависит от типа проекта или файла, в котором выполняется
разработка.
Рисунок 1. Начальная страница MV
C++
Расположение окон инструментов и других
элементов интегрированной среды разработки может изменяться в зависимости от
примененных параметров и настроек, выполняемых пользователем в процессе работы.
Параметры можно изменить с помощью средства Import and Export Settings Wizard.
Выбрав параметр Сбросить все параметры, можно изменить язык программирования по
умолчанию.
Можно легко перемещать и закреплять
окна с помощью визуального направляющего ромба или временно скрывать окна с
помощью функции автоскрытия. Дополнительные сведения см. в разделе Практическое
руководство.