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

Итак! Для начала нам потребуется программа-компилятор.
Сразу введем новое понятие: компилятор - программа, собирающая из кусков целое.
Такую программу можно скачать на сайте microsoft.ru и называется она Microsoft Visual Studio.

Статья 1 : Первое знакомство.

1. Небольшое введение.
Было ли у вас такое, что запустив свою любимую игру, вы в очередной раз вздыхали: «Вот если бы при ударе этим молотом земля вздрагивала», «Почему эта магическая стрела не проходит на вылет и не поражает следующих врагов», «А вот эту кнопочку было бы удобнее переместить сюда».
А может быть у вас уже давно есть идея сделать собственную игру, вот только вы не знаете как, с чего начать. Что ж, я попытаюсь вам в этом помочь.
Большинство тех захватывающих игр, что заставляли вас ночи напролет просиживать у монитора, написаны на языке программирования С++.
В этой и последующих статьях я познакомлю вас с основами этого замечательного языка. Сделать это я попытаюсь как можно проще и понятнее. И, поскольку мы учим С++ для того, чтобы делать игры, каждая статья будет строится на примере создания простенькой игры. Постепенно, вместе с ростом наших знаний и опыта, игры будут усложняться.
Конечно, путь этот долог и тернист, но не переживайте, у вас обязательно все получиться. Главное – не сомневаться в себе и быть настойчивым.

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

Code
#include <iostream>       
using namespace std;       
int main( void )  // главная функция программы
{       
cout << "Начинающий программист приветствует этот мир!";       
return 0;       
}
Совершенно непонятно, да к тому же и на английском. Правда? Ну что ж, сейчас будем со всем разбираться.

Первая строчка:

Code
#include <iostream>
В мире очень много программистов. Чтобы облегчить им жизнь и сэкономить время, некоторые часто используемые фрагменты кода были собрана в обширные библиотеки. Для лучшей ориентации в этих библиотеках их содержимое описывают в специальных заголовочных файлах. Команда #include подключает один из таких файлов с названием iostream.
Следующая строчка:

Code
using namespace std;
тесно связана с предыдущей. Она заставляет работать подключенные библиотеки так, как нам нужно. Более подробно ее назначение будет объяснено в следующих статьях, поскольку сейчас оно окажется весьма сложным.
Далее идет:

Code
int main( void )  // главная функция программы
Первая часть строки:

Code
int main( void )
это название самой главной функции, с которой начинается выполнение программы. Функция - это код или фрагмент кода, выполняющий определенные действия. С ними мы также познакомимся позже. Сейчас достаточно знать, что функция с названием main должна содержаться в каждой программе.
Вторая часть строки:

Code
// главная функция программы
это комментарий.

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

/*коментарий*/

/* - открывает комментарий, а */ - его закрывает. Все, что находится между ними, считается комментарием и игнорируется. Таким образом комментарий можно растянуть на несколько строк или вставить в любое место кода. Вот так:

Code
using namespace /*комментарий*/ std;
или так:

Code
int main(/*комментарий*/void )
Следующая строка состоит всего из одного символа – фигурной скобки:

{

Эта скобка открывающая. Если посмотреть дальше по коду то можно найти ее сестру } – скобку закрывающую. Между этими скобками заключается принадлежащий функции main код. Этот код также называют «телом функции».
Но мы немного забрались вперед, поэтому возвращаемся назад к строчке:

Code
cout « "Здравствуй, мир!";
Здесь cout – некий объект, представляющий средство для вывода данных. Для того, чтобы им пользоваться мы и подключили файл iostream.
cout можно перевести с английского как с-Вывод(с-Out). Все что он делает в нашем случае, это печатает строку "Здравствуй, мир!" на экране.

Ну и на конец:

Code
return 0;
Этой строчкой заканчивается выполнение функции main. Обычно выполняющая какую либо работу функция, возвращает таким образом результат своей деятельности. Но, поскольку main у нас самая главная, и после нее уже никакие действия выполняться не будут, возвратив 0, она показывает системе, что ее работа успешно завершена.
Как вы наверное заметили, большинство строк заканчивается точкой с запятой (. Таким образом в исходном коде эти строки отделяются друг от друга. Это обязательное правило, но не для всех строк. Чтобы понять где ставить точку с запятой, а где нет, введем такое понятие как инструкция. Каждая строчка кода, предназначенная для выполнения какого либо действия в конечной программе, называется инструкцией или оператором. По сути оператор это символ(+,-), пара символов(++, ==) или даже некий термин(sizeof), которые заставляют компьютер выполнять определенные действия. После инструкции или оператора обязательно ставится точка с запятой.
Но как мы можем видеть, после #include запятой нет. Все потому что #include - это так называемая директива предпроцессора. Директива начинаются со знака # и после нее точка с запятой не ставится. Директивы выполняются компилятором еще до начала процесса компиляции, поэтому на компиляцию поступают не они сами, а результат их работы.
Я только что трижды использовал непонятное слово – компиляция. Дальше вы узнаете, что это такое.

3. Немного о компиляции
Мы уже разобрались с устройством простейшей программы на С++. Все, что теперь нужно, это увидеть как она работает. Но не все так просто. Для того чтобы запустить программу, из понятной нам ее нужно сделать понятной для нашего компьютера.
Представьте что компьютер это иностранец, с которым вам необходимо поговорить, но требуемого языка вы не знаете. В таком случае вам поможет переводчик. Вот и в компьютере используется подобный переводчик, превращающий написанный вами исходный текст в понятный компьютеру «машинный код». Это делается с помощью специальной программы - компилятора, а сам процесс называется компиляцией. Только странный это переводчик. В машинный код он переводить умеет, а вот обратно – нет.
Но компиляция не делает из исходного кода полноценную программу. Компилятор лишь выдает нам результат своей работы - объектный файл. Почему так?
В нашей программе используется средство для вывода текста в виде объекта cout, функциональность которого обеспечивается сторонней библиотекой. Для работы эта библиотека, да и другие, о которых вы пока и понятия не имеете, должна быть подключена к вашей программе. Эти функции выполняет программа компоновщик. Она запускается после компилятора и компонует(собирает вместе) ваш объектный файл с необходимыми библиотеками, в результате чего создает исполняемый файл.
Как же все сложно, скажете вы. И будете правы. Когда-то все эти действия приходилось выполнять вручную, но сейчас для этих целей созданы специальные программы, в которых все необходимые инструменты(компилятор, компоновщик, редактор исходного кода и другие) собраны(интегрированы) вместе. Они так и называются - Интегрированная среда разработки программного обеспечения. На английском - Integrated Development Environment или сокращенно – IDE. Этим нерусским термином мы и будем чаще всего пользоваться.

4. Подготовка и основы работы с IDE Microsoft Visual Studio 2008
В процессе обучения мы будем использовать среду разработки Microsoft Visual Studio 2008. Взять ее можно на официальном сайте компании Микрософт. Студия поставляется в нескольких версиях:
Express – бесплатная, но с сильно урезанной функциональностью.
Standard, Professional, Team System – платные и полнофункциональные, но Микрософт дает на них довольно продолжительный период ознакомительного(триал) использования, на некоторые версии до 180 дней. Для обучения вполне хватит.
В общем, выбор я оставляю на ваше усмотрения, но сам буду использовать Microsoft Visual Studio Team System 2008(В дальнейшем я буду называть ее просто - Студия ). Если у вас не эта версия, то возможны некоторые отличия в интерфейсе на скринах. Обязательно качайте русскую версию, так будет проще и вам и мне.
Если вы выбрали Express, то рекомендую также скачать и установить отдельно поставляемую библиотеку документации – MSDN. Для остальных версий она входит в пакет установки. Поверьте, эта документация вам еще не раз пригодится.

Приступаем к работе
Будем считать, что Студию вы уже скачали и установили. Запустив ее, вы увидите вот такое окно:

Кроме панелей инструментов, в основном окне присутствуют три области – три окна:
1. Окно, в котором сейчас по умолчанию открыт Проводник решений – нечто вроде Проводника Windows, только этот служит для навигации по файлам проекта.
2. Рабочая область – окно, в котором сейчас открыта начальная страница, а в дальнейшем здесь будет открыт файл исходного кода.
3. Окно определения кода – в этом месте, во множестве вкладок, будет выводится информация о процессе создания программы, ее работе, уведомления об ошибках и другое.

Создание нового проекта
Далее для работы нам необходимо создать новый проект и добавить в него файл для исходного кода.
Делается это так:
1. Выберите пункт Файл→Создать→Проект
(подобная запись означает что вам необходимо кликнуть на пункте меню «Файл», затем в появившейся панели выбрать «Создать» и в следующей панели кликнуть на меню «Проект…»)

Откроется окно Новый проект. В левой его части Типы проектов необходимо кликнуть на плюсике напротив пункта Visual C++ и в открывшемся списке выбрать Win32. После этого в правой части Шаблоны выбрать «Консольное приложение Win32». Далее внизу указать имя нового проекта(у меня это Siege, вы же можете выбрать какое вам понравится), расположение каталога для проекта и поставить галочку напротив пункта «Создать каталог для решения». Имя решения будет заполнено автоматически, но при желании его можно изменить. Мы этого делать не будем.

Жмем ОК.
В следующем окне Мастер приложений Win32 в левой его части выбираем пункт Параметры приложения и в правой отмечаем галочкой Пустой проект. Если этого не сделать будет создан проект с несколькими файлами и пока нежелательными для нас настройками.

Жмем Готово.
После этого обозреватель решений примет такой вид:

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

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

Откроется следующее окно:

В Категориях нужно выбрать пункт Код, а в Шаблонах – Файл С++(.срр). (.срр - это формат расширения текстового файла, в котором содержатся исходные коды, написанные на языке С++.)
В строку Имя необходимо ввести желаемое имя файла.
После этого можно нажать Добавить.
В обозревателе решений в папке Файлы исходного кода должен появиться новый файл. В моем случае это Siege.cpp.

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

Теперь все что нам необходимо это создать исполняемую программу, или как это называется в студии - построить решение. Для этого нужно:
1. Откомпилировать исходный код.
2. Провести его компоновку, то есть собрать файлы проекта в один исполняемый файл.

Делается все это нажатием всего одной кнопки - F7.
Студия быстро выполнит все необходимые действия попутно выводя отчет о работе во вкладку Вывод, открывшуюся внизу вместо «Окно определения кода».

После этого приложение можно запустить, нажав комбинацию клавиш Ctrl+F5 или просто F5. Разницу между этими комбинациями мы узнаем немного позже.
При этом может появится вот такое диалоговое окно с вопросом:

Оно означает, что с момента последнего построения в исходный код были внесены изменения. Рекомендую отметить «Больше не выводить это сообщение» и нажать Да.
Кстати, из этого также следует, что специально проводить построение нет необходимости, достаточно нажать Ctrl+F5 или F5, и если исходный код изменялся, студия откомпилирует и скомпонует его автоматически.
В общем, вы нажали кнопку, но вместо запущенной программы на долю секунды появилось и пропало черное окно. В чем же проблема? Возможно ошибка?
Нет! Посмотрев в окно Вывод можно заметить там такую строчку.

Code
Программа "[3724] Siege.exe: Машинный код" завершилась с кодом 0 (0x0).
Ничего вам не напоминает? Объясняя код первой программы, я говорил о команде return 0;. О том, что в случае успешного завершения работы программы она возвращает ноль. «завершилась с кодом 0» - это он и есть. А значит, программа отработала так, как нужно. Все дело в том, что после того, как была отображена надпись, программа сразу же закрылась, и мы ничего не увидели. Нужно ее как-то затормозить.
Это мы сможем сделать, добавив перед return 0; следующую строчку:

Code
cin.get();
Она заставит окно программы оставаться открытым, пока не будет нажата любая клавиша. Внеся изменения в код, запускаем проект и появившемся окне видим следующее:

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

Code
setlocale( LC_ALL, "Russian" );
Поместить ее необходимо внутри функции main перед выводом текста:

Code
setlocale( LC_ALL, "Russian" );
cout << "Начинающий программист приветствует этот мир!";
После этого все заработает так, как нужно и после запуска появится вот такое окно.

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

Foundling - масштабная 2D RPG для мобильных устройств
WindMill 2D Game Engine

     
nilrem Дата: Среда, 19.08.2009, 00:11 | Сообщение # 2

Просветленный разум

Сообщений: 1134
Сейчас нет на сайте
5. Мини игра «Осада»
Теперь, приобретя некоторые знания, попытаемся написать небольшую игру. А как же иначе, ведь мы будущие программисты игр. В процессе ее разработки мы освоим такие новые элементы языка как переменные, операторы и ввод-вывод.

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

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

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

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

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

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

Code
cout << “””;
и компилятор выдаст ошибку.

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

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

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

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

Code
cout << "Начинающий программист приветствует этот мир!";
в любое понравившееся место выводимого текста, одну из представленных символьных последовательностей. Запустите программу и полюбуйтесь на результат. Наигравшись досхочу, можем переходить к изучению дальнейшего материала.

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

Code
cout << "Допустим что в этом тексте 150 символов.";   
cout << "И в этом 150";   
cout << "Ура, мы напечатали намного больше, чем 256 символов.";
Вышеуказанный пример можно немного сократить. Синтаксис языка допускает такой вариант оформления:

Code
cout << "Допустим что в этом тексте 150 символов." << "И в этом 150"  << "Ура, мы напечатали намного больше, чем 256 символов.";
Как в первом, так и во втором варианте текст будет выведен в одну строку. Каждый следующий cout начинает вывод в том месте, где остановился предыдущий.

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

Code
cout << "Допустим что в этом тексте 150 символов." << "И в этом 150"  << "\nУра, мы напечатали намного больше, чем 256 символов.";
И мы получим:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Code
int х = y + 256 - 13 * z / 3;
Надеюсь, вы помните со школы, что арифметические операторы имеют приоритет выполнения. Если нет, то я вам напомню. Выше по тексту в списке операторы расположены согласно их приоритета. То есть наивысший приоритет имеет умножение, оно будет выполнено в первую очередь, а вычитание будет выполнено последним.
Но самый низкий приоритет среди операторов имеет оператор присвоения (=). В выражении он всегда выполняется последним, присваивая результат вычислений переменной.
Если нам нужно чтобы вычисление в выражении произошло в иной последовательности чем это предписано приоритетами, то необходимо использовать скобки.

Code
int х = y + (256 – 13) * (z / 3);
В этом случае сначала будет выполнено вычитание и деление, а уже затем, согласно приоритета операторов – умножение, а за ним сложение.
Надеюсь что вы еще не устали. На текущий момент это вся информация, которую вам необходимо знать об арифметических операторах. Так что можете немного отвлечься и пойти погулять.

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

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

Code
    int Draco=2;    // Дракон
   int Golem=4;    // Голем
   int Arrows=3;    // Лучники
   int Peasant=1;    // Крестьяне
Дальше по сюжету нам необходимо выбрать, на какую стену, то есть против какого противника кого из воинов послать. Список воинов с их порядковыми номерами и небольшой инструкцией выводим следующим кодом:

Code
    cout << "Ваша армия состоит из\n";
   cout << "1. Асасинов\n";
   cout << "2. Магов\n";
   cout << "3. Латников\n";
   cout << "4. Катапульты\n\n";
   cout << "(Для выбора вариант ответа вводите соответствующий номер и нажимаете ENTER.\n";
   cout << "Выбрать войска можно только один раз.)\n\n";
   cout << "Кого вы отправите против Дракона?\n";

.
Здесь тоже все должно быть понятно. В последней строке программа задает вопрос, на который ожидает ответ. То есть далее предполагается получение от пользователя определенных данных. Эти даные нужно где-то хранить, поэтому нам необходимы еще целочисленные переменные. Но поскольку их ввод будет производится последовательно, после каждого введенного числа можно проводить вычисления для отдельного типа войск. Поэтому для ввода нам будет достаточно всего одной переменной.
Code
int i;
Как видим, значение у нее нет, поскольку оно в последствии будет получено от пользователя. Вспоминаем что ввод осуществляется с помощью оператора cin и добавляем необходимый код:

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

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

Code
cout << "Кого вы отправите против Голема?\n";
   cin >> i;
   Golem = Golem - i;
   cout << "Кого вы отправите против лучников?\n";
   cin >> i;
   Arrows = Arrows - i;
   cout << "Кого вы отправите против крестьян?\n";
   cin >> i;
   Peasant = Peasant - i;
Теперь, когда все данные получены, вычисления произведены можно выводить результат, добавив к нему описание условия победы или поражения:

Code
    cout << "У противника осталось " << Draco << " Драконов, "<< Golem << " Големов, "<< Arrows << " Лучников, "<< Peasant << " Крестьян\n." << "Если войск у противника не осталось - ВЫ ВЫИГРАЛИ";
Как видно из кода, я воспользовался вторым способом вывода, без повторного использования оператора cout. Но в коде, вместо текстовых строк присутствуют используемые для войск переменные. Как я уже упоминал, само имя переменной для программы не важно, она работает с ее значением. Поэтому вместо имен переменных в тексте будут напечатаны их значения. Переменная – это не текст, так что ее имя в кавычки заключать не нужно.
На этом написание нашей первой игры завершено. Добавлю лишь некоторые моменты. Обьявление переменных желательно проводить в начале кода, так сразу будет понятно, какими данными управляет программа.
Строка для вывода данных в конце прграммы получилась слишком длинной и в редакторе вышла за пределы экрана, что неудобно. Поэтому ее можно разбить на несколько частей вставив перенос строки(клавиша Enter). При этом важно знать что разбивать на части операторы, имена переменных или строки нельзя. Подобное будет воспринято компилятором как ошибка. Вот такая запись не правильная:

Code
cout << "У противника   
осталось " << Draco <<
" Драконов, "<< Golem <
< " Големов, ";

Нужно так:
Code
cout << "У противника осталось "
<< Draco <<   
" Драконов, "<< Golem <<
" Големов, ";
Вот полный исходный код нашей игры:

Code
#include <iostream>   
using namespace std;

int main( void )  // главная функция программы
{       
   setlocale( LC_ALL, "Russian" ); // задействование русского языка
     
   int Draco=2;    // переменная для Дракона
   int Golem=4;    // голем
   int Arrows=3;    // лучник
   int Peasant=1;    // крестьянин
   int i=0;  // переменная для хранения введенного игроком числа

   // Вывод вступительного текста
   cout << "После долгого, долгого перехода вы наконец-то добрались к окресностям форта,\n";
   cout << "который приказом короля вам велено захватить.\n";
   cout << "Но, как выяснилось, форт хорошо охраняется:\n\n";
   cout << "Южные ворота охраняет Дракон.\n";
   cout << "Северную стену - Голем.\n";
   cout << "На восточной расположились лучники,\n" ;
   cout << "а на западной - крестьяне.\n\n";
   cout << "Ваша армия состоит из\n";
   cout << "1. Асасинов\n";
   cout << "2. Магов\n";
   cout << "3. Латников\n";
   cout << "4. Катапульты\n\n";
   cout << "(Для выбора вариант ответа вводите соответствующий номер и нажимаете ENTER.\n";
   cout << "Выбрать войска можно только один раз.)\n\n";
   cout << "Кого вы отправите против Дракона?\n";
   cin >> i;    // получение данных от игрока
   Draco = Draco - i;  // вычисление результата для Дракона
   cout << "Кого вы отправите против Голема?\n";
   cin >> i;    // получение данных от игрока
   Golem = Golem - i;  // вычисление результата для Голема
   cout << "Кого вы отправите против лучников?\n";
   cin >> i;    // получение данных от игрока
   Arrows = Arrows - i;    // вычисление результата для Лучников
   cout << "Кого вы отправите против крестьян?\n";
   cin >> i;    // получение данных от игрока
   Peasant = Peasant - i;    // вычисление результата для Крестьян

   // Вывод результата вместе с условиями выиграша
   cout << "У противника осталось " << Draco << " Драконов,"
    << Golem << " Големов, "<< Arrows << " Лучников, "<< Peasant <<   
    " Крестьян\n." << "Если войска остались - ВЫ ПРОИГРАЛИ";

   cin.get();    // ожидание нажатия клавиши
   cin.get();    // ожидание нажатия клавиши
   return 0;    // возвращение значения, и завершение программы
}

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

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