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

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

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

Что для этого понадобится.
Программа сначала выводит небольшое сюжетное введение, а следовательно для этого мы должны ознакомится с таким понятиями как ввод-вывод и текстовые строки.

Ввод-вывод текстовой информации
Каждая игровая программа, чтобы быть хоть чуточку интересной, должна как-то взаимодействовать с пользователем, ну а в нашем случае - с игроком. То есть она должна выводить определенную информацию и принимать определенные данные. Делая разбор первой программы, мы уже печатали на мониторе текст "Начинающий программист приветствует этот мир!".
Для этого мы воспользовались инструкцией cout. Синтаксис ее такой.

cout воплощает в себе стандартное средство вывода, то есть монитор.
Две стрелки(<<) – это специальный оператор потока(поток – последовательность символов или данных вообще). Если говорить по-простому, то этот оператор запихивает наш текст в cout, выводя его таким образом на экран.
Согласно правил, строка текста – это набор символов, заключенных в кавычки. Так компилятор узнает, с чем он работает. В качестве выводимого текста могут быть также и числа. В таком случае кавычки не требуются.

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

и компилятор выдаст ошибку.

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

\a Сигнал
\b Возврат курсора на символ назад
\t Горизонтальная табуляция
\n Переход на новую строку
\v Вертикальная табуляция
\r Возврат курсора на строку вверх
\" Кавычки
\' Апостроф
\0 Ноль-символ
\\ Обратный слеш
\? Вопросительный знак

Теперь, зная их, вместо предыдущего варианта достаточно написать:

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

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

Открою вам один маленький, но неприятный момент. Максимальная длина строки выводимого текста – 256 символов. Если ваш текст окажется длиннее, то все что не поместилось, просто будет отброшено. В общем-то, ничего страшного, ведь на практике редко встречаются такие длинные предложения.
Чтобы напечатать большое количество текста просто достаточно воспользоваться двумя, тремя или вообще любым количеством операторов cout. Вот так это будет выглядеть:

Вышеуказанный пример можно немного сократить. Синтаксис языка допускает такой вариант оформления:

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

Предположим что нам необходимо, чтобы последнее предложение начиналось с новой строки. Для этого достаточно в его начало, или в конец предыдущего, вставить управляющий символ \n. Вот так:

И мы получим:

Что и требовалось.

Ну что ж. С выводом данных разобрались, теперь рассмотрим ввод. Для этих целей используется оператор cin. Его мы тоже уже немного упоминали раньше.
Также как и cout, cin ассоциируется с реальным устройством, но в его случае это стандартное устройство ввода – клавиатура. После набора данных и нажатия Enter, вся введенная информация достается cin. Вот синтаксис его использования.

cin >> переменная;

Здесь >> - все тот же поток, но теперь он получает из cin введенные данные и передает их в какую-то переменную. Чтобы следовать в нашем обучении дальше, теперь нам необходимо познакомится с этими самыми переменными.

Переменные. Типы данных.
В своей игре нам нужно в каком то виде представить и хранить наши войска. Со словом хранить в первую очередь ассоциируется такая вещь, как сундук. В языке с++ такими сундуками выступают переменные.
В программировании, как и в математике под переменной подразумевают некую величину, которая при необходимости может варьироваться. Опять на ум приходит то же сундук, в который можно что-то класть, что-то забирать. Также как сундук может быть приспособлен для хранения определенных вещей, так и переменные могут относится к определенному типу данных.
В языке программирования С++ используются основные данные такого типа:
void (Пустой тип) – как это ни парадоксально, но в С++ есть тип, который указывает на отсутствие информации.
char (Символьный тип) – в переменных этого типа может храниться один символ, то есть буква, спецсимвол, одна цифра и другие.
int (Целое число) – как понятно из названия используется для хранения целых чисел.
float (Число с плавающей точкой) – понятно и так, но на всякий случай приведу пример. Это числа вроде – 1.5, 127.52, 0.5867. То есть это числа, в которых присутствуют десятые, сотые, тысячные и т.д.
double – улучшенная, более точная версия float, отличается тем, что в нее вмещается больше цифр после точки.
bool (Логический тип) – очень простой, но весьма важный тип. Может иметь всего два значения – правда и ложь(true и false). Любой из перечисленных выше типов может содержать в себе это логическое значение. Просто если значение есть то это true, а если его нет или оно равно нолю то это false.

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

Тип_данных Имя_переменной;

Думаю, тут все просто. Сначала идет тип данных, затем имя переменной и заканчивается все неизменной точкой с запятой.
Пример:

Разбирая объявления нельзя не упомянуть об именах переменных и некоторых правилах:
1. Имя должно содержать только символы латинского алфавита.(В Microsoft Visual Studio 2005/2008 допускается использование кирилицы, тоесть имена можно писать на русском языке)
2. Имя может включать любые другие символы, кроме специальных(!@#$%^&*()+-=/.,<>).
3. Имя должно начинаться только буквой, также допускается символ подчеркивания(_).
4. Имя должно быть уникальным. Двух переменных с одинаковыми именами, пусть даже и разных типов, быть не должно.
5. Имя переменной не должно совпадать с зарезервированными словами.(Зарезервированные слова это слова за которыми в языке программирования С++ закреплены определенные действия или значения. Например include, или типы данных int, bool и т.д. Редактор Microsoft Visual Studio выделяет такие слова синим цветом).

Добавлю еще кое-что. Компилятор языка С++ делает четкое различие между одинаковыми буквами но в разном регистре.
То есть здесь:

с точки зрения компилятора было объявлено две разные переменные. И еще один пример:

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

Здесь х, y, z, cell – целочисленные переменные.

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

Тип_данных Имя_переменной = ЗНАЧЕНИЕ;

Здесь символ равно (=) это и есть оператор присвоения. Все просто. Но не настолько, как вы подумали. Вот пример:

Думаю с типом int и bool все понятно, а вот что это за странное число - 1.5f. Приписанная в его конце буква f означает, что это число с плавающей точкой, то есть – float. Вообще-то можно обойтись и без этой f. Все равно компилятор правильно его обработает. По большему счету, такая запись просто улучшает ориентацию в коде(или если говорить языком программистов – улучшает читабельность).
Ну и напоследок осталось разобраться с типом char. Относящиеся к нему данные в языке С++ записываются заключенными в одинарные кавычки, как выше и показано в примере.
Также следует знать, что значение переменным можно присваивать не только во время их объявления, но и позже. Вот так:

Ну и естественно, значения одних переменных, можно присваивать другим:

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

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

1. * (умножение),
2. / (деление).
3. +(сложение).
4. - (вычитание),

Думаю, объяснять, что они делают, не нужно, и пока что нам их хватит. В дальнейшем, по мере необходимости я познакомлю вас и с остальными. Да с остальными, ведь не думаете же вы, что в таком мощном языке как С++ всего четыре арифметических оператора.)
Строка кода, содержащая переменные, числа и арифметические операторы называется – выражение. В одном выражении может содержаться сколько угодно операторов:

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

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

«Осада»
Наконец- то мы добрались до этого места. Сейчас, используя все полученные знания, мы напишем свою первую игру. Раньше мы уже определились, что будем делать, и как это будет реализовано. Ну а в последних разделах я только и делал, что объяснял основы языка программирования, которые нам для этого понадобятся.
В самом начале обучения мы уже написали первую программу. Сейчас мы внесем в нее необходимые изменения, чтоб она превратилась в небольшую игру.
Приступаем к самой интересной части.
Как уже было оговорено раньше, наша игра сначала должна вывести небольшое сюжетное введение. Вы же помните, что за вывод текста у нас отвечает оператор cout. Откроем в редакторе студии ранее созданные файл с исходным кодом, у меня он называется Siege.cpp (siege – с английского «Осада»), и вместо имеющейся там строчки вывода приветствия, добавим следующий код:

Думаю теперь, после моих объяснений, в этом коде вам должно быть все знакомо. У нас здесь есть оператор cout, оператор потока и строки с текстом. Поскольку символов в тексте намного больше, чем допускается, каждую строчку я вывел с помощью отдельного оператора. Чтобы выводимый текст было удобнее читать, он отформатирован с помощью известного вам символа - \n.
Как видно из введения, форт охраняется четырьмя видами войск. Для их представления нам необходимо обьявить четыре целочисленные переменные. Как это сделать, вы уже знаете. Также нам необходимо присвоить им определенные значения. Их необходимо выбрать так, чтобы только в одной комбинации нападающих и защищающихся войск все защитники погибли, то есть, чтобы в соответствующей паре значения совпадали, в таком случае результат их вычитания будет равен нолю.
Я сделал так:

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

Как видим, значение у нее нет, поскольку оно в последствии будет получено от пользователя. Вспоминаем что ввод осуществляется с помощью оператора cin и добавляем необходимый код:

Здесь программа получит введенное число и передаст ее в переменную i.
После того как даные получены, выполняем вычисления для текущего защитника и нападающего. Для этого используем вот такое простое выражение.

Если значениями Draco и i является одинаковое число, то результат вычисления будет равен нолю, что нам и нужно. У меня драконам соответствую маги, големам – катапульта, лучникам – латники а крестьянам – асасины. Поэтому значение переменных в этих парах должно быть одинаковое. Добавим код и для остальных войск. Не забываем выводить запрос, получать введенные данные и проводить вычисления.

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

Как видно из кода, я воспользовался вторым способом вывода, без повторного использования оператора cout. Но в коде, вместо текстовых строк присутствуют используемые для войск переменные. Как я уже упоминал, само имя переменной для программы не важно, она работает с ее значением. Поэтому вместо имен переменных в тексте будут напечатаны их значения. Переменная – это не текст, так что ее имя в кавычки заключать не нужно.
На этом написание нашей первой игры завершено. Добавлю лишь некоторые моменты. Обьявление переменных желательно проводить в начале кода, так сразу будет понятно, какими данными управляет программа.
Строка для вывода данных в конце прграммы получилась слишком длинной и в редакторе вышла за пределы экрана, что неудобно. Поэтому ее можно разбить на несколько частей вставив перенос строки(клавиша Enter). При этом важно знать что разбивать на части операторы, имена переменных или строки нельзя. Подобное будет воспринято компилятором как ошибка. Вот такая запись не правильная:

Вот полный исходный код нашей игры:

С cin.get() мы уже знакомы. Она используется для того, чтобы заставить нашу программу подоздать нажатия клавишы. Но почему она дублируется?
Все очень просто. При вводе чисел вы подтвержнаете эту опрацию нажатием клавиши Enter. Так вот это нажатие и будет воспринято cin.get() и программа сразу же завершится. Чтобы этого не произошло, строка cin.get(); написана дважды.

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

Хорошо, когда все работает так, как нужно. Если вы были внимательными и тщательно следовали изложенным инструкция, то проблем у вас не должно возникнуть.
Но никто не застрахован от ошибок. В программировании малейшая неточность приводит к тому, что программа работает не так, как нужно, а то и вовсе не работает, даже не компилируется.
В этой части я специально сделаю ошибки, проиллюстрирую, как на них отреагирует среда разработки, и расскажу, как их исправлять.
Дальнейший материал я буду объяснять с той позиции, что у меня все работает. Не спешите ругаться, мол - у вас наоборот, ничего не запустилось. Может так случиться, что дочитав до конца, вы без труда сможете исправить все ошибки, и все имеющиеся сейчас вопросы сами собой отпадут.
Приступаем к работе. Запускаем студию и открываем в ней наш, уже существующий проект. Сделать это можно многими способами, но я упомяну самые простые. При запуске студии автоматически запускается начальная страница, на которой есть список последних проектов.

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

image017

Открываем файл с исходным кодом, если это не было сделано автоматически, и портим его ошибками
Первое, что мы сделаем это в строке:

в названии типа данных int вставим пробел, разбив его таким образом на два слова. Вот так:

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

В самом низу появившейся информации строчка «с ошибками: 1 » указывает на то, что ваш проект содержит ошибки. Экая новость, мы об этом и так знаем. Кроме того что студия может нам сообщить о наличии ошибок, она так же может и указать на них.
Рядом с вкладкой Вывод есть вкладка Список ошибок.
Если ее почему то нет, но найти ее можно так:
Выбираем пункт меню Вид → Другие окна → Список ошибок.

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

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

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

Поздравляю, вот вы и написали свою первую игру. Вернее мою игру. Но что теперь вам мешает написать собственную. Используя полученные знания, попытайтесь сделать что-то свое. Придумайте сюжет, воплотите его в код. Можете считать это домашним заданием.
Сегодня, познав самые азы С++, вы сделали очень важный шаг в своей жизни. Кто знает, возможно когда-то вы станете известным программистом и напишете десятки превосходных игр с восхитительной графикой, но могу поспорить что эту свою, примитивную и лишенную графики первую игру, вы запомните навсегда.
На этом все.
До встречи в следующих уроках.

Здравствуйте, уважаемые, жаждущие знаний, читатели. Прошло довольно много времени, у меня наконец то выдалась свободная минутка и я продолжаю начатое знакомство с языком программирования С++. Надеюсь что вы не теряли времени даром, поскольку делать столь длительные перерывы в обучении не то что не желательно, а даже вредно. Есть такое крылатое выражение – «Учится, все равно, что грести против течения, только перестанешь и тебя гонит назад». Поскольку писать уроки в спринтерском темпе у меня вряд ли получится, дабы исключить такие длительные перерывы и утолить жажду знаний, советую найти где-нибудь книгу по программированию. Могу посоветовать «С++ для чайников», брать что либо серьезнее не рекомендую, поскольку могут возникнуть проблемы с пониманием материала, вследствие чего вы оставите книгу пылится где-то на полке и плюнете на саму мысль об обучении С++. Все таки это не самый легкий для изучения язык.
Ладно, хватит пудрить мозги, пора грести против течения.

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

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

Логические операторы и операторы сравнения

Помните что такое логический тип данных. Это такая вещь, которая может иметь только два значения истина или ложь(true или false, ведь на русском компилятор не понимает).
Логический оператор помещается между двумя аргументами(переменными), и в результате совершения определенных действий над ними возвращает логическое значение.

Вот перечень логических операторов:

! – оператор НЕ. Он применяется всего к одной переменной, изменяя ее логическое значение на противоположное.
Пример:
!true возвратит false
!false возвратит true
(заметьте, после восклицательного знака пробела нет )

&& - оператор И. Возвращает true если оба аргумента истинны. В любом другом случае возвращает ложь.
Пример:
true && true возвратит true
true && false возвратит false
false && false возвратит false

|| - оператор ИЛИ. Возвращает true если один из аргументов истина.
Пример:
true || true возвратит true
true || false возвратит true
false || false возвратит false

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

> - оператор больше. Возвращает true если значение левого аргумента больше чем у правого.
Пример:
10 > 5 возвратит true
10 > 10 возвратит false
10 > 15 возвратит false

>= - оператор больше или равно. Возвращает true если значение левого аргумента больше или равно правому.
Пример:
10 >= 5 возвратит true
10 >= 10 возвратит true
10 >= 15 возвратит false

< - оператор меньше. Возвращает true если значение левого аргумента меньше чем у правого.
Пример:
10 < 5 возвратит false
10 < 10 возвратит false
10 < 15 возвратит true

<= - оператор меньше или равно. Возвращает true если значение левого аргумента меньше или равно правому.
Пример:
10 <= 5 возвратит false
10 <= 10 возвратит true
10 <= 15 возвратит true

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

!= - оператор не равно. Возвращает true если значение левого аргумента не равно правому.
Пример:
10 != 5 возвратит true
10 != 10 возвратит false

Как и в случае с арифметическими операторами, логические также имеют приоритет.
Как это ни странно, наивысший приоритет имеет !. Далее идут операторы сравнения, они изложены попарно в порядке снижения приоритета. За ними идут && и ||. Операторы с одинаковым приоритетом выполняются слева направо. Не буду приводить вам никаких примеров с приоритетами, кто захочет - разберется сам, а кто не захочет – будет пользоваться скобками.
Теперь я приведу вам один интересный пример. Компилятор С++ допускает такое выражение:

Как вы думаете, что будет возвращено после вычисления этого выражения?
Если смотреть с точки зрения математики, то это выражение должно быть ложным. Но мы будем рассматривать его с точки зрения логики программирования.
Начнем разбор. В соответствии с одинаковыми приоритетами сначала будут сравниваться 10 и 7, а затем их результат будет сравнен с цифрой 5. В результате первой операции будет получено значение false, поэтому выражение примет такой вид:

Как же нам теперь сравнить логическое значение с числовым. Помните, я при знакомстве с типами данных упоминал, что если значение есть то это true, а если его нет, то это false. Учитывая это наше выражение примет такой вид:

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

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

Операторы ветвления, выбора и условный оператор.

Операторами выбора называются операторы, которые в результате проверки определенных условий выбирают какое действие, будет выполнятся дальше.
Существует два вида операторов выбора: пара if else и switch.

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

Работает оператор так. Сначала проверяется условие, если оно истинно то выполняется Блок кода. Если условие ложно, то код пропускается.
Если в блоке кода находится всего одна строка, то фигурные скобки можно не ставить. Пример:

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

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

То второй и третий операторы будут выполнены, только если условие первого ложно. Но при этом они также будут выполнены не зависимо от истинности условий друг друга. Поэтому самый правильный вариант такой:

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

Разницу чувствуете)

Вот его синтаксис:

Будут выполнены для обоих значений.

Ну и напоследок говоря об операторах ветвления нельзя не упомянуть условный оператор - ?:. По сути это сокращенная запись того же if else.
Вот его синтаксис:

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

Если I больше 5, то Х будет присвоено 20, во всех остальных случаях 40.
Вот так бы выглядел этот пример с использованием if.

Теперь, на конец хотелось бы сделать небольшое пояснение относительно терминологии. Я использовал три термина: оператор ветвления для if else, оператор выбора для switch и условный оператор для ?:. Так вот, в разной литературе любым из этих терминов может называться любой из перечисленный операторов. Вот такое дело. Я так и не смог определится, кому принадлежит конкретный термин. Далее по тексту я буду использовать приведенные названия применительно к каждому конкретному оператору.
На этом знакомство с операторами ветвления закончено. Теперь мы можем внести изменения в нашу первую игру.

Корректируем «Осаду».
Открываем в студии проект с игрой осада и переходим к исходному коду. Как это сделать вы должны уже знать с первого урока. Находим там такие строки:

Поставив вместо нее изученный оператор ветвления.

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

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

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

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

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

Вот текст документа:

Соглашение об идентификаторах в программе.
Данный документ предназначен для изложения основных достоинств о формальном формировании идентификаторов.
При введении нового идентификатора в программу, хороший программист учитывает следующие факторы:
1. мнемоническое значение: идентификатор должен легко запоминаться
2. смысловое значение: роль идентификатора должна быть ясна из его названия
3. преемственность: часто рассматривается как чисто эстетическая идея, но все же, похожие объекты должны иметь похожие идентификаторы.
4. скорость решения: придумывание, ввод и редактирование идентификатора не должны занимать слишком много времени, идентификатор не должен быть слишком длинным.
Выбор имен может стать задачей, поглощающей лишнее время у разработчика. Часто идентификатор, удовлетворяющий одним условиям противоречит другим. Кроме того, поддержать преемственность имен иногда бывает достаточно трудно.
Преимущества Соглашений
Данные соглашения об идентификаторах обеспечивают удобную технологию для формирования имен, удовлетворяющих вышеупомянутым критериям. Основной идеей является передача основных характеристик идентификатора как части в его названии. Эта простая идея, безусловно, требует уточнения (что, например, предполагается под "критерием", что делать если они(критерии) не уникальны?). Однако, давайте сначала оговорим общие положения.
Названия будут мнемоническими в строго определенном смысле: идентификатор будет очевиден для того, кто помнит название характеристики или принцип его построения.
Названия имеют смысловое значение: должна быть возможность отобразить любое название в наборе характеристик.
Названия будут непротиворечивы, так как произведены теми же самыми правилами.
Построение названий будет производится механически, следовательно быстро.
Выражения в программе могут быть проверены на преемственность методами, похожими на обычные измерения свойств объекта.
Правила обозначения
Предлагаются следующие правила обозначения:
1) Описание характеристики идентификатора входит в идентификатор. Удобной пунктуацией является указание характеристики перед названием, с разделением их (началом названия с большой буквы в Cи, например: rowFirst: row - характеристика, Fist - название).
2) Название отличают идентификаторы, имеющие один и тот же тип и существующие в одном контексте. Контекстом может являться как система в целом, так и блок, процедура, структура данных в зависимости от среды программирования. Если существует стандартное название, оно должно быть использовано. Выбор должен быть максимально простым, так как требуется уникальность идентификатора только в пределах определенного контекста.
3) Простые типы названы короткими тегами, которые выбраны программистом. Такие теги должны быть интуитивно понятны большинству программистов.
Тег должен быть коротким для выполнения четвертого условия (фактора), введенного нами выше. Названия составных типов должны включать имена составляющих. Существуют стандартные схемы построения указателя и массива. Другие типы данных могут быть определены произвольно. Например префикс p используется для указателей. В принципе, соглашения могут быть обогащены в соответствии с новыми схемами типов данных. Однако стандартные конструкции могут послужить еще долгое время. Следует отметить что поля структур не должны участвовать в формировании префикса, так как в этом случае конструкции более чем с двумя полями были бы просто не читаемыми. Более важна передача в префиксе для структуры ее сути, зависимой не от набора полей, а от способа ее использования.
Я рекомендую использование нового тега для каждой новой структуры данных. Тег с некоторой пунктуацией (первая или все заглавные буквы) тоже может и должен использоваться как имя типа для структуры. Использование новых тегов так же оправдано в тех случаях, когда это влияет на удобочитаемость программы.
Мой опыт показывает, что теги более трудны для выбора по сравнению с названиями. Когда необходим новый тег, первым желанием бывает использовать короткий, наглядный, общий и универсальный термин как имя типа. Это - почти всегда ошибка. Нельзя резервировать наиболее полезные термины и фразы для частных целей конкретной задачи или даже версии. Как правило любой универсальный термин одинаково применим ко многим типам, даже в той же самой программе.
Обратите внимание, что, как правило, очевидный выбор для названия, является и самым правильным. Причиной этому является то, что название должно быть уникально в рамках значительно меньшего по сравнению с тегом контекста. Так как названия, как правило, не участвуют в формировании других названий, им не требуется быть особенно короткими.
Например мы создаем графическую программу. В данном случае у нас существует тип данных "цвет". Естественным желанием является сделать префикс color для обозначения цвета. Однако при детальном рассмотрении может оказаться, что применение термина color более удобно в приложении к названию, например: LineColor. Для обозначения цвета более выгодным является сокращение, например clr. clrDefault.
Обозначение для упрощения написания.
Правильное формирование идентификаторов должно позволить нескольким программистам независимо создавать программу для решения одной задачи. Каждый программист должен знать правила именования, иначе будет невозможно организовать взаимодействие. Такой эксперимент бесполезен при рассмотрении крупного проекта, однако представляет из себя четкую цель. Результатом является возможность понимать и исправлять программу, написанную другим человеком. Такой результат достижим при надлежащем использовании общеопределенных соглашений. Именно поэтому процесс документирования тегов крайне важен.
Обозначение для процедур.
К сожалению, простое понятие квалифицированных напечатанных тэгов не работает для названий процедуры. Некоторые процедуры не получают параметров или не возвращают значения. Контексты названий процедур имеют тенденцию быть большими. Следующий набор специальных правил для процедур может работать весьма удовлетворительно:
1) Названия процедур должны отличаться от других названий пунктуацией, например, всегда начинаясь с заглавной буквы (тогда как тэги характеристик других идентификаторов пишутся строчными буквами).
2) Начинайте название процедуры с тега типа возвращаемого значения, если таковое существует.
3) Выразите действие процедуры в одном или двух словах. Слова должны быть разделены пунктуацией для более простого разбора читателем (обычный метод заключается в использовании заглавных инициалов для каждого слова).
4) В конец названия можно добавить список тегов некоторых или всех формальных параметров, если есть смысл.
Последний пункт противоречит более ранним замечаниям по описанию структуры данных. Если параметры процедуры будут изменены, то это повлечет за собой изменение имени и всех точек вызова процедуры. Однако такое изменение может быть использовано для проверки того, что все точки вызова измененной процедуры будут также выполнены корректно. В случае же со структурами данных, добавление или изменение поля не оказывает решающего влияния на использование типа данных. В случае если процедура имеет один или два параметра использование тегов упростит выбор имени.
1. Некоторые примеры для названий процедуры
Описание Название
InitSy Берет sy как его параметр и инициализирует его.
OpenFn fn - параметр. Процедура "откроет" fn. Никакое значение не будет возвращено.
FcFromBnRn Возвращает fc, для переданной пары Bn,Rn (Названия не передают нам информации о типе данных для Fc, Rn, Bn).
Далее приведен список стандартных конструкций, X и Y замещают произвольные теги.

2. Стандартные конструкции типа
pX Указатель на X.
dX Различие между двумя образцами типа X. X + dX имеет тип X.
cX Индекс образцов типа X.
mpXY Массив Ys, индексированного по X.
rgX Массив Xs.
iX Индекс массива rgX.
grpX Группа Xs, сохраненных последовательно. Используется когда X элементы имеют переменный размер и не применима стандартная индексация. Элементы X индексируются способом, отличным от обычного.
bX относительное смещение к типу X. Используется для обращений к полям переменной длины в структурах. Смещение может быть указано в байтах или словах, в зависимости от вида индексации.
cbX Размер X в байтах.
cwX Размер X в словах.
C конструкциями такого типа существует одна проблема. Например, является ли pfc собственно тегом или это указатель на fc. Ответ на такой вопрос может дать только человек, знакомый с принятой в рамках контекста системой именования.
Далее приведены стандартные имена. X замещает любой тег типа, записанный в нижнем регистре.

3. Стандартные спецификаторы
XFirst первый элемент в упорядоченном наборе X
XLast последний элемент в упорядоченном наборе X
XLim строгий верхний предел набора значений X. Границей цикла должно быть X < XLim.
XMax строгий верхний предел набора значений X. Если X начинается с 0, то XMax равен числу различных значений X.
XT временное значение X.

4. Некоторые базовые типы
f Флажок (Булева переменная, логическое значение). Используемое название должно относиться к истинному состоянию. Исключение: константы fTrue и fFalse.
w Машинное слово
ch Символ, обычно в тексте ASCII.
b Байт
sz Указатель на строку терминированную нулем (ASCIZ)

5. Базовые префиксы типов данных Win32
g_ префикс для глобальной переменной
m_ префикс для переменной класса
c константа (префикс для типа) const
l длинный (префикс для типа) far, long
p указатель (префикс для типа) *
ch char char
b байт BYTE, unsinged char
w 16-битное слово (2 байта) WORD, unsigned short
dw 32-битное слово (4 байта) DWORD, unsigned long
n,i целое int
flt с плавающей точкой float
dbl с плавающей точкой double
f логическое BOOL
sz ASCIZ строка char[]
psz ASCIZ строка char *
pcsz константа ASCIZ строка const char *
pv произвольный указатель void *
ppv указатель на произвольный указатель void **
h хендл HANDLE, void *
unk OLE объект IUnknown
punk указатель на OLE объект IUnknown *
disp Automation объект IDispatch
pdisp указатель на Automation объект IDispatch *

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

Как всегда, начинаем с планирования.

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

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

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

Приступаем. Вспоминаем первый урок, открываем студию и создаем новый проект, который я назвал labyrinth. Затем добавляем в него файл исходного кода и начинаем писать программу.
Для этого может скопировать исходный код из нашей игры «Осада», и удалить оттуда, из главной функции main все, кроме строчки

Она нам еще понадобится.
Далее объявляем четыре переменные:

Дальнейший код мог бы исполняться, только если условие истинно. Тогда как переменная GameOver ложная. Поставленный логический оператор !(НЕ) и превращает ложь в правду.
Вообще-то в первом шаге эта проверка не нужна, но чтобы в дальнейшем иметь возможность просто скопировать эти строки дальше, я и поставил его с самого начала. Ведь правильной работе он не мешает.
После проверки, происходит ввод информации и присвоение ее соответствующим переменным. Далее с помощью все того же оператора ветвления происходит проверка первой переменной – i для направления движения, и выполняется соответствующий блок кода для конкретной сектора. Эта проверка построена по уже знакомому принципу, последующая проверка производится только если первое условие ложное. Также обрабатывается и вариант, когда оба условия не правильные, то есть если введено некорректное значение.
Проверка сектора производится с помощью оператора switch.

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

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

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

Поэтому выкладываю ссылки на екзешники:
Осада – http://fabermun.at.ua/cpp/siege.rar
Лабиринт - http://fabermun.at.ua/cpp/labyrinth.rar
На этом все.
До встречи.

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

Эта запись аналогична следующей:

Подобный вариант записи операторов называется префиксным, тогда как предыдущий - постфиксным.
Результат работы обоих вариантов идентичный, а вот способ этой самой работы кардинально отличается
Если в выражении встречается инкремента или декремента в префиксной записи, то есть перед переменной, то значение переменной сразу уменьшается или увеличивается на единицу. Если запись постфиксная, то сначала выражение вычисляется полностью, игнорируя инкременту/декременту, и только затем эта переменная увеличивается или уменьшается на единицу.
Чтобы лучше это понять приведу соответствующий пример:

Здесь сначала х умножится на пять, значение будет присвоено у, а затем сработает инкремента и х увеличится на единицу. В результате у == 5, х == 2.
Обратите внимание на использование скобок. Если этого не сделать, то компилятор потеряется в нагромождении операторов. Про ошибку он не скажет, но вот результат будет непредсказуемый.
Ну и пример для префиксной записи:

В этом случае сначала х будет увеличен, а затем умножен на 5. В результате у == 10, х == 2.

Надеюсь, что вам все понятно.
Кроме того как эти операторы работают, необходимо знать что префиксная их запись работает быстрее чем постфиксная. И вот почему:

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

Конечно, если оператор выполняется всего один раз, то затраты времени не ощутимы, а вот если это где-то в цикле повторяется несколько сотен а то и тысяч раз, то это уже совсем другое дело.

Раз мы уже упомянули способы упрощения и улучшения кода, расскажу вам еще и о вариантах оператора присвоения.
Запись:

Можно упростить так:

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

Эти записи идентичны следующим:

Вот синтаксис этого цикла:

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

Второй, с использованием оператора break:

В последнем примере также продемонстрирован способ организации бесконечного цикла:

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

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

Обратите внимание. Здесь после

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

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

Синтаксис таков:

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

И подобный вариант уже был проиллюстрирован в примере.
А теперь приведу пример, чтобы лучше понять цикл for:

Далее вновь проверяется условие и если оно по-прежнему истинно – все повторяется.

Отмечу, что как в случае с while, условие в цикле for не обязательно должно относится к счетчикам.
Как и с оператором while, с оператором for также возможна организация бесконечного цикла. Для этого достаточно оставить все поля пустыми:

Здесь, когда i станет равно 2, сработает оператор continue, в результате чего строка

будет опущена, и цикл начнется заново с увеличенным на единицу значением i. Это если условие не станет ложным.

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

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

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

Итак, как обычно начинаем с планирования:

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

Как это будет реализовано.
Реализовано это будет в виде диалога. Программа спрашивает, какое число она сгенерировала. Игрок пытается отгадать и вводит свое предположение. Игра проверяет введенные данные и выводит результат, сообщая больше введенное от сгенерированного, меньше или равно.

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

Для генерации случайных чисел в С++ предусмотрена специальная функция – rand(). Что такое функция, мы поговорим на следующем уроке. А сейчас вы просто следуйте предложенным примерам.
Для того, чтобы использовать ее в своих программах необходимо подключить к исходному коду заголовочный файл stdlib.h. Как это делается я надеюсь, вы помните:

Ну и небольшой пример :

происходит генерация случайного числа с помощью функции rand() и его присвоение переменной r, а затем эта переменная выводится на экран. Поскольку все это происходит в цикле, то этот код выполняется несколько, в данном случае 10, раз.

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

которая это начальное значение и устанавливает.
Все что остается, это сделать это значение случайным.
Замкнутый круг, но выход есть. В качестве начального используют значение системного времени. При запуске программы время каждый раз будет разное, соответственно и результат работы генератора будет неповторим.
Теперь нам осталось узнать, как получить это системное время.
Для этого нам понадобится еще одна функция – time(0), которая выдает время в секундах, ведя отсчет от 1 января 1970 года по текущий момент. Естественно, что это число никогда не повторится. Для использования этой функции необходимо подключить еще один заголовочный файл time.h.

Вот код примера:

Следующая программа это и делает, а как – видно из комментариев:

результат равен 2. Это остаток от целочисленного деления. То есть 20 = (3*6)+2. Здесь тройка ближайший делитель, а оставшаяся двойка и есть результат.

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

Здесь сначала происходит обычное деление 20 на 6. Результат равен 3,3 (3 целых 3 десятых). Поскольку i у нас целочисленная переменная, запомните, что числа вроде 3,3 в ней хранится не смогут, и в результате преобразования типов дробная часть пропадает. Остается только целая часть 3.
Теперь мы множим эту тройку на шесть и то, что получилось, отнимаем от двадцати.
Результат это и будет то, что называют остатком от деления, и это как раз то, что получается при делении по модулю.
Теперь мы знаем, как этот оператор работает, что же нам это дает. А то, что при делении по модулю результат всегда будет меньше делителя как минимум на единицу.
Поэтому поделив таким способом любое случайное число, например, на десять, мы в результате получим число от 0 до 9.
То есть:

не зависимо от того что здесь выдаст rand(), х будет присвоено значение от 0 до 9.

Так, думаю, немного разобрались. Но что делать, если нам необходимо число не от 0 и до, а например от 50 и до 80.

Вот как это вычислить:

Сначала вычисляется разность между максимумом и минимумом, что равно 30.
Затем в части выражения rand()%(max-min) получаем случайное число в диапазоне от 0 до 30, и прибавляем его к 50 (минимуму в данном случае), получив таким образом число в необходимом диапазоне.
Надеюсь вам все понятно, ибо на этом с генерацией случайных чисел мы закончили и переходим непосредственно к написанию кода игры.

Думаю, вдаваться в детали не нужно, лишь расскажу вкратце, как он работает.
Вначале объявлены три переменные для хранения случайного числа, введенного значения и счетчика, которым тут же и присвоено начальное значения. Для счетчика это начало отсчета – 0, а вот для вводимого это отрицательное значение, чтобы выражение в условии цикла r!=i было истинным. Ведь сгенерированное число всегда положительное.
Далее происходит инициализация генератора и генерация случайного числа. Это случайное число сравнивается в цикле с вводимым значением, и до тех пор, пока они не равны, программа выдает подсказку больше или меньше сгенерированное число от введенного. Каждый цикл происходит наращивание счетчика попыток.
Как только пользователь вводит верное значение, цикл завершается и выводится результат, с указанием количества попыток. Все.

Мы уже на протяжении трех уроков учимся писать программы. Но до сих пор программы, в прямом смысле этого слова мы так и не увидели. Ведь то, что мы пишем это исходный код. Да он работает так, как задумано. Но программа с точки зрения обычного человека (не программиста) это некий файл, имеющий окончание .ехе, и его можно запускать в не зависимости от студии, и можно поделится им с друзьями, похваставшись своими достижениями.
Я вас обрадую. Такой файл существует, просто вы пока не знаете, а кто-то может уже и знает, где он находится. Сейчас я укажу вам на его месторасположение, заодно рассказав, из каких файлов и папок состоит проект и для чего они предназначены. Я имею в виду не то, как мы видим проект в студии в обозревателе решений, а то как он хранится на диске.
Итак, все свои проекты, если вы конечно ничего не меняли в настройках, студия хранит в папке Мои документы. Надеюсь, что вы знаете где находится эта папка. Если нет, то самое время поискать самому, ибо объяснять, как пользоваться операционной системой я не намерен.
В Моих документах студия создает папку Visual Studio 2008, это если студия 2008 года. Здесь есть несколько папок, в одной из которых – Projects, и хранятся все создаваемые пользователем проекты.
Каждая папка в Projects, это отдельное решение, которое может включать в себя несколько проектов. Поскольку все С++ проекты имеют одинаковую структуру, то объяснять я буду на примере своего проекта seashell, добавленного к этой статье.
Открываем решение sea. Внутри мы видим папки Debug, Release, seashell и файлы sea. sln , sea.suo и sea.ncb.
О Debug и Release. В этих папках, в зависимости от конфигурации решения, и находится необходимый нам ехе файл вместе с промежуточными файлами компоновки - seashell.pdb, seashell.ilk. Думаю стоит немного упомянуть о конфигурации решения. Есть два варианта конфигурации, или по-простому два набора настроек - Debug и Release. Debug используется в процессе разработки и отладки программы, а Release - для более-менее нормально работающей программы, которую предполагается поставлять конечному пользователю. В зависимости от выбранного, ехе файл попадает в соответствующую папку. О конфигурациях мы поговорим, когда будем изучать отладку программы, а сейчас возвращаемся к структуре проекта.
Файл sea. sln содержит информацию о проектах, входящих в решение. Запуск этого файла приводит к старту студии и загрузки всех объединенных в это решение проектов.
В файле sea.suo хранятся настройки решения. seal.ncb содержит данные, необходимые для работы компонента студии Intellisence. Intellisence – это инструмент, облегчающий работу в студии, подсказывая нам существующие названия переменных, функций и операторов, выполняя автозавершение кода и многое другое
В папке seashell хранится все, что относится к конкретному проекту. В ней находятся папки Debug, Release и три файла:
seashell.cpp – файл исходного кода.
seashell.vcproj.user и seashell.vcproj – файлы с настойками проекта.
А в папках Debug, Release, как и в прошлый раз в зависимости от выбранной конфигурации, хранится скомпилированный исходный код с дополнительными файлами.
На этом разбор структуры закончен. Возможно, из-за повторяющихся названий все выглядит немного запутанным, но не волнуйтесь, со временем вы освоитесь, тем более что самое важное что нужно запомнить – где находится этот самый екзешник, а о назначении остальных файлов знать пока не обязательно.

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

Удачи вам в ваших начинаниях.
Помните, ваше усердие будет вознаграждено приобретенными знаниями.
До встречи.

sea_src.rar - студийный проект с исходным кодом,
seashell_EXE.rar - запускаемый файл игры.

Как мы уже знаем байт состоит из восьми битов. Поскольку количество этих самых битов небольшое, то и, естественно, что записать с их помощью много чисел не получится. Поэтому размер переменных увеличивают до нескольких байтов. При этом занимаемое ими в памяти место увеличивается.
Теперь нам необходимо возвратится к уже изученным типам данных и узнать о них то, о чем я раньше умолчал. Сейчас я расскажу, сколько каждый тип данных занимает места в памяти и в каком диапазоне он может принимать значение.
Но прежде чем это делать, нужно объяснить еще один момент. Из школьных уроков математики вы должны знать, что существую положительные и отрицательные числа. В языке С++ такие числа относятся к знаковым, то есть предполагается что перед числом стоит плюс или минус. Ну и поскольку есть знаковые, то можно предположить что есть и беззнаковые, То есть всегда положительные, почему так, поймете дальше. Такие числа имеют отдельное обозначение - unsigned. Это ключевое слово ставится при объявлении переменной перед типом. Знаковые переменные тоже имеют обозначение - signed, но поскольку переменная по умолчанию считается знаковой, то его можно не использовать.
Пример:

идентична:

ПРЕДУПРЕЖДЕНИЕ!!!
Применение unsigned к float или double превращает тип переменной в int.

Ключевые слова signed и unsigned называются модификаторы(или спецификаторы) типа. Кроме названных есть еще несколько спецификаторов. Например, ключевые слова short и long которые применяются по отношению к целочисленному типу и увеличивают или уменьшают диапазон значений ну и размер.
Теперь я приведу небольшую таблицу в которой представлены типы даны, занимаемый ими размер и диапазон значений. Стоп. Лучше мы напишем для этого программу. Чтобы это сделать, нам необходимо узнать, как получить размер переменной определенного типа и как вычислить диапазон.
С размером все просто. В языке С++ есть специальная функция, которая умеет это делать – sizeof(). Ну а диапазон нам придется определять вручную, с помощью цикла. Помните, как мы это делали для генератора случайных чисел. Здесь будет нечто подобное, но мы воспользуемся интересным свойством переменных. Допустим, переменная имеет диапазон от 0 до 255. И сейчас ей присвоено максимальное значение 255. Как вы думаете, что будет, если прибавить к нему единицу? Значение переменной изменится на 0. Переменная будто закольцована сама на себя, и за пределы допустимого значения никогда не выйдет. Так и будет изменяться по кругу, в ту или иную сторону. Закольцованность работает в обе стороны, то есть если переменная равна нолю и отнять единицу, то значение станет 255.

В общем вот код:

Главную работу здесь выполняет вот этот кусочек, который повторяется несколько раз с некоторыми изменениями, в основном касающимися типа данных:

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

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

Считать диапазон float и других последующих типов я не стал. Программа и так работает несколько минут, а тронь я float, работала бы несколько дней.
Дело в том, что при одинаковом размере с типом int, float имеет диапазон от -1.0Е+37 до 1.0Е+37.(Если кто не знает что это значит, объясняю. +37 означает что нужно передвинуть точку вправо (от единицы) на тридцать сем знаков, подставив ноли. В результате получится число в котором 38 цифр. (Как его назвать я даже не знаю. Знаю есть квинтиллион, вроде 18 нолей, так ведь и это очень мало) Куда тут int с его 4 миллиардами.
Ладно. Как видно из получившейся у нас таблицы, некоторые типы данных при одинаковом размере отличаются диапазоном значений. В первую очередь это касается знаковых и беззнаковых. Сейчас я объясню, почему так происходит. Если число имеет определенный знак, не важно, плюс это или минус, то естественно, что этот знак должен где-то храниться. В переменной под знак резервируется крайний левый бит, также называемый старшим битом. Если он равен 0 то переменная положительная(знак + ), если 1 то отрицательная(знак -). Потеря всего одного бита уменьшает значение переменной в два раза. Она как бы делится пополам - одна половина для положительных, другая - для отрицательных чисел, что вы и можете видеть.
Упомянув о спецификаторах типа не возможно не рассказать еще об одном – const. Объявленную с его помощью переменную невозможно изменить. Такую переменную называют константой, и используют для хранения определенных постоянных значений. При объявлении константы ей нужно сразу же присваивать значение.
Пример:

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

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

Тип_данных имя_массива[размер массива];

Здесь:
Тип данных может быть любым известным вам типом. Ограничений нет.
Имя массива также может быть любым, главное чтобы оно соответствовало описанным ранее требованиям к именам.
Размер массива – здесь внутри квадратных скобок указывается, сколько именно переменных будет содержаться в массиве. Каждая такая переменная называется элементом массива.

Теперь, зная синтаксис, объявим массив, состоящий из 10 элементов типа int:

Доступ к конкретному элементу массива выполняется с помощью его индекса – порядкового номера. Для этого просто указываем индекс в квадратных скобках:

Здесь мы обратились к элементу с индексом пять. Но не к пятому по порядку. Важно запомнить что отсчет в языке программах на языке С++ начинается с 0.
То есть самый первый элемент имеет индекс 0, второй – 1. И так далее. Так что в нашем массиве с 10 переменными, индекс последней переменной будет 9.

Если всем элементам массива нужно присвоить определенное значении или последовательность значений, то это удобно делать в цикле.
Вот пример кода:

Есть еще один способ инициализации массива. Он используется во время его объявления. Вот синтаксис:

Тип_данных имя_массива[размер массива] = {список_значений};

Количество значений в строке {1,2,3,4,5,6,7,8,9,10} желательно, но не обязательно должна соответствовать размеру массива.

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

В таком случае размер массива будет равен количеству значений. То есть в результате объявления:

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

image004.png

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

Чтобы не заморачиваться с нулевым символом и размером лучше всего использовать следующий способ:

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

Я проиллюстрирую это примером:

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

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

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

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

Пример:

Допустим, есть следующий массив:

Вот как его можно представить графически:

На что похоже. Ну, например, на урезанное шахматное поле. Таким способом, сделав массив 8 на 8 элементов можно представить шахматную доску, или если брать шире, то вообще любое игровое поле. А содержащееся значение могут, например, означать силу или количество находящихся там существ, или просто тип юнита.
Инициализируют многомерные массивы также как и обычные. Разве что есть небольшое отличие в записи.

Укажу лишь на вложенные цикл:

Именно так здесь заполняются «коробки, вложенные в коробки».
Завершая с массивами, выполняю данное ранее обещание и привожу код преобразования из десятичной системы в двоичную:

здесь используется инкремента в постфиксной записи, поэтому сначала вычисляется все выражение и только после переменная ic уменьшается на единицу.

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

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

~ Битовое Не. Меняет значение бита на противоположное. Вообще, если сравнить 1 с логическим true, а ноль с логическим false (как оно в общем-то и есть) здесь можно использовать аналогию с логическими операторами. Помните пример:

Ну а вот битовый аналог:

& Битовое И. Как и логический вариант, этот оператор возвращает 1 если оба аргумента равны единице, во всех остальных случаях 0.

Битовый & поочередно применяется ко всем битам числа. Вот как это работает:

11010 & 10101 равно 10000

Немного отформатируем, чтоб было понятнее:
11010 &
10101 равно
10000

Если перевести все в привычную нам десятичную систему, то будет так:

26 & 21 = 16

Вот такая вот арифметика)
Воплотим ее в код:

| Битовое ИЛИ. И опять знакомая ситуация. Если один из аргументов равен 1, то 1 и будет возвращено .

Пример:
11010 |
10101 равно
11111
26 | 21 = 31

Измените предыдущий пример и убедитесь, что я прав.

^ Исключающее ИЛИ. А вот это нечто новое. Такого мы еще не видели. Оператор ИЛИ возвращает единицу, только если один(только один) из аргументов равен 1.

Пример:
11010 ^
10101 равно
01111

В привычном нам, десятичном, виде:

26 ^ 21 = 15

Помимо логических, для работы с битами также используются операторы сдвига. Это уже знакомые нам << и >>. Они сдвигают все биты числа соответственно влево или вправо, заполняя освободившиеся нолем.
Синтаксис использования этих операторов выглядит так:

переменная << число битов
переменная >> число битов

здесь число битов, это значение, означающее на сколько нужно произвести сдвиг.
Пример:

01011010 << 1 даст
10110100

а

01011010 >> 1 даст
00101101

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

Эта запись, если вы помните прошлые уроки, использует условный оператор и может быть записана следующим образом:

Где:
v - переменная,
n - номер бита.

Работает оно так. Сначала с помощью оператора сдвига создается переменная, в которой интересующий нас бит равен 1. Для этого переменная 1 имеющая двоичное представление 00000001, сдвигается на нужное количество битов влево. Допустим нам нужно узнать значение второго бита. Вспомним, что биты нумеруются от ноля.

(1 << 2)
00000001 << 2
Результат сдвига
00000100

Далее применяем битовый И. Если у переменной второй бит 1 то в результате выражения:

Если же второй бит равен нолю то:

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

Намного проще, не правда ли. Если кому-то непонятно, замените строку:

на:

Теперь дошло?

Здесь, как и в прошлом случае используется сдвиг для получения переменной, в которой значение конкретного бита 1, остальных 0.
Далее используется битовый оператор ИЛИ. Если у переменной второй бит и так 1 то в результате выражения:

11111111 | 00000100 Получим 11111111

Если же второй бит равен нолю то:

000000000 | 00000100 Получим 00000100

Далее результат присваивается исходной переменной.

Пример кода:

Здесь, вместо строки

у меня записано

Для сокращения записи я воспользовался составным присваиванием |=.

(Здесь тоже составное присваивание &=)

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

~00000100 дает 11111011

Затем, как и в случае проверки, используется битовый И.
Если у переменной второй бит 1 то в результате выражения:

01010101 & 11111011 Получим 01010001

Если же второй бит уже равен нолю, то там и менять нечего:

10101010 & 11111011 Получим 10101010

Этот код нужно добавить в приведенный выше пример перед cin.get();.

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

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

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

Использование функции можно разделить на три этапа:
1. Объявление функции
2. Определение функции
3. Вызов.

Здесь:
Тип возвращаемого значения – это тип переменной, которую возвращает функция по завершению своей работы. Как я уже сказал, у каждой функции есть свое назначение, она выполняет определенную работу. Возьмем простой пример – функция умеет суммировать два целых числа. Результат этого сложения и будет возвращен в виде целого числа.
Имя функции – это и есть имя. Ведь к функции как то нужно обращаться. К именам функций применимы те же требования что и к именам переменной. Помните главное - имя должно быть понятным.
Список аргументов(еще называют параметры функции) - это записанные в скобках передаваемые функции значения, попросту говоря это список переменных над которыми эта функция будет совершать определенные действия. Объявляются эти аргументы так же как и обычные переменные, и дальнейшем используются внутри функции. Несколько аргументов отделяются друг от друга запятыми. Количество аргументов не ограничено, но им может и не быть вовсе.
И обращаю ваше внимание, что завершает объявление уже знакомые нам точка с запятой.
Пример объявления функций:

Подобную запись еще называют прототипом функции. Здесь у нас объявлена функция которая не возвращает никакого значения( тип void – пустой тип) и не принимающая ни одного аргумента. Судя из названия, функция умеет что-то там печатать.

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

Здесь имена a и b отсутствуют, но они в прототипе не очень-то и нужны. Функций мы еще наобъявляемся, так что не будем тратить время и двигаемся дальше.

Итак, функцию мы уже объявили. Компилятор уже знает о ее существовании, но понятия не имеет, как она работает. Весь, принадлежащий функции код это и есть определение, по-другому реализация, функции.
Синтаксис такой:

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

Аргументы int a, int b используются в функции как обычные переменные.
Как мы уже знаем, функция возвращает определенное значение. Для этих целей в примере мы и видим оператор возврата - return.
Синтаксис оператора следующий:

Возвращаемым значением также может быть и любое выражение, как в нашем примере это a + b. Оператор возврата имеет самый низкий приоритет, то есть будет выполнен только после того, как все выражение будет вычислено.
Запомните, тип возвращаемого значения обязательно должен соответствовать типу, указанному в объявлении функции.
В одной функции может содержаться несколько операторов return. Чаще всего в следующей конструкции:

Здесь возвращенное значение зависит от заданного условия.

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

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

вызов будет таким:

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

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

В этом примере мы видим все, о чем говорили ранее. Объявление, определение и вызов.
В строке:

возвращенный функцией результат присваивается переменной b.

Пример неплохо иллюстрирует учебный материал, но созданная нами функция бесполезная. Более того, код примера неэффективный и некорректный, поэтому далее, чтобы получше освоить функции и получить еще крупицу опыта, мы его улучшим.
Говоря об эффективности, я имел в виду, что в примере есть бесполезные строки кода, ненужное объявление переменных и другое. От всего этого можно и даже нужно избавится, сделав нашу программу компактнее и быстрее(чисто теоретически, поскольку кода мало и повышение производительности никто не заметит.)
Теперь о корректности. В программе наличествует ввод данных. Подразумевается, что будет ведено какое-то число. Но что если пользователь случайно введет какое-то левое значение?
В программе произойдет сбой. А это не есть хорошо. Поэтому сейчас нам необходимо сделать соответствующую проверку. Поскольку, в случае ввода неверного значения программа должна запросить его повторно и вводить нам нужно несколько значений, получение и проверка данных от пользователя будет производиться внутри одной функции GetDigit(). Вот ее код:

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

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

После завершения основного цикла мы должны возвратить значения.

Поскольку с это массив символов(строка), а нам нужно число, чтобы выполнить соответствующее преобразование, используется еще одна стандартная функция atoi().
(Прототип int atoi(const char *str); Функция принимает указатель на строку, а возвращает число)
Она умеет превращать последовательность символов в число, при условии что символы – цифры. Иначе будет возвращен 0. Здесь нужно быть осторожным, поскольку можно запутаться, ведь строка тоже может быть «0». (Можете сами добавить соответствующую проверку, я этого делать не буду, а ниже приведу более сложный вариант функции GetDigit().)

Эту запись можно сократить, ведь абсолютно незачем использовать лишнюю переменную

Здесь напрямую возвращается результат работы функции atoi©. То есть, можно сказать, что после выполнения работы функция замещается значением возвращаемого ею типа. Поэтому ее и можно использовать в тексте программы непосредственно как значение:

аналогом этой записи будет

то есть:

Надеюсь это уяснили. Теперь внесем в нашу программу изменения, задействуем созданную нами функцию GetDigit(). Не забудьте добавить ее объявление. Теперь функция main() примет такой вид:

Здесь переменные a и a2 получают корректное значение, возвращенное нашей функцией.

ЗАДАЧКА.
До сих пор я не давал вам домашних заданий. Пора это менять. Итак, небольшая задачка. Измените приведенный выше пример так, чтобы переменная а2 оказалась ненужной.

Ну а теперь обещанный мной более продвинутый вариант функции GetDigit().

Я не буду вам объяснять как она работает. Вы должны попытаться разобраться в ней сами. В этом вам поможет встроенная в студию справка, или если у вас нелады с английским то Интернет.
Основное внимание в этом примере следует уделить новым функциям:
cin.peek()
cin.clear()
cin.get()
Правда с последней вы уже знакомы, но вот что она делает на самом деле вряд ли знаете.

Ах да. Я же на протяжении стольких уроков так и не рассказал, как пользоваться справкой . Виноват. Исправляюсь. Хотя там и рассказывать особо нечего.
Как и во всех других Windows приложениях, справка в студии вызывается нажатием клавиши F1. При этом справка здесь умная. Во вновь открывшемся окне выдается информация об элементе, который в данный момент является активным. Чтобы получить информацию о неизвестной вам стандартной функции языка, достаточно поместить на нее курсор и нажать вышеупомянутую клавишу.

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

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

И нажимаем F1. В появившемся окне можно получить информацию не только о природе ошибки, но и подробно, с примерами, узнать причины ее возникновения, а также способы устранения. Кстати если у вас русская студия, то информацию по ошибкам вы получите на родном языке. Эту часть они уже успели перевести.

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

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

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

Переменная i, объявленная вне главной функции main(), является глобальной. Она видима и внутри main и внутри вообще любой другой функции, например func.
Запомните, глобальная область предназначена только для объявлений или определений. Никакие другие действия в ней не работают. Если вы захотите выполнить, например, присваивание:

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

То есть:

Присваивание s = 10; никак не затрагивает s глобальную. Тогда как в функции func присваивание производится как раз глобальной переменной. Так что можно даже сказать, что это две разные переменные. И следующая программа это продемонстрирует:

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

Сейчас нам необходимо вспомнить об указателях. Функции способны работать с ними так же, как и с любым другим типом данных. В приведенном примере func()
возвращает указатель на переменную i. Вот только сама переменная, по завершении работы функции, перестает существовать. В результате наш указатель указывает на все, что угодно, то есть по старому адресу, только не на существовавшую ранее переменную, а ее значение (55) окажется потерянным.
Хуже всего то, что компилятор никак не сможет помочь вам избежать таких вот ситуаций. Тут уж все в руках программиста.

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