Переменные и типы данных в C++ — урок 2
Из школьного курса математики мы все знаем, что такое переменные. В программировании принципы довольно схожи. Переменная — это «ячейка» оперативной памяти компьютера, в которой может храниться какая-либо информация.
В программировании переменная, как и в математике, может иметь название, состоящее из одной латинской буквы, но также может состоять из нескольких символов, целого слова или нескольких слов.
Типы данных
В языке С++ все переменные имеют определенный тип данных. Например, переменная, имеющая целочисленный тип не может содержать ничего кроме целых чисел, а переменная с плавающей точкой — только дробные числа.
Тип данных присваивается переменной при ее объявлении или инициализации. Ниже приведены основные типы данных языка C++, которые нам понадобятся.
Основные типы данных в C++
- int — целочисленный тип данных.
- float — тип данных с плавающей запятой.
- double — тип данных с плавающей запятой двойной точности.
- char — символьный тип данных.
- bool — логический тип данных.
Объявление переменной
Объявление переменной в C++ происходит таким образом: сначала указывается тип данных для этой переменной а затем название этой переменной.
Пример объявления переменных
int a; // объявление переменной a целого типа. float b; // объявление переменной b типа данных с плавающей запятой. double c = 14.2; // инициализация переменной типа double. char d = 's'; // инициализация переменной типа char. bool k = true; // инициализация логической переменной k.
- Заметьте, что в C++ оператор присваивания(=) — не является знаком равенства и не может использоваться для сравнения значений. Оператор равенства записывается как «двойное равно» — == .
- Присваивание используется для сохранения определенного значение в переменной. Например, запись вида a = 10 задает переменной a значение числа 10.
Простой калькулятор на C++
Сейчас мы напишем простую программу-калькулятор, которая будет принимать от пользователя два целых числа, а затем определять их сумму:
Переменные
Теги: Си переменные. char, int, unsigned, long, long long, float, double, long double, long float, lexical scoping. Объявление переменных. Область видимости. Инициализация переменных. Имена переменных. Экспоненциальная форма.
Переменные
Например, правильные идентификаторы
a, _, _1_, Sarkasm, a_long_variable, aLongVariable, var19, defaultX, char_type
неверные
1a, $value, a-long-value, short
Си — регистрозависимый язык. Переменные с именами a и A, или end и END, или perfectDark и PerfectDarK – это различные переменные.
Типы переменных
- 1) Размер переменной в байтах (сколько байт памяти выделит компьютер для хранения значения)
- 2) Представление переменной в памяти (как в двоичном виде будут расположены биты в выделенной области памяти).
Целые
- char — размер 1 байт. Всегда! Это нужно запомнить.
- short — размер 2 байта
- int — размер 4 байта
- long — размер 4 байта
- long long — размер 8 байт.
Указанные выше значения характерны для компилятора VC2012 на 32-разрядной машине. Так что, если ваша программа зависит от размера переменной, не поленитесь узнать её размер.
Теперь давайте определим максимальное и минимальное число, которое может хранить переменная каждого из типов. Числа могут быть как положительными, так и отрицательными. Отрицательные числа используют один бит для хранения знака. Иногда знак необходим (например, храним счёт в банке, температуру, координату и т.д.), а иногда в нём нет необходимости (вес, размер массива, возраст человека и т.д.). Для этого в си используется модификатор типа signed и unsigned. unsigned char — все 8 бит под число, итого имеем набор чисел от 00000000 до 11111111 в двоичном виде, то есть от 0 до 255 signed char от -128 до 128. В си переменные по умолчанию со знаком. Поэтому запись char и signed char эквивалентны.
Тип | Размер, байт | Минимальное значение | Максимальное значение |
---|---|---|---|
unsigned char | 1 | 0 | 255 |
signed char ( char ) | 1 | -128 | 127 |
unsigned short | 2 | 0 | 65535 |
signed short ( short ) | 2 | -32768 | 32767 |
unsigned int ( unsigned ) | 4 | 0 | 4294967296 |
signed int ( int ) | 4 | -2147483648 | 2147483647 |
unsigned long | 4 | 0 | 4294967296 |
signed long ( long ) | 4 | -2147483648 | 2147483647 |
unsigned long long | 8 | 0 | 18446744073709551615 |
signed long long ( long long ) | 8 | -9223372036854775808 | 9223372036854775807 |
sizeof
В си есть оператор, который позволяет получить размер переменной в байтах. sizeof переменная, или sizeof(переменная) или sizeof(тип). Это именно оператор, потому что функция не имеет возможности получить информацию о размере типов во время выполнения приложения. Напишем небольшую программу чтобы удостовериться в размерах переменных.
(Я думаю ясно, что переменные могут иметь любое валидное имя). Эту программу можно было написать и проще
В си один и тот же тип может иметь несколько названий
short === short int
long === long int
long long === long long int
unsigned int === unsigned
Типы с плавающей точкой
- float — 4 байта,
- long float — 8 байт
- double — 8 байт
- long double — 8 байт.
Переполнение переменных
Си не следит за переполнением переменных. Это значит, что постоянно увеличивая значение, скажем, переменной типа int в конце концов мы «сбросим значение»
#include #include void main() < unsigned a = 4294967295; int b = 2147483647; //Переполнение беззнакового типа printf("%u\n", a); a += 1; printf("%u", a); //Переполнение знакового типа printf("%d\n", b); b += 1; printf("%d", b); getch(); >
Вообще, поведение при переполнении переменной определено только для типа unsigned: Беззнаковое целое сбросит значение. Для остальных типов может произойти что угодно, и если вам необходимо следить за переполнением, делайте это вручную, проверяя аргументы, либо используйте иные способы, зависящие от компилятора и архитектуры процессора.
Постфиксное обозначение типа
- 11 — число типа int
- 10u — unsigned
- 22l или 22L — long
- 3890ll или 3890LL — long long (а также lL или Ll)
- 80.0f или 80.f или 80.0F — float (обязательно наличие десятичной точки в записи)
- 3.0 — число типа double
Следующий код, однако, не будет приводить к ошибкам, потому что происходит неявное преобразование типа
Шестнадцатеричный и восьмеричный формат
В о время работы с числами можно использовать шестнадцатеричный и восьмеричный формат представления. Числа в шестнадцатиричной системе счисления начинаются с 0x, в восьмеричной системе с нуля. Соответственно, если число начинается с нуля, то в нём не должно быть цифр выше 7:
#include #include void main()
Экспоненциальная форма представления чисел
Э кспоненциальной формой представления числа называют представление числа в виде M e ± p , где M — мантиса числа, p — степень десяти. При этом у мантисы должен быть один ненулевой знак перед десятичной запятой.
Например 1.25 === 1.25e0, 123.5 === 1.235e2, 0.0002341 === 2.341e-4 и т.д.
Представления 3.2435e7 эквивалентно 3.2435e+7
Существеут и другое представление («инженерное»), в котором степень должна быть кратной тройке. Например 1.25 === 1.25e0, 123.5 === 123.5e0, 0.0002341 === 234.1e-6, 0.25873256 === 258.73256e-3 и т.д.
Объявление переменных
В си переменные объявляются всегда в начале блока (блок — участок кода ,ограниченный фигурными скобками)
При объявлении переменной пишется её тип и имя.
Можно объявить несколько переменных одного типа, разделив имена запятой
#include #include int main() < int a = 10; int b; while (a>0) < int z = a*a; b += z; >>
Здесь объявлены переменные a и b внутри функции main, и переменная z внутри тела цикла. Следующий код вызовет ошибку компиляции
Это связано с тем, что объявление переменной стоит после оператора присваивания. При объявлении переменных можно их сразу инициализировать.
int i = 0;
При этом инициализация при объявлении переменной не считается за отдельный оператор, поэтому следующий код будет работать
Начальное значение переменной
О чень важно запомнить, что переменные в си не инициализируются по умолчанию нулями, как во многих других языках программирования. После объявления переменной в ней хранится «мусор» — случайное значение, которое осталось в той области памяти, которая была выделена под переменную. Это связано, в первую очередь, с оптимизацией работы программы: если нет необходимости в инициализации, то незачем тратить ресурсы для записи нулей (замечание: глобальные переменные инициализируются нулями, почему так, читайте в этой статье).
Если выполнять эту программу на VC, то во время выполнения вылетит предупреждение
Run-Time Check Failure #3 — The variable ‘i’ is being used without being initialized.
Если нажать «Продолжить», то программа выведет «мусор». В многих других компиляторах при выполнении программы не будет предупреждения.
Область видимости переменной
П еременные бывают локальными (объявленными внутри какой-нибудь функции) и глобальными. Глобальная переменная видна всем функциям, объявленным в данном файле. Локальная переменная ограничена своей областью видимости. Когда я говорю, что переменная «видна в каком-то месте», это означает, что в этом месте она определена и её можно использовать. Например, рассмотрим программу, в которой есть глобальная переменная
#include #include int global = 100; void foo() < printf("foo: %d\n", global); >void bar(int global) < printf("bar: %d\n", global); >int main()
Будет выведено
foo: 100
bar: 333
Здесь глобальная переменная global видна всем функциям. Но аргумент функции затирает глобальную переменную, поэтому при передаче аргумента 333 выводится локальное значение 333.
Вот другой пример
#include #include int global = 100; int main()
Программа выведет 555. Также, как и в прошлом случае, локальная переменная «важнее». Переменная, объявленная в некоторой области видимости не видна вне её, например
#include #include int global = 100; int main() < int x = 10; < int y = 30; printf("%d", x); >printf("%d", y); >
Этот пример не скомпилируется, потому что переменная y существует только внутри своего блока.
Вот ещё пример, когда переменные, объявленные внутри блока перекрывают друг друга
#include #include int global = 100; int main() < int x = 10; < int x = 20; < int x = 30; printf("%d\n", x); >printf("%d\n", x); > printf("%d\n", x); getch(); >
Программа выведет
30
20
10
Глобальных переменных необходимо избегать. Очень часто можно услышать такое. Давайте попытаемся разобраться, почему. В ваших простых проектах глобальные переменные выглядят вполне нормально. Но представьте, что у вас приложение, которое
- 1) Разрабатывается несколькими людьми и состоит из сотен тысяч строк кода
- 2) Работает в несколько потоков
Во-первых, глобальная переменная, если она видна всем, может быть изменена любой частью программы. Вы изменили глобальную переменную, хотите её записать, а другая часть программы уже перезаписала в неё другое значение (на самом деле это целый класс проблем, которые возникают в многопоточной среде). Во-вторых, при больших размерах проекта не уследить, кто и когда насоздавал глобальных переменных. В приведённых выше примерах видно, как переменные могут перекрывать друг друга, то же произойдёт и в крупном проекте.
Безусловно, есть ситуации, когда глобальные переменные упрощают программу, но такие ситуации случаются не часто и не в ваших домашних заданиях, так что НЕ СОЗДАВАЙТЕ ГЛОБАЛЬНЫХ ПЕРЕМЕННЫХ!
Переменные могут быть не только целочисленными и с плавающей точкой. Существует множество других типов, которые мы будем изучать в дальнейшем.
Всё ещё не понятно? – пиши вопросы на ящик