Триколор 

Основные типы данных в си. Типы данных в си. Оператор создания типов данных в СИ

Последнее обновление: 17.09.2017

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

    bool : логический тип. Может принимать одну из двух значений true (истина) и false (ложь). Размер занимаемой памяти для этого типа точно не определен.

    char : представляет один символ в кодировке ASCII. Занимает в памяти 1 байт (8 бит). Может хранить любое значение из диапазона от -128 до 127, либо от 0 до 255

    signed char : представляет один символ. Занимает в памяти 1 байт (8 бит). Может хранить любой значение из диапазона от -128 до 127

    unsigned char : представляет один символ. Занимает в памяти 1 байт (8 бит). Может хранить любой значение из диапазона от 0 до 255

    wchar_t : представляет расширенный символ. На Windows занимает в памяти 2 байта (16 бит), на Linux - 4 байта (32 бита). Может хранить любой значение из диапазона от 0 до 65 535 (при 2 байтах), либо от 0 до 4 294 967 295 (для 4 байт)

    char16_t : представляет один символ в кодировке Unicode. Занимает в памяти 2 байта (16 бит). Может хранить любой значение из диапазона от 0 до 65 535

    char32_t : представляет один символ в кодировке Unicode. Занимает в памяти 4 байта (32 бита). Может хранить любой значение из диапазона от 0 до 4 294 967 295

    short : представляет целое число в диапазоне от –32768 до 32767. Занимает в памяти 2 байта (16 бит).

    Данный тип также имеет синонимы short int , signed short int , signed short .

    unsigned short : представляет целое число в диапазоне от 0 до 65535. Занимает в памяти 2 байта (16 бит).

    Данный тип также имеет синоним unsigned short int .

    int : представляет целое число. В зависимости от архитектуры процессора может занимать 2 байта (16 бит) или 4 байта (32 бита). Диапазон предельных значений соответственно также может варьироваться от –32768 до 32767 (при 2 байтах) или от −2 147 483 648 до 2 147 483 647 (при 4 байтах). Но в любом случае размер должен быть больше или равен размеру типа short и меньше или равен размеру типа long

    Данный тип имеет синонимы signed int и signed .

    unsigned int : представляет положительное целое число. В зависимости от архитектуры процессора может занимать 2 байта (16 бит) или 4 байта (32 бита), и из-за этого диапазон предельных значений может меняться: от 0 до 65535 (для 2 байт), либо от 0 до 4 294 967 295 (для 4 байт).

    В качестве синонима этого типа может использоваться unsigned

    long : представляет целое число в диапазоне от −2 147 483 648 до 2 147 483 647. Занимает в памяти 4 байта (32 бита).

    У данного типа также есть синонимы long int , signed long int и signed long

    unsigned long : представляет целое число в диапазоне от 0 до 4 294 967 295. Занимает в памяти 4 байта (32 бита).

    Имеет синоним unsigned long int .

    long long : представляет целое число в диапазоне от −9 223 372 036 854 775 808 до +9 223 372 036 854 775 807. Занимает в памяти, как правило, 8 байт (64 бита).

    Имеет синонимы long long int , signed long long int и signed long long .

    unsigned long long : представляет целое число в диапазоне от 0 до 18 446 744 073 709 551 615. Занимает в памяти, как правило, 8 байт (64 бита).

    Имеет синоним unsigned long long int .

    float : представляет вещественное число ординарной точности с плавающей точкой в диапазоне +/- 3.4E-38 до 3.4E+38. В памяти занимает 4 байта (32 бита)

    double : представляет вещественное число двойной точности с плавающей точкой в диапазоне +/- 1.7E-308 до 1.7E+308. В памяти занимает 8 байт (64 бита)

    long double : представляет вещественное число двойной точности с плавающей точкой не менее 8 байт (64 бит). В зависимости от размера занимаемой памяти может отличаться диапазон допустимых значений.

    void : тип без значения

Таким образом, все типы данных за исключением void могут быть разделены на три группы: символьные (char, wchar_t, char16_t, char32_t), целочисленные (short, int, long, long long) и типы чисел с плавающей точкой (float, double, long double).

Символьные типы

Для представления символов в приложении используются типы char , wchar_t , char16_t и char32_t .

Определим несколько переменных:

Char c ="d"; wchar_t d ="c";

Переменная типа char в качестве значения принимает один символ в одинарных кавычках: char c ="d" . Также можно присвоить число из указанного выше в списке диапазона: char c = 120 . В этом случае значением переменной c будет тот символ, который имеет код 120 в таблице символов ASCII.

Стоит учитывать, что для вывода на консоль символов wchar_t следует использовать не std::cout, а поток std::wcout :

#include int main() { char a = "H"; wchar_t b = "e"; std::wcout << a << b << "\n"; return 0; }

При этом поток std::wcout может работать как с char, так и с wchar_t. А поток std::cout для переменной wchar_t вместо символа будет выводить его числовой код.

В стандарте С++11 были добавлены типы char16_t и char32_t , которые ориентированы на использование Unicode. Однако на уровне ОС пока не реализованы потоки для работы с этими типами. Поэтому если потребуется вывести на консоль значения переменных этих типов, то необходимо преобразовать переменные к типам char или wchar_t:

#include int main() { char a = "H"; wchar_t b = "e"; char16_t c = "l"; char32_t d = "o"; std::cout << a << (char)b << (char)c << (char)d << "\n"; return 0; }

В данном случае при выводе перед переменными указывается операция приведения к типу char - (char) , благодаря чему значения переменных b, c и d преобразуются в тип char и могут быть выведены на консоль с помощью потока std::cout.

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

Целочисленные типы представлены следующими типами: short , unsigned short , int , unsigned int , long , unsigned long , long long и unsigned long long :

Short a = -10; unsigned short b= 10; int c = -30; unsigned int d = 60; long e = -170; unsigned long f = 45; long long g = 89;

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

Типы чисел с плавающей точкой иили дробные числа представлены такими типами как float , double и long double :

Float a = -10.45; double b = 0.00105; long double c = 30.890045;

Размеры типов данных

В выше приведенном списке для каждого типа указан размер, который он занимает в памяти. Однако стоит отметить, что предельные размеры для типов разработчики компиляторов могут выбирать самостоятельно, исходя из аппаратных возможностей компьютера. Стандарт устанавливает лишь минимальные значения, которые должны быть. Например, для типов int и short минимальное значение - 16 бит, для типа long - 32 бита, для типа long double. При этом размер типа long должен быть не меньше размера типа int, а размер типа int - не меньше размера типа short, а размер типа long double должен быть больше double. К примеру, компилятор g++ под Windows для long double использует 12 байт, а компилятор, встроенный в Visual Studio и также работающий под Windows, для long double использует 8 байт. То есть даже в рамках одной платформы разные компиляторы могут по разному подходить к размерам некоторых типов данных. Но в целом используются те размеры, которые указаны выше при описании типов данных.

Однако бывают ситуации, когда необходимо точно знать размер определенного типа. И для этого в С++ есть оператор sizeof() , который возвращает размер памяти в байтах, которую занимает переменная:

#include int main() { long double number = 2; std::cout << "sizeof(number) =" << sizeof(number); return 0; }

Консольный вывод при компиляции в g++:

sizeof(number) = 12

При этом при определении переменных важно понимать, что значение переменной не должно выходить за те пределы, которые очерчены для ее типа. Например:

Unsigned short number = -65535;

Компилятор G++ при компиляции программы с этой строкой выдаст ошибку о том, что значение -65535 не входит в диапазон допустимых значений для типа unsigned short и будет усечено.

В Visual Studio компиляция может пройти без ошибок, однако при этом переменная number получит значение 2 - результат преобразования числа -65535 к типу unsigned short. То есть опять же результат будет не совсем тот, который ожидается. Значение переменной - это всего лишь набор битов в памяти, которые интерпретируются в соответствии с определенным типом. И для разных типов один и тот же набор битов может интерпретироваться по разному. Поэтому важно учитывать диапазоны значений для того или иного типа при присвоении переменной значения.

Спецификатор auto

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

Auto number = 5;

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

В языке Си различают понятия “тип данных” и “модификатор типа”. Тип данных – это целый, а модификатор – со знаком или без знака. Целое со знаком будет иметь как положительные, так и отрицательные значения, а целое без знака – только положительные значения. В языке Си можно выделить пять базовых типов.

  • char – символьный.

    • Переменная типа char имеет размер 1 байт, ее значениями являются различные символы из кодовой таблицы, например: ‘ф’, ‘:’, ‘j’ (при записи в программе они заключаются в одинарные кавычки).

  • int – целый.

    • Размер переменной типа int в стандарте языка Си не определен. В большинстве систем программирования размер переменной типа int соответствует размеру целого машинного слова. Например, в компиляторах для 16-разрядных процессоров переменная типа int имеет размер 2 байта. В этом случае знаковые значения этой переменной могут лежать в диапазоне от -32768 до 32767.

  • float – вещественный.

    • Ключевое слово float позволяет определить переменные вещественного типа. Их значения имеют дробную часть, отделяемую точкой, например: -5.6, 31.28 и т.п. Вещественные числа могут быть записаны также в форме с плавающей точкой, например: -1.09e+4. Число перед символом “е” называется мантиссой, а после “е” – порядком. Переменная типа float занимает в памяти 32 бита. Она может принимать значения в диапазоне от 3.4е-38 до 3.4e+38.

  • double – вещественный двойной точности;

    • Ключевое слово double позволяет определить вещественную переменную двойной точности. Она занимает в памяти в два раза больше места, чем переменная типа float. Переменная типа double может принимать значения в диапазоне от 1.7e-308 до 1.7e+308.

  • void – не имеющий значения.

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

Типы переменных:

Программы оперируют с различными данными, которые могут быть простыми и структурированными. Простые данные – это целые и вещественные числа, символы и указатели (адреса объектов в памяти). Целые числа не имеют, а вещественные имеют дробную часть. Структурированные данные – это массивы и структуры; они будут рассмотрены ниже.

Переменная – это ячейка в памяти компьютера, которая имеет имя и хранит некоторое значение. Значение переменной может меняться во время выполнения программы. При записи в ячейку нового значения старое стирается.

Хорошим стилем является осмысленное именование переменных. Имя переменной может содержать от одного до 32 символов. Разрешается использовать строчные и прописные буквы, цифры и символ подчёркивания, который в Си считается буквой. Первым символом обязательно должна быть буква. Имя переменной не может совпадать с зарезервированными словами.

Тип char

char – является самым экономным типом. Тип char может быть знаковым и беззнаковым. Обозначается, как “signed char” (знаковый тип) и “unsigned char” (беззнаковый тип). Знаковый тип может хранить значения в диапазоне от -128 до +127. Беззнаковый – от 0 до 255. Под переменную типа char отводится 1 байт памяти (8 бит).

Ключевые слова signed и unsigned указывают, как интерпретируется нулевой бит объявляемой переменной, т.е., если указано ключевое слово unsigned, то нулевой бит интерпретируется как часть числа, в противном случае нулевой бит интерпретируется как знаковый.

Тип int

Целочисленная величина int может быть short (короткой) или long (длинной). Ключевое слово short ставится после ключевых слов signed или unsigned. Таким образом, есть типы: signed short int, unsigned short int, signed long int, unsigned long int.

Переменная типа signed short int (знаковая короткая целая) может принимать значения от -32768 до +32767, unsigned short int (беззнаковая короткая целая) – от 0 до 65535. Под каждую из них отводится ровно по два байта памяти (16 бит).

При объявлении переменной типа signed short int ключевые слова signed и short могут быть пропущены, и такой тип переменной может быть объявлен просто int. Допускается и объявление этого типа одним ключевым словом short.

Переменная unsigned short int может быть объявлена как unsigned int или unsigned short.

Под каждую величину signed long int или unsigned long int отводится 4 байта памяти (32 бита). Значения переменных этого типа могут находиться в интервалах от -2147483648 до 2147483647 и от 0 до 4294967295 соответственно.

Существуют также переменные типа long long int, для которых отводится 8 байт памяти (64 бита). Они могут быть знаковыми и беззнаковыми. Для знакового типа диапазон значений лежит в пределах от -9223372036854775808 до 9223372036854775807, для беззнакового – от 0 до 18446744073709551615. Знаковый тип может быть объявлен и просто двумя ключевыми словами long long.

Тип Диапазон Шестнадцатеричный диапазон Размер
unsigned char 0 … 255 0x00 … 0xFF 8 bit
signed char
или просто
char 		-128 … 127 -0x80 … 0x7F 8 bit
unsigned short int
или просто
unsigned int или unsigned short 		0 … 65535 0x0000 … 0xFFFF 16 bit
signed short int или signed int
или просто
short или int 		-32768 … 32767 0x8000 … 0x7FFF 16 bit
unsigned long int
или просто
unsigned long 		0 … 4294967295 0x00000000 … 0xFFFFFFFF 32 bit
signed long
или просто
long 		-2147483648 … 2147483647 0x80000000 … 0x7FFFFFFF 32 bit
unsigned long long 0 … 18446744073709551615 0x0000000000000000 … 0xFFFFFFFFFFFFFFFF 64 bit
signed long long
или просто
long long 		-9223372036854775808 … 9223372036854775807 0x8000000000000000 … 0x7FFFFFFFFFFFFFFF 64 bit

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

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

[модификаторы] спецификатор_типа идентификатор [, идентификатор] ...

Модификаторы – ключевые слова signed, unsigned, short, long.
Спецификатор типа – ключевое слово char или int, определяющее тип объявляемой переменной.
Идентификатор – имя переменной.

Char x; int a, b, c; unsigned long long y;

При объявлении переменную можно проинициализировать, то есть присвоить ей начальное значение.

Int x = 100;

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

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

Язык программирования, как правило, имеет набор примитивных типов данных - типы, предоставляемые языком программирования как базовая встроенная единица. В 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;

Программист говорит:

Здравствуйте! Я прочел вашу статью. Мне было очень грустно и одновременно смешно. Особенно убивает эта ваша фраза: «Так как переменную типа char часто используют как массив, то определяют количество возможных значений». 😆 😆 😆
Я не смеюсь над вами. Создание сайта это действительно подвиг. Я лишь хочу поддержать вас советом и указать несколько ошибок.

1. Значение переменной типа char присваивается так:

Вот здесь:

Char a = *"A";

Происходит разадресация указателя на массив и в результате возвращается значение первого элемента массива т.е. ‘A’

2. Обнуление происходит так:

Char a = NULL;
char b = {};

//А так очищается строка в теле программы

"" -- этот символ называется ноль-терминатор. Он ставится в конце строки. Вы сами того не зная заполнили этим символом массив s1 из вашей статьи. А ведь можно было присвоить этот символ только нулевому элементу массива.

3. Смело пользуитесь терминологией.
Знак = это операция присваивания.
Знак * операция разадресации.
Я имею в виду вот этот фрагмент статьи: "Настолько всё оказалось просто, перед знаком = нужно было поставить знак * и нужно было объявить номер элемента (ноль соответствует первому)"

Поймите меня правильно, статья в нынешнем виде не может существовать. Не поленитесь, перепишите ее.
На вас лежит большая ответственность! Я серьезно. Страницы вашего сайта попали в первую страницу выдачи Яндекса. Много людей уже начали повторять за вами ошибки.

Удачи! Вы справитесь!

:
Я это давно знаю, просто трудно перечитывать 200 статей постоянно, чтобы что-то исправить. А некоторые грубые типы так пишут, что даже зная, что лучше исправить, исправлять совсем не охота.

Я буду рад исправить и другие ошибки. поправить неточности, если они выскочат. Я ценю вашу помощь. спасибо.Я это давно знаю, просто трудно перечитывать 200 статей постоянно, чтобы что-то исправить. А некоторые грубые типы так пишут, что даже зная, что лучше исправить, исправлять совсем не охота.
С вашим char b = {}; Это не обнуление совсем. проверили бы хотя б.
если говорить о нулевом символе "" ; Я хорошо знал, когда заполнял им строку и цель была в том, чтобы показать настоящее очищение, а не видимое на глаз, ибо в строку входит мусор, который иногда мешает. Вы бы с терминами сами поаккуратнее, "символ нуль-терминации" или просто "нулевой символ", не терминатор))) А символ-терминатор звучит просто круто.

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

Я буду рад исправить и другие ошибки. поправить неточности, если они выскочат. Я ценю вашу помощь. спасибо.

Здравствуйте еще раз!
Хочу пояснить. Термином "ноль-терминатор" (terminator с англ. ограничитель) пользовался мой преподаватель в ВУЗе. Видимо это old school!
Что касается обнуления строк.
char b = {}; Это действительно обнуление. Весь массив заполнен нулями. Не верите -- проверьте!
Если рассматривать строку в её естественном, бытовом смысле, то "пустой" будет та строка в которой нет ни одного символа. Поэтому в 99.9% случаев достаточно поставить в начало нулевой символ. Обычно обработка строки идет до первого нулевого символа а какие символы идут за ним уже не важно. Я понимаю что вы хотели обнулить строку. Просто решил предложить проверенный временем классический вариант.

:
Когда "Обычно обработка строки идет до первого нулевого символа а какие символы идут за ним уже не важно" - да, строка обнуляется
Если рассматривать "реальное обнуление всех ячеек строки (о котором писал я)" - нет, не обнуление и, даже, первый символ не нулевой. Я этим вариантом проверял. MinGW(CodeBlock) - весь массив отдает символ "a"
не думаю, что это повод для споров.

В данном разделе будут рассмотрены основные типы данных в С++, эти типы данных ещё называются встроенными. Язык программирования С++ является расширяемым языком программирования. Понятие расширяемый означает то, что кроме встроенных типов данных, можно создавать свои типы данных. Поэтому в С++ существует огромное количество типов данных. Мы будем изучать только основные из них.

Таблица 1 — Типы данных С++
Тип байт Диапазон принимаемых значений

целочисленный (логический) тип данных
bool 1 0 / 255

целочисленный (символьный) тип данных
char 1 0 / 255

целочисленные типы данных
short int 2 -32 768 / 32 767
unsigned short int 2 0 / 65 535
int 4
unsigned int 4 0 / 4 294 967 295
long int 4 -2 147 483 648 / 2 147 483 647
unsigned long int 4 0 / 4 294 967 295

типы данных с плавающей точкой
float 4 -2 147 483 648.0 / 2 147 483 647.0
long float 8
double 8 -9 223 372 036 854 775 808 .0 / 9 223 372 036 854 775 807.0

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

Тип данных bool

Первый в таблице — это тип данных bool — целочисленный тип данных, так как диапазон допустимых значений — целые числа от 0 до 255. Но как Вы уже заметили, в круглых скобочках написано — логический тип данных, и это тоже верно. Так как bool используется исключительно для хранения результатов логических выражений. У логического выражения может быть один из двух результатов true или false . true — если логическое выражение истинно, false — если логическое выражение ложно.

Но так как диапазон допустимых значений типа данных bool от 0 до 255, то необходимо было как-то сопоставить данный диапазон с определёнными в языке программирования логическими константами true и false . Таким образом, константе true эквивалентны все числа от 1 до 255 включительно, тогда как константе false эквивалентно только одно целое число — 0. Рассмотрим программу с использованием типа данных bool .

// data_type.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include using namespace std; int main(int argc, char* argv) { bool boolean = 25; // переменная типа bool с именем boolean if (boolean) // условие оператора if cout << "true = " << boolean << endl; // выполнится в случае истинности условия else cout << "false = " << boolean << endl; // выполнится в случае, если условие ложно system("pause"); return 0; }

В строке 9 объявлена переменная типа bool , которая инициализирована значением 25. Теоретически после строки 9 , в переменной boolean должно содержаться число 25, но на самом деле в этой переменной содержится число 1. Как я уже говорил, число 0 — это ложное значение, число 1 — это истинное значение. Суть в том, что в переменной типа bool могут содержаться два значения — 0 (ложь) или 1 (истина). Тогда как под тип данных bool отводится целый байт, а это значит, что переменная типа bool может содержать числа от 0 до 255. Для определения ложного и истинного значений необходимо всего два значения 0 и 1. Возникает вопрос: «Для чего остальные 253 значения?».

Исходя из этой ситуации, договорились использовать числа от 2 до 255 как эквивалент числу 1, то есть истина. Вот именно по этому в переменной boolean содержится число 25 а не 1. В строках 10 -13 объявлен , который передает управление оператору в строке 11 , если условие истинно, и оператору в строке 13 , если условие ложно. Результат работы программы смотреть на рисунке 1.

True = 1 Для продолжения нажмите любую клавишу. . .

Рисунок 1 — Тип данных bool

Тип данных char

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

ASCII (от англ. American Standard Code for Information Interchange) - американский стандартный код для обмена информацией.

Рассмотрим программу с использованием типа данных char .

// symbols.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include using namespace std; int main(int argc, char* argv) { char symbol = "a"; // объявление переменной типа char и инициализация её символом "a" cout << "symbol = " << symbol << endl; // печать символа, содержащегося в переменной symbol char string = "сайт"; // объявление символьного массива (строки) cout << "string = " << string << endl; // печать строки system("pause"); return 0; }

Итак, в строке 9 объявлена переменная с именем symbol , ей присвоено значение символа "a" (ASCII код ). В строке 10 оператор cout печатает символ, содержащийся в переменной symbol . В строке 11 объявлен строковый массив с именем string , причём размер массива задан неявно. В строковый массив сохранена строка "сайт" . Обратите внимание на то, что, когда мы сохраняли символ в переменную типа char , то после знака равно мы ставили одинарные кавычки, в которых и записывали символ. При инициализации строкового массива некоторой строкой, после знака равно ставятся двойные кавычки, в которых и записывается некоторая строка. Как и обычный символ, строки выводятся с помощью оператора cout , строка 12 . Результат работы программы показан на рисунке 2.

Symbol = a string = сайт Для продолжения нажмите любую клавишу. . .

Рисунок 2 — Тип данных char

Целочисленные типы данных

Целочисленные типы данных используются для представления чисел. В таблице 1 их аж шесть штук: short int , unsigned short int , int , unsigned int , long int , unsigned long int . Все они имеют свой собственный размер занимаемой памяти и диапазоном принимаемых значений. В зависимости от компилятора, размер занимаемой памяти и диапазон принимаемых значений могут изменяться. В таблице 1 все диапазоны принимаемых значений и размеры занимаемой памяти взяты для компилятора MVS2010. Причём все типы данных в таблице 1 расположены в порядке возрастания размера занимаемой памяти и диапазона принимаемых значений. Диапазон принимаемых значений, так или иначе, зависит от размера занимаемой памяти. Соответственно, чем больше размер занимаемой памяти, тем больше диапазон принимаемых значений. Также диапазон принимаемых значений меняется в случае, если тип данных объявляется с приставкой unsigned — без знака. Приставка unsigned говорит о том, что тип данных не может хранить знаковые значения, тогда и диапазон положительных значений увеличивается в два раза, например, типы данных short int и unsigned short int .

Приставки целочисленных типов данных:

short — приставка укорачивает тип данных, к которому применяется, путём уменьшения размера занимаемой памяти;

long — приставка удлиняет тип данных, к которому применяется, путём увеличения размера занимаемой памяти;

unsigned (без знака)— приставка увеличивает диапазон положительных значений в два раза, при этом диапазон отрицательных значений в таком типе данных храниться не может.

Так, что, по сути, мы имеем один целочисленный тип для представления целых чисел — это тип данных int . Благодаря приставкам short , long , unsigned появляется некоторое разнообразие типов данных int , различающихся размером занимаемой памяти и (или) диапазоном принимаемых значений.

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

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

Итак, мы рассмотрели главные моменты, касающиеся основных типов данных в С++. Осталось только показать, откуда взялись все эти диапазоны принимаемых значений и размеры занимаемой памяти. А для этого разработаем программу, которая будет вычислять основные характеристики всех, выше рассмотренных, типов данных.

// data_types.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include // библиотека манипулирования вводом/выводом #include // заголовочный файл математических функций #include using namespace std; int main(int argc, char* argv) { cout << " data type " << "byte" << " " << " max value " << endl // заголовки столбцов << "bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; system("pause"); return 0; }

Данная программа выложена для того, чтобы Вы смогли просмотреть характеристики типов данных в своей системе. Не стоит разбираться в коде, так как в программе используются управляющие операторы, которые Вам, вероятнее всего, ещё не известны. Для поверхностного ознакомления с кодом программы, ниже поясню некоторые моменты. Оператор sizeof() вычисляет количество байт, отводимое под тип данных или переменную. Функция pow(x,y) возводит значение х в степень y , данная функция доступна из заголовочного файла . Манипуляторы fixed и setprecision() доступны из заголовочного файла . Первый — fixed , передаёт в поток вывода значения в фиксированной форме. Манипулятор setprecision(n) отображает n знаков после запятой. Максимальное значение некоторого типа данных вычисляется по такой формуле:

Max_val_type = 2^(b * 8 - 1) - 1; // для типов данных с отрицательными и положительными числами // где, b - количество байт выделяемое в памяти под переменную с таким типом данных // умножаем на 8, так как в одном байте 8 бит // вычитаем 1 в скобочках, так как диапазон чисел надо разделить надвое для положительных и отрицательных значений // вычитаем 1 в конце, так как диапазон чисел начинается с нуля // типы данных с приставкой unsigned max_val_type = 2^(b * 8) - 1; // для типов данных только с положительными числами // пояснения к формуле аналогичные, только в скобочка не вычитается единица

Пример работы программы можно увидеть на рисунке 3. В первом столбце показаны основные типы данных в С++, во втором столбце размер памяти, отводимый под каждый тип данных и в третьем столбце — максимальное значение, которое может содержать соответствующий тип данных. Минимальное значение находится аналогично максимальному. В типах данных с приставкой unsigned минимальное значение равно 0.

Data type byte max value bool = 1 255.00 char = 1 255.00 short int = 2 32767.00 unsigned short int = 2 65535.00 int = 4 2147483647.00 unsigned int = 4 4294967295.00 long int = 4 2147483647.00 unsigned long int = 4 4294967295.00 float = 4 2147483647.00 double = 8 9223372036854775808.00 Для продолжения нажмите любую клавишу. . .

Рисунок 3 — Типы данных С++

Если, например, переменной типа short int присвоить значение 33000, то произойдет переполнение разрядной сетки, так как максимальное значение в переменной типа short int это 32767. То есть в переменной типа short int сохранится какое-то другое значение, скорее всего будет отрицательным. Раз уж мы затронули тип данных int ,стоит отметить, что можно опускать ключевое слово int и писать, например, просто short . Компилятор будет интерпретировать такую запись как short int . Тоже самое относится и к приставкам long и unsigned . Например:

// сокращённая запись типа данных int short a1; // тоже самое, что и short int long a1; // тоже самое, что и long int unsigned a1; // тоже самое, что и unsigned int unsigned short a1; // тоже самое, что и unsigned short int