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

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с. Массивы. стр. 35¸62
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с.