Тип данных

Примитивные типы данных

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


  • Логический тип данных или булевый. Переменные данного вида могу принимать лишь два значения: истина (true, либо 1) или ложь (false, либо 0). В различных языках программирования булевы переменные объявляются с помощью ключевого слова bool либо boolean. Логический тип данных имеет широчайшее применение (как собственно и другие типы). Например, он фигурирует в условных операторах ветвления (if) и операторах цикла (for, while, do-while).
  • Целочисленный тип данных. Обычно объявляется ключевым словом int или integer. Переменные данного типа могут принимать только целочисленные значения. Часто тип int занимает четыре байта (232 = 4294967296), следовательно переменные могут принимать значения от – 2 147 483 648 и до 2 147 483 647 в случае, когда целый тип учитывает знак числа. Если использовать беззнаковый целый тип данных (unsigned int), то его диапазон значений от 0 до 4294967295. В языке программирования Java целый тип всегда 4 байта. В языках Си и C# предполагаемый размер также 4 байта, но на деле – всё зависит от конкретной реализации языка на программной платформе. Данный тезис относится не только к типу int. Размер каждого примитивного типа данных в любой реализации языка Java всегда строго определен и одинаков. В C-подобных языках это не так.
  • Целочисленный тип byte. Исходя из названия типа, он занимает в памяти один байт, то есть восемь бит. 28 = 256 – такое количество значений он может в себя вместить. Если говорить конкретно, то в случае, если тип byte со знаком, то диапазон от -128 до 127 (не забываем, что есть еще число ноль); когда byte беззнаковый, то от 0 до 255.
  • Короткий целый тип short. В памяти для него выделено 2 байта = 16 бит (216 = 65536). Диапазон принимаемых значений типом short со знаком – это .
  • Длинный целый тип long. Длинный целый тип занимает в памяти 8 байт, то есть 64 бита. 264 = 1,8446744 × 1019. Диапазон допустимых значений очень велик: в случае знакового типа, это . Кроме того, модификатор long можно использовать в сочетании с другими типами (long пишется перед названием типа, например: long double), расширяя, тем самым, диапазон допустимых значений типа согласно спецификации конкретного языка программирования.
  • Число с плавающей запятой. Этот тип обозначается ключевым словом float, также же этот тип называют вещественным типом одинарной точности. float – это ни что иное, как десятичная дробь (привычная нам на письме), но в памяти компьютера она представляется в виде экспоненциальной записи: состоит из мантиссы и показателя степени. Например: 0,0506 = 506,0 ⋅ 10-4, где 506 – мантисса, а -4 – показатель степени десяти. Размер типа данных float в спецификации языка Си четко не определен.
  • Число с плавающей запятой двойной точности – это тип double. Данный тип схож с типом float, единственное их различие – это размер в памяти и, соответственно, диапазон принимаемых значений. Естественно тип double больше; но всё зависит от реализации языка, говоря строго: тип double по крайней мере должен быть не меньше, чем float.
  • Символьный тип данных занимает в памяти один байт – если используется кодировка ASCII и два байта – если установлена кодировка Unicode. Данный тип по сути является целым числом. Цифра, хранящаяся в переменной символьного типа – это номер символа в таблице кодировки. Обычно объявляется с помощью ключевого слова char. Нужно четко представлять себе, что char – это число, и работать с ним, как с числом, в некоторых случаях очень удобно и эффективно.

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

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

Примечания

  1. IEEE Std 1320.2-1998 (R2004) IEEE Standard for Conceptual Modeling Language Syntax and Semantics for IDEF1X97:a set of values and operations on those values
  2. IEEE Std 1320.2-1998 (R2004) IEEE Standard for Conceptual Modeling Language Syntax and Semantics for IDEF1X97:a categorization of an abstract set of possible values, characteristics, and set of operations for an attribute
  3. ISO/IEC 19500-2:2003, Information technology — Open Distributed Processing — Part 2: General Inter-ORB Protocol (GIOP)/Internet Inter-ORB Protocol (IIOP):a categorization of values operation arguments, typically covering both behavior and representation
  4. С. J. Date. On The Logical Differences Between Types, Values, and Variables // Date on database: Writings 2000—2006, Apress, 2006, ISBN 978-1-59059-746-0
  5. , 3.6.4. Polymorphism, p. 36—37.
  6. , 2. Typeful languages, p. 5.
  7. .

Структуры

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

struct birthday
{
    char name20];
    int day;
    int month;
    int year;
};

Объявление структур в теле программы всегда должно начинаться с ключевого struct (необязательно в C++). Доступ к элементам структуры осуществляется с помощью оператора . или ->, если мы работаем с указателем на структуру. Структуры могут содержать указатели на самих себя, что позволяет реализовывать многие структуры данных, основанных на связных списках. Такая возможность может показаться противоречивой, однако все указатели занимают одинаковое число байт, поэтому размер этого поля не изменится от числа полей структуры.

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

Некоторые особенности структур:

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

Числовые типы данных

Тип данных Объем памяти Диапазон Описание
TINYINT (M) 1 байт от -128 до 127 или от 0 до 255 Целое число. Может быть объявлено положительным с помощью ключевого слова UNSIGNED, тогда элементам столбца нельзя будет присвоить отрицательное значение. Необязательный параметр М — количество отводимых под число символов. Необязательный атрибут ZEROFILL позволяет свободные позиции по умолчанию заполнить нулями.Примеры: TINYINT — хранит любое число в диапазоне от -128 до 127. TINYINT UNSIGNED — хранит любое число в диапазоне от 0 до 255. TINYINT (2) — предполагается, что значения будут двузначными, но по факту будет хранить и трехзначные. TINYINT (3) ZEROFILL — свободные позиции слева заполнит нулями. Например, величина 2 будет отображаться, как 002.
SMALLINT (M) 2 байта от -32768 до 32767 или от 0 до 65535 Аналогично предыдущему, но с большим диапазоном.Примеры: SMALLINT — хранит любое число в диапазоне от -32768 до 32767. SMALLINT UNSIGNED — хранит любое число в диапазоне от 0 до 65535. SMALLINT (4) — предполагается, что значения будут четырехзначные, но по факту будет хранить и пятизначные. SMALLINT (4) ZEROFILL — свободные позиции слева заполнит нулями. Например, величина 2 будет отображаться, как 0002.
MEDIUMINT (M) 3 байта от -8388608 до 8388608 или от 0 до 16777215 Аналогично предыдущему, но с большим диапазоном.Примеры: MEDIUMINT — хранит любое число в диапазоне от -8388608 до 8388608. MEDIUMINT UNSIGNED — хранит любое число в диапазоне от 0 до 16777215. MEDIUMINT (4) — предполагается, что значения будут четырехзначные, но по факту будет хранить и семизначные. MEDIUMINT (5) ZEROFILL — свободные позиции слева заполнит нулями. Например, величина 2 будет отображаться, как 00002.
INT (M) или INTEGER (M) 4 байта от -2147683648 до 2147683648 или от 0 до 4294967295 Аналогично предыдущему, но с большим диапазоном.Примеры: INT — хранит любое число в диапазоне от -2147683648 до 2147683648. INT UNSIGNED — хранит любое число в диапазоне от 0 до 4294967295. INT (4) — предполагается, что значения будут четырехзначные, но по факту будет хранить максимально возможные. INT (5) ZEROFILL — свободные позиции слева заполнит нулями. Например, величина 2 будет отображаться, как 00002.
BIGINT (M) 8 байта от -263 до 263-1 или от 0 до 264 Аналогично предыдущему, но с большим диапазоном.Примеры: BIGINT — хранит любое число в диапазоне от -263 до 263-1. BIGINT UNSIGNED — хранит любое число в диапазоне от 0 до 264. BIGINT (4) — предполагается, что значения будут четырехзначные, но по факту будет хранить максимально возможные. BIGINT (7) ZEROFILL — свободные позиции слева заполнит нулями. Например, величина 2 будет отображаться, как 0000002.
BOOL или BOOLEAN 1 байт либо 0, либо 1 Булево значение. 0 — ложь (false), 1 — истина (true).
DECIMAL (M,D) или DEC (M,D) или NUMERIC (M,D) M + 2 байта зависят от параметров M и D Используются для величин повышенной точности, например, для денежных данных. M — количество отводимых под число символов (максимальное значение — 64). D — количество знаков после запятой (максимальное значение — 30).Пример: DECIMAL (5,2) — будет хранить числа от -99,99 до 99,99.
FLOAT (M,D) 4 байта мин. значение +(-) 1.175494351 * 10-39 макс. значение +(-) 3. 402823466 * 1038 Вещественное число (с плавающей точкой). Может иметь параметр UNSIGNED, запрещающий отрицательные числа, но диапазон значений от этого не изменится. M — количество отводимых под число символов. D — количество символов дробной части. Пример: FLOAT (5,2) — будет хранить числа из 5 символов, 2 из которых будут идти после запятой (например: 46,58).
DOUBLE (M,D) 8 байт мин. значение +(-) 2.2250738585072015 * 10-308 макс. значение +(-) 1.797693134862315 * 10308 Аналогично предыдущему, но с большим диапазоном. Пример: DOUBLE — будет хранить большие дробные числа.

Другие типы данных

  Программа, написанная на языке Си, оперирует с данными различных типов. Все данные имеют имя и тип. Обращение к данным в программе осуществляется по их именам (идентификаторам).Идентификатор — это последовательность, содержащая не более 32 символов, среди которых могут быть любые буквы латинского алфавита a — z, A — Z, цифры 0 — 9 и знак подчеркивания (_). Первый символ идентификатора не должен быть цифрой. Несмотря на то, что допускается имя, имеющее до 32 символов, определяющее значение имеют только первые 8 символов. Помимо имени, все данные имеют тип. Указание типа необходимо для того, чтобы было известно, сколько места в оперативной памяти будет занимать данный объект. Компилятор языка Си придерживается строгого соответствия прописных и строчных букв в именах идентификаторов и лексем.

Верно Неверно
int a = 2, b; b = a+3; Int a=2;  // правильно int INT a=2;
int a = 2, b; b = A + 3; // идентификатор А не объявлен
int a = 2; b = a + 3; // идентификатор b не объявлен

Pulse тип #

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

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

Импульсный сигнал может сообщить нам, что у нас есть новый TCP-пакет из сети, обнаружена карта NFC или какой-то временной интервал. Мы используем импульсный сигнал для запуска команды отправки SMS или сброса счетчика.

Импульсные сигналы часто сопровождаются другими типами значений на соседних пинах. Значения описывают “что”, в то время как импульс описывает “когда”.

Вот краткий список нод, которые вы часто будете использовать в сочетании с импульсами:

Типы указателей

Для любого типа T существует тип «указатель на T».

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

char letterC = 'C';
char *letter = &letterC; //взятие адреса переменной letterC и присваивание в переменную letter
printf("This code is written in %c.", *letter); //"This code is written in C."

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

struct Point { int x,y; } A;
A.x = 12;
A.y = 34;
struct Point *p = &A;
printf("X: %d, Y: %d", (*p).x, (*p).y); //"X: 12, Y: 34"

Для обращения к полям структуры по указателю существует оператор «стрелочка» , синонимичный предыдущей записи: — то же самое, что и .

Поскольку указатель — тоже тип переменной, правило «для любого типа T» выполняется и для них: можно объявлять указатели на указатели. К примеру, можно пользоваться :

int w = 100;
int *x = &w;
int **y = &x;
int ***z = &y;
printf("w contains %d.", ***z); //"w contains 100."

Существуют также указатели на массивы и на функции. Указатели на массивы имеют следующий синтаксис:

char *pc10]; // массив из 10 указателей на char
char (*pa); // указатель на массив из 10 переменных типа char

 — массив указателей, занимающий байт (на распространённых платформах — обычно 40 или 80 байт), а  — это один указатель; занимает он обычно 4 или 8 байт, однако позволяет обращаться к массиву, занимающему 10 байт: , но . Указатели на массивы отличаются от указателей на первый элемент арифметикой. Например, если указатели указывает на адрес 2000, то указатель будет указывать на адрес 2010.

char (*pa);
char array10 = "Wikipedia";
pa = &array;
printf("An example for %s.\n", *pa); //"An example for Wikipedia."
printf("%c %c %c", (*pa), (*pa), (*pa)); //"i i i"

Деление целочисленных переменных

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

#include <iostream> int main() { std::cout << 20 / 4 << std::endl; return 0; }

1 2 3 4 5 6 7

#include <iostream>

intmain()

{

std::cout<<204<<std::endl;

return;

}

Результат:

Но что произойдет, если в результате деления двух целых чисел мы получим дробное число? Например:

#include <iostream> int main() { std::cout << 8 / 5 << std::endl; return 0; }

1 2 3 4 5 6 7

#include <iostream>

intmain()

{

std::cout<<85<<std::endl;

return;

}

Результат:

В языке C++ при делении целых чисел результатом всегда будет другое целое число. А такие числа не могут иметь дробь (она просто отбрасывается, не округляется!).

Рассмотрим детально пример выше: . Но, как мы уже знаем, при делении целых чисел, результатом является другое целое число. Таким образом, дробная часть () значения отбрасывается и остается .


Правило: Будьте осторожны при делении целых чисел, так как любая дробная часть всегда отбрасывается.

Типы данных, образуемые в прикладном решении

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

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

На уровне платформы поддерживается несколько классов (шаблонов) прикладных объектов, которые сами по себе не могут быть использованы в конкретном прикладном решении. Например, можно перечислить такие классы прикладных объектов как Справочники, Документы, Регистры сведений, Планы видов характеристик и пр.

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

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

Например, разработчик может добавить в свое прикладное решение новый справочник Номенклатура, который будет наследовать функциональность класса Справочники, или новый документ КассовыйОтчет, который будет наследовать функциональность класса Документы.

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

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

  • СправочникМенеджер.Номенклатура;
  • СправочникСсылка.Номенклатура;
  • СправочникОбъект.Номенклатура;
  • СправочникВыборка.Номенклатура;
  • СправочникСписок.Номенклатура.

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

В то же время, после создания нового регистра накопления ПродажиКомпании, состав новых типов данных будет уже другим:

  • РегистрНакопленияМенеджер.ПродажиКомпании,
  • РегистрНакопленияВыборка.ПродажиКомпании,
  • РегистрНакопленияСписок.ПродажиКомпании,
  • РегистрНакопленияНаборЗаписей.ПродажиКомпании,
  • РегистрНакопленияЗапись.ПродажиКомпании,
  • РегистрНакопленияКлючЗаписи.ПродажиКомпании.

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

Еще один момент, на котором следует акцентировать внимание, проще всего продемонстрировать на примере.

Допустим, в прикладном решении созданы два новых справочника: Номенклатура и Цены. Несмотря на то, что оба эти объекта унаследовали функциональность соответствующего класса Справочники, и для них в прикладном решении был создан один и тот же состав типов данных, «одноименные» типы данных будут являться различными типами данных. Например, СправочникОбъект.Номенклатура и СправочникОбъект.Цены — это различные типы данных.

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

Элементы страницы

Переменная автоматического события

Регистрирует информацию о действиях, вызвавших событие (например, кликах, заполнении форм, показах элементов и т. п.).

  • Element. Возвращает объект элемента. Его можно использовать как объект для собственного кода JavaScript, например , или в селекторах CSS, например {{Element}} соответствует селектору CSS .
  • Element Type. Возвращает значение (например, ‘A’, ‘BUTTON’ или ‘IMG’).
  • Element Attribute. Возвращает значение атрибута, название которого указано.
  • Element Classes. Возвращает список классов из атрибута нужного элемента.
  • Element ID. Возвращает значение атрибута .
  • Element Target. Возвращает значение атрибута (например, ‘_blank’).
  • Element Text. Возвращает значение текста, который содержит элемент.
  • Element URL. Возвращает URL элемента, полученный из атрибута или .
  • History New URL Fragment. Возвращает новый фрагмент URL из истории браузера (например, ‘#summary’).
  • History Old URL Fragment. Возвращает фрагмент URL, который использовался ранее, из истории браузера (например, ‘#intro’).
  • History New State. Новый объект состояния истории, управляемый вызовами .
  • History Old State. Старый объект состояния истории, управляемый вызовами .
  • History Change Source. Возвращает событие, которое привело к изменению истории (например, ‘pushState’, ‘replaceState’ и т. п).

Элемент DOM

Принимает значение идентификатора элемента из модели DOM. Модель DOM (Document Object Model – объектная модель документа) содержит все HTML-элементы страницы. Когда нужного значения нет на уровне данных (см. ), его можно найти в модели DOM с помощью этого типа переменной.

Если задано необязательное имя атрибута, переменная примет значение, полученное из этого атрибута (например, ). В противном случае значением переменной будет текст, содержащийся в элементе DOM.

Видимость элемента

Значение этой переменной зависит от видимости указанного элемента DOM. В отличие от триггера «Видимость элемента», переменная принимает значение, соответствующее видимости только одного элемента. Элемент можно выбирать с помощью атрибута ID или селектора CSS. Если селектору CSS соответствует несколько элементов, будет использоваться только первый подходящий элемент.

Вы можете выбрать тип переменной:

  • True/False. Логическое значение, которое показывает, отображается ли выбранный элемент в момент обращения к переменной. 
  • Percent. Числовое значение (0–100), которое показывает долю выбранных элементов, отображаемых на экране в момент обращения к переменной.

Используя тип переменной True/False, вы можете также задать минимальный процент видимости, который показывает, какая часть выбранного элемента должна отображаться на экране, чтобы возвращалось значение True.

Ошибки округления

Рассмотрим дробь 1/10. В десятичной системе счисления эту дробь можно представить, как 0.1, в двоичной системе счисления эта дробь представлена в виде бесконечной последовательности: 0.00011001100110011… Именно из-за подобных разногласий в представлении чисел в разных системах счисления — у нас могут возникать проблемы с точностью. Например:

#include <iostream> #include <iomanip> // для std::setprecision() int main() { double d(0.1); std::cout << d << std::endl; // используем точность cout по умолчанию (6 цифр) std::cout << std::setprecision(17); std::cout << d << std::endl; return 0; }

1 2 3 4 5 6 7 8 9 10 11

#include <iostream> #include <iomanip> // для std::setprecision()

intmain()

{

doubled(0.1);

std::cout<<d<<std::endl;// используем точность cout по умолчанию (6 цифр)

std::cout<<std::setprecision(17);

std::cout<<d<<std::endl;

return;

}

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


Первый cout выводит (что и ожидаемо). После того, как мы изменили для объекта cout точность вывода до 17 цифр, мы увидели, что значением переменной является не совсем ! Подобное происходит из-за ограничений в количестве выделяемой памяти для переменных типа double, а также из-за необходимости «округлять» числа. По факту мы получили типичную ошибку округления.

Подобные ошибки могут иметь неожиданные последствия:

#include <iostream> #include <iomanip> // для std::setprecision() int main() { std::cout << std::setprecision(17); double d1(1.0); std::cout << d1 << std::endl; double d2(0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1); // должно получиться 1.0 std::cout << d2 << std::endl; }

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <iostream> #include <iomanip> // для std::setprecision()

intmain()

{

std::cout<<std::setprecision(17);

doubled1(1.0);

std::cout<<d1<<std::endl;

doubled2(0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1);// должно получиться 1.0

std::cout<<d2<<std::endl;

}

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

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

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

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

Разные типы данных могут представлять одно значение по-разному, например, значение типа int и значение типа float хранятся как совершенно разные двоичные шаблоны.

И как вы думаете, что произойдет, если сделать следующее:

float f = 4; // инициализация переменной типа с плавающей точкой целым числом 4

1 floatf=4;// инициализация переменной типа с плавающей точкой целым числом 4

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

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

Случай №1: Присваивание или инициализация переменной значением другого типа данных:


double k(4); // инициализация переменной типа double целым числом 4 k = 7; // присваиваем переменной типа double целое число 7

1 2

doublek(4);// инициализация переменной типа double целым числом 4

k=7;// присваиваем переменной типа double целое число 7

Случай №2: Передача значения в функцию, где тип параметра — другой:

void doSomething(long l) { } doSomething(4); // передача числа 4 (тип int) в функцию с параметром типа long

1 2 3 4 5

voiddoSomething(longl)

{ }

doSomething(4);// передача числа 4 (тип int) в функцию с параметром типа long

Случай №3: Возврат из функции, где тип возвращаемого значения — другой:

float doSomething() { return 4.0; // передача значения 4.0 (тип double) из функции, которая возвращает float }

1 2 3 4

floatdoSomething()

{

return4.0;// передача значения 4.0 (тип double) из функции, которая возвращает float

}

Случай №4: Использование с операндами разных типов:

double division = 5.0 / 4; // операция деления со значениями типов double и int

1 doubledivision=5.04;// операция деления со значениями типов double и int

Во всех этих случаях (и во многих других) C++ будет использовать преобразование типов.

Есть 2 основных способа преобразования типов:

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

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


С этим читают