Создание программы циклической структуры. Работа с массивами

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Негосударственное образовательное учреждение

высшего профессионального образования

Московский технологический институт «ВТУ»

Факультет Техники и современных технологий

Кафедра Информатики и автоматизации

КУРСОВАЯ РАБОТА

по дисциплине Программирование на языке высокого уровня

на тему

«Создание программы циклической структуры. Работа с массивами»

Уровень образования бакалавриат

Направление Информатика и вычислительная техника

Профиль Сети ЭВМ и телекоммуникации

Выполнил студент:

Форма обучения экстернат

Койсин Дмитрий Борисович

Караганда 2013г.



Введение

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

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

Цель и задачи

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



Циклические алгоритмы на языке С++

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

В языке программирования С++ существуют такие циклы:

· цикл for

· цикл while

· цикл do…while

Цикл for

Цикл со счетчиком позволяет выполнить один или несколько операторов определенное количество раз. Синтаксис данного цикла:

for (начальная_инструкция; условие; выражение)

{

инструкции;

}

Семантика (смысл) цикла for такова, что сначала выполняется начальная_инструкция - она инициализует переменную, используемую в цикле. Затем проверяется условие. Если оно истинно, то выполняются инструкции, вычисляется выражение, и управление передается обратно в начало цикла for с той разницей, что начальная_инструкция уже не выполняется. Это продолжается до тех пор, пока условие не станет ложно, после чего управление передается следующей_инструкции. Каждый проход цикла называется итерацией цикла.

Начальной_инструкцией может быть просто объявление или же сложное выражение либо инструкция.

Цикл for является итерационной инструкцией, обычно используется с увеличивающейся либо уменьшающейся переменной. Например, в следующем коде инструкция for используется для сложения целых чисел от 1го до 10и:

rez=0;

for(int i=1; i<=10;++i)

rez+=i;

Когда инструкция for начинает выполняться, управляющей переменной i задается начальное значение 1. Затем проверяется условие продолжения цикла i <= 10. Поскольку начальное значение i равно 1, это условие удовлетворяется, так что оператор тела инструкции суммирует к значению переменной rez, равному 0, значение счетчика i, равное 1. Затем управляющая переменная i увеличивается на единицу в выражении ++i и цикл опять начинается с проверки условия его продолжения. Поскольку значение i теперь 2, предельная величина не превышена, так что программа снова выполняет тело цикла. Этот процесс продолжается, пока управляющая переменная i не увеличится до 11 -- это приведет к тому, что условие продолжения цикла нарушится и повторение прекратится. Выполнение программы продолжится с первого оператора, расположенного после цикла for.

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

for (j = 0,i = 1; i <= 10; ++i)

j += i;

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

for(i=0,j=0;i<3,j<`4;i++,j+=2)

cout<<i*j;

Данный цикл проведет две итерации, после которых значение счетчика i станет равным 2, а значение счетчика j = 4. При этом условие для второго счетчик не выполняется (т.к. j строго должен быть меньше 4) и цикл будет прерван. На экране будет выведено 02.

В цикле for может присутствовать локальное объявление переменной управления циклом, как в следующем примере.

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

rez+= i*i;

Целая переменная i теперь является объявленной в программе. Это может вносить путаницу, поэтому лучше объявлять все программные переменные в начале блока.

Любое или все выражения в инструкции for могут отсутствовать, но две точки с запятой должны быть обязательно. Если пропущена начальная_инструкция, то никакая инициализация в цикле for не выполняется. Если пропущено выражение, то не производится приращение, а в случае отсутствия условия не производится проверка. Есть специальное правило для тех случаев, когда пропущено условие; в такой ситуации компилятор будет считать условие выполненным всегда. Так, цикл for в следующем фрагменте бесконечен.

for (i = 1, rez = 0 ; ; rez += i++ )

cout << rez << endl;

Размещение точки с запятой сразу после правой закрывающей скобки заголовка for делает тело структуры пустым оператором. Обычно это логическая ошибка.

"Приращение” инструкции for может быть отрицательным (в этом случае в действительности происходит не приращение, а уменьшение переменной, управляющей циклом).

Если условие продолжения цикла с самого начала не удовлетворяется, то операторы тела инструкции for не выполняются и управление передается оператору, следующему за for.

Управляющая переменная иногда печатается или используется в вычислениях в теле инструкции for, но обычно это делается без изменений ее величины. Чаще управляющая переменная используется только для контроля числа повторений и никогда не упоминается в теле инструкции.

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

Давайте рассмотрим несколько вариантов применения цикла for:

a) Изменение управляющей переменной от 100 до 1 с шагом -1 (с уменьшением на 1).



for (int i = 100; i >= 1; i--)

Распространенная ошибка при программировании, это использование несоответствующей операции отношения в условии продолжения цикла при счете циклов сверху вниз (например, использование i <= 1 при счете циклов сверху до 1 не включая).

b) Изменение управляющей переменной от 7 до 77 с шагом 7.

for (int i = 0; i <= 77; i += 7)

c) Изменение управляющей переменной от 20 до 2 с шагом -2.

for (int i = 20; i >= 2; i -= 2)

d) Изменение управляющей переменной в следующей последовательности:

2, 5, 8, 11, 14.

for (int j = 2;j <= 14; j += 3)

e) Изменение управляющей переменной в следующей последовательности:

99, 88, 77, 66, 55, 44, 33, 22, 11, 0.

for (int j = 99; j >= 0; j -= 11)

Если мы скомпилируем этот код и запустим программу, то она покажет нам ответ: 500500. Это и есть сумма всех целых чисел от 1 до 1000. Если считать это вручную, понадобится очень много времени и сил. Цикл выполнил всю рутинную работу за нас.

Ниже на рисунке 1 отображен исходный код программы, считающей сумму всех целых чисел от 1 до 1000.

Рисунок 1- цикл for

Заметьте, что конечное значение счетчика я задал нестрогим неравенством ( <= -- меньше либо равно), поскольку, если бы я поставил знак меньше, то цикл произвел бы 999 итераций, т.е. на одну меньше, чем требуется. Это довольно важный момент, т.к. здесь часто допускают ошибки, особенно при работе с массивами. Значение шага цикла я задал равное единице. i++ -- это тоже самое, что и i = i + 1.

Цикл while

Когда мы не знаем, сколько итераций должен произвести цикл, нам понадобится цикл while или do...while. Циклический алгоритм while - является циклом с предисловием, а do…while - цикл с постусловием.

Оператор цикла while или цикл while - цикл, повторяющий одно и то же действие, пока условие продолжения цикла while остаётся истинным.

Синтаксис цикла while в C++ выглядит следующим образом.

// форма записи цикла while

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

{

/*блок операторов*/;

/*управление условием*/;

}

Условие продолжения цикла должно быть истинно - «true», как только условие стало ложным, выполняется выход из цикла. Вначале вычисляется выражение. Если результат отличен от нуля (true), тогда выполняется оператор и управление переходит обратно к началу цикла while. Это приводит к выполнению тела цикла while, а именно оператора, который будет выполняться до тех пор, пока выражение не станет равным нулю (false). Фигурные скобки могут опускаться в том случае, если тело цикла -- это один оператор. Но как правило в цикле выполняется несколько операторов, так как кроме выполнения полезного действия необходимо делать условие цикла while ложным, иначе цикл будет бесконечным, а это, в свою очередь, приведет к зависанию программы.

Если условие цикла ложно - управление передается следующему оператору. Таким образом, цикл может выполняться ноль или более раз.

Рассмотрим применение цикла while на примере движения автомобиля. На псевдокоде, то это будет так: Пока скорость движения автомобиля меньше 60 км/ч, продолжать наращивать скорость.

Истинным условием цикла, в данном случае, является скорость автомобиля меньше 60 км/ч, а ложным -- скорость автомобиля больше или равно 60 км/ч. Повторение цикла будет продолжаться до тех пор пока скорость автомобиля не станет больше или равно 60 км/ч, после наступления этого момента условие цикла станет ложным, и программа выйдет из цикла.

Рассмотрим фрагмент кода на C++ с циклом while решающим поставленную задачу.

1 int speed = 5; // начальная скорость автомобиля

2 while ( speed < 60 ) // заголовок цикла while

3 speed += 10; // тело цикла

Для начала в строке 1 была объявлена и инициализирована переменная speed. В строке 2 программа проверяет условие цикла while, 5 < 60 = true. Программа входит в цикл и выполняет оператор в строке 3. Теперь уже speed = 15. Опять выполняется проверка 15 < 60 = true. Условие истинно, значение в переменной изменяется, speed = 25. Таким образом, выполняются последовательные повторения цикла, переменная speed ещё принимает такие значения: 35, 45, 55, 65. Последнее изменение переменной speed приводит к тому, что условие в цикле while становится ложным 65 < 60 = false, и производится выход из цикла while. Таким образом, выполнилось 6 повторений, при этом speed = 65; - с таким значением переменной закончилась работа цикла while. Давайте запрограммируем эту задачу, и убедимся в достоверности всего выше сказанного (Рисунок 2).

Рисунок 2 - цикл while

Итак, в конце операторов цикла добавил переменную-счётчик, для подсчёта прохождений цикла. Тело цикла увеличилось, поэтому пришлось поставить фигурные скобочки. Результат работы программы (см. Рисунок 3).

Рисунок 3 - результат работы

Как я и говорил, всего 6 повторений цикла и после выхода из цикла while переменная speed = 65.

Рассмотрим еще один пример когда количество итераций нам не известно. Для этого примера используем игру «Отгадай число». Число будет загадывать компьютер, а мы отгадывать. На псевдокоде это будет так:

Пока загаданное число не угадано, продолжать угадывать его

Используя генератор случайных чисел, компьютер загадает число от 1 до 10, включительно, пока мы не отгадаем число - выход из цикла не произойдет. На рисунке 4 отображен код игры.

Рисунок 4 - код игры «угадай число»

Чтобы войти в цикл необходимо инициализировать переменную enter_number, тогда цикл while начнёт корректную проверку условия, вот для этого перед циклом while мы запрашиваем пользователя ввести число. После того как пользователь ввёл число, начинает работать цикл while, выйти из которого получится только в случае угадывания числа. Результат работы программы (см. Рисунок 5).

Рисунок 5 - результат работы

Цикл do…while

Цикл do…while отличается от цикла while тем, что в do…while сначала выполняется тело цикла, а затем проверяется условие продолжения цикла. Из-за такой особенности do…while называют циклом с «постусловием». Таким образом, если условие do…while заведомо ложное, то хотя бы один раз блок операторов в теле цикла do…while выполнится. В итоге do…while отличается от цикла while структурой. Если в while сначала выполняется проверка условия продолжения цикла, и если условие истинно, то только тогда выполняется тело цикла. Цикл do…while работает с точностью да наоборот, сначала выполняется тело цикла, а потом проверяется условие, вот почему тело цикла do…while, хотя бы раз, выполнится.

Синтаксис цикла do…while выглядит следующим образом:

// форма записи оператора цикла do while:

do // начало цикла do while

{

/*блок операторов*/;

}

while (/*условие выполнения цикла*/); // конец цикла do while

В начале цикла do…while пишется зарезервированное слово do, после идут фигурные скобки, которые можно опускать, в случае использования одного оператора в теле цикла do…while. После закрывающей фигурной скобки, обозначающей конец тела цикла do while, стоит условие цикла do…while, после которого обязательно нужно ставить точку с запятой. Рассмотрим программу с циклом do…while, которая выполняет некоторые транзакции с денежным счётом в банке. На рисунке 6 отображен код данной программы:

Рисунок 6 - код программы

Переменная balance, отвечает за остаток денежных средств на счету. Сразу после ее объявления - записан цикл do…while. В цикле do…while выполняются все транзакции со счётом balance, а именно -- перевод денежных средств на какой-то другой счёт, строка «balance -= removal;». Строка «cout << "balance = " << balance << endl;» показывает остаток денежных средств на счету balance. В строке «int removal = rand() % 3;» объявлена переменная, в которой хранится вычитаемое значение, причём это значение генерируется случайно в интервале [0;2]. Переменная removal один раз объявляется в теле цикла do…while, и каждый раз при повторении цикла эта переменная не переопределяется. А вот её значение меняется, в зависимости от того, какое число сгенерировалось. В строке «while ( balance > 0 );» записано условие цикла do…while, как только условие станет ложным, программа передаст управление следующему оператору, после цикла do…while. Результат работы программы показан на рисунке 7.

Рисунок 7 - результат работы

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

Так как while - цикл с предусловием, то нам необходимо было сначала считать число перед началом while, а потом уже выполнять проверку продолжения цикла while. В случае с do…while нам не нужно считывать число до начала цикла, так как проверка условия в do…while идет в конце цикла. В зависимости от ситуации, используется цикл while или do…while, они друг друга дополняют.

Вспомним игру «Угадай число». В этой задаче правильней было бы использовать цикл do…while, код уменьшится на две строки (Рисунок 8).

Рисунок 8 - игра «угадай число»

Специальные функции для циклов

В любом цикле мы можем использовать 2 специальные функции для работы с циклом:

цикл алгоритм язык массив

continue - перейти к следующему шагу цикла

break - прекратить цикл

Оператор continue используется только в циклах.

В операторах for, while, do…while, оператор continue выполняет пропуск оставшейся части кода тела цикла и переходит к следующей итерации цикла.

Рассмотрим фрагмент кода с оператором continue.

// пример использования оператора continue:

int count = 0;

do // начало цикла do…while

{

continue;

count++;

}

while ( count < 10 )

Посмотрим внимательно на приведенный выше пример, и мы увидим, что do…while бесконечный, так как каждая итерация цикла приводит к выполнению оператора continue, который пропускает операцию инкремента переменной-счётчика count и переходит на следующую итерацию цикла. Таким образом значение в переменной count не меняется, а значит и условие всегда будет истинным.

Разработаем программу с оператором continue.

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

Цикличность в программе организуем циклом с постусловием - do while. В цикле сначала считываем введённое число в переменную in_number, после чего, выполняется проверка условия в операторе if. Условие оператора условного выбора if будет истинным в том случае, если введённое число будет строго меньше нуля или строго больше 10.

При введении отрицательного числа осуществить выход из цикла. На рисунке 9 отображен код данной программы:

Рисунок 9 - использование оператора «continue»

Заданный интервал -- [0;10], число взятое из этого интервала возводится в квадрат. Истинность условия оператора if приводит к выполнению оператора continue. После чего переходит к проверке условия продолжения цикла do…while. Условие в цикле будет истинно, пока вводимые числа будут строго больше 0. Результат работы программы показан на рисунке 10.

Рисунок 10 - результат работы программы

Сначала вводились числа 15 и 11, эти числа не входят в заданный интервал и поэтому квадрат этих чисел не вычислялся. Числа 5 и 9 принадлежат заданному интервалу, а значит программа должна вычислить их квадраты. Когда ввели отрицательное число, do…while завершил свою работу.

Когда оператор break выполняется в цикле, то досрочно прерывается исполнение цикла и выходит из него, а управление передаётся следующему оператору после цикла. Разработаем программу с использованием оператора break. Программа печатает таблицу степеней двойки. Код программы на рисунке 11.

Рисунок 11 - использование оператора «break»

В данной программе мы используем заголовочный файл содержащий прототипы основных математических функций, для того, чтобы использовать функцию pow(). Функция pow(a,b) возводит число а в степень b. В цикле for объявлена переменная-счётчик count, значение которой меняется от 0 до 10 включительно. При выполнении условия, оператор условного выбора if, запускает на выполнение оператор break, который, в свою очередь, приводит к выходу из цикла for. Ниже запускается функция pow(). Условие продолжения цикла for будет истинно до тех пор, пока значение в переменной count <= 10. Тогда как, выход из цикла for произойдёт раньше, чем условие продолжения цикла станет ложным. Выход из цикла for выполнится, когда значение в переменной count станет равным шести. Результат работы программы показан на рисунке 12.

Рисунок 12 - результат работы

Из рисунка 12 видно, что таблица степеней двойки напечаталась, включительно, до пятой степени. Если убрать оператор условного выбора if, то напечатаются степени двойки, включительно до десятой.

Многие программисты считают, что операторы break и continue нарушают структурность программного кода и предпочитают обходится без них. Хотя скорей всего это обычный консерватизм людей.

Массивы

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

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

Рисунок 13 - структура одномерного массива

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

Синтаксис объявления массивы выглядит следующим образом:

/*тип данных*/ /*имя одномерного массива*/[/*размерность одномерного массива*/];

Пример объявления одномерного массива, изображенного на рисунке 13:

int a[16];

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

а - имя одномерного массива;

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

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

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

Пример инициализации одномерного массива:

int a[16] = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 };

На рисунке 14 показан пример простейшей программы для обработки массива:

Рисунок 14 - простейшая обработка массива

Любая обработка массива осуществима только совместно с циклами. Но лучше всего для этой задачи подходит цикл for. Переменную-счётчик counter будем использовать для обращения к элементам одномерного массива array1. В условии продолжения цикла for стоит строгий знак неравенства, так как шестнадцатого индекса в одномерном массиве array1 нет. А так как нумерация ячеек начинается с нуля, то элементов в массиве 16. В теле цикла for оператор cout печатает элементы одномерного массива. Результат работы данной программы на рисунке 15:

Рисунок 15 - результат работы программы обработки массива

Рассмотрим ещё одну программу на обработку одномерного массива в С++. Программа будет последовательно считывать десять введённых чисел с клавиатуры. Все введённые числа просуммировать, результат вывести на экран. На рисунке 16 код данной программы:

Рисунок 16 - код программы суммирования элементов массива

Перед тем как выполнять обработку массива его необходимо объявить, причём размер одномерного массива равен 10, так как это оговорено условием задачи. В переменной sum будем накапливать сумму элементов одномерного массива. Первый цикл for заполняет объявленный одномерный массив, введёнными с клавиатуры числами. Переменная счётчик counter используется для последовательного доступа к элементам одномерного массива array1, начиная с индекса 0 и до 9-го включительно. Второй цикл for выводит на экран элементы массива. Третий цикл for последовательно считывает элементы одномерного массива и суммирует их, сумма накапливается в переменной sum. Результат работы программы смотреть на рисунке 17.

Рисунок 17 - результат работы

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

Двумерные массивы

Одномерными массивами не всегда можно ограничиться. Например, необходимо обработать некоторые данные из таблицы. Таблица состоит из строк и столбцов - их количество определяет размер таблицы. Также и в двумерном массиве, есть такие характеристики как, количество строк и количество столбцов двумерного массива.

То есть, визуально, двумерный массив -- это обычная таблица, со строками и столбцами. Структура двумерного массива, с именем a, размером m на n показана ниже (рисунок 18).

Рисунок 18 - структура двумерного массива

где, m - количество строк двумерного массива;

n - количество столбцов двумерного массива;

m * n - количество элементов массива.

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

· тип данных;

· имя массива.

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

Пример объявление двумерного массива:

int a[5][3]

· a - имя целочисленного массива

· число в первых квадратных скобках указывает количество строк двумерного массива, в данном случае их 5;

· число во вторых квадратных скобках указывает количество столбцов двумерного массива, в данном случае их 3.

Пример инициализации двумерного массива:

int a[5][3] = { {4, 7, 8}, {9, 66, -1}, {5, -5, 0}, {3, -3, 30}, {1, 1, 1} };

В данном массиве 5 строк, 3 столбца. после знака присвоить ставятся общие фигурные скобочки, внутри которых ставится столько пар фигурных скобочек, сколько должно быть строк в двумерном массиве, причём эти скобочки разделяются запятыми. В каждой паре фигурных скобочек записывать через запятую элементы двумерного массива. Во всех фигурных скобочках количество элементов должно совпадать. Так как в массиве пять строк, то и внутренних пар скобочек тоже пять. Во внутренних скобочках записаны по три элемента, так как количество столбцов -- три. Графически наш массив будет выглядеть, как двумерная таблица (Рисунок 19).

Рисунок 19 - графическое представление массива

Рассмотрим программу, на обработку двумерного массива, которая называется «Лабиринт». Лабиринт должен быть построен на основе двумерного массива. Размер лабиринта будет 33 строки и 20 символов в строке.

// array2.cpp: определяет точку входа для консольного приложения.

#include <iostream>

using namespace std;

int main()

{

// 1-условно "стенки лабиринта"

// 2-"правильный путь, выход из лабиринта"

// 0-"ложный путь"

char wall=176; //символ для изображения стенки лабиринта

int mas[33][20] = { {1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,},

// инициализация двумерного массива

{1,2,1,0,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,},

{1,2,1,1,0,1,0,1,2,1,2,2,2,2,1,0,1,1,0,1,},

{1,2,2,2,2,2,2,1,2,1,1,1,1,2,1,0,0,1,0,1,},

{1,1,1,1,1,1,2,1,2,1,0,0,1,2,1,1,0,1,0,1,},

{1,0,0,1,0,0,2,2,2,1,1,0,0,2,0,0,0,1,0,1,},

{1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1,0,1,},

{1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,},

{1,1,1,1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,},

{1,1,0,0,0,1,0,0,1,1,2,1,1,1,1,0,0,0,0,1,},

{1,0,0,1,0,0,0,0,0,1,2,2,2,2,1,1,1,1,0,1,},

{1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,0,0,0,0,1,},

{1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,0,1,1,1,1,},

{1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,},

{1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,},

{1,2,1,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,},

{1,2,1,2,2,2,1,2,1,2,2,2,1,1,1,1,1,1,1,1,},

{1,2,1,2,1,2,1,2,1,0,1,2,2,2,2,2,2,2,2,1,},

{1,2,1,2,1,2,1,2,1,0,1,1,1,1,1,1,1,1,2,1,},

{1,2,1,2,1,2,1,2,1,0,0,0,0,0,0,0,0,0,2,1,},

{1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0,1,2,1,},

{1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1,},

{1,2,1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,},

{1,2,1,1,2,1,1,0,0,0,0,0,1,0,1,0,0,1,2,1,},

{1,2,1,1,2,1,0,0,1,1,1,1,1,1,1,1,1,1,2,1,},

{1,2,1,1,2,1,1,0,1,2,2,2,2,2,2,2,2,2,2,1,},

{1,2,1,1,2,1,0,0,1,2,1,1,1,1,1,1,1,1,1,1,},

{1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1,1,1,2,2,},

{1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1,},

{1,2,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,},

{1,2,1,1,2,1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,},

{1,2,2,2,2,1,0,1,1,2,2,2,2,0,0,1,0,0,0,1,},

{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,} };

// два цикла - внутренний и внешний, осуществляющие обращение к каждому элементу массива

for (int i = 0; i < 33; i++) //переключение по строкам

{

for (int j = 0; j < 20; j++)// переключение по столбцам

if (mas[i][j] == 1)

{

// вывести два раза символ (номер которого 176 в таблице аски) в консоль

cout << wall;

cout << wall;

} else

cout << " "; // вывести два пробела

cout << endl;

}

return 0;

}

Правильный и ложный пути можно было бы обозначать одной и той же цифрой, например, нулём, но для наглядности правильный путь обозначен цифрой 2. Инициализация массива выполнялась вручную, только для того, что бы упростить программу. Так как в программе выполняется обработка двумерного массива, нужны два цикла, для переключения между элементами двумерного массива. Первый цикл for выполняет переключение между строками двумерного массива. Так как строк в двумерном массиве 33, то и переменная-счетчик i инкрементируется от 0 до 33. Внутри первого цикла стоит цикл for, который переключается между элементами строки двумерного массива. В теле второго цикла for внутри оператора условного выбора if в консоль выводится символ таблицы ASCII, под номером 176. Двойной вывод символов нужен для увеличения ширины лабиринта. Результат работы программы (Рисунок 20).

Рисунок 20 - результат работы программы «лабиринт»



Заключение

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

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

Кроме того циклы служат не только для обработки массивов, но и просто для выполнения повторяющихся действий.

В процессе выполнения данной работы мы рассмотрели основные типы циклов и методы их применения. Кроме того рассмотрены специальные функции циклов - break и continue. Исследованы методы применения специальных функций.

Считаю, задачи и цели поставленные перед данной курсовой работой достигнуты в полной мере.



Список используемой литературы

1. Джесс Либерти. Освой самостоятельно С++ за 21 день. Издательский дом «Вильямс». 2001. с. 167-185

2. Борис Пахомов. С/С++ и MS Visual C++ 2010 для начинающих. БХВ-Петербург. 2011. с. 30-37

3. Бьерн Страуструп. Программирование. Принципы и практика использования С++. Издательский дом «Вильямс». 2011. с. 86-92

4. Айвор Хортон. Visual C++ 2010. Полный курс. Издательский дом «Вильямс» 2011. с. 164-200

5. Дэвид Гриффитс, Дон Гриффитс. Изучаем программирование на С. Издательство «Эксмо» 2013. с. 74- 81

6. Прата С. Язык программирования С++. Издание 6. Издательский дом «Вильямс» 2011. с. 192- 196

7. Брайан Керниган, Деннис Ритчи. Язык программирования С++. Издательство «Невский диалект» 2001. с. 124-164

8. Р. Лафоре. Объектно-ориентированное программирование в С++. Издательство «Питер». Издание 4. 2004. с. 262-271

9. Хусаинов Б.С. Структуры и алгоритмы обработки данных. Примеры на языке Си. Учеб. пособие. - Финансы и статистика, 2004. - 464с. Массивы. стр. 3562

10. Кубенский А.А. Структуры и алгоритмы обработки данных: объектно-ориентированный подход и реализация на С++. - СПб.: БХВ-Петербург, 2004. - 464с.

11. Седжвик Роберт. Фундаментальные алгоритмы на С++. Анализ/Структуры данных/Сортировка/Поиск: Пер. с англ./ Седжвик Роберт. К.: Издательство «ДиаСофт», 2001. с. 87- 93

С/С++. Структурное программирование: Практикум/Т.А. Павловская, - СПб.: Питер. 2003.-461с.

Двумерные массивы: стр.71 -88

12. Язык С++: Учеб. пособие/И.Ф. Астахова, С.В. Власов, В.В. Фертиков, А.В. Ларин.-Мн.: Новое знание, 2003. - 203с.

13. Лаптев В.В., Морозов А.В., Бокова А.В. С++. Объектно-ориентированное программирование. Задачи и упражнения. - СПб.: Питер. 2007.-288с

14. Кнут, Дональд, Эрвин. Искусство программирования. Том 1. Основные алгоритмы. 3-е изд. Пер. с англ. - : Уч. пос. М.: Издательский дом. «Вильямс», 2000.- 720с. Массивы и ортогональные списки: 341 351

15. С++ Стандартная библиотека. Для профессионалов./Н. Джосьютис. - СП Питер, 2004. Обычные массивы как контейнеры STL - стр. 223

16. Динман М.И. С++. Освой на примерах. - СПб.: БХВ-Петербург, 2006. Массивы: стр. 79 138

17. Харви Дейтел, Пол Дейтел. Как программировать на С++. Пер. с англ. - М.: ЗАО «Издательство БИНОМ», 1998 г. Массивы: стр. 260-289

18. Майерс С. Эффективное использование С++. 50 рекомендаций по улучшению ваших программ и проектов. Пер. с англ. - М.: ДМК Пресс; - СПб.: Питер. 2006.-240с.

19. Штерн Виктор. Основы С++: Методы программной инженерии.- Издательство «Лори», 2003. - 860с. О массивах стр.143-166

20. Скляров В.А. Язык С++ и объектно-ориентированное программирование. Справочное пособие. - Минск. «Вышейшая школа». - 1997г. - 478с.

Размещено на Allbest.ru