11.Условная инструкция. Условный оператор. Пример.

Условный оператор if используется для выбора одного из двух вариантов вычислений.

Синтаксис оператора

if (выражение) S1; [else S2;]

где S1, S2 – операторы или блоки.

Сначала вычисляется выражение, которое может иметь логический, арифметический тип или тип указателя. Если оно не равно нулю (имеет значение true), выполняется S1, иначе – S2. После этого управление передается на оператор, следующий за условным.

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

Примеры

cin>>a>>x>>y;

/*1)*/ if(а<0) b = 1;else b=0;

/*2)*/ if(а<0) {b = 1;c=1;} else {b=0;c=0;}

/*3)*/ if(а<0) a= -a;

/*4)*/ if(а!=0) b = a; else b=1;

/*5)*/ if(а) b = a; else b=1;

/*6)*/ if(a>=x&&a<=y) cout<<” a принадлежит [x,y]”;

else cout<< “a не принадлежит [x,y]”;

Примеры 4 и 5 идентичны.

Распространенная ошибка при записи условных операторов – это использование в выражениях вместо проверки на равенство (==) простого присваивания (=), например,

if (a = 1) b = 0;

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

12. Оператор множественного выбора. Пример. Управление оператором множественного выбора с помощью оператора break.

Оператор switch (переключатель) предназначен для разветвления процесса вычислений на несколько направлений.

Формат оператора

switch (выражение){

case константное_выражение_1: [список_операторов_1]

case константное_выражение_2: [список_операторов_2]

…

case константное_выражение_n: [список_операторов_n]

[default: операторы ] }

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

Выход из переключателя обычно выполняется с помощью операторов break. Оператор break выполняет выход из самого внутреннего из объемлющих его операторов switch, for, while, do. Все константные выражения должны иметь разные значения, но быть одного и того же целочисленного типа. Несколько меток могут следовать подряд. Если совпадения не произошло, выполняются операторы, расположенные после слова default (а при его отсутствии управление передается следующему за switch оператору).

Пример (программа реализует простейший калькулятор на четыре действия):

#include <iostream.h>

int main(){

int а, b, res;

char op;

cout << "\nВведите 1й операнд: "; cin >> а;

cout << "\nВведите знак операции: "; cin >> op;

cout << "\nВведите 2й операнд: "; cin >> b;

bool f = true;

switch(op){

саsе ' + ': res = а + b; break;

саsе ' - ': res = а - b; break;

саsе ' * ': res = а * b; break;

саsе ' / ': res = а / b; break;

default: cout << "\nНеизвестная операция";

f = false;

}

if (f) cout << "\nРезультат : " << res;

return 0;

}

Билет № 13 - 15. Циклические структуры. Цикл с предусловием/постусловием/фиксированным количеством итераций (с параметром for) . Примеры.

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

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

Исполнение любого цикла включает первоначальную инициализацию переменных цикла, проверку условия выхода, исполнение тела цикла и обновление переменной цикла на каждой итерации. Кроме того, большинство языков программирования предоставляют средства для досрочного управления циклом, например, операторы завершения цикла, то есть выхода из цикла независимо от истинности условия выхода (в языке Си — break) и операторы пропуска итерации (в языке Си — continue).

Цикл с предусловием

Цикл с предусловием — цикл, который выполняется пока истинно некоторое условие, указанное перед его началом. Это условие проверяется до выполнения тела цикла, поэтому тело может быть не выполнено ни разу (если условие с самого начала ложно). В большинстве процедурных языков программирования реализуется оператором while, отсюда его второе название — while-цикл.

На языке Си:

while(<условие>)

{

<тело цикла>

}

Пример: программа находит все делители целого положительного числа

#include <iostream.h>

int main() {

int num;

cout << "\n введите число : "; cin >> num;

int half = num / 2; // половина числа

int div = 2; // кандидат на делитель

while (div <= half) {

if (!num % div ) cout << div << "\n";

div ++;

}

return 0;

}

Цикл с постусловием

Цикл с постусловием — цикл, в котором условие проверяется после выполнения тела цикла. Отсюда следует, что тело всегда выполняется хотя бы один раз. В языке Си — do…while.

do

{

<тело цикла>

}

while(<условие продолжения цикла>)

Пример: программа осуществляет проверку ввода

#include <iostream.h>

int main () {

char answer;

do {

cout << "\n Купи слона! "; cin >> answer;

} while (answer !='y');

return 0;

}

Цикл с параметром for

Цикл с параметром имеет следующий формат:

for (инициализация; выражение ; модификации ) оператор ;

Инициализация используется для объявления и присвоения начальных значений величинам, используемым в цикле. В этой части можно записать несколько операторов, разделенных запятой (операцией "последовательное выполнение"), например, так:

for (int i=0; j=2; ...

int k, m;

for (k=1, m=0; ...

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

Выражение определяет условие выполнения цикла: если его результат, приведенный к типу bool , равен true, цикл выполняется. Цикл с параметром реализован как цикл с предусловием.

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

Пример : программа находит все делители целого положительного числа.

#include <isotream.h>

int main () {

int num, half, div;

for (half = num / 2, div = 2; div <= half ; div++)

if (!(num % div )) cout << div << "\n;

return 0; }

Билет № 16. Операторы перехода (break, return, continue). Примеры использования.

Оператор break

Оператор break применяется в двух случаях. Во-первых, в операторе switch с его помощью прерывается выполнение последовательности case (см. раздел "Оператор выбора — switch" ранее в этой главе). В этом случае оператор break не передает управление за пределы блока. Во-вторых, оператор break используется для немедленного прекращения выполнения цикла без проверки его условия, в этом случае оператор break передает управление оператору, следующему после оператора цикла.

Когда внутри цикла встречается оператор break, выполнение цикла безусловно (т.е. без проверки каких-либо условий.) прекращается и управление передается оператору, следующему за ним. Например, программа

#include <stdio.h>

int main(void)

{

int t;

for(t=0; t<100; t++) {

printf("%d ", t);

if(t==10) break;

}

return 0;

}

выводит на экран числа от 0 до 10. После этого выполнение цикла прекращается оператором break, условие t < 100 при этом игнорируется.

Оператор break часто используется в циклах, в которых некоторое событие должно вызвать немедленное прекращение выполнения цикла. В следующем примере нажатие клавиши прекращает выполнение функции look_up():

void look_up(char *name)

{

do {

/* поиск имени 'name' */

if(kbhit()) break;

} while(!found);

/* process match */

}

Библиотечная функция kbhit() возвращает 0, если клавиша не нажата (то есть, буфер клавиатуры пуст), в противном случае она возвращает ненулевое значение. В стандарте С функция kbhit() не определена, однако практически она поставляется почти с каждым компилятором (возможно, под несколько другим именем).

Оператор break вызывает выход только из внутреннего цикла. Например, программа

for(t=0; t<100; ++t) {

count = 1;

for(;;) {

printf("%d ", count);

count++;

if(count==10) break;

}

}

100 раз выводит на экран числа от 1 до 9. Оператор break передает управление внешнему циклу for.

Если оператор break присутствует внутри оператора switch, который вложен в какие-либо циклы, то break относится только к switch, выход из цикла не происходит.

Оператор continue

Можно сказать, что оператор continue немного похож на break. Оператор break вызывает прерывание цикла, a continue — прерывание текущей итерации цикла и осуществляет переход к следующей итерации. При этом все операторы до конца тела цикла пропускаются. В цикле for оператор continue вызывает выполнение операторов приращения и проверки условия цикла. В циклах while и do-while оператор continue передает управление операторам проверки условий цикла. В следующем примере программа подсчитывает количество пробелов в строке, введенной пользователем:

/* Подсчет количества пробелов */

#include <stdio.h>

int main(void)

{

char s[80], *str;

int space;

printf("Введите строку: ");

gets(s);

str = s;

for(space=0; *str; str++) {

if(*str != ' ') continue;

space++;

}

printf("%d пробелов\n", space);

return 0;

}

Каждый символ строки сравнивается с пробелом. Если сравниваемый символ не является пробелом, оператор continue передает управление в конец цикла for и выполняется следующая итерация. Если символ является пробелом, значение переменной space увеличивается на 1.

В следующем примере оператор continue применяется для выхода из цикла while путем передачи управления на условие цикла:

void code(void)

{

char done, ch;

done = 0;

while(!done) {

ch = getchar();

if(ch=='$') {

done = 1;

continue;

}

putchar(ch+1); /* печать следующего в алфавитном

порядке символа */

}

}

Функция code предназначена для кодирования сообщения путем замены каждого символа символом, код которого на 1 больше кода исходного символа в коде ASCII. Например, символ А заменяется символом В (если это латинские символы.). Функция прекращает работу при вводе символа $. При этом переменной done присваивается значение 1 и оператор continue передает управление на условие цикла, что и прекращает выполнение цикла.

Оператор return

Оператор return используется для выхода из функции. Отнесение его к категории операторов перехода обусловлено тем, что он заставляет программу перейти в точку вызова функции. Оператор return может иметь ассоциированное с ним значение, тогда при выполнении данного оператора это значение возвращается в качестве значения функции. В функциях типа void используется оператор return без значения.

Стандарт С89 допускает наличие оператора return без значения, даже если тип функции отличен от void. В этом случае функция возвращает неопределенное значение. Но что касается языков С99 и C++, если тип функции отличен от void, то ее оператор return обязательно должен иметь значение. Конечно, и в программе на С89 отсутствие возвращаемого значения в функции, тип которой отличен от void, является признаком плохого стиля!

Общая форма оператора return следующая:

return выражение;

Выражение присутствует только в том случае, если функция возвращает значение. Это значение выражения становится возвращаемым значением функции.

Внутри функции может присутствовать произвольное количество операторов return. Выход из функции происходит тогда, когда встречается один из них. Закрывающаяся фигурная скобка } также вызывает выход из функции. Выход программы на нее эквивалентен оператору return без значения. В этом случае функция, тип которой отличен от void, возвращает неопределенное значение.

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

Билет № 17-18. Регулярные структурированные типы. Одномерные массивы. Доступ к элементу массива. Примеры работы с одномерными массивами (ввод-вывод элементов, сумма/произведение элементов, преобразование элементов, добавление/удаление эл-тов, циклические сдвиги).

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

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

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

Если все элементы, образующие структуру, однотипны (например – целые числа или символы), то структура является однородной; если же в ней «перепутаны» элементы разной природы (например, числа чередуются с символами), то неоднородной.

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

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

Если у структуры размер (длина, количество элементов) не может быть изменен «на ходу», а фиксирован заранее, то такую структуру называют статической. Программные средства информатики иногда позволяют не фиксировать размер структуры, а устанавливать его по ходу решения задачи и менять при необходимости, что бывает очень удобно. Такую структуру называют динамической. Например, при описании закономерностей движения очереди в магазине мы не знаем заранее, сколько человек в ней будет в тот или иной момент, и соответствующую структуру данных (например, список фамилий участников очереди) лучше представлять динамической.

Массивы

Самым традиционным и широко известным из структурированных типов данных является массив (иначе называемый регулярным типом) – однородная упорядоченная статическая структура прямого доступа.

Массив это структура данных, представленная в виде группы ячеек одного типа, объединенных под одним единым именем. Массивы используются для обработки большого количества однотипных данных. Имя массива является указателем,   что такое указатели расскажу немного позже. Отдельная ячейка данных массива называется элементом массива.  Элементами массива могут быть  данные любого типа. Массивы могут иметь как одно, так и более одного измерений. В зависимости от количества измерений массивы делятся на одномерные массивы, двумерные массивы, трёхмерные массивы и так далее до n-мерного массива. Чаще всего в программировании используются одномерные и двумерные массивы, поэтому мы рассмотрим только эти  массивы.

Одномерные массивы в С++

Одномерный массив — массив, с одним параметром, характеризующим количество элементов одномерного массива. Фактически одномерный массив — это массив, у которого может быть только одна строка, и n-е количество столбцов. Столбцы в одномерном массиве — это элементы массива. На рисунке 1 показана структура целочисленного одномерного массива a. Размер этого массива — 16 ячеек.

Рисунок 1 — Массивы в С++

Заметьте, что максимальный индекс одномерного массива a равен 15, но размер массива 16 ячеек, потому что нумерация ячеек массива всегда начинается с 0. Индекс ячейки – это целое неотрицательное число, по которому можно обращаться к каждой ячейке массива и выполнять какие-либо действия над ней (ячейкой).

1 2 3 4

//синтаксис  объявления одномерного массива в С++: /*тип данных*/  /*имя одномерного массива*/[/*размерность одномерного массива*/]; //пример объявления одномерного массива, изображенного на рисунке 1: int a[16];

где, int - целочисленный тип данных;

        а -  имя одномерного массива; 16 — размер одномерного массива, 16 ячеек.

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

1 2	ещё один способ объявления одномерных массивов int mas[10], a[16];

Объявлены два одномерных массива  mas и а размерами 10 и 16 соответственно. Причём в таком способе объявления все массивы будут иметь одинаковый тип данных, в нашем случае - int.

1 2	// массивы могут быть инициализированы при объявлении: int a[16] = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // инициализация одномерного массива

Инициализация одномерного массива выполняется в фигурных скобках после знака равно, каждый элемент массива отделяется от предыдущего запятой.

1	int a[]={5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15}; // инициализация массива без определения его размера

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

В языке C массивы и указатели тесно связаны друг с другом. Например, когда объявляется массив в виде int a[25], то при этом не только выделяется память для 25 элементов массива, но и формируется указатель с именем a, значение которого равно адресу первого по счету (нулевого) элемента массива. Доступ к элементам массива может осуществляться через указатель с именем a. С точки зрения синтаксиса языка указатель a является константой, значение которой можно использовать в выражениях, но изменить это значение нельзя.

Поскольку имя массива является указателем-константой, допустимо, например, такое присваивание:

int a[25];

int *ptr;

ptr=a;

В этом примере в переменную-указатель ptr записывается адрес начала массива a, т. е. адрес первого элемента массива.

Также справедливы следующие соотношения: например, имеется массив a[N], тогда истинными будут следующие сравнения:

a==&a[0];

*a==a[0].

Указатели можно увеличивать или уменьшать на целое число:

ptr=a+1;

Теперь указатель ptr будет указывать на второй элемент массива a, что эквивалентно &a[1].

При увеличении указателя на единицу адрес, который он представляет, увеличивается на размер объекта связанного с ним типа, например:

int a[25];

int *ptr=a;

ptr+=3;

Первоначально указатель ptr указывал на начало массива a. После прибавления к переменной ptr числа 3 значение указателя увеличилось на 3*sizeof(int), а указатель ptr теперь будет указывать на четвертый элемент массива a. Указатель можно индексировать точно так же, как и массив. На самом деле компилятор преобразует индексацию в арифметику указателей, например, ptr[3]=10 представляется как *(ptr+3)=10.

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

Таким образом, в языке C для доступа к элементам массива существует два различных способа. Первый способ связан с использованием обычных индексных выражений в квадратных скобках, например, a[7]=3 или a[i+2]=5. При таком способе доступа записываются два выражения, причем второе выражение заключается в квадратные скобки. Первое из этих выражений должно быть указателем, а второе – выражением целого типа. Указатель, используемый в индексном выражении, не обязательно должен быть константой, указывающей на какой-либо массив, это может быть и переменная-указатель. В частности, после выполнения присваивания ptr=a доступ к седьмому элементу массива можно получить как с помощью константы-указателя a в форме a[7], так и переменной-указателя ptr в форме ptr[7].

Второй способ доступа к элементам массива связан с использованием адресных выражений и операции косвенной адресации в форме *(a+3)=10 или *(a+i+2)=5.

При реализации на компьютере первый способ приводится ко второму, т. е. индексное выражение приводится к адресному. Для приведенных примеров обращение к элементу массива a[3] преобразуется в *(a+3).

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

*a=2;

a[0]=2;

*(a+0)=2;

*ptr=2;

ptr[0]=2;

*(ptr+0)=2;

присваивает начальному элементу массива значение 2.

Ввод/вывод массива:

Сумма элементов массива:

#include<iostream.h>

#include<conio.h>

Const int n=10;

Void input (int w[n]){

Cout<<”input massive\n”;

For (int i=0; i<n; i++)

Cin>>w[i];}

Void Edition(int w[n]){

Int i, Sum=0;

For (i=0; i<n; i++)

Sum+=w[i];

Cout<<”Sum= “<<Sum;

Getch();

}

Void main(){

Int A[n];

Input(A); Edition(A);}

Произведение элементов:

#include<iostream.h>

#include<conio.h>

Const int n=5;

Void input (int w[n){

Cout<<”input massive\n”;

For (int i=0; i<n; i++)

Cin>>w[i][j]; }

Void Multiplication(int w[n]) {

Int i, Mult=0;

For (i=0; i<n; i++)

Mult=w[i][j]*w[i+1][j+1];

Cout<<”Mult= “<<Mult;

Getch();

}

удаление i-го элемента из массиво ( как в лечке ):

void delete (int *a, int & n, int i)

{ n - -;

for (int j=i; j<n ; j++)

a[j] = a[j+1]

}

добавление элемента после i-го

void add (int *a, int &n, int i)

{ for (int j=n-1; j<i; i++)

a[j+1]=a[j];

a[i+1] = rand ()%100 ; n++ } // вроде, увеличивает размер массива на случайное число до 100

Циклический сдвик на к позицию:

#include <stdio.h>

int main( int, char ** )

{

int * array; // массив

unsigned N; // размер

int k; // сдвиг

printf( "Input array size:\n" );

scanf( "%u", &N );

if ( N ) // Если размер массива ненулевой

{

array = new int[ N ]; // Создаём массив

// Читаем элементы массива

printf( "Input %u elements of array:\n", N );

for ( unsigned i = 0; i < N; ++i ) scanf( "%d", &array[ i ] );

// Размер сдвига

printf( "Input shift size:\n" );

scanf( "%u", &k );

// Вычисляем эквивалентный сдвиг

if ( k < 0 ) k += ( ( -k + N - 1 )/N )*N;

else k %= N;

if ( k ) // Если сдвиг есть

{

for ( int i = 0; i < k; ++i )

{

int temp = array[ N - 1 ];

for ( unsigned j = N - 1; j > 0; --j )

array[ j ] = array[ j - 1 ];

array[ 0 ] = temp;

}

}

// Разультат

printf( "Shifted array is:\n" );

for ( unsigned i = 0; i < N; ++i ) printf( "%d ", array[ i ] );

// Уничтожаем массив

delete [] array;

}

getchar();

return 0;

}

или менее верный, но более простой способ ( работает только вправо )

#include<conio.h>

#include<stdio.h>

#include<locale.h>

void main()

{

setlocale(LC_CTYPE, "Russian");

int k, i, A[100], N, f;

printf("введите размер массива: ");

scanf_s("%d", &N);

for (i=0; i<N; i++)

scanf_s ("%d", &A[i]);

printf ("введите k= ");

scanf_s ("%d", &k);

if(k>0){

while (k!=0)

{

i= N-1;

f= A[i];

for(i=N-1; i> 0; i--)

A[i]= A[i-1];

A[0]= f;

k--;

}

}

else

{

while (k!=0)

{

i= N+1;

f= A[i];

for (i=0; i< N-1; i++)

A[i]= A[i+1];

A[N]= f;

k++;

}

}

for (i= 0; i<N; i++)

printf ("%d ", A[i]);

_getch();

}