Оформление программы
Грамотно оформленная программа должна быть удобочитаема и иметь необходимые комментарии. В Delphi (Pascal) комментарии могут содержать русские буквы и должны начинаться с «//», например:
// Расчет положения прямоугольника на форме
В Borland C++ Builder комментарии оформляются аналогично.
Названия переменных и констант в программе должны иметь только английские буквы и цифры. Рекомендуется для удобства использовать английские слова. Возможно объединение нескольких слов (два - три) в одно без пробелов, каждое слово с большой буквы. Примеры названий переменных и констант приведены ниже.
Position // Позиция объекта на форме
Razmer // Размер прямоугольника
SpeedTelegka // Скорость тележки
Вложения одних частей программы в другие, такие как команды (тело) подпрограмм, блоки команд условных функций, циклов, выборки и т.д., необходимо показывать отступами с помощью пробелов или клавиши «Tab». Например, на языке Pascal:
| отступ |
begin
A:=A+i; // с помощью <Tab> показываем, что данная
// строка вложена в цикл for
end;
На языке C++:
| отступ |
{
A+=i; // с помощью <Tab> показываем, что данная
// строка вложена в цикл for
};
На приведенных выше примерах показаны логические скобки «begin-end;» и «{-};», обозначающие начало и конец вложения. Для улучшения восприятия программы рекомендуется эти логические скобки располагать на одном уровне вложения (одно расстояние с левой стороны).
Другие примеры оформления показаны далее в п. 1.3.
Переменные и константы
Типы
При выполнении программы всегда есть необходимость хранить какие-нибудь данные. Чаще всего данные хранятся либо в оперативной памяти компьютера, либо непосредственно в программе. В первом случае имеется возможность изменять значения этих данных в процессе выполнения программы. И такие ячейки называют «переменные». Во втором случае данные фиксированы и не могут быть изменены, поэтому их называют «константы».
Пользователь сам определяет, какие типы ячеек следует использовать в программе согласно логическому построению будущей программы. Если данные не будут изменяться, то их следует оформить как константы. Тем самым высвобождаются ресурсы оперативной памяти для других данных. Примером константы может быть число Pi, которое определено значением 3.14159265…
Как переменные, так и константы могут содержать различные типы данных. Название, размерность и объявления на языках Pascal и С++ наиболее часто употребляемых типов данных представлены в таблице 1.1.
Таблица 1.1 – Типы переменных
| Тип | Размер байт | Pascal (объявление) | С++ (объявление) |
| Целое без знака 0…255 | 1 | i:byte; | unsigned char i; |
| Целое без знака 0…65 535 | 2 | a:word; | unsigned short int a; unsigned short a; |
| Целое без знака 0… 4 294 967 295 | 4 | b:longword; | unsigned int b; |
| Целое -128…127 | 1 | i:shortint; | char i; |
| Целое -32 768..32 767 | 2 | a:smallint; | short int a; |
| Целое -2 147 483 648 …2 147 483 647 | 4 | b:longint; b:integer; | int b; |
| С плавающей запятой (десятичные дроби, 7 знаков) ±1.18∙10-38… ±3.4∙10+38 | 4 | c:single; | float c; |
| С плавающей запятой (десятичные дроби, 15 знаков) ±2.23∙10-308… ±1.79∙10+308 | 8 | d:real; d:double; | double d; |
| Логический False…True | 1 | f:boolean; | bool f; |
| Символ ‘0’, ‘a’, ‘D’,… | 1 | s:char; s:=’a’; // пример | char s; s=’a’; // пример |
| Строка символов | N | s:string; s:=’aBc’; // пример | AnsiString s; s=’aBc’; // пример |
Выбор того или иного типа переменной или константы осуществляется самим программистом исходя из поставленной задачи и характера данных, оперируемых программой.
Записи (структуры)
Для удобства восприятия многочисленных переменных их можно логически группировать в некую структуру с единым именем. Чаще всего группируются переменные, относящиеся к одному конкретному объекту, действию или событию. Например, для математического описания движения объекта «тележка мостового крана» необходимы следующие переменные:
- положение тележки относительно крана;
- скорость тележки;
- ускорение тележки.
Так как все переменные предназначены для хранения данных в виде десятичных дробей, например «1.25», (для повышения точности – целый тип в этом случае неприменим!), то тип переменных должен быть «real» или «double». Организация записи на языке Pascal в этом случае будет выглядеть следующим образом:
type // Служебное слово для обозначения
// пользовательского типа
TTelegka = record // Имя пользовательского типа TTelegka
// Служебное слово, обозначающее
// начало записи.
s: real; // 1-я переменная, позиция
v: real; // 2-я переменная, скорость
a: real; // 3-я переменная, ускорение
end; // конец записи
var // Служебное слово для обозначения
// списка пользовательских переменных
Telegka: TTelegka; // Переменная Telegka типа TTelegka
На языке C++:
typedef // Служебное слово для обозначения
// пользовательского типа
struct // Служебное слово, обозначающее
// начало структуры.
{
double s; // 1-я переменная, позиция
double v; // 2-я переменная, скорость
double a; // 3-я переменная, ускорение
} TTelegka; // Имя пользовательского типа TTelegka
TTelegka Telegka; // Определение переменной Telegka типа
// TTelegka
В приведенных выше примерах имя типа похоже на имя определяемой переменной за исключением буквы «T» в начале (от первой буквы служебного слова «Type»). Строго говоря, это требование не обязательное, так как имя типа и имя переменной могут совершенно не совпадать. Но для облегчения восприятия программы, когда это возможно, следует пользоваться данным правилом.
В самой программе доступ к той или иной переменной в записи (структуре) осуществляется следующим образом.
На языке Pascal:
Telegka.s:= 0; // Имя записи и переменной в этой записи
Telegka.s:= Telegka.s + Telegka.v * 0.01;
На языке C++:
Telegka.s = 0; // Имя записи и переменной в этой записи
Telegka.s = Telegka.s + Telegka.v * 0.01;
Массивы
Иногда для решения поставленной задачи необходимо обработать последовательность переменных одного и того же типа (массивы). Например, для моделирования передвижения нескольких объектов по конвейеру удобно эти объекты объединить в последовательность. Или же для обработки статистических данных, поступающих с какого-нибудь датчика, эти данные удобно расположить последовательно друг за другом. Позиция данных в этой последовательности будет определять время их считывания.
Типы данных, которые могут быть помещены в массивы, различны. Это могут быть и стандартные типы (таблица 1.1), и определенные пользователем, в том числе и записи (структуры).
Пример определения массивов на языке Pascal:
S: array [1..10] of integer; // Определение массива с
// именем S, состоящего из
// 10 элементов целого типа
// с индексами с 1 по 10
MTelegka: array [1..20] of TTelegka; // Определение массива с
// именем MTelegka, состоящего из
// 10 элементов типа TTelegka
// с индексами с 1 по 10
На языке C++:
int S[10]; // Определение массива с
// именем S, состоящего из
// 10 элементов целого типа
// с индексами с 0 по 9
TTelegka MTelegka[20]; // Определение массива с
// именем MTelegka, состоящего из
// 10 элементов типа TTelegka
// с индексами с 0 по 9
Доступ к конкретному элементу массива осуществляется с помощью индекса. На языке Pascal:
S[2]:= 10; // Элементу массива S c индексом 2
// присваивается значение 10
MTelegka[i].v:= 1.5; // Переменной v записи MTelegka с
// индексом по значению переменной i
// присваивается значение 1.5
На языке C++:
S[2] = 10; // Элементу массива S c индексом 2
// присваивается значение 10
MTelegka[i].v = 1.5; // Переменной v записи MTelegka с
// индексом по значению переменной i
// присваивается значение 1.5
Необходимо отметить, что на языке Pascal начальный индекс массива указывается пользователем и может быть любым. В то же время в C++ индекс массива всегда начинается с 0. Поэтому в этом случае максимальный индекс массива равен длине массива минус 1.
Локальные и глобальные переменные
Программа в общем случае состоит из набора процедур и функций, вызываемых при заранее определенных событиях, или пользователем при написании программы. В свою очередь каждую процедуру либо функцию можно рассматривать как отдельную программу со своим именем, своими переменными и константами. При этом имеет смысл разграничить области действия (и существования) некоторых переменных только в пределах этих подпрограмм. Например, если в конкретной подпрограмме используется переменная «i» в качестве счетчика цикла, то ее лучше объявить как локальную, действующую только в пределах этой подпрограммы. Тем самым экономится ОЗУ компьютера, так как переменная уничтожается при выходе из подпрограммы. С другой стороны, это же имя «i» можно будет использовать для объявления другой локальной переменной в другой подпрограмме. Если требуется хранение данных, доступных из любой подпрограммы пользовательской программы, то такие переменные объявляются глобальными и, соответственно, такое имя уже считается зарезервированным и недоступным для других переменных.
Пример объявления глобальных и локальных переменных и констант в программе в среде Delphi:
...
var
Form1: TForm1; // Объявление глобальной переменной
// Form1 – текущая форма программы
Revers: boolean; // Объявление глоб. переменной Revers
// логического типа
const
Pi: real = 3.14159265; // Объявление глобальной константы
// типа с плавающей запятой
implementation // Определяет внешнюю видимость этого
// модуля
{$R *.dfm}
// Процедура, вызываемая при нажатии кнопки Button1 на форме
procedure TForm1.Button1Click(Sender: TObject);
var
i: integer; // объявление локальной внутри процедуры
// переменной «i»
const
A: array [0..9] of char = ('0','1','2','3','4','5','6','7', '8','9'); // объявление локального массива констант
begin // начало процедуры
for i:=0 to 10 do
begin
end;
end; // конец процедуры
// Функция пользователя
function Polozenie ():real;
var
a,b,c:real; // объявление локальных внутри процедуры
i:integer; // переменных, в том числе «i»
begin // начало функции
end; // конец функции
На языке C++
TForm1 *Form1; // Объявление глобальной переменной
// Form1 – текущая форма программы
bool Revers; // Объявление глоб. переменной Revers
// логического типа
const double Pi = 3.14159265; // Объявление глобальной константы
// типа с плавающей запятой
//--------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//--------------------------------------------------------------
// Процедура, вызываемая при нажатии кнопки Button1 на форме
void __fastcall TForm1::Button1Click(TObject *Sender)
{ // начало функции
int i; // объявление локальной внутри процедуры
// переменной «i»
// объявление локального массива констант
const char A[10] = {'0','1','2','3','4','5','6','7','8','9'};
...
} // конец функции
//--------------------------------------------------------------
double Polozenie (void)
{ // начало функции
double a,b,c;
int i;
} // конец функции
Указатели
Существует определенный класс переменных, называемых указателями. Аналогом указателя можно назвать оглавление в книге. Для того, чтобы найти определенную информацию сначала читатель по оглавлению находит название главы, параграфа, подпункта. Затем по номеру страницы переходит непосредственно к тексту.
Указатель есть переменная, которая указывает, в каком месте памяти искать информацию. По другому, указатель хранит адрес в памяти, по которому находится начало информации. Таким образом, указателями удобно пользоваться для доступа к массивам однотипных данных.
На языке Pascal работа с указателями осуществляется следующим образом:
type MyIntPointer = ^Integer; // Объявление пользов. типа
// указатель на переменную
// целого типа
function Polozenie ():real;
var
i:integer;
k:MyIntPointer; // объявление указателя
P: ^TButton; // объявление указателя на объект «TButton»
begin
P:=@Form1.Button1; // определение адреса объекта «Button1»
P^.Visible:= True; // изменение свойства «Button1» с помощью
// указателя
k:=@i; // Определение адреса переменной «i»
k^:=10; // доступ к переменной «i» через указатель «k»
inc(k,2); // перемещение указателя вперед на 2 длины
// переменной целого типа, то есть доступ к
// другой переменной через указатель «k»
end;
Необходимо отметить, что при выполнении последней команды указатель указывает на несуществующую переменную. Если же выполнить операцию записи (присвоения) через указатель (например, k^:=5;), то это может привести к ошибке выполнения программы, или к порче информации.
На языке C++:
typedef int *MyIntPointer; // Объявление пользов. типа
// указатель на переменную
// целого типа
double Polozenie (void)
{
int i;
MyIntPointer k; // объявление указателя
TButton *P; // объявление указателя на объект «TButton»
P = Form1->Button1; // определение адреса объекта «Button1»
P->Visible = True; // изменение свойства «Button1» с помощью
// указателя
k = &i; // Определение адреса переменной «i»
*k = 10; // доступ к переменной «i» через указатель «k»
k += 2; // перемещение указателя вперед на 2 длины
// переменной целого типа, то есть доступ к
// другой переменной через указатель «k»
};
Необходимо отметить, что команда «P = Form1->Button1;» фактически копирует адрес объекта «Button1» в указатель «P». Дело в том, что на языке C++ доступ к объектам, помещаемым на форме, осуществляется только через указатели.
Команды
Для выполнения каких-либо действий над данными используются команды. Правильное написание команд, необходимые сопутствующие слова и порядок представления данных называют синтаксисом.
Список наиболее часто употребляемых команд, назначение и различие в синтаксисах на языке Pascal и C++ приведены в таблице 1.2.
Таблица 1.2 Список некоторых команд Pascal и C++
| N п/п | Pascal | С++ | ||
| 1 | Команда присвоения | |||
| := | = | |||
| A:=10; B:=B+1; D:=D-10; | A=10; B=B+1; B++; B+=1; D=D-10; D-=10; | |||
| 2 | Арифметические команды | |||
| + - / * div mod | сложение вычитание деление умножение целая часть от деления целого на целое остаток от деления целого на целое | + - / * (int) AAA/BBB % | сложение вычитание деление умножение целая часть от деления целого на целое остаток от деления целого на целое | |
| B:=D+C; A:=D div N; | B=D+C; A=(int) D/N; | |||
| 3 | Логические команды | |||
| and or not | логическое И логическое ИЛИ логическое отрицание | && || ! | логическое И логическое ИЛИ логическое отрицание | |
| not ((A and B) or (C and D)) | (!((A && B) || (C && D))) | |||
| 4 | Команды сравнения | |||
| > < = >= <= <> | больше меньше равно больше либо равно меньше либо равно не равно | > < == >= <= != | больше меньше равно больше либо равно меньше либо равно не равно | |
| (A = B) ((D <> C) and (N > 1)) | (A == B) ((D!= C) && (N > 1)) | |||
| 5 | Битовые команды | |||
| and or xor shl shr | побитовое И побитовое ИЛИ побитовое исключающее ИЛИ битовый сдвиг влево битовый сдвиг вправо | & | ^ << >> | побитовое И побитовое ИЛИ побитовое исключающее ИЛИ битовый сдвиг влево битовый сдвиг вправо | |
| A:=11; B:=21; C:=A or B; // C равно 31 C:=C shl 1; // C равно 62 | A=11; B=21; C=A | B; // C равно 31 C=C << 1; // C равно 62 | |||
| 6 | Условие (сравнение, ветвление) | |||
| if условие then begin // когда условие // выполняется end else begin // когда условие // не выполняется end; | if (условие) { // когда условие // выполняется } else { // когда условие // не выполняется }; | |||
| 7 | Выбор (переключатель) | |||
| case Переменная выбора of выбор1: begin // при равенстве // переменной выбора // выбор1 end; выбор2: begin // при равенстве // переменной выбора // выбор2 end; //... else begin // если ничего // не подошло end end; | switch (Переменная выбора) { case выбор1: // при равенстве // переменной выбора // выбор1 break; case выбор2: // при равенстве // переменной выбора // выбор2 break; //... default: // если ничего // не подошло }; | |||
| 8 | Безусловный переход | |||
| goto Метка; | goto Метка; | |||
| 9 | Цикл For | |||
| for Var:= Min to Max do begin // тело цикла end; | for (Var = Min; Var < Max; Var ++ ) { // тело цикла }; | |||
| for Var:= Max downto Min do begin // тело цикла end; | for (Var = Max; Var < Min; Var -- ) { // тело цикла }; | |||
| 10 | Цикл While | |||
| while условие выхода do begin // тело цикла end; | while (условие выхода) { // тело цикла }; | |||
