}
Как правило, функция используется для вычисления какого-либо значения, поэтому перед именем функции указывается его тип.
Сведения:
- если функция не должна возвращать значение, указывается тип void;
- тело функции является блоком и, следовательно, заключается в фигурные скобки;
- функции не могут быть вложенными;
- каждый оператор заканчивается точкой с запятой (кроме составного оператора).
Каждая программа должна содержать функцию с именем main. Эта функция является точкой входа, с которой начинается выполнение программы. Обычно в main() отсутствуют параметры. Тело функции всегда заключается в фигурные скобки. Ключевое слово intиспользуется для обозначения того факта, что функция возвращает некоторое целочисленное значение, которое затем будет использовано операционной системой для определения факта завершения программы с ошибкой. Если ошибок не было, то функция main должна возвратить значение, равное 0.
Листинг 1.2
// Приложение с использованием стандартной
// библиотеки ввода-вывода
#include “stdafx.h”
#include <stdio.h>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
printf(“\tHello world!\n”);
return 0;
}
Листинг 1.3
// Приложение с использованием потоковой
// библиотеки ввода-вывода
#include “stdafx.h”
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
cout << ‘\t’ << “Hello world” << ‘\n’;
// можно и так: cout << “\tHello world!\n”;
return 0;
}
Эта программа выводит на экран фразу «Hello world!». Кроме переменных, cout и printf воспринимают еще и управляющие символы, такие как \n - символ перевода строки. Все, что встречается после символов \n, будет показано с начала следующей строки. В приведенном примере кроме \n присутствует еще и символ табуляции \t. Он поводит к тому, что фраза «Hello world!» окажется не в начале строки, а с некоторым отступом вправо.
|
|
Последовательности символов, начинающиеся с обратной косой черты, называют управляющими, или escape-последовательностями. Управляющая последовательность интерпретируется как одиночный символ. Если непосредственно за обратной косой чертой следует символ, не предусмотренный таблице, результат интерпретации не определен. Если в последовательности цифр встречается недопустимая, она считается концом цифрового кода.
Управляющие последовательности могут использоваться и в строковых константах, называемых иначе строковыми литералами. Например, если внутри строки требуется записать кавычку, ее предваряют косой чертой, по которой компилятор отличает ее от кавычки, ограничивающей строку:
"Открытое Акционерное Общество \"Волна\""
Все строковые литералы рассматриваются компилятором как различные объекты. Строковые константы, отделенные в программе только пробельными символами, при компиляции объединяются в одну. Длинную строковую константу можно разместить на нескольких строках, используя в качестве знака переноса обратную косую черту, за которой следует перевод строки. Эти символы игнорируются компилятором, при этом следующая строка воспринимается как продолжение предыдущей.
Управляющие символы (табл. 1.2) заключаются в одинарные кавычки и начинаются с обратной косой черты (обратного слеша). Не будь ее, объект cout и функция printf воспринял бы запись 'n' как строчную латинскую букву «n», а 't' - как латинскую букву «t» и т.д. Поэтому фразу «Hello world!» можно вывести на экран «по буквам».
|
|
Таблица 1.2 - Управляющие символы
| Название | Обозначение |
| Символ новой строки | \n |
| Горизонтальная табуляция | \t |
| Вертикальная табуляция | \v |
| Возврат на шаг | \b |
| Возврат каретки | \r |
| Обратная слэш | \\ |
| Апостроф | \’ |
| Двойная кавычка | \” |
| Нулевой символ | \0 |
| Звуковой сигнал | \a |
| Перевод страницы (формата) | \f |
| Восьмеричный код символа | \0ddd |
| Шестнадцатеричный код символа | \0xddd |
Листинг 1.4
#include “stdafx.h”
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
cout << ‘\t’ << ‘H’ << ‘e’ << ‘l’ << ‘l’ << ‘o’
<< ‘\x20’ << ‘w’ << ‘o’ << ‘r’ << ‘l’ << ‘d’
<< ‘!’ << ‘\n’;
return 0
}
Одна из особенностей языка C++ - так называемая перегрузка дает необязательным использование указателей формата. В отличие от функцииprintf(), которая требует обязательное указание формата, coutпри передаче параметров сам определяет формат на основании типа получаемых данных. Этот процесс называется перегрузкой. Аналогично оператору потокового вывода cout работает оператор потокового ввода cin:
cin >> t;
где t - переменная, значение которой необходимо ввести пользователем.
Программа, составленная на языке C++, может содержать одну или больше функций. Многие функции, которые могут понадобиться, уже написаны, откомпилированы и помещены в библиотеки, так что достаточно просто указать компилятору использовать одну из стандартных функций. Необходимость написания собственной функции возникает только в том случае, если подходящей нет в библиотеках.
|
|
В программах на C++, использующих консоль, должна присутствовать функция main(), в отличие от приложений Windows, где точкой входа является функция WinMain(). Круглые скобки являются частью имени функции и ставить их надо обязательно, так как именно они указывают компилятору, что имеется в виду функция, а не просто английское слово main. В противном случае компиляция не будет завершена. Фактически каждая функция включает в свое имя круглые скобки, но в большинстве случаев в них содержится некая информация. В дальнейшем в тексте книги, ссылаясь на функцию, мы всегда будем ставить после ее имени круглые скобки.
Следом за main() вводятся инструкции. Инструкции могут быть представлены в виде стандартных команд и имен функций, содержащихся в библиотеках или написанных вами самостоятельно. Прямая, или открывающая фигурная скобка ({) помещается перед первой инструкцией, а обратная, или закрывающая фигурная скобка (}) следует за последней инструкцией.
Открывающая и закрывающая фигурные скобки называются ограничителями блока и служат для выделения части кода в единый блок. Каждая функция всегда должна начинаться и заканчиваться фигурными скобками. Кроме того, отдельные блоки внутри функции также могут отмечаться при помощи своих собственных пар фигурных скобок.
При запуске программы компьютер начинает ее выполнение с первой инструкции функции main().
Функции консольного ввода-вывода clrscr(), getch(), cputs(). Поскольку разрабатываемые в данном методическом указании программы будут совместимы с MS-DOS, то рассмотрим функции консольного ввода-вывода.
Все прототипы этих функций находятся в файле conio.h. Приведем краткое назначение каждой из этих функций.
Функция clrscr() предназначена для очистки экрана.
Функция getch() предназначена для ввода одного символа с клавиатуры. Она ожидает нажатие клавиши и не отображает введенный символ на экран. Часто эту функцию используют для задержки окна вывода.
Функция puts() выводит на экран текстовую константу, заключенную в кавычки, в конце строки в обязательном порядке печатаются символы ‘\r’ и ‘\n’, иными словами при использовании данной функции курсор автоматически переводится на новую строку. В отличие от предыдущих двух функций, данная функция входит в библиотеку стандартного ввода-вывода, и для ее использования необходимо подключить заголовочный файл stdio.h. Аналогом данной функции в библиотеке консольного ввода-вывода служит функция cputs().
Ниже приведен листинг программа на C++, которая выводит на экран монитора фразу «Hello world!» с помощью описанных функций.
Листинг 1.5
#include “stdafx.h”
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
puts(“Hello world!”);
cputs(“Hello world!”);
}
Кавычки, отмечающие слово внутри круглых скобок в функции puts() не выводятся на экран. В языке C++ они означают, что на экран следует вывести заключенную в них последовательность символов, а не константу или переменную.
Точка с запятой в языке C/C++ является разделителем и отмечает конец инструкции. Разделитель показывает компилятору что данная инструкция завершена и дальше начинается следующая инструкция или заканчивается программа. Точку с запятой необходимо ставить после каждой отдельной инструкции, так, как это показано в листинге 1.5. Вышесказанное не означает, что точку с запятой надо ставить в конце каждой строки. Иногда инструкция занимает больше одной строки и в этом случае точку с запятой надо ставить только один раз, отмечая конец команды.
C++ является языком свободного формата. Это означает, что для него не имеет значения, где будут помещены ограничители и начало строки. С таким же успехом можно написать программу следующим образом:
int main(){puts("Hello world!"); return 0}
и компилятор обработает ее так же, как и предыдущую. Но для того, чтобы сделать программу более читабельной, принято следовать определенным правилам:
- помещать функцию main() на отдельной строке;
- помещать фигурные скобки на отдельных строках;
- создавать в тексте программы отступы с помощью табуляции.
Когда ваша программа станет достаточно длинной, вы увидите, что с помощью отступов можно сделать более понятной структуру программы и выделить логические единицы.
В то время как наличие или отсутствие пробелов не оказывает влияния на код, создаваемый компилятором, правильная расстановка всех знаков пунктуации имеет принципиальное значение. Если вы пропустите скобку, кавычку или точку с запятой, компилятор немедленно остановит работу и сообщит об ошибке. Такие ошибки называются синтаксическими, и для того, чтобы компилятор мог создать исполняемый код программы, вам придется исправить их.
Использование комментариев. По мере того, как программа усложняется, становится все труднее запоминать, почему вы употребили ту или иную инструкцию, особенно если вы решили снова посмотреть программу по прошествии некоторого времени с момента ее создания. Еще сложнее разобраться в программе, написанной другим человеком.
Добавление комментариев сделает любую программу более легкой для понимания. Комментарий - это сообщение для того, кто читает исходный код программы. Комментарии могут помещаться в любом месте программы. Компилятор и компоновщик игнорируют комментарии, так что их содержимое не включается в объектный и исполняемый файлы.
Тому, кто только начинает программировать, введение комментариев не нужной роскошью, ведь он и так тратит массу времени на создание программы. Действительно, небольшой, простой, легко тестируемой программе, ее из небольшого числа строк, комментарии не нужны. Однако, читая программу, вы будете благодарны ее автору за любые пояснения, пусть программа не так уж и сложна.
Комментарий либо начинается с двух символов «прямая косая черта» (//) и заканчивается символом перехода на новую строку, либо заключается между символами-скобками /* и */. Внутри комментария можно использовать любые допустимые на данном компьютере символы, а не только символы из алфавита языка C++, поскольку компилятор комментарии игнорирует. Вложенные комментарии-скобки стандартом не допускаются, хотя в некоторых компиляторах разрешены.
Листинг 1.6
/*Эта программа выводит сообщение на экран*/
#include “stdafx.h”
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
puts("Hello world!");
return 0;
}
Символы /* указывают начало строки комментария, а символы */ отмечают ее конец. Все, что помещено между ними, C++ игнорирует. Как правило, в начале текста программы программисты помещают строку комментария чтобы пояснить цель ее создания. Внутри текста программы помещаются комментарии, поясняющие употребление отдельных инструкций или последовательность логических шагов. Такие комментарии обычно помещают после разделителя, то есть точки с запятой:
Листинг 1.7
/*Эта программа выводит сообщение на экран */
#include “stdafx.h”
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
/*На экран выводится сообщение "ОК"*/
puts("Hello world");
return 0; /*Возврат в операционную систему*/
}
При записи инструкции и комментария в одной строке принято (исключительно для удобства чтения) разделять их некоторым количеством пробелов. Комментарий может быть многословным и занимать не одну, а несколько строк. В этом случае символы */, указывающие конец комментария, можно поместить сразу после текста комментария или на отдельной строке.
Весьма распространенным недосмотром, который часто допускают начинающие программисты, является то, что они забывают ставить символы */ в конце комментария, и в результате получают сообщение об ошибке компилятора, в C++ использование комментария несколько облегчается за счет введения пары символов //, указывающих начало строки комментария. В этом с концом комментария считается конец строки, так что нет необходимости отмечать его специальным символом:
Листинг 1.8
//Эта программа выводит сообщение на экран
#include “stdafx.h”
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
puts("Hello world!");
return 0; //Возврат в операционную систему
}
Однако если комментарий занимает больше одной строки, каждая строка должна начинаться с символов //.
Литералы. Идентификаторы, константы, переменные, ключевые слова. Литералом называется любой элемент данных, который вводится непосредственно в инструкции языка C++. Литералом может являться любое число, символ или строка, которые вводятся как начальные значения переменной. Например: cout=8, где число 8 являться литералом.
Каждой программе для работы необходима информация - данные. Данные вводятся в компьютер, он обрабатывает их, следуя нашим инструкциям, затем выдает результат.
Идентификатор - это имя программного объекта. В идентификаторе могут использоваться латинские буквы, цифры и знак подчеркивания. Прописные и строчные буквы различаются, например, sysop, SySoP и SYSOP - три различных имени. Первым символом идентификатора может быть буква или знак подчеркивания, но не цифра. Пробелы внутри имен не допускаются.
Длина идентификатора по стандарту не ограничена, но некоторые компиляторы и компоновщики налагают на нее ограничения. Идентификатор создается на этапе объявления переменной, функции, типа и т.п., после этого его можно использовать в последующих операторах программы. При выборе идентификатора необходимо иметь в виду следующее:
- идентификатор не должен совпадать с ключевыми словами именами используемых стандартных объектов языка;
- не рекомендуется начинать идентификаторы с символа подчеркивания, поскольку они могут совпасть с именами системных функций или переменных, и, кроме того, это снижает мобильность программы;
- на идентификаторы, используемые для определения внешних переменных, налагаются ограничения компоновщика (использование различных компоновщиков или версий компоновщика накладывает разные требования на имена внешних переменных).
Константами называют неизменяемые величины. Различаются целые, вещественные, символьные и строковые константы. Компилятор, выделив константу в качестве лексемы, относит ее к одному из типов по ее внешнему виду. Форматы констант, соответствующие каждому типу, приведены в таблице 1.3.
Таблица 1.3 - Форматы констант, соответствующие каждому типу
| Константа | Формат | Примеры |
| Целая | Десятичный: последовательность десятичных цифр, начинающаяся не с нуля, если это не число нуль | 8, 0, 199226 |
| Восьмеричный: нуль, за которым следуют восьмеричные цифры (0,1,2,3,4,5,6,7) | 01, 020, 07155 | |
| Шестнадцатеричный: 0х или 0Х, за которым следуют шестнадцатеричные цифры (0,l,2,3,4,5,6,7,8,9,A,B,C,D,E,F) | 0хА, 0x1B8, 0X00FF | |
| Вещественная | Десятичный: [цифры].[цифры] | 5.7,.001, 35. |
| Экспоненциальный: [цифры][.][цифры]{Е|е}[+-][ЦиФры] | 0.2Е6,.lle-3, 5E10 | |
| Символьная | Один или два символа, заключенных в апострофы | ‘А’, ‘ю’, ‘*’, ‘db’, ‘\0’, ‘\n’, ‘\012’, ‘\x07\x07’ |
| Строковая | Последовательность символов, заключенная в кавычки | “Здесь был Vasia”, “\tЗначение r=\0xF5\n” |
Если требуется сформировать отрицательную целую или вещественную константу, то перед константой ставится знак унарной операции изменения знака (-), например: -218, -022, -0хЗС, -4.8, -0.1е4.
Вещественная константа в экспоненциальном формате представляется в виде мантиссы и порядка. Мантисса записывается слева от знака экспоненты (Е или е), порядок - справа от знака. Значение константы определяется как произведение мантиссы и возведенного в указанную в порядке степень числа 10. Обратите внимание, что пробелы внутри числа не допускаются, а для отделения целой части от дробной используется не запятая, а точка.
Символьные константы, состоящие из одного символа, занимают в памяти один байт и имеют стандартный тип char. Двухсимвольные константы занимают два байта и имеют тип int, при этом первый символ размещается в байте с меньшим адресом.
Символ обратной косой черты используется для представления:
- кодов, не имеющих графического изображения (например, \a - звуковой сигнал, \n - перевод курсора в начало следующей строки);
- символов апострофа ('), обратной косой черты (\), знака вопроса (?) и кавычки (");
- любого символа с помощью его шестнадцатеричного или восьмеричного кода, например, \073, \0xF5. Числовое значение должно находиться в диапазоне от 0 до 255.
Определить константу - это, значит, сообщить компилятору C ее имя, тип и значение. Для определения константы в языке C перед функцией main() часто помещают директиву #define для объявления констант и макроопределений. Однако использование этой директивы сопряжено с появлением трудно диагностируемых ошибок, лучшей альтернативой для констант является использование переменных с модификатором const. Такие переменные носят название константных переменных и объявляются следующий образом:
const <Тип> <Имя_Переменной> = <Значение>;
Наличие инициализатора <Значение> при объявлении константной переменной обязательно. Значение константной переменной не может быть изменено в процессе работы программы. Например:
const double pi = 3.1415926; // вещественная кон.
const int size = 400; // целая константа
const char new_line = ‘\n’; // символьная константа
const char topic[] = “Тема”; // строковая константа
В любой программе требуется производить вычисления. Для вычисления значений используются выражения, которые состоят из операндов, знаков операций и скобок. Операнды задают данные для вычислений. Операции задают действия, которые необходимо выполнить. Каждый операнд является, в свою очередь, выражением или одним из его частных случаев, например, константой или переменной. Операции выполняются в соответствии с приоритетами. Для изменения порядка выполнения операций используются круглые скобки. Рассмотрим составные части выражений и правила их вычисления.
Переменная - это именованная область памяти, в которой хранятся данные определенного типа. У переменной есть имя и значение. Имя служит для обращения к области памяти, в которой хранится значение. Во время выполнения программы значение переменной можно изменять. Перед использованием любая переменная должна быть описана. Пример описания целой переменной с именем а и вещественной переменной х:
int a; double x;
Общий вид оператора описания переменных:
[класс памяти] [const|volatile] тип имя[инициализатор];
Каждой используемой в программе константе и переменной должно быть присвоено имя. Для формирования имен констант, переменных, ключевых слов используются:
- большие и малые буквы латинского алфавита,
- арабские цифры,
- символ подчеркивания «_».
Компилятор C++ рассматривает одну и ту же большую и малую буквы как разные символы. Например, переменные dx_1, Dx_1, dX_1, DX_1 имеют различные имена и являются, соответственно, разными литералами.
Первым символом в имени должна стоять буква или знак подчеркивания. Например: Num, _min, max_, sum_7, и так далее. Тем не менее, не рекомендуется использовать знак подчеркивания в качестве первого символа литерала, поскольку таковые в основном используются для системных нужд и определяют литералы собственно компилятора или операционной системы, например _UNICODE, литерал, используемый в директивах условной компиляции, если программа написана с использованием кодировки Unicode.
Определить переменную - это, значит, сообщить ее имя и тип компилятору C++. Объявление переменной можно совместить с ее инициализацией. В этом случае объявлений переменной записывают следующим способом:
<Тип> <Имя_Переменной> = <Начальное_значение>;
Знак «=» обозначает инструкцию присваивания. Она предназначена для изменения значения переменных
<имя>=<выражение>;
Разновидность операции присваивания
<имя>=<имя> <знак операции> <выражение>;
Имя переменной не должно совпадать с ключевыми словами языка C++, перечень которых, приведен в табл. 1.4.
Ключевые слова - это зарезервированные идентификаторы, которые имеют специальное значение для компилятора. Их можно использовать только в том смысле, в котором они определены.
Таблица 1.4 - Ключевые слова стандарта языка C++
| asm | else | new | this |
| auto | enum | operator | throw |
| bool | explicit | private | true |
| break | export | protected | try |
| case | extern | public | typedef |
| catch | false | register | typeid |
| char | float | reinterpret_cast | typename |
| class | for | return | union |
| const | friend | short | unsigned |
| const_cast | goto | signed | using |
| continue | if | sizeof | virtual |
| default | int | static | void |
| delete | inline | static_cast | volatile |
| do | long | struct | wchar_t |
| double | mutable | switch | while |
| dynamic_cast | namespace | template |
Описание переменной, кроме типа и класса памяти, явно или по умолчанию задает ее область действия. Класс памяти и область действия зависят не только от собственно описания, но и от места его размещения в тексте программы. Область действия идентификатора - это часть программы, в которой его можно использовать для доступа к связанной с ним области памяти. В зависимости от области действия переменная может быть локальной или глобальной. Если переменная определена внутри блока, она называется локальной, область ее действия - от точки описания до конца блока, включая все вложенные блоки. Если переменная определена вне любого блока, она называется глобальной и областью ее действия считается файл, в котором она определена, от точки описания до его конца. Класс памяти определяет время жизни и область видимости программного объекта (в частности, переменной). Если класс памяти не указан явным образом, он определяется компилятором исходя из контекста объявления.
Время жизни может быть постоянным (в течение выполнения программы) и временным (в течение выполнения блока).
Областью видимости идентификатора называется часть текста программы, из которой допустим обычный доступ к связанной с идентификатором областью памяти. Чаще всего область видимости совпадает с областью действия. Исключением является ситуация, когда во вложенном блоке описана переменная с таким же именем. В этом случае внешняя переменная во вложенном блоке невидима, хотя он и входит в ее область действия. Тем не менее, к этой переменной, если она глобальная, можно обратиться, используя операцию доступа к области видимости::.
Для задания класса памяти используются следующие спецификаторы:
auto - автоматическая переменная. Память под нее выделяется в стеке и при необходимости инициализируется каждый раз при выполнении оператора, содержащего ее определение. Освобождение памяти происходит при выходе из блока, в котором описана переменная. Время ее жизни - с момента описания до конца блока. Для глобальных переменных этот спецификатор не используется, а для локальных он принимается по умолчанию, поэтому задавать его явным образом большого смысла не имеет.
extern - означает, что переменная определяется в другом месте программы (в другом файле или дальше по тексту). Используется для создания переменных, доступных во всех модулях программы, в которых они объявлены.
static - статическая переменная. Время жизни - постоянное. Инициализируется один раз при первом выполнении оператора, содержащего определение переменной. В зависимости от расположения оператора описания статические переменные могут быть глобальными и локальными. Глобальные статические переменные видны только в том модуле, в котором они описаны.
register - аналогично auto, но память выделяется по возможности в регистрах процессора. Если такой возможности у компилятора нет, переменные обрабатываются как auto.
int a; // 1 глобальная переменная а
int main()
{
int b; // 2 локальная переменная b
extern int x; /* 3 переменная х определена в другом месте */
static int с; /* 4 локальная статическая переменная с */
а = 1; // 5 присваивание глобальной переменной
int a; // 6 локальная переменная а
а = 2; // 7 присваивание локальной переменной
::а = 3; // 8 присваивание глобальной переменной
return 0;
}
int x = 4; // 9 определение и инициализация х
В этом примере глобальная переменная a определена вне всех блоков. Память под нее выделяется в сегменте данных в начале работы программы, областью действия является вся программа. Область видимости - вся программа, кроме строк 6-8, так как в первой из них определяется локальная переменная с тем же именем, область действия которой начинается с точки ее описания и заканчивается при выходе из блока. Переменные b и с - локальные, область их видимости - блок, но время жизни различно: память под b выделяется в стеке при входе в блок и освобождается при выходе из него, а переменная с располагается в сегменте данных и существует все время, пока работает программа.
Если при определении начальное значение переменных явным образом не задается, компилятор присваивает глобальным и статическим переменным нулевое значение соответствующего типа. Автоматические переменные не инициализируются.
Имя переменной должно быть уникальным в своей области действия (например, в одном блоке не может быть двух переменных с одинаковыми именами).
Описание переменной может выполняться в форме объявления или определения. Объявление информирует компилятор о типе переменной и классе памяти, а определение содержит, кроме этого, указание компилятору выделить память в соответствии с типом переменной. В C++ большинство объявлений являются одновременно и определениями. В приведенном выше примере только описание 3 является объявлением, но не определением.
Переменная может быть объявлена многократно, но определена только в одном месте программы, поскольку объявление просто описывает свойства переменной, а определение связывает ее с конкретной областью памяти.
Простые типы данных. Прежде чем использовать в программе на языке C++ какую-либо переменную, ее необходимо описать. Переменные в языке C++ могут быть описаны как в теле функции (между { }), так и вне ее. При описании переменной внутри функции область ее действия ограничена функцией. При описании переменной указать тип переменной и ее имя (идентификатор), для того, чтобы C++ должен зарезервировать достаточное количество памяти для хранения введенной информации. Разные типы данных занимают не одинаковый объем памяти. Не все функции языка C могут работать с данными любого типа.
В процессе написания программы необходимо определить все данные, которые будут использоваться, причем сделать это надо и для вводимой информации, и для результата. Данные классифицируются по типу значений, которые они содержат. Значение не обязательно означает числовую величину, но и буквы, слова, фразы.
Тип данных определяет:
- внутреннее представление данных в памяти компьютера;
- множество значений, которые могут принимать величины тина;
- операции и функции, которые можно применять к величинам типа.
Рассмотрим наиболее часто употребляемые простые типы языка C++:
- целые числа со знаком int, long, short,
- целые беззнаковые константы unsigned,
- символы, занимающие один байт char и два байта wchar_t,
- числа с плавающей точкой float, double.
Тип char определяет целочисленные переменные, занимающие один байт, в диапазоне от -128 до 127. Этот тип, как правило, применяется для символьных переменных (числовым значением является код символа).
Тип wchar_t определяет целочисленные переменные, занимающие два байта, в диапазоне от -32768 до 32767. Этот тип, как правило, применяется для символьных переменных в кодировке Unicode (числовым значением является код символа в кодировке Unicode).
Тип short определяет целые переменные, занимающие два байта, в диапазоне от -32768 до 32767. Этот тип используется для небольших целых чисел, в основном для управления циклами.
Тип long определяет целочисленные переменные, занимающие четыре байта, в диапазоне от -2147483647 до 2147483646.
В зависимости от компилятора и операционной системы тип int может быть эквивалентен либо типу short, либо типу long. Для компилятора Borland C++ Builder тип int эквивалентен типу long.
Беззнаковые типы unsigned определяяют беззнаковые целые числа. Это ключевое слово используется с другими типами данных для определения этого типа как беззнакового, т.е. только положительные числа и ноль. К беззнаковым типам относятся unsigned char, unsigned wchar_t, unsigned short, unsigned long, unsigned int. Тип unsigned эквивалентен типу unsigned int.
Тип float определяет переменные, занимающие четыре байта, для чисел с плавающей точкой в диапазоне от 
до 
Тип double определяет переменные, занимающие восемь байт, для чисел с плавающей точкой в диапазоне от 
до 
. Также используется в научных расчетах, но может содержать до 15 значащих цифр.
Таблица 1.5 - Диапазоны значений простых типов данных на IBM PC
| Тип | Диапазон значений | Размер (байт) |
| bool | true и false | |
| signed char | -128... 127 | |
| unsigned char | 0... 255 | |
| signed short int | -32 768... 32 767 | |
| unsigned short int | 0... 65 535 | |
| signed long int | -2 147 483 648... 2 147 483 647 | |
| unsigned long int | 0... 4 294 967 295 | |
| float | 3.4e-38... 3.4c+38 | |
| double | 1.7e-308... 1.7e+308 | |
| long double | 3.4c-4932... 3.4e+4932 |
При описании данных достаточно ввести тип, за которым должен следовать список имен переменных. Например:
int tdw, _sek, g1o; char elen, ogi;
long kid, g2o; char isi ='j';
float z2_c; unsigned rib = 6;
double pi = 3.14159;
Операторы языка С++. Рассмотрим список всех операций, определенных в языке C++, в соответствии с их приоритетами (по убыванию приоритетов, операции с разными приоритетами разделены чертой). В соответствии с количеством операндов, которые используются в операциях, они делятся на унарные (один операнд), бинарные (два операнда) и тернарную (три операнда).
Все приведенные в таблице 1.6 операции, кроме условной «?:», sizeof, селектора членов класса «.», доступа к области видимости «::» и оператора последовательного вычисления «,» могут быть перегружены.
Таблица 1.6 - Операции, определенные в С++
| Операция | Краткое описание |
| Унарные операции | |
| :: | Доступ к области видимости |
| . | Селектор членов класса |
| -> | Селектор членов класса |
| [ ] | Индексация |
| () | Вызов функции |
| ++ | Постфиксный инкремент |
| -- | Постфиксный декремент |
| typeid | Идентификация типа |
| dynamic_cast | Преобразование типа с проверкой на этапе выполнения |
| static_cast | Преобразование типа с проверкой на этапе компиляции |
| reinterpret_cast | Преобразование типа без проверки |
| const_cast | Константное преобразование типа |
| sizeof | Размер объекта или типа |
| -- | Префиксный декремент |
| ++ | Префиксный инкремент |
| ~ | Поразрядное отрицание |
| ! | Логическое отрицание |
| - | Арифметическое отрицание (унарный минус) |
| + | Унарный плюс |
| & | Взятие адреса |
| * | Разадресация |
| new | Выделение памяти |
| delete | Освобождение памяти |
| (<тип>) | Преобразование типа |
| .* | Селектор членов класса по указателю |
| ->* | Селектор членов класса по указателю |
| Бинарные и тернарные операции | |
| * | Умножение |
| / | Деление |
| % | Остаток от деления |
| + | Сложение |
| - | Вычитание |
| << | Сдвиг влево |
| >> | Сдвиг вправо |
| < | Меньше |
| <= | Меньше или равно |
| > | Больше |
| >= | Больше или равно |
| == | Равно |
| != | Не равно |
| & | Поразрядная конъюнкция (И) |
| ^ | Поразрядное исключающее ИЛИ |
| | | Поразрядная дизъюнкция (ИЛИ) |
| && | Логическое И |
| | | | Логическое ИЛИ |
| ?: | Условная операция (тернарная) |
| = | Присваивание |
| *= | Присваивание с умножением |
| /= | Деление с присваиванием |
| %= | Остаток от деления с присваиванием |
| += | Сложение с присваиванием |
| -= | Вычитание с присваиванием |
| <<= | Сдвиг влево с присваиванием |
| >>= | Сдвиг вправо с присваиванием |
| &= | Поразрядное И с присваиванием |
| |= | Поразрядное ИЛИ с присваиванием |
| ^= | Исключающее ИЛИ с присваиванием |
| throw | Инициировать исключение |
| , | Последовательное вычисление |
Рассмотрим основные операции подробнее.
Операции увеличения и уменьшения на 1 (++ и --). Эти операции, называемые также инкрементом и декрементом, имеют две формы записи - префиксную, когда операция записывается перед операндом, и постфиксную. В префиксной форме сначала изменяется операнд, а затем его значение становится результирующим значением выражения, а в постфиксной форме значением выражения является исходное значение операнда, после чего он изменяется.
В отличие от других языков программирования в Си и C++ инструкция присваивания, выполняющая некоторое действие, может быть записана несколькими способами.