Глава 2 переменые, константы и типы данных.

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

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

Таким образом

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

Что бы иметь возможность работать с переменной её необходимо объявить (описать), то есть сообщить компилятору имя и тип нужной переменной. В этом случае компилятор выделит часть оперативной памяти нужного размера и логически соединит её с именем для использования. Тип переменной это служебное (ключевое) слово.

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

Редактор Microsoft Visual Studio 2008 подсвечивает их определенным цветом, когда вводится текст программы. Если ключевое (служебное) слово, при вводе, не окрашивается соответствующим образом — значит, ввод выполнен неправильно. Необходимо помнить, что ключевые слова, как весь язык C++, зависят от регистра.

Имя – задаётся пользователем. В языке С существуют правила именования переменных, констант и функций. Если им не следовать, компилятор не будет воспринимать имя как переменную.

Правила:

1. Имя не должно совпадать со служебным словом.

2. Имя может содержать только английские буквы, цифры и знак подчёркивания (_).

3. на первом месте не должна стоять цифра, то есть ставится или буква или знак подчеркивания _.

4. заглавные и прописные буквы имеют значение.

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

Объявление переменной -- это оператор, состоящий из:

тип (пробел будем ставить знаком )<список имен>;

<список имен> это имена переменных, разделённые запятыми..

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

Если одновременно с объявлением переменной ей присваивается значение, то этот процесс носит название инициализации.

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

int value = 0; int count =10; int number =5;

В данном случае value получает значение 0, count — значение 10, a number — значение 5.

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

int value (0); int count(10); int number (5);

Разновидность информации, которую может содержать переменная, называется ее типом данных. Все данные и переменные в программе должны относиться к определенному типу данных. Стандарт C++ ISO/ANSI предоставляет набор фундаментальных типов данных, специфицированных определенными ключевыми словами. Фундаментальные типы данных называются так потому, что они хранят значения типов, представляющих фундаментальные данные на компьютере — по сути, числовые значения, в которые входят и символы, потому что они представлены числовыми кодами.

Кроме фундаментальных или стандартных типов данных язык С предоставляет возможность определения собственных типов данных, и конечно, разнообразные библиотеки, поставляемые с Microsoft Visual Studio 2008 также определяют свои типы данных. Но пока достаточно рассмотреть типы данных, представленные в ISO/ANSI C++. Фундаментальные типы подразделяются на три категории — типы, содержащие целые числа, типы, содержащие не целочисленные значения, и тип void, указывающий пустое множество значений или отсутствие типа.

Тип данных считается определенным, если для него определены: размер памяти, занимаемый переменной, правило интерпретации двоичных значений в значения типа, ограничения, задаваемые разрядной сеткой машины и идентификатор типа (служебное слово). Например: если рассматривать тип целых чисел int, то для него можно узнать при помощи функции sizeof(int) сколько байт выделяется системой для этого типа данных. Так как тип целочисленный, то из 8*4=32 бита 1 бит выделяется на знак, а остальные служат для распределения 2³¹ значений от -2147483648 до 2147483647.

Тип символьных значений char, занимающий 1 байт (8 бит) можно интерпретировать как целые в диапазоне от 0 до 255, символы определяются по соответствующим кодам кодировочных таблиц, поэтому символы в разных кодировках имеют разные символьные значения, при одинаковых численных кодах. Для компьютера первичны коды, для пользователя важны символы.

Тип float служит для представления вещественных чисел в нормальном виде (с плавающей запятой). Представление числа с плавающей запятой в общем виде определяется выражением

, ... 1

где М — мантисса числа; — характеристика числа; р — порядок числа.

Мантисса и порядок задаются в системе счисления с основанием s. Знак числа совпадает со знаком мантиссы. По формату IEEE (Institute of Electrical and Electronics Engineers) значения мантисс должны удовлетворять неравенству 1<M<2, целая часть =1 не хранится , таким образом на переменную типа float выделяется 4 байта памяти, которые распределяются следующим образом из 32 бит 1 бит на знак для мантиссы, 24 бита для мантиссы, 1 бит для знака порядка и оставшиеся 6 бит для порядка.

Например типы float и int занимают по 4 байта, но если интерпретировать один и тот же набор 0 и 1, получим например тип float = 100.1, и тип int =1120416563 в той же самой ячейки памяти.

Таким образом, любой кусок оперативной памяти, содержащий остаточные значения 0 и 1, может быть всегда интерпретирован в зависимости от типа представляемой переменной. Пока значение переменной не присвоено, в ней находится «мусор», то есть какое-то значение всегда находится в переменной. Поэтому такую переменную нельзя использовать в расчётах, её можно использовать только как результат. Язык С не следит за чистотой содержания переменных, но если попытаться использовать неинициализированную переменную в расчётах отладчик сообщит об ошибке в процессе выполнении программы.

Основные описания стандартных типов данных можно посмотреть в заголовочных в файлах limits.h и float.h. Объем памяти можно получить при помощи функции sizeof(тип). При помощи этих инструментов языка, написав соответствующую программу можно заполнить следующую таблицу с данными.

Рассмотрим основные стандартные типы данных языка С:

спецификатор	тип	Объём памяти	Максимально возможное		Минимально возможное		точность
			константа	значение	константа	значение	константа	значение
1	2	3	4	5	6	7	8	9
int	целые	4	INT_MAX	2147483647	INT_MIN	-2147483648	1
long		4	LONG_MAX	2147483647	LONG_MIN	-2147483648	1
short		2	SHRT_MAX	32767	SHRT_MIN	-32768	1
unsigned int	целые положительные	4	UINT_MAX	4294967295	0		1
unsigned long		4	ULONG_MAX	4294967295	0		1
unsigned short		2	USHRT_MAX	65535	0		1
float	Вещественные	4	FLT_MAX	3.40282e+038	FLT_MIN	1.17549e-038	FLT_EPSILON	1.19209e-007
double		8	DBL_MAX	1.79769e+308	DBL_MIN	2.22507e-308	DBL_EPSILON	2.22045e-016
char	Символьные	1	SCHAR_MAX	127	SCHAR_MIN	-128	1
unsigned char		1	UCHAR_MAX	255	0		1
wchar_t		2		65 535	0
bool	логические	1	1		0		1

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

#include <iostream>

#include<limits.h>

#include<float.h>

using namespace std;

int main(void)

{

int i;

long l;

short s;

unsigned int ui;

unsigned long ul;

unsigned short us;

float f;

double d;

long double ld;

char c;

unsigned char uc;

bool b;

cout<<" int\n bite="<<sizeof(i)<<" max="<< INT_MAX <<" min="<<INT_MIN <<"esp="<<1<<endl;

cout<<" long\n bite="<<sizeof(l)<<" max="<< LONG_MAX <<" min="<<LONG_MIN <<"esp="<<1<<endl;

cout<<" short\n bite="<<sizeof(s)<<" max="<< SHRT_MAX <<" min="<<SHRT_MIN <<"esp="<<1<<endl;

cout<<" unsigned int\n bite="<<sizeof(ui)<<" max="<< UINT_MAX <<" min="<<0 <<"esp="<<1<<endl;

cout<<" unsigned long\n bite="<<sizeof(ul)<<" max="<< ULONG_MAX <<" min="<<0 <<"esp="<<1<<endl;

cout<<" unsigned short\n bite="<<sizeof(us)<<" max="<< USHRT_MAX <<" min="<<0 <<"esp="<<1<<endl;

cout<<" double\n bite="<<sizeof(d)<<" max="<< DBL_MAX <<" min="<<DBL_MIN <<"esp="<<DBL_EPSILON<<endl;

cout<<" long double\n bite="<<sizeof(ld)<<" max="<< LDBL_MAX <<" min="<<LDBL_MIN <<"esp="<<LDBL_EPSILON<<endl;

cout<<" float\n bite="<<sizeof(f)<<" max="<<FLT_MAX <<" min="<<FLT_MIN <<"esp="<<FLT_EPSILON <<endl;

cout<<" char\n bite="<<sizeof(c)<<" max="<< SCHAR_MIN <<" min="<< SCHAR_MAX <<"esp="<<1<<endl;

cout<<" unsigned char\n bite="<<sizeof(uc)<<" max="<< UCHAR_MAX <<" min="<< 0 <<"esp="<<1<<endl;

cout<<" bool\n bite="<<sizeof(b)<<" max="<< 1 <<" min="<< 0 <<"esp="<<1<<endl;

return 0;

}

Результат работы программы выглядит так:

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

Именованная константа -- это поименованная область оперативной памяти определённого размера, которая содержит определённое значение, неизменяемое в течение работы программы.

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

constтипимя константы = значение константы ;

«значение константы» является литералом, то есть это запись явного значения при помощи символов разрешенного алфавита, для данного типа данных.

Примеры литералов для различных типов:

Тип	Примеры литералов
char, signed char или unsigned char	‘A’, ‘Z’ ‘8’ ‘*’
wchar_t	L’A’, L’Z’ L’8’, L’*’
int	-77, 65, 12345, 0x9FE
unsigned int	10U, 64000U
long	-77L, 65L, 12345L
unsigned long	5UL, 999999999UL
float	3.14f, 34.506f
double	1.414, 2.71828
long double	1.414L, 2.71828L
bool	true, false

То есть оператор объявления переменной

wchar_t letter = L’Z’; // Переменная хранит 16-битный код символа

определяет переменную letter, инициализированную 16-битным кодом буквы Z. Символ L, предшествующий символьной константе ‘Z’, сообщает компилятору, что это 16-битное значение кода символа

При использовании литералов типа long int оператор инициализации будет иметь вид

long bigNumber = 1000000L; long largeValue = 0L;

Эти операторы объявляют переменные bigNumber и largeValue с начальными значениями 1000000 и 0 соответственно. Буква L, добавленная в конец литералов, указывает на то, что это — целые типа long. Для той же цели можно также применять и прописную букву l, но ее недостаток в том, что ее легко спутать с цифрой 1. Целые литералы без добавленной буквы L имеют тип int.

При написании больших чисел в программе нельзя вставлять в них запятые или пробелы в качестве разделителей групп, в тексте можно написать 12,245,678 либо 12 245 678, но в коде программы следует писать 12345678.

Тип данных char служит двум целям. Он специфицирует однобайтную переменную, в которой можно сохранять целые числа в пределах определенного диапазона значений, или же код отдельного символа ASCII (American Standard Code for Information Interchange— американский стандартный код обмена информацией). Набор кодов символов ASCII приведен в приложении Б. Вы можете объявить переменную char с помощью следующего оператора:

char letter = ‘A’;

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

Поскольку символ ‘A’ в кодировке ASCII представлен десятичным значением 65, можно написать этот оператор следующим образом:

char letter =65; // Эквивалент символа А

Это дало бы тот же результат, что и предыдущий оператор.

Обратите внимание, что стандарт ISO/ANSI C++ не требует, чтобы тип char представлял однобайтные целые со знаком. Это выбор реализации компилятора: представлять char как целые со знаком в диапазоне от-128 до 127 либо как целые без знака в диапазоне от 0 до 255. Следует иметь это в виду, если может потребоваться переносить код C++ в другую среду.

Тип wchar_t назван так, поскольку это расширенный символьный тип (wide char type), и переменные этого типа сохраняют 2-байтные символьные

Для инициализации переменных char (как и других целых типов) можно использовать шестнадцатеричные константы, что во многих случаях удобнее. Шестнадцатеричное число записывается с применением стандартного представления шестнадцатеричных цифр: от 0 до 9 и от А до F (или от а до f), означающие в десятичном эквиваленте цифры от 0 до 15. Кроме того, они предваряются сочетанием 0х (или 0Х) для того, чтобы отличать их от десятичных значений. Таким образом, чтобы получить тот же результат, можно переписать оператор, приведенный выше, следующим образом:

char letter = 0x41; // Эквивалент А

Целочисленные значения с ведущим нулем интерпретируются как восьмеричные значения, поэтому значение, записанное как 065, равно 53 в десятичной нотации.

Переменные целочисленных типов int, short или long сохраняют по умолчанию целые значения со знаком (signed), поэтому их можно применять как для хранения положительных, так и отрицательных значений. Это объясняется тем, что для этих типов по умолчанию принят модификатор типа signed. Поэтому когда пишется int или long, то это означает signed int или signed long соответственно. Ключевое слово signed можно явно использовать для спецификации типа переменной. В этом случае оно означает signed int, например: signed value = -5; // Эквивалент signed int

Но такое написание не очень распространено, и многие программисты предпочитают применять int, что выглядит более очевидно.

Диапазон значений, которые могут быть сохранены в переменной типа char, находится в пределах от -128 до +127, что совпадает с диапазоном допустимых значений переменных типа short char. Но как это ни прискорбно, тип char и тип signed char трактуются как разные типы, поэтому не стоит допускать ошибку, думая, что это одно и то же.

Если в переменной необходимо хранить в только положительные значения (например, количество человек посетивших лекцию), то желательно специфицировать переменную как unsigned: unsigned long chel = OUL; Буква U (или u), добавленная к константе -- это спецификатор для unsigned. В предыдущем примере к ней был добавлен L, чтобы указать, что константа— long.

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

Булевские переменные — это такие переменные, которые могут хранить только два значения: true и false. Тип таких логических переменных называется bool, по имени Джорджа Буля (Gerorge Boole), который разработал булеву алгебру. Тип bool трактуется как целый. Булевские переменные также называют логическими переменными. Переменные типа bool используются для сохранения результата проверок, которые могут принимать значения либо "истина" (true), либо "ложь" (false), например, как в случае проверки равенства одного значения другому.

На самом деле тип bool представляется в коде программы как int. Это наследие тех времен, когда в C++ еще не был реализован тип bool, и для представления логических значений обычно применялись переменные типа int. При этом нулевые значения трактовались как "ложь", а ненулевые— как "истина ". Символы TRUE и FALSE все еще применяются в MFC, где они представляют ненулевые целые и 0, соответственно. Стоит обратить внимание но то, что TRUE и FALSE, записанные заглавными буквами, не являются ключевыми словами в C++; это просто символы, определенные внутри MFC и следовательно они не являются допустимыми значениями типа bool, и потому не стоит путать TRUE и true.

Числовые переменные, не относящиеся к целым, хранятся как числа с плавающей точкой. Число с плавающей точкой может быть выражено в виде десятичного значения наподобие 112.5 либо в экспоненциальном виде, таком как 1.25Е2, где десятичная часть умножается на 10 в степени, указанной после Е (экспонента). Таким образом, последнее число— это 1.125х10², что равно 112.5.

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

Можно специфицировать переменную с плавающей точкой, используя ключевое слово double, как в следующем операторе: double in_to_mm = 25.4; для использования константы типа float необходимо использовать спецификатор f, как в примере: float pi = 3.14159f; Без f константа имела бы тип double.

Стандарт C++ ISO/ANSI также определяет тип с плавающей точкой long double, который в Visual C++ 2008 реализован с тем же диапазоном и точностью, что и double.

Ключевое слово typedef позволяет определить своё собственное имя для существующего типа данных. Используя typedef, можно определить имя типа kol_vo как эквивалент стандартного типа long int, применив следующее объявление:

typedef long int kol_vo; // Определение kol_vo как имени типа

Это определяет kol_vo как альтернативное имя для long int, поэтому теперь можно объявить переменную mynum типа long int таким объявлением:

kol_vo mynum = OL; // определение переменной типа long int. При этом не будет никакой разницы между таким объявлением и тем, что использует встроенное имя типа. То есть следующий оператор эквивалентен предыдущему:

long int mynum = OL; // определение переменной типа long int

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

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

Для определения пользовательских типов данных используются спецификаторы языка enum, struct, class.( struct будет разобрано много ниже, а понятие class используется в объектно-ориентированном С, который в данном пособии не рассматривается).

Иногда возникает потребность в переменных, которые могут принимать значения лишь из ограниченного набора допустимых значений, ссылаться на которые удобно было бы по каким-то меткам — дни недели, например, или месяцы года. В C++ предусмотрено специальное средство для таких ситуаций, называемое перечислением (enumeration). Возьмем пример— переменная, которая должна принимать значения, соответствующие цветам радуги. Её можно определить следующим образом:

enum Color{Red, Orange, Yellow, Green, light_Blue, Blue , Violet} thisColor;

Этот оператор объявляет тип перечисления по имени Color и переменную thisColor, являющуюся экземпляром перечислимого типа Week, которая может принимать только константные значения, указанные между фигурными скобками. Если попытаться присвоить thisColor что-то такое, что не входит в указанный набор, то это вызовет ошибку. Эти символические имена, перечисленные между скобками, называются перечислителями (enumerators). Фактически каждое из названий цвета автоматически представляется компилятором как фиксированное целое значение. Первое имя в списке — Red — получает значение 0, Orange будет 1 и так далее.

Можно присвоить одну из перечисленных констант в качестве значения переменной thisColor:

thisColor = Green;

Необходимо обратить внимание на то, что не нужно квалифицировать перечислимые константы именем перечисления. Значение thisColor будет равно 3, потому что определенным в перечислении символическим константам присваиваются значения типа int по умолчанию, начиная с 0.

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

enum Color { Red = 1, Orange, Yellow, Green, light_Blue, Blue , Violet} thisColor;

Теперь константы перечисления будут равны от 1 до 7. Элементы перечисления даже не обязаны иметь уникальные значения. Можно определить, что и Red, и Orange должны, например, иметь значение 1, с помощью следующего оператора:

enum Color { Red =1,Orange=1,Yellow, Green, light_Blue, Blue , Violet} thisColor;

Поскольку, по сути, типом переменной thisWeek является int, она займет 4 байта, как и все переменные перечислимого типа.

Имея определение перечисления, можно определить другую переменную того же типа: enum Color nextColor;

Это определяет переменную nextColor как перечисление, которое может принимать значения, специфицированные ранее. Разрешается пропустить ключевое слово enum в объявлении переменной, поэтому предыдущий оператор может быть переписан так: Week nextWeek;

При желании можете присвоить определенные значения всем перечислителям. Например, можно определить следующее перечисление:

enum Punctuation {Comma = ‘,’, Exclamation = ‘!’, Question = ‘?’} things;

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

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

enum {Mon, Tues, Wed, Thurs, Fri, Sat, Sun} thisWeek, nextWeek, lastWeek; Здесь объявлены три переменных, которые могут принимать значения от Mon до Sun. Поскольку тип перечисления не указан, не возможно позднее сослаться не него. В этом случае вообще не возможно объявить другие переменные типа этого перечисления, потому что повторять это определение также не разрешается. Попытка сделать это означала бы, что программист собирается переопределить значения от Mon до Sun, а это недопустимо.

Перечислимые константы по умолчанию имеют тип int, но можно указать их тип явно, добавив двоеточие и имя типа для констант вслед за именем типа перечисления в его объявлении. Тип перечислимых констант может быть знаковым либо беззнаковым целочисленным типом: short, int, long, char или же bool.

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

enum Color:char {Red, Orange, Yellow, Green, light_Blue, Blue , Violet};

Здесь константы перечисления будут относиться к типу char, причем первая из них будет равна 0. Однако, имея константы типа char, было бы логично, предпочесть инициализировать их явно:

enum Color:char {Red=’R’, Orange=’O’, Yellow=’Y’, Green=’G’, light_Blue=’B’, Blue=’B’ , Violet=’V’};

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

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

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

Область памяти, куда «ссылается» указатель может быть выделена непосредственно под этот указатель, либо может быть выделена под другую переменную или константу.

Второе разделение типов данных можно рассматривать по сложности организации переменной. Типы делятся на простые и сложные.

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

К простым переменным можно отнести все фундаментальные типы данных. К сложным типам относят структуры, массивы

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

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

Оператором в языке называют устойчивую конструкцию, однозначно приводящую к результату. Каждый оператор языка С заканчивается ;.

Одним из часто используемых операторов является оператор присваивания. Оператор присваивания имеет вид: имя переменной = <вычисляемое выражение>;. Вычисляемое выражение может быть математическим выражением, вызовом функции, другой переменной или константой. Справа от знака = можно использовать знаки операций, парные (), то есть писать выражение по правилам математических выражений из школьного курса математики. Слева можно использовать только имя переменной, так как при выполнении этого оператора выражение справа вычисляется, и это значение помещается в переменную, которая стоит слева. Нельзя интерпретировать оператор присваивания как математическое =, они не эквивалентны. С точки зрения математики уравнение написано верно, а с точки зрения программирования нет.

Константы это значения, которые не изменяются в течение работы программы. Константы бывают именованные и литерные. Именованные константы требуют объявления, литерные записываются в выражениях при помощи цифр или символов.

Оператор объявления констант имеет вид:

constтипимя=значение;

Например

const float pi=3.141516; // float вещественная константа

const char bu=’A’; //char буквы и символы

const int i=5; //int целые числа

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

Используемая литература:

1. Бочков С.О., Субботин Д.М.Язык программирования Си для персонального компьютера. М.: Радио и связь,1990.384 с.

2. Вдовенко В.В. Объектно-ориентированное программирование. Кр.: СибГАУ , 2001.188 с.

3. Либерти Д. Осной самостоятельно С++ за 21 день. М. изд. Дом Вильямс, 2000.816 с.

4. Хортон А. Visual C++2008 базовый курс. М. Диалектика, 2009,1280 с.

Список используемых сокращений