Все типы данных c. Типы данных. Постфиксное обозначение типа

Все данные в языке Си имеют свой тип. Переменные определенных типов занимают в памяти какое-то место, разное в зависимости от типа. В Си нет четкого закрепления количества памяти за определенными типами. Это отдано на реализацию конкретного компилятора под конкретную платформу. Например, переменная типа int в одном компиляторе может занимать в памяти 16 бит, в другом — 32 бита, в третьем — 8 бит. Все определяет конкретный компилятор. Правда, все стремятся к универсализации, и в основном в большинстве компиляторов тип int , например, занимает 2 байта, а тип char — один.

Я в последнее время немного затупил, не мог вспомнить, сколько байт занимает тип double в AVR-GCC . Обычно при программировании контроллеров работаешь с целочисленными типами, типа int и char , а к типам с плавающей точкой прибегаешь не часто, в связи с их ресурсоемкостью.

Поэтому, на будущее, оставлю себе здесь памятку с указанием размеров занимаемой памяти типами данных для компилятора AVR-GCC и диапазон изменения переменных этого типа.

Типы данных в языке Си для компилятора AVR-GCC

Тип Размер в
байтах (битах) 		Интервал изменения
char 1 (8) -128 .. 127
unsigned char 1 (8) 0 .. 255
signed char 1 (8) -128 .. 127
int 2 (16) -32768 .. 32767
unsigned int 2 (16) 0 .. 65535
signed int 2 (16) -32768 .. 32767
short int 2 (16) -32768 .. 32767
unsigned short int 2 (16) 0 .. 65535
signed short int 2 (16) -32768 .. 32767
long int 4 (32) -2147483648 .. 2147483647
unsigned long int 4 (32) 0 .. 4294967295
signed long int 4 (32) -2147483648 .. 2147483647
float 4 (32) 3.4Е-38 .. 3.4Е+38
double 4 (32) 3.4Е-38 .. 3.4Е+38
long double 10 (80) 3.4Е-4932 .. 3.4Е+4932

Реализация типа double в AVR-GCC отступает от стандарта. По стандарту double занимает 64 бита. В AVR-GCC переменная этого типа занимает 32 бита, и соответственно, она эквивалентна переменной с типом float !

В дополнение к этому, в библиотеках AVR-GCC введено несколько производных от стандартных типов. Они описаны в файле stdint.h . Сделано это, наверно, для улучшения наглядности и уменьшения текста программ (ускорения их написания:)). Вот табличка соответствия:

Производные типы от стандартных в языке Си для компилятора AVR-GCC

Производный тип Стандартный тип
int8_t signed char
uint8_t unsigned char
int16_t signed int
uint16_t unsigned int
int32_t signed long int
uint32_t unsigned long int
int64_t signed long long int
uint64_t unsigned long long int

Тип Void

В языке Си есть еще один тип — тип void . Void используется для указания, что функция не возвращает ничего в качестве результата, или не принимает на вход никаких параметров. Этот тип не применяется для объявления переменных, соответственно он не занимает места в памяти.

Типом данных в программировании называют совокупность двух множеств: множество значений и множество операций, которые можно применять к ним. Например, к типу данных целых неотрицательных чисел, состоящего из конечного множества натуральных чисел, можно применить операции сложения (+), умножения (*), целочисленного деления (/), нахождения остатка (%) и вычитания (−).

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

  • логический (bool);
  • символьный (напр., char);
  • целый (напр., int);
  • с плавающей точкой (напр., float);
  • перечисления (определяется программистом);
  • void .

Поверх перечисленных строятся следующие типы:

  • указательные (напр., int*);
  • массивы (напр., char);
  • ссылочные (напр., double&);
  • другие структуры.

Перейдём к понятию литерала (напр., 1, 2.4F, 25e-4, ‘a’ и др.): литерал - запись в исходном коде программы, представляющаясобой фиксированное значение. Другими словами, литерал - это просто отображение объекта (значение) какого-либо типа в коде программы. В C++ есть возможность записи целочисленных значений, значений с плавающей точкой, символьных, булевых, строковых.

Литерал целого типа можно записать в:

  • 10-й системе счисления. Например, 1205 ;
  • 8-й системе счисления в формате 0 + число. Например, 0142 ;
  • 16-й системе счисления в формате 0x + число. Например, 0x2F .

24, 030, 0x18 - это всё записи одного и того же числа в разных системах счисления.
Для записи чисел с плавающей точкой используют запись через точку: 0.1, .5, 4. - либо в
экспоненциальной записи - 25e-100. Пробелов в такой записи быть не должно.

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

Const int example = 3; // здесь const - спецификатор // int - базовый тип // example - имя переменной // = 3 - инициализатор.

Имя переменной является последовательностью символов из букв латинского алфавита (строчных и прописных), цифр и/или знака подчёркивания, однако первый символ цифрой быть не может . Имя переменной следует выбирать таким, чтобы всегда было легко догадаться о том, что она хранит, например, «monthPayment». В конспекте и на практиках мы будем использовать для правил записи переменных нотацию CamelCase. Имя переменной не может совпадать с зарезервированными в языке словами, примеры таких слов: if, while, function, goto, switch и др.

Декларатор кроме имени переменной может содержать дополнительные символы:

  • * - указатель; перед именем;
  • *const - константный указатель; перед именем;
  • & - ссылка; перед именем;
  • - массив; после имени;
  • () - функция; после имени.

Инициализатор позволяет определить для переменной её значение сразу после объявления. Инициализатор начинается с литерала равенства (=) и далее происходит процесс задания значения переменной. Вообще говоря, знак равенства в C++ обозначает операцию присваивания; с её помощью можно задавать и изменять значение переменной. Для разных типов он может быть разным.

Спецификатор задаёт дополнительные атрибуты, отличные от типа. Приведённый в примере спецификатор const позволяет запретить последующее изменение значение переменной. Такие неизменяемые переменные называют константными или константой.

Объявить константу без инициализации не получится по логичным причинам:

Const int EMPTY_CONST; // ошибка, не инициализована константная переменная const int EXAMPLE = 2; // константа со значением 2 EXAMPLE = 3; // ошибка, попытка присвоить значение константной переменной

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

Основные типы данных в C++

Разбирая каждый тип, читатель не должен забывать об определении типа данных.

1. Целочисленный тип (char, short (int), int, long (int), long long)

Из названия легко понять, что множество значений состоит из целых чисел. Также множество значений каждого из перечисленных типов может быть знаковым (signed) или беззнаковым (unsigned). Количество элементов, содержащееся в множестве, зависит от размера памяти, которая используется для хранения значения этого типа. Например, для переменной типа char отводится 1 байт памяти, поэтому всего элементов будет:

  • 2 8N = 2 8 * 1 = 256, где N - размер памяти в байтах для хранения значения

В таком случае диапазоны доступных целых чисел следующие:

  • - для беззнакового char
  • [-128..127] - для знакового char

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

Unsigned long values; // задаёт целый (длинный) беззнаковый тип.

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

  • 1 = размер char ≤ размер short ≤ размер int ≤ размер long.

Обычно размеры типов следующие: char - 1, short - 2, int - 4, long -8, long long - 8 байт.

Со значениями целого типа можно совершать арифметические операции: +, -, *, /, %; операции сравнения: ==, !=, <=, <, >, >=; битовые операции: &, |, xor, <<, >>.
Большинство операций, таких как сложение, умножение, вычитание и операции сравнения, не вызывают проблем в понимании. Иногда, после выполнения арифметических операций, результат может оказаться за пределами диапазона значений; в этом случае программа выдаст ошибку.
Целочисленное деление (/) находит целую часть от деления одного целого числа, на другое. Например:

  • 6 / 4 = 1;
  • 2 / 5 = 0;
  • 8 / 2 = 4.

Символ процента (%) обозначает операцию определение остатка от деления двух целых чисел:

  • 6 % 4 = 2;
  • 10 % 3 = 1.

Более сложные для понимания операции - битовые: & (И), | (ИЛИ), xor (исключающее ИЛИ), << (побитовый сдвиг влево), >> (побитовый сдвиг вправо).

Битовые операции И, ИЛИ и XOR к каждому биту информации применяют соответствующую логическую операцию:

  • 1 10 = 01 2
  • 3 10 = 11 2
  • 1 10 & 3 10 = 01 2 & 11 2 = 01 2
  • 1 10 | 3 10 = 01 2 | 11 2 = 11 2
  • 1 10 xor 3 10 = 01 2 xor 11 2 = 10 2

В обработке изображения используют 3 канала для цвета: красный, синий и зелёный - плюс прозрачность, которые хранятся в переменной типа int, т.к. каждый канал имеет диапазон значений от 0 до 255. В 16-иричной системе счисления некоторое значение записывается следующим образом: 0x180013FF; тогда значение 18 16 соответствует красному каналу, 00 16 - синему, 13 16 - зелёному, FF - альфа-каналу (прозрачности). Чтобы выделить из такого целого числа определённый канал используют т.н. маску, где на интересующих нас позициях стоят F 16 или 1 2 . Т.е., чтобы выделить значение синего канала необходимо использовать маску, т.е. побитовое И:

Int blue_channel = 0x180013FF & 0x00FF0000;

После чего полученное значение сдвигается вправо на необходимое число бит.

Побитовый сдвиг смещает влево или вправо на столько двоичных разрядов числа, сколько указано в правой части операции. Например, число 39 для типа char в двоичном виде записывается в следующем виде: 00100111. Тогда:

Char binaryExample = 39; // 00100111 char result = binaryExample << 2; // сдвигаем 2 бита влево, результат: 10011100

Если переменная беззнакового типа, тогда результатом будет число 156, для знакового оно равно -100. Отметим, что для знаковых целых типов единица в старшем разряде битового представления - признак отрицательности числа. При этом значение, в двоичном виде состоящие из всех единиц соответствует -1; если же 1 только в старшем разряде, а в остальных разрядах - нули, тогда такое число имеет минимальное для конкретного типа значения: для char это -128.

2. Тип с плавающей точкой (float, double (float))

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

Float value = 0.2; value == 0.2; // ошибка, value здесь не будет равно 0.2.

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

Value - 0.2 < 1e-6; // ok, подбирать интервал тоже нужно осторожно

Помимо операций сравнения тип с плавающей точкой поддерживает 4 арифметические операции, которые полностью соответствуют математическим операциям с вещественными числами.

3. Булевый (логический) тип (bool)

Состоит всего из двух значений: true (правда) и false (ложь). Для работы с переменными данного типа используют логические операции: ! (НЕ), == (равенство), != (неравенство), && (логическое И), || (логическое ИЛИ). Результат каждой операции можно найти в соответствующей таблицы истинности. например:

X Y XOR 0 0 0 0 1 1 1 0 1 1 1 0

4. Символьный тип (char, wchar_t)

Тип char - не только целый тип (обычно, такой тип называют byte), но и символьный, хранящий номер символа из таблицы символом ASCII . Например код 0x41 соответствует символу ‘A’, а 0x71 - ‘t’.

Иногда возникает необходимость использования символов, которые не закреплены в таблицы ASCII и поэтому требует для хранения более 1-го байта. Для них существует широкий символ (wchar_t).

5.1. Массивы

Массивы позволяют хранить последовательный набор однотипных элементов. Массив хранится в памяти непрерывным блоком, поэтому нельзя объявить массив, не указав его размер . Чтобы объявить массив после имени переменной пишут квадратные скобки () с указанием его размера. Например:

Int myArray; // Массив из 5-и элементов целого типа

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

Int odds = {1, 3, 7, 9, 11}; // Массив инициализируется 5-ю значениями

Для доступа к определённому значению в массиве (элемента массива) используют операцию доступа по индексу () с указанием номера элемента (номера начинаются с 0). Например:

Odds; // доступ к первому элементу массива. Вернёт значение 1 odds; // доступ к третьему элементу. Вернёт значение 7 odds = 13; // 5-му элементу массива присваиваем новое значение odds; // ошибка доступа

5.3. Строки

Для записи строки программисты используют идею, что строка - последовательный ряд (массив) символов. Для идентификации конца строки используют специальный символ конца строки: ‘\0’. Такие специальные символы, состоящие из обратного слэша и идентифицирующего символа, называют управляющими или escape-символами. Ещё существуют, например, ‘\n’ - начало новой строки, ‘\t’ - табуляция. Для записи в строке обратного слэша применяют экранирование - перед самим знаком ставят ещё один слэш: ‘\’. Экранирование также применяют для записи кавычек.

Создадим переменную строки:

Char textExample = {‘T’, ‘e’, ‘s’, ‘t’, ‘\0’}; // записана строка «Test»

Существует упрощённая запись инициализации строки:

Char textExample = “Test”; // Последний символ не пишется, но размер всё ещё 5

Не вдаваясь в подробности, приведём ещё один полезный тип данных - string. Строки
такого типа можно, например, складывать:

String hello = "Привет, "; string name = "Макс!"; string hello_name = hello + name; // Получится строка «Привет, Макс!»

6. Ссылка

Int a = 2; // переменная «a» указывает на значение 2 int &b = a; // переменная «b» указывает туда же, куда и «a» b = 4; // меняя значение b, программист меняет значение a. Теперь a = 4 int &c = 4; // ошибка, так делать нельзя, т.к. ссылка нельзя присвоить значение

7. Указатель

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

Адреса 0x0 означает, что указатель пуст, т.е. не указывает ни на какие данные. Этот адрес имеет свой литерал - NULL:

Int *nullPtr = NULL; // пустой указатель

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

Операция получения данных, начинающихся по адресу, хранящемуся в указателе, называется разыменовывания (*). Программа считывает необходимое количество ячеек памяти и возвращает значение, хранимое в памяти.

Int valueInMemory = 2; // задаём переменну целого типа int *somePtr = &valueIntMemory; // копируем адрес переменной, здесь & - возвращает адрес переменной somePtr; // адрес ячейки памяти, например, 0x2F *somePtr; // значение хранится в 4-х ячейках: 0x2F, 0x30, 0x31 и 0x32

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

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

8. Перечисления

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

Enum color {RED, BLUE, GREEN};

По умолчанию, RED = 0, BLUE = 1, GREEN = 2. Поэтому значения можно сравнивать между собой, т.е. RED < BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

Enum access {READ = 1, WRITE = 2, EXEC = 4};

Часто удобно использовать перечисления, значения которых являются степенью двойки, т.к. в двоичном представлении число, являющееся степенью 2-и, будет состоять из 1-й единицы и нулей. Например:

8 10 = 00001000 2

Результат сложения этих чисел между собой всегда однозначно указывает на то, какие числа складывались:

37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10

Void

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

Void object; // ошибка, не существует объектов типа void void &reference; // ошибка, не существует ссылов на void void *ptr; // ok, храним указатель на неизвестный тип

Часто мы будем использовать void именно для обозначения того, что функция не возвращает никакого значения. С указателем типа void работают, когда программист берёт полностью на себя заботу о целостности памяти и правильном приведении типа.

Приведение типов

Часто бывает необходимо привести значение переменной одного типа к другому. В случае, когда множество значений исходного типа является подмножеством большего типа (например, int является подмножеством long, а long - double), компилятор способен неявно (implicitly ) изменить тип значения.

Int integer = 2; float floating = integer; // floating = 2.0

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

Существует возможность явного (explicitly) преобразования типов, для этого слева от переменной или какого-либо значения исходного типа в круглых скобках пишут тип, к которому будет произведено приведение:

Int value = (int) 2.5;

Унарные и бинарные операции

Те операции, которые мы выполняли ранее, называют бинарными: слева и справа от символа операции находятся значения или переменные, например, 2 + 3. В языках программирования помимо бинарных операций также используют унарные операции, которые применяются к переменным. Они могу находится как слева, так и справа от переменной, несколько таких операций встречались ранее - операция разыменовывания (*) и взятие адреса переменной (&) являются унарными. Операторы «++» и «—» увеличивают и уменьшают значение целочисленной переменной на 1 соответственно, причём могу писаться либо слева, либо справа от переменной.

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

A += 2; // то же самое, что и a = a + 2; b /= 5; // то же самое, что и b = b / 5; c &= 3; // то же самое, что и c = c & 3;

Целый тип (int)

Размер типа int не определяется стандартом, а зависит от компьютера и компилятора.

Для 16-разрядного процессора под величины этого типа отводится 2 байта,

для 32-разрядного - 4 байта.

Спецификатор short перед именем типа указывает компилятору, что под число требуется отвести 2 байта независимо от разрядности процессора.

Спецификатор long означает, что целая величина будет занимать 4 байта.

Таким образом, на 16-разрядном компьютере эквиваленты int и short int,

а на 32-разрядном - int и long int.

Внутреннее представление величины целого типа - целое число в двоичном коде. При использовании спецификатора signed старший бит числа интерпретируется как знаковый (0 - положительное число, 1 - отрицательное). Спецификатор unsigned позволяет представлять только положительные числа, поскольку старший разряд рассматривается как часть кода числа. Т. о., диапазон значений типа int зависит от спецификаторов. Диапазоны значений величин целого типа с различными спецификаторами для IBM PC-совместимых компьютеров приведены в таблице «Диапазоны значений простых типов данных».

По умолчанию все целочисленные типы считаются знаковыми, то есть спецификатор signed можно опускать.

Константам, встречающимся в программе, приписывается тот или иной тип в соответствии с их видом. Если он по каким-либо причинам не устраивает программиста, моно явно указать требуемый тип с помощью суффиксов L, l (long) и U, u (unsigned). Например, константа 32L будет иметь тип long и занимать 4 байта. Можно использовать суффиксы L и U одновременно, например, 0x22UL или 05Lu.

Примечание. Типы short int, long int, signed int и unsigned int можно сокращать до short, long, signed и unsigned соответственно.

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

Под величину символьного типа отводится количество байт, достаточное для размещения любого символа из набора символов для данного компьютера, что и обусловило название типа. Как правило, это 1 байт. Тип char, как и другие целые типы, может быть со знаком или без знака. В величинах со знаком можно хранить значения в диапазоне от -128 до 127. При использовании спецификатора unsigned значения могут находиться в пределах от 0 до 255. Этого достаточно для хранения любого символа из 256-символьного набора ASCII. Величины типа char применяются также для хранения целых чисел.



Расширенный символьный тип (wchar_t)

Тип wchar_t предназначен для работы с набором символов, для кодировки которых недостаточно 1 байта. Например, Unicode. Размер этого типа зависит от реализации; как правило, он соответствует типу short. Строковые константы типа wchar_t записываются с префиксом L, например, L“Gates”.

Логический тип (bool)

Величины логического типа могут принимать только значения true и false , являющиеся зарезервированными словами. Внутренняя форма представления значения false - 0 (нуль). Любое другое значение интерпретируется как true. При преобразовании к целому типу true имеет значение 1.

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

Стандарт C++ определяет три типа данных для хранения вещественных значений: float, double и long double.

Типы данных с плавающей точкой хранятся в памяти иначе, чем целочисленные. Внутреннее представление вещественного числа состоит из двух частей - мантиссы и порядка .

В IBM PC-совместимых компьютерах величины типа float занимают 4 байта, из которых один двоичный разряд отводится под знак мантиссы , 8 разрядов под порядок и 23 под мантиссу . Мантисса - это число, большее 1.0, но меньшее 2.0. Поскольку старшая цифра мантиссы всегда равна 1, она не хранится.

Для величин типа double, занимающих 8 байт, под порядок и мантиссу отводится 11 и 52 разряда соответственно. Длина мантиссы определяет точность числа, а длина порядка - его диапазон. Как можно видеть из таблицы в конце записи, при одинаковом количестве байт, отводимом под величины типа float и long int, диапазоны их допустимых значений сильно различаются из-за внутренней формы представления .

Спецификатор long перед именем типа double указывает, что под его величину отводится 10 байт.

Константы с плавающей точкой имеют по умолчанию тип double. Можно явно указать тип константы с помощью суффиксов F, f (float) и L, l (long).

Например, константа 2E+6L будет иметь тип long double, а константа 1.82f - тип float.

При написании универсальных для разных платформ программ нельзя делать допущений о размере типа int. Для его получения необходимо пользоваться операцией sizeof, результатом которой является размер типа в байтах.

Например, для операционной системы MS-DOS sizeof (int) даст в результате 2, а для Windows 98 или OS/2 результатом будет 4.

В стандарте ANSI диапазоны значений для основных типов не задаются, определяются только соотношения между их размерами, например:

sizeof(float) ≤ slzeof(double) ≤ sizeof(long double)
sizeof(char) ≤ slzeof(short) ≤ sizeof(int) ≤ sizeof(long)

Примечание. Минимальные и максимальные допустимые значения для целых типов зависят от реализации и приведены в заголовочном файле (), характеристики вещественных типов - в файле (), а также в шаблоне класса numeric_limits

Тип void

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

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

Тип Диапазон значений Размер (байт)
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.4e+38
double 1.7e-308 … 1.7C+308
long double 3.4e-4932 … 3.4e+4932

Структура программы

Программа на языке С++ состоит из функций , описаний и директив препроцессора . Одна из функций должна иметь имя main . Выполнение программы начинается с первого оператора этой функции. Простейшее определение функции имеет следующий формат:

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

  • если функция не должна возвращать значение, указывается тип void:
  • тело функции является блоком и, следовательно, заключается в фигурные скобки;
  • функции не могут быть вложенными;
  • каждый оператор заканчивается точкой с запятой (кроме составного оператора).

Пример структуры программы, содержащей функции main, fl и f2:

Программа может состоять из нескольких модулей (исходных файлов).

Замечания о вводе/выводе в C++

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

Используется два способа: функции, унаследованные из языка С, и объекты С++.

Основные функции ввода/вывода в стиле С:

int scanf (const char* format, ...) // ввод
int printf(const char* format, ...) // вывод

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

Пример программы, использующей функции ввода/вывода в стиле С:

#include
int main() {
int i;
printf("Введите целое число\п");
scanf("%d", &i);
printf("Вы ввели число %d, спасибо!", i);
return 0;
}

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

Третья строка - описание переменной целого типа с именем i.

Функция printf в четвертой строке выводит приглашение «Введите целое число» и переходит на новую строку в соответствии с управляющей последовательностью \n. Функция scanf заносит введенное с клавиатуры целое число в переменную i (знак & означает операцию получения адреса), а следующий оператор выводит на экран указанную в нем строку, заменив спецификацию преобразования на значение этого числа.

Программа с использованием библиотеки классов С++:

#include
int main() {
int i;
cout << "Введите целое число\n "; cin >> i;
cout << "Вы ввели число " << i << ", спасибо!";
return 0;
}

Заголовочный файл содержит описание набора классов для управления вводом/выводом. В нем определены стандартные объекты-потоки cin для ввода с клавиатуры и cout для вывода на экран, а также операции помещения в поток < < и чтения из потока >>.

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

Последнее обновление: 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 - в математических операциях. Общие различия между этими двумя типами можно выразить следующей таблицей.

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

Типы данных в C/C++ разделяются на основные и производные .
К основным типам относят:

  1. void (пустой тип),
  2. int (целый тип),
  3. float (вещественные числа с плавающей точкой),
  4. double (вещественные числа с плавающей точкой двойной точности),
  5. char (символьный тип),
  6. bool - логический.

Составные типы

Для формирования других типов данных используют основные типы + так называемые спецификаторы . Типы данных, созданные на базе стандартных типов с использованием спецификаторов, называют составными типами данных . В C++ определены четыре спецификатора типов данных:
  1. short - короткий;
  2. long - длинный;
  3. signed-знаковый;
  4. 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 - логический);
имя – уникальный идентификатор переменной, задающий символический адрес объекта программы в памяти ЭВМ;
инициатор – начальное значение переменной, которое может отсутствовать в описании.
Например: Однотипные переменные можно сгруппировать, разделив «,». Описание переменных разного типа разделяется « ; ».
По месту обьявления переменные в языке С/С++ можно разделить на три класса:
  1. локальные- объяв­ляются внутри функции и доступны только в ней;
  2. глобальные - описываются до всех функций и доступны из любо­го места программы;
  3. формальные параметры функций описываются в списке параметров функции.
Пример: