Обработка комманд менб с помощью оператора switch

⇐ ПредыдущаяСтр 25 из 85Следующая ⇒

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

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

Листинг 7.17. Пример бесконечного цикла

1: //Листинг 7.17.

2: //Обработка диалога с пользователем

3: //посредством бесконечного цикла

4: #include < lostream, h>

6: // прототипы функций

7: int menu();

8: void DoTaskOne();

9: void DoTaskMany(int);

10:

11: int main()

12: {

13:

14: bool exit = false;

15: for (;; )

16: {

17: int choice = menu();

18: switch(choice)

19: {

20: case (1):

21: DoTaskOne();

22: break;

23: case (2):

24: DoTaskOne(2);

25: break;

26: case (3):

27: DoTaskOne(3);

28: break;

29: case (4):

30: continue;

31: break;

32: case (5):

33: exit=true;

34: break;

35: default:

36: cout < < " Please select again! \n";

37: break;

38: } // конец блока switch

39:

40: if (exit)

41: break;

42: } // и так до бесконечности

43: return 0;

44: } // конец функции main()

45:

46: int menu()

47: {

48: int choice;

49:

50: cout < < " **** Menu **** \n\n";

51: cout < < " (1) Choice one\n";

52: cout < < " (2) Choice two\n";

53: cout < < " (3) Choice three\n";

54: cout < < " (4) Redisplay menu.\n";

55: cout < < " (5) Quit.\n\n";

56: cout < < ": ";

57: cin > > choice;

58: return choice;

59: }

60:

61: void DoTaskOne()

62: {

63: cout < < " Task One! \n";

64: }

65:

66: void DoTaskMany(int which)

67: {

68: if (which == 2)

69: cout < < " Task Two! \n";

70: else

71: cout < < " Task Three! \n";

72: }

Результат:

**** Menu ****

(1) Choice one.

(2) Choice two.

(3) Choice three.

(4) Redisplay menu.

(5) Quit.

: 1

Task One!

**** Menu ****

(1) Choice one.

(2) Choice two.

(3) Choice three.

(4) Redisplay menu.

(5) Quit.

: 3

Task Three!

**** Menu ****

(1) Choice one.

(2) Choice two.

(3) Choice three.

(4) Redisplay menu.

(5) Quit.

: 5

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

Работа бесконечного цикла начинается в строке 15. Функция menu() обеспечивает вывод на экран команд меню и возвращает номер выбранной пользователем команды. Обработка введенного номера осуществляется в конструкции switch в строках 18—38.

При выборе первой команды управление передается следующему после строки case (1): оператору (строка 21). Далее, в строке 21, вызывается функция DoTaskOne(), которая выводит на экран сообщение о выборе пользователя. После завершения работы функции осуществляется возврат в точку вызова и выполняется оператор break (строка 22). Оператор break прерывает работу блока switch и управление передается в строку 39. Далее, в строке 40, проверяется значение переменной exit. Если оно истинно, бесконечный цикл прерывается оператором break в строке 41. В противном случае выполняется следующая итерация цикла (строка 15).

Особое внимание следует уделить оператору continue в строке 30. Внимательно проанализировав структуру программы, вы заметите, что этот оператор можно опустить, причем работа программы не изменится. Если бы строки с этим оператором не было, выполнялся бы оператор break, затем оператор if и, так как переменная exit содержала бы значение false, запускалась следующая итерация цикла. Использование оператора continue просто позволяет перейти на новую итерацию без проверки значения exit.

Резюме

В языке C++ существует множество способов организации циклических процессов. Оператор while проверяет условие и, если оно истинно, передает управление телу цикла. В конструкции do...while условие проверяется уже после выполнения тела цикла. Оператор for позволяет инициализировать переменные цикла, после чего проверяется выполнение условия. Если оно истинно, выполняется тело цикла, а затем операция, являющаяся третьей частью заголовка конструкции for. Перед началом каждой следующей итерации условие проверяется заново.

Оператора goto следует по возможности избегать, поскольку он позволяет осуществить переход в любую точку программы, что значительно усложняет ее восприятие и анализ. С помощью оператора continue можно осуществить переход на следующую итерацию цикла while, do...while или for, а break позволяет мгновенно завершить работу цикла.

Вопросы и ответы

Как определить, какой из операторов, if/else или switch, лучше использовать в конкретной ситуации?

Если приходится использовать более двух вложений операторов if, то лучше воспользоваться конструкцией с оператором switch.

Как выбрать между операторами while и do...while?

Если тело цикла должно выполняться хотя бы один раз, используйте цикл do...while. Во всех остальных случаях используйте оператор while.

Как выбрать между операторами while и for?

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

В каких случаях лучше использовать рекурсию, а в каких итерацию?

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

Какой из операторов, for(;; ) или while(true) работает эффективнее?

Существенного различия между ними нет.

Коллоквиум

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

Контрольные вопросы

1. Можно ли в цикле for инициализировать сразу несколько переменных-счетчиков?

2. Почему следует избегать использование оператора goto?

3. Можно ли с помощью оператора for организовать цикл, тело которого не будет выполняться?

4. Можно ли организовать цикл while внутри цикла for?

5. Можно ли организовать цикл, который никогда не завершится? Приведите пример.

6. Что происходит при запуске бесконечного цикла?

Упражнения

1. Каким будет значение переменной x после завершения цикла for (int x = 0; x < 100; x++)?

2. Создайте вложенный цикл for, заполняющий нулями массив размером 10x10.

3. Организуйте цикл for, счетчик которого изменяется от 100 до 200 с шагом 2.

4. Организуйте цикл while, счетчик которого изменяется от 100 до 200 с шагом 2.

5. Организуйте цикл do...while, счетчик которого изменяется от 100 до 200 с шагом 2.

6. Жучки: найдите ошибку в приведенном фрагменте программы.

int counter = 0;

while (counter < 10)

{

cout < < " counter: " < < counter;

}

7. Жучки: найдите ошибку в приведенном фрагменте программы.

for(int counter = 0; counter < 10; counter++);

cout < < counter < < " ";

8. Жучки: найдите ошибку в приведенном фрагменте программы.

int counter = 100;

while (counter < 10)

{

cout < < " counter: " < < counter;

counter--;

}

9. Жучки: найдите ошибку в приведенном фрагменте программы.

cout < < " Enter а number between 0 and 5: ";

cin > > theNumber;

switch (theNumber)

{

case 0:

doZero();

case 1: // идем дальше

case 2: // идем дальше

case 3: // идем дальше

case 4: // идем дальше

case 5:

doOneToFive();

break;

default:

doDefault();

break;

}

Подведение итогов

Листинг. Итоги первой недели

1: #include < iostream.h>

2: intintboolfalsetrue

3: enum CHOICE { DrawRect = 1, GetArea,

4: GetPerim, ChangeDimensions, Quit};

5: // Объявление класса Rectangle

6: class Rectangle

7: {

8: public:

9: // constructors

10: Rectangle(int width, int height);

11: ~Rectangle();

12:

13: // Методы доступа

14: int GetHeight() const { return itsHeight; }

15: int GetWidth() const { return itsWidth; }

16: int GetArea() const { return itsHeight * itsWidth; }

17: int GetPerim() const { return 2*itsHeight + 2*itsWidth; }

18: void SetSize(int newWidth, int newHeight);

19:

20: // Прочие методы

21:

22:

23: private:

24: int itsWidth;

25: int itsHeight;

26: };

27:

28: // Выполнение методов класса

29: void Rectangle:: SetSize(int newWidth, int newHeight)

30: {

31: itsWidth = newWidth;

32: itsHeight = newHeight;

33: }

34:

35:

36: Rectangle:: Rectangle(lnt width, int height)

37: {

38: itsWidth = width;

39: itsHeight = height;

40: }

41:

42: Rectangle:: ~Rectangle() { }

43:

44: int DoMenu();

45: void DoDrawRect(Rectangle);

46: void DoGetArea(Rectangle);

47: void DoGetPerim(Rectangle);

48:

49: int main ()

50: {

51: // Инициализация объекта rectangle значением 30, 5

52: Rectangle theRect(30, 5);

53:

54: int choice = DrawRect;

55: int fQuit = false;

56:

57: while (! fQuit)

58: {

59: choice = DoMenu();

60: if (choice < DrawRect || choice > Quit)

61: {

62: cout < < " \nInvalid Choice, please try again.\n\n"

63: continue;

64: }

65: switch (choice)

66: {

67: case DrawRect:

68: DoDrawRect(theRect);

69: break;

70: case GetArea:

71: DoGetArea(theRect);

72: break;

73: case GetPerim:

74: DoGetPerim(theRect);

75: break;

76: case ChangeDimensions:

77: int newLength, newWidth;

78: cout < < " \nNew width: ";

79: cin > > newWidth;

80: cout < < " New height: ";

81: cin > > newLength;

82: theRect.SetSize(newWidth, newLength);

83: DoDrawRect(theRect);

84: break;

85: case Quit:

86: fQuit = true;

87: cout < < " \nExiting...\n\n";

88: break;

89: default:

90: cout < < " Error in choioe! \n";

91: fQuit = true;

92: break;

93: } // end switch

94: } // end while

95: return 0;

96: } // end main

97:

98: int DoMenu()

99: {

100: int choice;

101: cout < < " \n\n *** Menu *** \n";

102: cout < < " (1) Draw Rectangle\n";

103: cout < < " (2) Area\n";

104: cout < < " (3) Perimeter\n";

105: cout < < " (4) Resize\n";

106: cout < < " (5) Quit\n";

107:

108: cin > > choice;

109: return choice;

110: }

111:

112: void DoDrawRect(Rectangle theRect)

113: {

114: int height = theRect.GetHeight();

115: int width = theRect.GetWidth();

116:

117: for (int i = 0; i< height; i++)

118: {

119: for (int j = 0; j< width; j++)

120: cout < < " *";

121: cout < < " \n";

122: }

123: }

124:

125:

126: void DoGetArea(Rectangle theRect)

127: {

128: cout < < " Area: " < < theRect.GetArea() < < endl;

129: }

130:

131: void DoGetPerim(Rectangle theRect)

132: {

133: cout < < " Perimeter: " < < theRect.GetPerim() < < endl;

134: }

Результат:

*** Menu***

(1) Draw Rectangle

(2) Area

(3) Perimeter

(4) Resize

(5) Quit

******************************

*** Menu***

(1) Draw Rectangle

(2) Area

(3) Perimeter

(4) Resize

(5) Quit

Area: 150

*** Menu***

(1) Draw Rectangle

(2) Area

(3) Perimeter

(4) Resize

(5) Quit

Perimeter: 70

*** Menu***

(1) Draw Rectangle

(2) Area

(3) Perimeter

(4) Resize

(5) Quit

New Width: 10

New height: 8

**********

*** Menu***

(1) Draw Rectangle

(2) Area

(3) Perimeter

(4) Resize

(5) Quit

Area: 80

> > ** Menu***

(1) Draw Rectangle

(2) Area

(3) Perimeter

(4) Resize

(5) Quit

Perimeter: 36

*** Menu***

(1) Draw Rectangle

(2) Area

(3) Perimeter

(4) Resize

(5) Quit

Exiting...

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

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

В строках 6—26 объявляется класс Rectangle. Он содержит открытые методы доступа для возвращения и установки ширины и высоты прямоугольника, а также для вычисления его площади и периметра. Строки 29-40 содержат определения тех функций-членов класса, которые не объявлялись с ключевым словом inline.

Прототипы обычных функций, не являющихся членами класса, находятся в строках 44—47, а основной блок программы начинается со строки 49. Суть программы состоит в построении виртуального прямоугольника с выводом меню, предлагающего выбор из пяти опций: вывод прямоугольника на экран, определение его площади, определение периметра, изменение размера прямоугольника и выход из программы.

Флаг устанавливается в строке 55, и если пользователь установит неверное значение, то вывод меню на экран повторится. Это будет продолжатся до тех пор, пока пользователь правильно не укажет один из режимов работы либо не выберет завершение программы.

В случае выбора одного из режимов работы, за исключением ChangeDimensions, будет вызываться соответствующая функция, выбираемая с помощью оператора switch. Выбор константы ChangeDimensions не вызывает никакой функции, поскольку в этом случае пользователь должен ввести новые значения размера прямоугольника. Если предположить, что для изменения размеров прямоугольника в программе существовала бы специальная функция DoChangeDimensions(), в которую объект Rectangle передавался бы как значение, то все изменения в функции производились бы над копией существующего объекта, а сам объект в функции main() оставался бы неизменным. На занятии 8, посвященном указателям, и на занятии 10, где речь идет о разработке более сложных функций, вы узнаете, как обойти это ограничение, передавая объекты в функции как ссылки. Но пока все изменения значения объекта можно осуществлять только в функции main().

Обратите внимание, что использование перечисления сделало конструкцию оператора switch более понятной. Если бы вместо констант, о назначении которых можно судить по их именам, проверялись бы вводимые пользователем числовые значения от 1 до 5, нам бы пришлось каждый раз возвращаться к описанию меню, чтобы не запутаться в том, какой номер соответствует той или иной опции.

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

Итоги первой недели

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

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

Неделя №2

Основные вопросы

Мы завершили первую неделю обучения и научились основным принципам и средствам программирования на C++. Для вас теперь не должно составлять труда написание и компиляция небольшой программы. Также вы должны четко представлять, что такое классы и объекты, составляющие основу объект-ориентированного программирования.

Что дальше

Вторую неделю начнем с изучения указателей. Указатели традиционно являются сложной темой для освоения начинающими программистами на C++. Но в этой книге вы найдете подробные и наглядные разъяснения того, что такое указатель и как он работает, поэтому, мы надеемся, что через день вы уже свободно будете владеть этим средством программирования. На занятии 9 вы познакомитесь со ссылками, которые являются близкими родственниками указателей. На занятии 10 вы узнаете как замешать функции, а занятие 11 будет посвящено наследованию и разъяснению фундаментальных принципов объект-ориентированного программирования. На занятии 12 вы узнаете как создавать структуры данных от простых массивов до связанных списков. Занятие 13 расширит ваши представления об объект-ориентированном программировании и познакомит с полиморфизмом, а занятие 14 завершит вторую неделю обучения рассмотрением статических функций и функций друзей класса.

День 8-й. Указатели

Возможность непосредственного доступа к памяти с помощью указателей — одно их наиболее мощных средств программирования на C++. Сегодня вы узнаете:

• Что такое указатели

• Как объявляются и используются указатели

• Как работать с памятью

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

Что такое указатель

Указатель — это переменная, в которой записан адрес ячейки памяти компьютера.

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

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

Рис. 8.1. Сохранение в памяти переменной theAge

Листинг 8.1. Оператор адреса

1: // Листинг 8.1. Пример использования

2: // оператора адреса

4: #include < iostream.h>

6: int main()

7: {

8: unsigned short shortVar=5;

9: unsigned long longVar=65535;

10: long sVar = -65535;

11:

12: cout < < " shortVar: \t" < < shortVar;

13: cout < < " Address of shortVar: \t";

14: cout < < & shortVar < < " \n";

15:

16: cout < < " longVar: \t" < < longVar;

17: cout < < " Address of longVar: \t"

18: cout < < & longVar < < " \n";

19:

20: cout < < " s.Var: \t" < < sVar;

21: cout < < " Address of sVar: \t"

22: cout < < & sVar < < " \n";

23:

24: return 0;

25: }

Результат:

shortVar: 5 Address of shortVar: 0x8fc9: fff4

longVar: 65535 Address of longVar: 0x8fc9: fff2

sVar: -65535 Address of sVar: 0x8fc9: ffee

(Ваши результаты могут отличаться от приведенных в листинге.)

Анализ: В начале программы объявляются и инициализируются три переменные: в строке 8 — переменная типа unsigned short, в строке 9 — типа unsigned long, а в строке 10 — типа long. Затем в строках 12-16 выводятся значения и адреса этих переменных, полученные с помощью оператора адреса (& ).

При запуске программы на компьютере с процессором 80386 значение переменной shortVar равно 5, а ее адрес — 0x8fc9: fff4. Адрес размещения переменной выбирается компьютером и может изменяться при каждом последующем запуске программы. Поэтому ваши результаты могут отличаться от приведенных. Причем разница между двумя первыми адресами будет оставаться постоянной. При двухбайтовом представлении типа short эта разница составит 2 байта, а разница между третьим и четвертым адресами — 4 байта при четырехбайтовом представлении типа long. Порядок размещения этих переменных в памяти показан на рис. 8.2.

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

⇐ Предыдущая 20 21 22 23 242526 27 28 29 Следующая ⇒