Особенности работы программ для Windows

Особенности работы программ для Windows

Изначально программирование было делом простым. Даже если программа создавалась на языке ассемблера, то ее структура ничем не отличалась, скажем, от Бейсика, Паскаля или Си.Программа начиналась сначала и продолжалась до конца, а всякие переходы к подпрограммам и прямые переходы по Goto были на совести самих программистов. Менялись парадигмы программирования, стиль, но это не мешало писать программы так, как нравится.Но вот появилось ООП, за ним Windows, и стало ясно, что теперь программы в десяток строк можно забыть. А что делается внутри системы – один Гейтс знает. Постепенно популяризаторы сделали свое дело, и оказалось, что достаточно уяснить себе несколько важных моментов в технологии Windows, и все становится более-менее понятным. К примеру то, что ООП и Windows особо между собой не связаны, что и демонстрируют программисты, создавая программы на ассемблере для Win32. Если это пугает, то можно начать работу с FASM – там попроще будет.

Новые форматы программ – NE и PE – сделали структуру программ очень простой. Грубо говоря, теперь в них отсутствуют всяческие программные хитрости, а образ программы на диске собран из готовых кусков, загружаемых в память по своим адресам. Каждая программа четко сообщает о себе все сведения, включая данные ресурсов, списки импорта и экспорта внешних имен и библиотек. Так, просто взяв из таблицы список, можно с уверенностью сказать, что программа просит у Windows. Сам код тоже стал проще. Во-первых, в него почти не добавились новые команды процессоров. Во-вторых, многочисленные вызовы функций системы организованы по методу стека, то есть вся программа буквально пронизана вызовами внешних функций, за исключением циклов и вычисления выражений. Хакеры даже умудряются заменять в коде на диске одни функции на другие – иногда получается весело. Хотя в памяти это сделать еще проще. Если смотреть на технологию обработки событий, то там тоже нет ничего ужасного. Просто нужно привыкнуть, что программа во время исполнения работает в зацикленном режиме, постоянно слушая команды Windows, поступающие ко всем окнам и процессам. Если программа понимает, что команда касается ее, она должна как-то отреагировать - для этого и вызывается программа обработки события. После этого программа дальше занимается своими делами. А можно, кстати, и вовсе игнорировать всякие интересные события, включив только обработку кнопок и меню. Так, например, по умолчанию работают с системами Delphi, VС++ и прочими системами. Единственное, что трудно воспринимать – это иерархия классов, и то только потому, что там слишком много возможностей, чтобы сходу запомнить, но можно работать вовсе без них.

 

3. Переменные. Типы переменных

 

Типы переменных. Объявление переменных.
Константы. Присваивание. Арифметические операции.
Инкремент и декремент.

 

Переменные

 

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

Давая переменной имя, программист одновременно тем же именем называет и область памяти, куда будут записываться значения переменной для хранения.

Хорошим стилем является осмысленное именование переменных. Имя переменной может содержать от одного до 32 символов. Разрешается использовать строчные и прописные буквы, цифры и символ подчёркивания, который в Си считается буквой. Первым символом обязательно должна быть буква. Имя переменной не может совпадать с зарезервированными словами.

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

При объявлении переменной компилятор отводит ей место в памяти в зависимости от её типа. Стандартными средствами AVR GCC работает с типами данных char (символьный тип) и int (целочисленный тип).

Типы переменных

 

Тип char

char - является самым экономным типом. Тип char может быть знаковым и беззнаковым. Обозначается, соответственно, как " signed char " (знаковый тип) и " unsigned char " (беззнаковый тип). Знаковый тип может хранить значения в диапазоне от -128 до +127. Беззнаковый - от 0 до 255. Под переменную типа char отводится 1 байт памяти (8 бит).

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

Тип int

Целочисленная величина int может быть short (короткой) или long (длинной).

Ключевое слово (модификатор) short ставится после ключевых слов signed или unsigned. Таким образом, различают следующие типы: signed short int, unsigned short int, signed long int, unsigned long int.

Переменная типа signed short int (знаковая короткая целая) может принимать значения от -32768 до +32767, unsigned short int (беззнаковая короткая целая) - от 0 до 65535. Под каждую из них отводится ровно по два байта памяти (16 бит).

При объявлении переменной типа signed short int ключевые слова signed и short могут быть пропущены, и такой тип переменной может быть объявлен просто int. Допускается и объявление этого типа одним ключевым словом short.

Переменная unsigned short int может быть объявлена как unsigned int или unsigned short.

Под каждую величину signed long int или unsigned long int отводится 4 байта памяти (32 бита). Значения переменных этого типа могут находиться в интервалах от -2147483648 до 2147483647 и от 0 до 4294967295 соответственно.

Существуют также переменные типа long long int, для которых отводится 8 байт памяти (64 бита). Они также могут быть знаковыми и беззнаковыми. Для знакового типа диапазон значений лежит в пределах от -9223372036854775808 до 9223372036854775807, для беззнакового - от 0 до 18446744073709551615. Знаковый тип может быть объявлен и просто двумя ключевыми словами long long.

Тип	Диапазон	Шестнадцатиричный диапазон	Размер
unsigned char	0... 255	0x00... 0xFF	8 bit
signed char или просто char	-128... 127	-0x80... 0x7F	8 bit
unsigned short int или просто unsigned int или unsigned short	0... 65535	0x0000... 0xFFFF	16 bit
signed short int или signed int или просто short или int	-32768... 32767	0x8000... 0x7FFF	16 bit
unsigned long int или просто unsigned long	0... 4294967295	0x00000000... 0xFFFFFFFF	32 bit
signed long или просто long	-2147483648... 2147483647	0x80000000... 0x7FFFFFFF	32 bit
unsigned long long	0... 18446744073709551615	0x0000000000000000... 0xFFFFFFFFFFFFFFFF	64 bit
signed long long или просто long long	-9223372036854775808... 9223372036854775807	0x8000000000000000... 0x7FFFFFFFFFFFFFFF	64 bit

 

Объявление переменных

 

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

Объявление переменной имеет следующий формат:

[модификаторы] спецификатор_типа идентификатор [, идентификатор]...

Модификаторы - ключевые слова signed, unsigned, short, long.
Спецификатор типа - ключевое слово char или int, определяющее тип объявляемой переменной.
Идентификатор - имя переменной.

Пример:

char x;

int a, b, c;

unsigned long long y;

Таким образом, будут объявлены переменные x, a, b, c, y. В переменную x можно будет записывать значения от -128 до 127. В переменные a, b, c - от -32768 до +32767. В переменную y - от 0 до 18446744073709551615.

Оператор присваивания

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

переменная:= выражение;

Знак:= читается как "присвоить".

Оператор присваивания работает следующим образом: сначала вычисляется выражение, стоящее справа от знака:=, затем результат записывается в переменную, стоящую слева от знака. Например, после выполнения оператора

k:=k+2;

текущее значение переменной k увеличится на 2.

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

Приведем примеры.

1. Записать оператор присваивания, который позволяет вычислить расстояние между двумя точками на плоскости с координатами (x 1, y 1) и (x 2, y 2).

Оператор будет иметь вид

d:=sqrt(sqr(x1-x2)+sqr(y1-y2));

2. Записать последовательность операторов присваивания, обеспечивающих обмен значениями переменных x и y в памяти компьютера.

c:=x; x:=y; y:=c;

Здесь с -- дополнительная переменная того же типа, что x и y, через которую осуществляется обмен. Грубой ошибкой было бы, например, попытаться выполнить обмен операторами x:=y; y:=x; -- ведь уже после первого из них мы имеем два значения y, а исходное значение x потеряно.

 

Оператор ввода

Базовая форма оператора ввода позволяет пользователю ввести с клавиатуры значения одной или нескольких переменных. Оператор ввода с клавиатуры может быть записан в одной из следующих форм:

read(список_переменных);

readln(список_переменных);

Имена переменных в списке перечисляются через запятую. Здесь и далее список данных, передаваемых любому оператору (а позднее и написанным нами подпрограммам), мы будем называть параметрами. Таким образом, параметрами оператора (точней, стандартной процедуры) read являются имена переменных, описанных ранее в разделе var.

По достижении оператора ввода выполнение программы останавливается и ожидается ввод данных пользователем. Вводимые значения переменных разделяются пробелом или переводом строки (нажатием Enter). После ввода значений всех переменных из списка работа программы продолжается со следующего оператора.

Оператор readln отличается от read только тем, что все переменные должны быть введены в одну строку экрана, клавиша Enter нажимается один раз по окончании ввода. Форма записи readln используется, в основном, для ввода строк текста, для ввода числовых значений лучше использовать read, т. к. в этом случае пользователь может вводить данные более свободно (и в одну, и в несколько строк экрана).

Если пользователь вводит данные недопустимого типа (например, строку текста вместо числа), то выводится системное сообщение об ошибке и работа программы прерывается.

В качестве примера организуем ввод исходных данных для решения квадратного уравнения:

var a,b,c:real;

...

read (a,b,c);

Для задания значений a=1, b=4, c=2.5 на экране вводится:

1_4_2.5

Здесь и далее "_" означает пробел, а "" -- нажатие Enter. Другой вариант ввода с клавиатуры:

2.5

Третий вариант:

4_2.5

Во всех вариантах пробелов может быть и несколько, лишние будут проигнорированы оператором.

Как правило, перед оператором ввода ставится оператор вывода, служащий приглашением к вводу и поясняющий пользователю, что именно следует сделать (см. п. 4.3).

 

Оператор вывода

Базовая форма оператора вывода позволяет отобразить на экране значения переменных, АВ или констант, а также строки текста в апострофах. Оператор записывается в одной из следующих форм:

write(список);

writeln(список);

Элементы списка перечисляются через запятую.

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

Оператор writeln отличается от write тем, что после вывода значения последнего элемента списка выполняется перевод курсора на следующую строку экрана.

Приведем примеры.

1. Нужно дать пользователю возможность ввести с клавиатуры число, затем программа возведет это число в квадрат и выведет результат на экран.

var a,a2:integer;

...

writeln ('Введите целое число:');

{это приглашение к вводу}

read (a);

a2:=sqr(a);

writeln ('Квадрат числа=',a2);

Если ввести значение a=2, на экране будет напечатано

Квадрат числа=4

|

Символ |здесь и далее обозначает курсор. Видно, что оператор writeln перевел курсор на следующую строку.

После вывода результата выполнение программы продолжится, а если оператор writeln был в ней последним, то и завершится. Чтобы пользователь успел прочитать результат, следует в конце программы добавить оператор

readln;

который будет ждать нажатия клавиши Enter.

2. Требуется вывести на экран результаты решения квадратного уравнения: значения x1=1.5 и x2=2.5:

write ('x1=',x1,'_x2=',x2);

Пробел в строкой константе '_x2=' нужен, чтобы значение x1 не слилось со строкой 'x2='. На экране будет напечатано:

x1= 1.5000000000E+00 x2= 2.5000000000E+00|

Курсор остался в конце строки, т.к. использована форма оператора write.

Вещественные числа читать в подобной форме неудобно, для их вывода используйте решение из следующего раздела.

 

5. Оператор сравнения.Простые и сложные условия

 

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

Операторы сравнения
Пример	Название	Результат
$a == $b	Равно	TRUE если $a равно $b после преобразования типов.
$a === $b	Тождественно равно	TRUE если $a равно $b и имеет тот же тип.
$a!= $b	Не равно	TRUE если $a не равно $b после преобразования типов.
$a <> $b	Не равно	TRUE если $a не равно $b после преобразования типов.
$a!== $b	Тождественно не равно	TRUE если $a не равно $b или они разных типов.
$a < $b	Меньше	TRUE если $a строго меньше $b.
$a > $b	Больше	TRUE если $a строго больше $b.
$a <= $b	Меньше или равно	TRUE если $a меньше или равно $b.
$a >= $b	Больше или равно	TRUE если $a больше или равно $b.

В случае, если вы сравниваете число со строкой или две строки, содержащие числа, каждая строка будет преобразована в число, и сравниваться они будут как числа. Эти правила также распространяются на оператор switch. Преобразование типов не происходит при использовании === или!== так как в этом случае кроме самих значений сравниваются еще и типы.

<?php
var_dump(0 == "a"); // 0 == 0 -> true
var_dump("1" == "01"); // 1 == 1 -> true
var_dump("10" == "1e1"); // 10 == 10 -> true
var_dump(100 == "1e2"); // 100 == 100 -> true

switch ("a") {
case 0:
echo "0";
break;
case "a": // Эта ветка никогда не будет достигнута, так как "a" уже сопоставленно с 0
echo "a";
break;
}
?>

Для различных типов сравнение происходит в соответствии со следующей таблицей (по порядку).

Сравнение различных типов
Тип операнда 1	Тип операнда 2	Результат
null илиstring	string	NULL преобразуется в "", числовое или лексическое сравнение
bool или null	что угодно	Преобразуется в bool, FALSE < TRUE
object	object	Встроенные классы могут определять свои собственные правила сравнения, объекты разных классов не сравниваются, объекты одного класса - сравниваются свойства тем же способом, что и в массивах (PHP 4), в PHP 5 есть свое собственное объяснение
string,resourceили number	string,resourceили number	Строки и ресурсы переводятся в числа, обычная математика
array	array	Массивы с меньшим числом элементов считаются меньше, если ключ из первого операнда не найден во втором операнде - массивы не могут сравниваться, иначе идет сравнение соответствующих значений (смотри пример ниже)
array	что угодно	array всегда больше
object	что угодно	object всегда больше

Пример #1 Алгоритм сравнения обычных массивов

<?php
// Так сравниваются массивы при сравнении стандартными операторами
function standard_array_compare($op1, $op2)
{
if (count($op1) < count($op2)) {
return -1; // $op1 < $op2
} elseif (count($op1) > count($op2)) {
return 1; // $op1 > $op2
}
foreach ($op1 as $key => $val) {
if (!array_key_exists($key, $op2)) {
return null; // не могут быть сравнимы
} elseif ($val < $op2[$key]) {
return -1;
} elseif ($val > $op2[$key]) {
return 1;
}
}
return 0; // $op1 == $op2
}
?>

Одной из основных алгоритмических структур является ветвление (альтернатива).
Если условие выполняется, то будет выполнена инструкция "1", если нет, то - инструкция "2". Несмотря на то, что в схеме присутствуют два действия, выполнено будет только одно, так как условие либо ложно, либо истинно. Третьего не дано. Такая схема позволяет решать задачи, в которых в зависимости от сложившихся обстоятельств требуется совершить то или иное действие. Нет никакого сомнения, что число задач такого рода огромно. Более того, очень сложно придумать реально значимое задание, алгоритм выполнения которого содержал бы в себе простое прямое следование команд. Даже примитивный пример, взятый из курса математики, как вы увидите, не может быть решен без использования ветвления. Итак, необходимо вычислить значение выражения y=1/x. Вам известно, что данная функция не всегда имеет значение, то есть не для всех значений аргумента существует значение результата. Наша задача так составить алгоритм, чтобы исполнитель ни в коем случае не встал в тупик, даже при получении нуля в качестве аргумента. Сформулировать это на естественном языке не трудно:
1. Получить значение x.
2. Если x=0, то сообщить, что выражение значения не имеет, иначе - вычислить y как 1/x.
Таким образом используется приведенная выше алгоритмическая структура. Она может быть выражена простыми словами:
Если <усл.> {Если выполняется условие}
то <действие 1> {то выполнить действие № 1 }
иначе <действие 2> {иначе - выполнить действие № 2 }
все
Как это записать на Паскале? Да точно так же, только по-английски.
Формат условного оператора на языке Паскаль:

If <условие>
Then <оператор 1>
Else <оператор 2>;
Обратите внимание на то, что в Then- и Else- части стоит только один оператор. Но что делать, чтобы решить задачу, в которой по выполнению или невыполнению условия нужно совершить не одно, а несколько действий? Здесь приходит на помощь уже известный вам составной оператор. В операторные скобки можно заключить любое количество операторов.
Вариант условного оператора в этом случае:
If <условие>
Then Begin <группа операторов 1> end
Else Begin < группа операторов 2> end;
Знак "точка с запятой" не ставится перед служебным словом Else, но операторы в группах, естественно, отделяются друг от друга этим знаком.
Теперь поговорим об условиях. В программах на языке Паскаль условия представляют собой выражения, значением которых является величина логического (Boolean) типа. Это может быть как просто переменная указанного типа, так и сложная последовательность высказываний, связанных логическими операциями.
В простых условиях могут применяться знаки операций сравнения: >(больше), <(меньше), =(равно), <>(не равно), >=(больше или равно), <=(меньше или равно).
Примеры простых условий:
A=5 {Значение переменной А равно 5}
(C+D3)>=(D1*(45-2)) {Значение выражения в левой части больше либо равно значению выражения из правой части}
S<>'ABC' {Значение переменной S не равно строковой константе 'ABC'}
Приведем пример решения еще одной задачи: "Из двух чисел выбрать наибольшее".
На первый взгляд решение очевидно, но оно не столь тривиально, как кажется.
Program Example;
Var A,B,C: Real; {A,B - для хранения аргументов, C - результат}
Begin
Writeln('Введите два числа');
Readln(A,B); {Вводим аргументы с клавиатуры}
If A>B Then C:=A Else C:=B; {Если A>B, то результат - A, иначе результат - B}
Writeln(C); {Выводим результат на экран}
End.
Еще один классический пример: "По заданным коэффициентам решить квадратное уравнение". Эта задача сложнее, поэтому перед тем как писать программу составим алгоритм, записав его в виде блок-схемы.Сначала вводим коэффициенты, затем вычисляем дискриминант. Теперь возникает две возможности: либо отсутствие действительных корней в случае отрицательного дискриминанта, либо эти корни можно все-таки вычислить и вывести на экран в случае неотрицательного дискриминанта (случай равенства дискриминанта нулю входит сюда же, корней - два, только они одинаковые J).
При записи алгоритма на языке программирования следует учесть, что в ветви "нет" не одно действие, а три, поэтому следует применить составной оператор. Арифметические выражения не забывайте записывать в соответствии с правилами языка Паскаль. В остальном, эта программа не сложнее предыдущей.
Program Sq1;
Var A, B, C, D, X1, X2: Real;
Begin
Writeln ('Введите коэффициенты квадратного уравнения');
Readln (A,B,C);
D:=B*B-4*A*C;
If D<0 Then Writeln ('Корней нет! ')
Else
Begin
X1:=(-B+SQRT(D))/2/A;
X2:=(-B-SQRT(D))/2/A;
Writeln ('X1=', X1:8:3, ' X2=',X2:8:3)
End
End.
Интересно, что в качестве оператора, который выполняется по выполнению или невыполнению условия, может выступать условный же оператор. В этом случае говорят о вложенности условных операторов. Я настоятельно рекомендую при решении такого рода задач составлять блок-схему алгоритма в тетради. Только потом, при составлении программы, вам остается лишь аккуратно прописывать сначала всю Then- часть, а затем переходить к Else- части. Обычно при записи условных операторов на языке Паскаль (особенно при множественных ветвлениях) команды записывают уступом вправо и вниз. Это повышает наглядность, и, поверьте, снижает потери времени на отладку.
Для иллюстрации решим еще одну задачу: "решить уравнение вида A*x^2 + B*x + C = 0". Прошу не путать с квадратным уравнением, для которого нам было известно, что коэффициент А не равен нулю. Здесь же коэффициенты могут быть любыми числами. Исходя из элементарных математических рассуждений, получаем следующий алгоритм:
Program Sq2;
Var A, B, C, D, X, X1, X2: Real;
Begin
Writeln ('Введите коэффициенты уравнения (A, B, C) ');
If A=0 Then
If B=0 Then
If C=0 Then Writeln('X - любое число')
Else Writeln('Корней нет! ')
Else Begin X:=-C/B; Writeln('X=',X:8:3) End
Else
Begin
D:=B*B-4*A*C;
If D<0 Then Writeln ('Корней нет! ')
Else
Begin
X1:=(-B+SQRT(D))/2/A;
X2:=(-B-SQRT(D))/2/A;
Writeln ('X1=', X1:8:3, ' X2=',X2:8:3)
End
End
End.
Выбор вариантов
Существуют условия, которые имеют много вариантов, в зависимости от которых необходимо выполнить то или иное действие, например: при вводе месяца необходимо вывести сезон, которому соответствует данный месяц. В паскале есть специальный оператор выбора case, который оформляется следующим образом:
case mesiac of
'Декабрь','Январь','Февраль': writeln('Зима');
'Март','Апрель','Май': writeln('Весна');
'Июнь','Июль','Август': writeln('Лето');
'Сентябрь','Октябрь','Ноябрь': writeln('Осень');
else wrteln('Такого месяца не существует!');
end;
Где в операторе перечисляются все варианты для которых выполняются те или иные действия, оператор else выполняет действия если операнд имеет значение, которое не перечислено в case.
Сложные условия (связки)
Повествовательное предложение, о котором можно сказать верно оно или нет называют высказыванием. Например:
Сегодня вторник.
Идёт дождь.
Небо может быть голубым или серым.
Число может быть чётным.
Завтра будет не среда.
Высказывания могут объединяться с помощью слов (операций) И, Или, НЕ. Эти операции называют логическими операциями. Объединённые высказывания называют связками. Например:
Сегодня вторник и идёт дождь.
Число может быть чётным или нечётным.
Завтра будет не вторник.
Логическую операцию И(AND) обозначают ^, операцию ИЛИ(OR) V, отрицание НЕ(NOT) ---.
Верность или неверность связки двух высказываний (истинность) определяют по правилам истинности.


Например: Определить истинно или ложно следующее высказывание:
not ((4>8) and (5<7))

4>8	ложно
5<7	истинно
(4>8) and (5<7)	ложно
not ((4>8) and (5<7))	истинно

Итак высказывание истинно.

ОРГАНИЗАЦИЯ ВЕТВЛЕНИЙ В ПРОГРАММАХ НА ПАСКАЛЕ. ОПЕРАТОР IF THEN... ELSE
Формат оператора:
IF условие THEN оператор 1 ELSE оператор 2;
Правило работы:
1. Проверяется условие.
2. Если условие истинно, то выполняется оператор1
3. Если условие ложно, то выполняется оператор2.
Допустим сокращенный формат записи оператора:
IF условие THEN оператор 1;
Правило работы:
1. Проверяется условие.
2. Если условие истинно, то выполняется оператор1.
3. Если условие ложно, то выполняется оператор следующий после IF.
Под условием понимается логическое (булевское) выражение.
ЛОГИЧЕСКОЕ ВЫРАЖЕНИЕ - это выражение, которое принимает значение TRUE(истина) или FALSE(ложь), и включает в себя арифметические выражения, связанные операциями отношения и логическими операциями.
ОПЕРАЦИИ ОТНОШЕНИЯ:
> больше
>= больше или равно
< меньше
<= меньше или равно
= равно
<> неравно
Имеют один и тот же приоритет и соединяют два выражения одного и того же типа. Результатом любой операции сравнения является значение TRUE или FALSE.
ЛОГИЧЕСКИЕ ОПЕРАЦИИ:: NOT - НЕ; AND - И; OR - ИЛИ
ПОРЯДОК ВЫПОЛНЕНИЯ ОПЕРАЦИЙ:
1. - (унарный минус, т.е. отрицание числа) NOT
2. * / DIV MOD AND
3. + - OR
4. < <= > >= = <>
Оператор ветвления (условный оператор)
Формат оператора:
If условие THEN
оператор1
ELSE оператор2;
где условие - логическое выражение (т.е. в него обязательно входит знак отношения, и можно определить, истинно выражение или ложно)
оператор1 - любой оператор Паскаля; этот оператор исполняется, когда условие истинно;
оператор2 - любой оператор Паскаля, в том числе и условный; этот оператор исполняется, когда условие ложно.
Выполнение оператора:
При выполнении этого оператора сначала вычисляется значение условия.
Если условие истинно (true), то выполняется оператор после слова THEN, а оператор2 пропускается;
если условие ложно (false), то оператор1 пропускается, а выполняется оператор после слова ELSE.
Примеры:

if x > 0 then
y:=sqrt(x
else write ('Решений нет');
Операторы 1 и 2 могут быть любыми, в том числе и условными. В этом случае их называют вложенными.
Примеры:
if x > 0 then
y:=sqrt(x
else
if x <= -3 then
y:=sqr(x)
else write ('Решений нет');
Краткая форма условного оператора
Части ELSE оператор2 может и не быть, тогда формат оператора:
If условие THEN оператор1;
Выполнение оператора:
Если условие истинно, то выполняется оператор после слова THEN, а иначе он пропускается.
Примеры:
if abs(x) >= 5 then
y:=exp(3*ln(x))
Составной оператор
В условном операторе после слов THEN и ELSE можно помещать по несколько операторов. В этом случае их надо объединить в СОСТАВНОЙ оператор, который начинается словом BEGIN и заканчивается словом END; (на конце не точка, а точка с запятой!)
Примеры
Составить программу, которая перераспределит заданные значения x, y так, что в х окажется большее значение, а в y - меньшее.
program PRMAX;
var x, y, z: real;
begin
write ('Введите два числа: ');
read (x, y);
if x < y then
begin z:=x;
x:=y;
y:=z
end;
writeln ('x =', x, 'y=', y);
end.
Сложное условие
После слова IF допускается:
конъюнкция условий (условия связываются при помощи логической операции and),
дизъюнкция условий (условия связываются при помощи логической операции or);
инверсия условий (отрицание условия not)
Примеры:
Выяснить, принадлежит ли точка с координатами (x, y) кольцу с центром в точке (0, 0), внешним радиусом r1 и внутренним радиусом r2
program PRcir;
var x, y, r1, r2: real;
begin
write ('Введите координаты точки: ');
read (x, y);
writeln ('Введите радиусы r1, r2:: ');
read (r1, r2);
if (sqrt(sqr(x)+sqr(y))<r1) and (sqrt(sqr(x)+sqr(y))>r2) then
writeln ('Точка принадлежит кольцу');
else writeln ('Точка не принадлежит кольцу');
end.

 

6. Оператор цикла for

 

Выполнение оператора цикла for начинается с вычисления "выражения1". Это своего рода инициализация цикла, которая выполняется только один раз и предшествует последующим действиям.

После этого вычисляется "выражение2". Если оно истинно, то выполняется "оператор". Далее вычисляется "выражение3". Первая итерация цикла закончена. Вторая итерация начинается опять с вычисления "выражения2". Если оно истинно, то выполняется "оператор". Далее опять вычисляется "выражение3" и так продолжается до тех пор, пока "выражение2" будет истинным. Если же уже на первой итерации "выражение2" будет ложным, то цикл не исполнится ни разу.

Если вникнуть в логику работы оператора цикла for, то можно заметить, что она полностью соответствует следующему фрагменту кода с использование оператора цикла while:

выражение1;
while (выражение2)
{
оператор;
выражение3;
}

 

7. Оператор цикла while

 

Формат оператора цикла while:

while (выражение)
оператор;

Каждый раз перед выполнением "оператора" будет проверяться значение "выражения". Если "выражение" истинно, то "оператор" будет выполнен. Далее "выражение" проверяется еще раз. Если оно опять истинно, то "оператор" будет выполнен еще раз. И так будет продолжаться до тех пор, пока "выражение" будет равно true. Как только выражение станет ложным, произойдет выход из цикла и управление будет передано оператору, следующему за циклом while.

Цикл while может быть не выполнен ни разу, если "выражение" изначально (при первой проверке) было ложным.

Если требуется, чтобы в теле цикла выполнялся не один оператор, а несколько, нужно использоватьсоставной оператор, т.е. заключить несколько операторов в фигурные скобки {}. После закрывающей фигурной скобки } не должно стоять точки с запятой.

К сожалению, в нашем первом эксперте я не использую цикл while, поэтому пример его использования мне придется просто придумать:

int i = 0;
while (i < 9)
{
Print(i);
i++;
}
Print ("Done");

При первой проверке "выражение" (i<9) будет истинным (т.к. 0<9) и будет выполнен составной оператор, который состоит из функции Print (вывода информации в журнал экспертов), которая выведет число 0 в журнал, и из оператора i++, который увеличивает переменную i на единицу.

Далее выражение i<9 будет вычислено еще раз. На этот раз оно опять будет истинным. В результате в лог файл будет выведено текущее значение переменной i (т.е. 1), а после этого значение переменной будет опять увеличено на единицу и станет равным 2. Цикл будет повторяться до тех пор, пока значение переменной i не станет равным 9. Тогда выражение i<9 перестанет быть истинным и цикл прервется, а управление будет передано следующему оператору:

Print ("Done");

 

8. Процедуры и функции

 

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

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

В языке Паскаль имеется два вида подпрограмм - процедуры и функции.

Процедуры и функции помещаются в раздел описаний программы. Для обмена информацией между процедурами и функциями и другими блоками программы существует механизм входных и выходных параметров. Входными параметрами называют величины, передающиеся из вызывающего блока в подпрограмму (исходные данные для подпрограммы), а выходными - передающиеся из подрограммы в вызывающий блок (результаты работы подпрограммы).

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

 

назад содержание вперед

Выбор шрифтов

Шрифты просто оставьте в покое. Заданные по умолчанию самой Delphi шрифты подойдут для любой системы, на которой может работать Ваша программа. Полужирный шрифт используйте только для выделения важных элементов. Применение же курсива и особенно подчёркивания, которое пользователь может принять за гиперссылку - дурной тон.

Выбор цветов

Что касается цветов элементов интерфейса, то также, как и в случае со шрифтами, лучше оставьте их стандартными, по умолчанию. Delphi использует системную палитру Windows, и пользователь, изменив её, легко настроит цвета под себя.

Альтернативное управление

Профессионально сделанная программа должна иметь возможность управляться не только мышкой, но и с клавиатуры. Не должно быть функций, доступных выполнению только мышью (рисование в графических редакторах не в счёт!). Для наиболее используемых функций следует предусмотреть "горячие клавиши" для их быстрого вызова.

Кирпичики интерфейса

Что касается конкретных элементов интефейса пользователя, то качество взаимодействия пользователя с программой зависит от:

• соответствия элемента управления выполняемой им задаче;
• правил, по которым функционирует элемент управления.
  На этой страничке рассматриваются правила создания некоторых элементов интерфейса.

А сейчас хочу показать, какие инструменты предлагает Delphi для управления компонентами на Форме, их взаимным расположением и поведением курсора при нажатии клавиши Tab.

Для того, чтобы расположить относительно друг друга компоненты в правильном порядке, сначала необходимо их выделить. Можно просто обвести мышкой область на Форме, в которой содержатся выбранные компоненты. Или, удерживая " Shift ", указать той же мышкой каждый подлежащий выделению компонент. Повторный щелчок мышкой по выделенному компоненту (при нажатом " Shift ") снимает с него выделение.

Выделенными компонентами можно управлять как единым целым - передвигать по Форме, присвоить значение одинаковым свойствам, скопировать (для установки, например, на другую Форму), даже удалить.

 

Выделение мышкой области с компонентами:

Что такое e-mail адрес