К каким типам относится тип char. Переменные

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

Теги: Си переменные. char, int, unsigned, long, long long, float, double, long double, long float, lexical scoping. Объявление переменных. Область видимости. Инициализация переменных. Имена переменных. Экспоненциальная форма.

Переменные

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

auto	double	int	struct
break	else	long	switch
register	typedef	char	extern
return	void	case	float
unsigned	default	for	signed
union	do	if	sizeof
volatile	continue	enum	short
while	inline

А также ряд других слов, специфичных для данной версии компилятора, например far , near , tiny , huge , asm , asm_ и пр.

Например, правильные идентификаторы
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 байт.

Здесь следует сделать замечание. Размер переменных в си не определён явно, как размер в байтах. В стандарте только указано, что

char <= short <= int <= long <= long long

Указанные выше значения характерны для компилятора VC2012 на 32-разрядной машине. Так что, если ваша программа зависит от размера переменной, не поленитесь узнать её размер.

Теперь давайте определим максимальное и минимальное число, которое может хранить переменная каждого из типов. Числа могут быть как положительными, так и отрицательными. Отрицательные числа используют один бит для хранения знака. Иногда знак необходим (например, храним счёт в банке, температуру, координату и т.д.), а иногда в нём нет необходимости (вес, размер массива, возраст человека и т.д.). Для этого в си используется модификатор типа signed и unsigned. unsigned char - все 8 бит под число, итого имеем набор чисел от 00000000 до 11111111 в двоичном виде, то есть от 0 до 255 signed char от -128 до 128. В си переменные по умолчанию со знаком. Поэтому запись char и signed char эквивалентны.

Таб. 1 Размер целых типов в си.

Тип	Размер, байт	Минимальное значение	Максимальное значение
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(тип). Это именно оператор, потому что функция не имеет возможности получить информацию о размере типов во время выполнения приложения. Напишем небольшую программу чтобы удостовериться в размерах переменных.

#include #include int main() { char c; short s; int i; long l; long long L; //Вызов sizeof как "функции" printf("sizeof(char) = %d\n", sizeof(c)); printf("sizeof(short) = %d\n", sizeof(s)); printf("sizeof(int) = %d\n", sizeof(i)); printf("sizeof(long) = %d\n", sizeof(l)); printf("sizeof(long long) = %d\n", sizeof(L)); //Вызов как оператора printf("sizeof(char) = %d\n", sizeof c); printf("sizeof(short) = %d\n", sizeof s); printf("sizeof(int) = %d\n", sizeof i); printf("sizeof(long) = %d\n", sizeof l); printf("sizeof(long long) = %d\n", sizeof L); _getch(); }

(Я думаю ясно, что переменные могут иметь любое валидное имя). Эту программу можно было написать и проще

#include #include int main() { printf("sizeof(char) = %d\n", sizeof(char)); printf("sizeof(short) = %d\n", sizeof(short)); printf("sizeof(int) = %d\n", sizeof(int)); printf("sizeof(long) = %d\n", sizeof(long)); printf("sizeof(long long) = %d\n", sizeof(long long)); //нельзя произвести вызов sizeof как оператора для имени типа //sizeof int - ошибка компиляции _getch(); }

В си один и тот же тип может иметь несколько названий
short === short int
long === long int
long long === long long int
unsigned int === unsigned

Типы с плавающей точкой

float - 4 байта,
long float - 8 байт
double - 8 байт
long double - 8 байт.

Здесь также приведены значения для VC2012, по стандарту размер типов float <= long float <= double <= long double все числа с плавающей точкой - со знаком.

Переполнение переменных

Си не следит за переполнением переменных. Это значит, что постоянно увеличивая значение, скажем, переменной типа 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

Экспоненциальная форма записи также по умолчанию обозначает число типа double. #include #include int main() { printf("sizeof(int) = %d\n", sizeof(10)); printf("sizeof(unigned) = %d\n", sizeof(10u)); printf("sizeof(long) = %d\n", sizeof(10l)); printf("sizeof(long long) = %d\n", sizeof(10ll)); printf("sizeof(float) = %d\n", sizeof(10.f)); printf("sizeof(double) = %d\n", sizeof(10.)); printf("sizeof(double) = %d\n", sizeof(10e2)); getch(); }

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

Int a = 10u; double g = 3.f;

Шестнадцатеричный и восьмеричный формат

В о время работы с числами можно использовать шестнадцатеричный и восьмеричный формат представления. Числа в шестнадцатиричной системе счисления начинаются с 0x, в восьмеричной системе с нуля. Соответственно, если число начинается с нуля, то в нём не должно быть цифр выше 7:

#include #include void main() { int x = 0xFF; int y = 077; printf("hex x = %x\n", x); printf("dec x = %d\n", x); printf("oct x = %o\n", x); printf("oct y = %o\n", y); printf("dec y = %d\n", y); printf("hex y = %x", y); getch(); }

Экспоненциальная форма представления чисел

Э кспоненциальной формой представления числа называют представление числа в виде 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 и т.д.

Объявление переменных

В си переменные объявляются всегда в начале блока (блок - участок кода,ограниченный фигурными скобками)

<возвращаемый тип> <имя функции> (<тип> <аргумент>[, <тип> <аргумент>]) { объявление переменных всё остальное }

При объявлении переменной пишется её тип и имя.

Int a; double parameter;

Можно объявить несколько переменных одного типа, разделив имена запятой

Long long arg1, arg2, arg3;

Например

#include #include int main() { int a = 10; int b; while (a>0){ int z = a*a; b += z; } }

Здесь объявлены переменные a и b внутри функции main , и переменная z внутри тела цикла. Следующий код вызовет ошибку компиляции

Int main() { int i; i = 10; int j; }

Это связано с тем, что объявление переменной стоит после оператора присваивания. При объявлении переменных можно их сразу инициализировать.
int i = 0;
При этом инициализация при объявлении переменной не считается за отдельный оператор, поэтому следующий код будет работать

Int main() { int i = 10; int j; }

Начальное значение переменной

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

#include #include int main() { int i; printf("%d", i); getch(); }

Если выполнять эту программу на 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(); bar(333); getch(); }

Будет выведено
foo: 100
bar: 333
Здесь глобальная переменная global видна всем функциям. Но аргумент функции затирает глобальную переменную, поэтому при передаче аргумента 333 выводится локальное значение 333.
Вот другой пример

#include #include int global = 100; int main() { int global = 555; printf("%d\n", global); getch(); }

Программа выведет 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) Работает в несколько потоков

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

Безусловно, есть ситуации, когда глобальные переменные упрощают программу, но такие ситуации случаются не часто и не в ваших домашних заданиях, так что НЕ СОЗДАВАЙТЕ ГЛОБАЛЬНЫХ ПЕРЕМЕННЫХ!
Переменные могут быть не только целочисленными и с плавающей точкой. Существует множество других типов, которые мы будем изучать в дальнейшем.

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

прописные, строчные латинские буквы A, B, C…, x, y, z и знак подчеркивания;
арабские цифры от 0 до 9;
специальные знаки: { } , | , () + - / % * . \ ‘ : ? < > = ! & # ~ ; ^
символы пробела, табуляции и перехода на новую строку.

В тесте программы можно использовать комментарии . Если текст с двух символов «косая черта» // и заканчивается символом перехода на новую строку или заключен между символами /* и */, то компилятор его игнорирует.

Данные в языке C++

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

Для формирования других типов данных используют основные и так называемые спецификаторы. В C++ определенны четыре спецификатора типов данных:

short - короткий;
long - длинный;
signed - знаковый;
unsigned - беззнаковый.

Целочисленный тип

Переменная типа int в памяти компьютера может занимать либо 2, либо 4 байта. Это зависит разрядности процессора. По умолчанию все целые типы считаются знаковыми, то есть спецификатор signed можно не указывать. Спецификатор unsigned позволяет представлять только положительные числа. Ниже представлены некоторые диапазоны значений целого типа

Тип	Диапазон	Размер
int	-2147483648…2147483647	4 байта
unsigned int	0…4294967295	4 байта
signed int	-2147483648…2147483647	4 байта
short int	-32768…32767	2 байта
long int	-2147483648…2147483647	4 байта
unsigned short int	0…65535	2 байта

Вещественный тип

Число с плавающей точкой представлено в форме mE +- p, где m - мантисса (целое или дробное число с десятичной точкой), p - порядок (целое число). Обычно величины типа float занимают 4 байта, а double 8 байт. Таблица диапазонов значений вещественного типа:

float	3,4E-38…3,4E+38	4 байта
double	1,7E-308…1,7E+308	8 байт
long double	3,4E-4932…3,4E+4932	8 байт

Логический тип

Переменная типа bool может принимать только два значения true (истина) или fasle (ложь). Любоезначение, не равное нулю, интерпретируется как true. Значение false представлено в памяти как 0.

Тип void

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

Преобразование типов данных

В C++ различают два вида преобразования типов данных: явное и неявное.

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

#include "stdafx.h" #include using namespace std; int main() { int i=5; float f=10.12; cout<>void"); return 0; }

#include "stdafx.h"
#include
using namespace std ;
int main ()
int i = 5 ; float f = 10.12 ;
cout << i / f ;
system ("pause>>void" ) ;
return 0 ;

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

Явное преобразование в отличие от неявного осуществляется программистом. Существует несколько способов такого преобразования:

Преобразование в стили C : (float ) a

Преобразование в стили C++ : float ()

Также приведения типов может осуществляться при помощи следующих операций:

static_cast <> () const_cast <> () reinterpret_cast <> () dynamic_cast <> ()

static_cast <> ()
const_cast <> ()
reinterpret_cast <> ()
dynamic_cast <> ()

static_cas - осуществляет преобразование связанных типов данных. Этот оператор приводит типы по обычным правилам, что может потребоваться в случае, когда компилятор не выполняет автоматическое преобразование. Синтаксис будет выглядеть так:

Тип static_cast <Тип> (объект);

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

Тип const_cast < Тип > (объект );

reinterpret_cast - применяется для преобразования разных типов, целых к указателю и наоборот. Если вы увидели новое слово «указатель» - не пугайтесь! это тоже тип данных, но работать с ним Мы будем не скоро. Синтаксис тут такой же как, у ранее рассмотренных операторах:

Тип reinterpret _cast < Тип > (объект );

dynamic_cast - используется для динамического преобразования типов, реализует приведение указателей или ссылок. Синтаксис:

Тип dynamic _cast < Тип > (объект );

Управляющие символы

С некоторыми из этих самых «управляющих символов» Вы уже знакомы (например, с \n ). Все они начинаются с обратного «слеша», а также обрамляются двойными кавычками.

Изображение

Шестнадцатеричный код

Наименование

Звуковой сигнал бипера

Возврат на шаг

Перевод страницы (формата)

Перевод строки

Возврат каретки

Горизонтальная табуляция

Вертикальная табуляция

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

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

Примитивные встроенные типы

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

Type Keyword
Boolean bool
Character char
Integer int
Floating point float
Double floating point double
Valueless void
Wide character wchar_t
Некоторые из основных типов могут быть изменены с использованием одного или нескольких модификаторов этого типа:

signed

unsigned

short

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

Type Typical Bit Width Typical Range
char 1byte -127 to 127 or 0 to 255
unsigned char 1byte 0 to 255
signed char 1byte -127 to 127
int 4bytes -2147483648 to 2147483647
unsigned int 4bytes 0 to 4294967295
signed int 4bytes -2147483648 to 2147483647
short int 2bytes -32768 to 32767
unsigned short int Range 0 to 65,535
signed short int Range -32768 to 32767
long int 4bytes -2,147,483,648 to 2,147,483,647
signed long int 4bytes same as long int
unsigned long int 4bytes 0 to 4,294,967,295
float 4bytes +/- 3.4e +/- 38 (~7 digits)
double 8bytes
long double 8bytes +/- 1.7e +/- 308 (~15 digits)
wchar_t 2 or 4 bytes 1 wide character
Размер переменных может отличаться от размера, указанного в приведенной выше таблице, в зависимости от компилятора и компьютера, который вы используете. Ниже приведен пример, который даст правильный размер различных типов данных на вашем компьютере.
#include using namespace std; int main() { cout << "Size of char: " << sizeof(char) << endl; cout << "Size of int: " << sizeof(int) << endl; cout << "Size of short int: " << sizeof(short int) << endl; cout << "Size of long int: " << sizeof(long int) << endl; cout << "Size of float: " << sizeof(float) << endl; cout << "Size of double: " << sizeof(double) << endl; cout << "Size of wchar_t: " << sizeof(wchar_t) << endl; return 0; }
В этом примере используется endl , который вводит символ новой строки после каждой строки, а оператор << используется для передачи нескольких значений на экран. Мы также используем оператор sizeof () для получения размера различных типов данных.

Когда приведенный выше код компилируется и выполняется, он производит следующий результат, который может варьироваться от машины к машине:
Size of char: 1 Size of int: 4 Size of short int: 2 Size of long int: 4 Size of float: 4 Size of double: 8 Size of wchar_t: 4
Декларации typedef

Вы можете создать новое имя для существующего типа с помощью typedef . Ниже приведен простой синтаксис для определения нового типа с использованием typedef:
Typedef type newname;
Например, следующее говорит компилятору, что ногами является другое имя для int:
Typedef int feet;
Теперь следующая декларация совершенно легальна и создает целочисленную переменную, называемую расстоянием:
Feet distance;
Перечисленные типы

Перечислимый тип объявляет необязательное имя типа и набор из нуля или более идентификаторов, которые могут использоваться как значения типа. Каждый перечислитель является константой, тип которой является перечислением. Для создания перечисления требуется использование ключевого слова enum . Общий вид типа перечисления:
Enum enum-name { list of names } var-list;
Здесь enum-name - это имя типа перечисления. Список имен разделяется запятой. Например, следующий код определяет перечисление цветов, называемых цветами, и переменной c цвета типа. Наконец, c присваивается значение «blue».
Enum color { red, green, blue } c; c = blue;
По умолчанию значение первого имени равно 0, второе имя имеет значение 1, а третье - значение 2 и т. Д. Но вы можете указать имя, определенное значение, добавив инициализатор. Например, в следующем перечислении зеленый будет иметь значение 5.
Enum color { red, green = 5, blue };
Здесь blue будет иметь значение 6, потому что каждое имя будет больше, чем предыдущее.

К данным относится любая информация, представленная в таком виде, который позволяет автоматизировать её сбор, хранение и обработку в ЭВМ (числа, символы, биты и др.).
Данные в программе могут быть исходными (задаваемыми на входе программы) или результатами обработки (промежуточными или выходными).
Все данные - переменные и константы - принадлежат определенному типу.
С каждым типом данных связан свой диапазон значений (количество байт под одно значение) и допустимые операции .
Типы данных в C/C++ разделяются на основные и производные .
К основным типам относят:
void (пустой тип),

int (целый тип),

float (вещественные числа с плавающей точкой),

double (вещественные числа с плавающей точкой двойной точности),

char (символьный тип),

bool - логический.

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

long - длинный;

signed-знаковый;

unsigned-беззнаковый.

Производные типы – это:
массивы,

функции,

классы,

указатели,

ссылки,

структуры,

объединения.

Символьный тип
Данные типа char в памяти компьютера всегда занимают 1 байт. Это связано с тем, что обычно под величину символьного типа отводят столько памяти, сколько необходимо для хранения любого из 256 символов клавиатуры.
Символьный тип может быть со знаком или без знака .
В величинах со знаком signed char можно хранить значения в диапазоне от -128 до 127. Соответственно значения переменных типа unsigned char могут находиться в диапазоне от 0 до 255.
Тип данных Диапазон значений Размер
char -128...+127 1 байт
unsigned char 0...255 1 байт
signed char -128...127 1 байт

При работе с символьными данными нужно помнить, что если в выражении встречается одиночный символ , он должен быть заключен в одинарные кавычки . Последовательность символов, то есть строка, при использовании в выражениях заключается в двойные кавычки . Например: ‘F’ , ‘3’ , “Иван”, “235”
Целочисленный тип
Данные типа int в памяти компьютера могут занимать либо 2, 4 или 8 байт. Это зависит от разрядности процессора.
По умолчанию все целые типы считаются знаковыми, то есть спецификатор signed (знаковый) можно не указывать.
Спецификатор unsigned (беззнаковый) позволяет представлять только положительные числа.
Диапазоны значений целочисленных типов

Тип данных Диапазон значений Размер(байт)
int
signed int
signed long int -2147483648 ... 2147483647 4
unsigned int
unsigned long int 0 ... 4294967295 4
short int
signed short int -32768 ... 32767 2
unsigned short int 0... 65535 2
long long int $-(2^{63}-1)...(2^{63}-1)$ 8
unsigned long
long int $0...(2^{64}-1)$ 8
Вещественный тип
Внутреннее представление вещественного числа в памяти компьютера отличается от представления целого числа. Число с плавающей точкой представлено в экспоненциальной форме . $$\pm mE\pm p$$ где m - мантисса (целое или дробное число с десятичной точкой), р - порядок (целое число). Для того чтобы перевести число в экспоненциальной форме к обычному представлению с фиксированной точкой, необходимо мантиссу умножить на десять в степени порядок Например: $-6.42E+2=-6,42*10^{2}$
Диапазоны значений вещественных типов

Тип данных Диапазон значений Размер (байт)
float 3.4E-38 ... 3.4E+38 4
double 1.7E-308... 1.7E+308 8
long double 3.4E-4932 ... 3.4E+4932 10

Длина мантиссы определяет точность числа, а длина порядка его диапазон.
Данные типа float занимают 4 байт, из которых 1 двоичный разряд отводится под знак, 8 разрядов - под порядок и 23 - под мантиссу. По-скольку старшая цифра мантиссы всегда равна 1, она не хранится.
Данные типа double занимают 8 байт, в них под порядок -11 разрядов и под мантиссу -52 разряда соответственно.
Спецификатор типа long перед именем типа double указывает, что под величину отводится 10 байт.
Логический тип
Переменная типа bool может принимать только два значения true (истина) или false (ложь). Любое значение, не равное нулю, интерпретируется как true, а при преобразовании к целому типу принимает значение, равное 1. Значение false представлено в памяти как 0.
Тип void (пустой)
Множество значений этого типа пусто.
Тип void используется для:
определения функций, которые не возвращают значения;

для указания пустого списка аргументов функции;

как базовый тип для указателей;

в операции приведения типов.

Объявление переменных
Переменная - это поименованный участок памяти, в котором хранится значение определенного типа.
У переменной есть имя (идентификатор) и значение .
Имя служит для обращения к области памяти, в которой хранится значение.
Имя (идентификатор) - это совокупность букв, цифр и знаков подчёркивания, задающая имя переменной, название функции или ключевое слово в программе. Язык С/C++ чувствителен к регистру (т.е. Sum и sum будут восприниматься как две разные переменные).
где, тип – ключевое слово, определяющее объём памяти (число байтов), выделенный для хранения значения переменной (как объекта программы), (int – целый, float, double – вещественный, char – символьный, bool - логический);
имя – уникальный идентификатор переменной, задающий символический адрес объекта программы в памяти ЭВМ;
инициатор – начальное значение переменной, которое может отсутствовать в описании.
Например: Однотипные переменные можно сгруппировать, разделив «,». Описание переменных разного типа разделяется « ; ».
По месту обьявления переменные в языке С/С++ можно разделить на три класса:
локальные- объявляются внутри функции и доступны только в ней;

глобальные - описываются до всех функций и доступны из любого места программы;

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

Пример:
Последнее обновление: 13.11.2017

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

В языке C# есть следующие примитивные типы данных:

bool : хранит значение true или false (логические литералы). Представлен системным типом System.Boolean
Bool alive = true; bool isDead = false;

byte : хранит целое число от 0 до 255 и занимает 1 байт. Представлен системным типом System.Byte
Byte bit1 = 1; byte bit2 = 102;

sbyte : хранит целое число от -128 до 127 и занимает 1 байт. Представлен системным типом System.SByte
Sbyte bit1 = -101; sbyte bit2 = 102;

short : хранит целое число от -32768 до 32767 и занимает 2 байта. Представлен системным типом System.Int16
Short n1 = 1; short n2 = 102;

ushort : хранит целое число от 0 до 65535 и занимает 2 байта. Представлен системным типом System.UInt16
Ushort n1 = 1; ushort n2 = 102;

int : хранит целое число от -2147483648 до 2147483647 и занимает 4 байта. Представлен системным типом System.Int32 . Все целочисленные литералы по умолчанию представляют значения типа int:
Int a = 10; int b = 0b101; // бинарная форма b =5 int c = 0xFF; // шестнадцатеричная форма c = 255

uint : хранит целое число от 0 до 4294967295 и занимает 4 байта. Представлен системным типом System.UInt32
Uint a = 10; uint b = 0b101; uint c = 0xFF;

long : хранит целое число от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 и занимает 8 байт. Представлен системным типом System.Int64
Long a = -10; long b = 0b101; long c = 0xFF;

ulong : хранит целое число от 0 до 18 446 744 073 709 551 615 и занимает 8 байт. Представлен системным типом System.UInt64
Ulong a = 10; ulong b = 0b101; ulong c = 0xFF;

float : хранит число с плавающей точкой от -3.4*10 38 до 3.4*10 38 и занимает 4 байта. Представлен системным типом System.Single

double : хранит число с плавающей точкой от ±5.0*10 -324 до ±1.7*10 308 и занимает 8 байта. Представлен системным типом System.Double

decimal : хранит десятичное дробное число. Если употребляется без десятичной запятой, имеет значение от ±1.0*10 -28 до ±7.9228*10 28 , может хранить 28 знаков после запятой и занимает 16 байт. Представлен системным типом System.Decimal

char : хранит одиночный символ в кодировке Unicode и занимает 2 байта. Представлен системным типом System.Char . Этому типу соответствуют символьные литералы:
Char a = "A"; char b = "\x5A"; char c = "\u0420";

string : хранит набор символов Unicode. Представлен системным типом System.String . Этому типу соответствуют символьные литералы.
String hello = "Hello"; string word = "world";

object : может хранить значение любого типа данных и занимает 4 байта на 32-разрядной платформе и 8 байт на 64-разрядной платформе. Представлен системным типом System.Object , который является базовым для всех других типов и классов.NET.
Object a = 22; object b = 3.14; object c = "hello code";

Например, определим несколько переменных разных типов и выведем их значения на консоль:
Using System; namespace HelloApp { class Program { static void Main(string args) { string name = "Tom"; int age = 33; bool isEmployed = false; double weight = 78.65; Console.WriteLine($"Имя: {name}"); Console.WriteLine($"Возраст: {age}"); Console.WriteLine($"Вес: {weight}"); Console.WriteLine($"Работает: {isEmployed}"); } } }
Для вывода данных на консоль здесь применяется интерполяция: перед строкой ставится знак $ и после этого мы можем вводить в строку в фигурных скобках значения переменных. Консольный вывод программы:

Имя: Tom Возраст: 33 Вес: 78,65 Работает: False

Использование суффиксов

При присвоении значений надо иметь в виду следующую тонкость: все вещественные литералы рассматриваются как значения типа double . И чтобы указать, что дробное число представляет тип float или тип decimal , необходимо к литералу добавлять суффикс: F/f - для float и M/m - для decimal.
Подобным образом все целочисленные литералы рассматриваются как значения типа int . Чтобы явным образом указать, что целочисленный литерал представляет значение типа uint, надо использовать суффикс U/u , для типа long - суффикс L/l , а для типа ulong - суффикс UL/ul :
Uint a = 10U; long b = 20L; ulong c = 30UL;
Использование системных типов

Выше при перечислении всех базовых типов данных для каждого упоминался системный тип. Потому что название встроенного типа по сути представляет собой сокращенное обозначение системного типа. Например, следующие переменные будут эквивалентны по типу:
Int a = 4; System.Int32 b = 4;
Неявная типизация

Ранее мы явным образом указывали тип переменных, например, int x; . И компилятор при запуске уже знал, что x хранит целочисленное значение.

Однако мы можем использовать и модель неявной типизации:
Var hello = "Hell to World"; var c = 20; Console.WriteLine(c.GetType().ToString()); Console.WriteLine(hello.GetType().ToString());
Для неявной типизации вместо названия типа данных используется ключевое слово var . Затем уже при компиляции компилятор сам выводит тип данных исходя из присвоенного значения. В примере выше использовалось выражение Console.WriteLine(c.GetType().ToString()); , которое позволяет нам узнать выведенный тип переменной с. Так как по умолчанию все целочисленные значения рассматриваются как значения типа int , то поэтому в итоге переменная c будет иметь тип int или System.Int32

Эти переменные подобны обычным, однако они имеют некоторые ограничения.

Во-первых, мы не можем сначала объявить неявно типизируемую переменную, а затем инициализировать:
// этот код работает int a; a = 20; // этот код не работает var c; c= 20;
Во-вторых, мы не можем указать в качестве значения неявно типизируемой переменной null:
// этот код не работает var c=null;
Так как значение null, то компилятор не сможет вывести тип данных.

double или decimal

Из выше перечисленного списка типов данных очевидно, что если мы хотим использовать в программе числа до 256, то для их хранения мы можем использоват переменные типа byte . При использовании больших значений мы можем взять тип short, int, long. То же самое для дробных чисел - для обычных дробных чисел можно взять тип float, для очень больших дробных чисел - тип double. Тип decimal здесь стоит особняком в том плане, что несмотря на большую разрядность по сравнению с типом double, тип double может хранить большее значение. Однако значение decimal может содержать до 28 знаков после запятой, тогда как значение типа double - 15-16 знаков после запятой.

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

Type	Keyword
Boolean	bool
Character	char
Integer	int
Floating point	float
Double floating point	double
Valueless	void
Wide character	wchar_t

Type	Typical Bit Width	Typical Range
char	1byte	-127 to 127 or 0 to 255
unsigned char	1byte	0 to 255
signed char	1byte	-127 to 127
int	4bytes	-2147483648 to 2147483647
unsigned int	4bytes	0 to 4294967295
signed int	4bytes	-2147483648 to 2147483647
short int	2bytes	-32768 to 32767
unsigned short int	Range	0 to 65,535
signed short int	Range	-32768 to 32767
long int	4bytes	-2,147,483,648 to 2,147,483,647
signed long int	4bytes	same as long int
unsigned long int	4bytes	0 to 4,294,967,295
float	4bytes	+/- 3.4e +/- 38 (~7 digits)
double	8bytes
long double	8bytes	+/- 1.7e +/- 308 (~15 digits)
wchar_t	2 or 4 bytes	1 wide character

Тип данных	Диапазон значений	Размер
char	-128...+127	1 байт
unsigned char	0...255	1 байт
signed char	-128...127	1 байт

Тип данных	Диапазон значений	Размер(байт)
int signed int signed long int	-2147483648 ... 2147483647	4
unsigned int unsigned long int	0 ... 4294967295	4
short int signed short int	-32768 ... 32767	2
unsigned short int	0... 65535	2
long long int	\(-(2^{63}-1)...(2^{63}-1)\)	8
unsigned long long int	\(0...(2^{64}-1)\)	8

Тип данных	Диапазон значений	Размер (байт)
float	3.4E-38 ... 3.4E+38	4
double	1.7E-308... 1.7E+308	8
long double	3.4E-4932 ... 3.4E+4932	10

Поддержите проект — поделитесь ссылкой, спасибо!

Читайте также

Что несут в себе символы? Ярославский государственный технический университет Эрик берн трансакционный анализ и психотерапия - книга

Изображение	Шестнадцатеричный код	Наименование
		Звуковой сигнал бипера
		Возврат на шаг
		Перевод страницы (формата)
		Перевод строки
		Возврат каретки
		Горизонтальная табуляция
		Вертикальная табуляция