Сколько возможных значений у переменной типа bool

Д. П. Кириенко. Программирование на языке Python (школа 179 г. Москвы)

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

Допустим мы хотим по данному числу x определить его абсолютную величину (модуль). Программа должна напечатать значение переменной x, если x>0 или же величину -x в противном случае. Линейная структура программы нарушается: в зависимости от справедливости условия x>0 должна быть выведена одна или другая величина. Соответствующий фрагмент программы на Питоне имеет вид:

x = int(input()) if x > 0: print(x) else: print(-x)

В этой программе используется условная инструкция if (если). После слова if указывается проверяемое условие (x > 0) , завершающееся двоеточием. После этого идет блок (последовательность) инструкций, который будет выполнен, если условие истинно, в нашем примере это вывод на экран величины x . Затем идет слово else (иначе), также завершающееся двоеточием, и блок инструкций, который будет выполнен, если проверяемое условие неверно, в данном случае будет выведено значение -x .

Итак, условная инструкция в Питоне имеет следующий синтаксис:

if Условие: Блок инструкций 1 else: Блок инструкций 2 

Блок инструкций 1 будет выполнен, если Условие истинно. Если Условие ложно, будет выполнен Блок инструкций 2 .

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

if x < 0: x = -x print(x)

В этом примере переменной x будет присвоено значение -x , но только в том случае, когда x

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

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

Boolean (Булев, Логический тип данных)

Boolean (Булев, Логический тип данных) — примитивный тип данных в информатике, которые могут принимать два возможных значения, иногда называемых истиной ( true ) и ложью ( false ). Например, в JavaScript Булевы состояния часто используются для того, чтобы определить какие части кода выполнять (например, в операторах if) или повторять (например, циклы for).

Ниже приведён некоторый псевдокод JavaScript (это не действительно исполняемый код), демонстрирующий эту концепцию.

Пример использования оператора if :

if (условие) < блок кода, выполняемый если условие возвращает true >else

if (hour  18)  greeting = "Добрый день"; > else  greeting = "Добрый вечер"; > 

Пример использования логического условия в цикле for :

for (начало; условие; шаг) < // . тело цикла . >

for (let i = 0; i  3; i++)  alert(i); > 

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

Смотрите также

Техническая справка

• Глобальный объект JavaScript: Boolean
• Типы данных JavaScript и структуры данных

Сколько возможных значений у переменной типа bool

На этом шаге мы рассмотрим основные типы данных .

С переменными мы кратко познакомились на предыдущих шагах. Напомним, что переменной называется именованный блок памяти . Этот блок может хранить определенное значение. Мы в программе имеем возможность прочитать эго значение и изменить его. Для получения доступа к блоку памяти используется переменная . Перед тем как переменную использовать, ее необходимо объявить . Объявление переменной подразумевает, что указывается имя переменной и ее тип . При выполнении команды, которой объявляется переменная, для этой переменной в памяти выделяется место. Каждый раз, когда мы будем обращаться к этой переменной, в действительности будет выполняться обращение к соответствующему месту в памяти. При этом совершенно не важно, где именно в памяти выделено место под переменную. Нам достаточно знать имя переменной, чтобы прочитать ее текущее значение или присвоить новое.

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

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

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

• объем памяти, выделяемой для хранения числа;
• возможность или невозможность использовать отрицательные числа.

Для записи целых чисел в памяти компьютера используется битовое представление. Вся память, выделяемая для записи числа, разбита на отдельные блоки - биты. Каждый бит может содержать значения 0 или 1. Блок из 8 битов называется байтом. Для хранения данных определенного типа выделяется одно и то же количество битов. Например, для записи значений типа int в языке C# выделяется 32 бита, или 4 байта. Таким образом, значение типа int представляет собой последовательность из 32 нулей и единиц. Такой код интерпретируется как двоичное представление числа. Чем больше выделяется битов для записи числа, тем больше значений можно закодировать. Если через n обозначить количество битов, с помощью которых кодируются числа, то всего с помощью такого количества битов можно реализовать 2 n разных чисел. Для значений типа int количество чисел, которые можно реализовать через переменную данного типа, равно 2 32 . Диапазон возможных значений для переменной типа int ограничен числами -2 31 (число -2147483648) и 2 31 - 1 (число -2147483647) включительно. Всего с учетом нуля получается 2 32 разных чисел.

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

Для реализации целых чисел, кроме типа int , используются типы byte, sbyte, short, ushort, uint, long и ulong . Значения типов byte и sbyte кодируются с помощью 8 битов. Различие между типами в том, что значение типа byte - эго неотрицательное число. Значение типа sbyte может быть и положительным, и отрицательным.

Начальная буква s в названии типа sbyte - это "остаток" от слова "signed" (что означает "со знаком" ).

С помощью 8 битов можно записать 2 8 = 256 разных чисел. Поэтому возможное значение для переменной типа byte лежит в пределах от 0 до 255 включительно. Значение переменной типа sbyte находится в пределах от -128 до 127 включительно.

Для хранения значения типов short и ushort выделяется 16 битов. То есть "мощность" этих типов одинакова. Но тип short используется для работы с отрицательными и положительными числами, а тип ushort используют при работе с неотрицательными числами.

Начальная буква и в названии типа ushort , а также в названиях рассматриваемых далее типов uint и ulong появилась из слова "unsigned" (что означает "без знака" ).

Следующая пара типов int (числа со знаком) и uint (неотрицательные числа) использует 32 бита для хранения числовых значений. Наконец, самые "мощные" целочисленные типы - это long и ulong . Переменные данных типов хранятся в ячейках памяти объемом в 64 бита. Значения типа long интерпретируются как числа со знаком, а значения типа ulong обрабатываются как неотрицательные числа. Более подробная информация не только о целочисленных типах, но и о прочих базовых типах языка C# приведена в таблице 1.

Таблица 1. Базовые типы языка C#

Тип	Память в битах	Диапазон значений	Описание	Структура
byte	8	от 0 до 255	Целое неотрицательное число	Byte
sbyte	8	от -128 до 127	Целое число	SByte
short	16	от -32768 до 32767	Целое число	Intl6
ushort	16	от 0 до 65535	Целое неотрицательное число	UIntl6
int	32	от - 2147483648 до 2147483647	Целое число	Int32
uint	32	от 0 до 4294967295	Целое неотрицательное число
long	64	от -9223372036854775808 до 9223372036854775807	Целое число	Int64
ulong	64	от 0 до 18446744073709551615	Целое неотрицательное число	UInt64
float	32	от 1.5Е-45 до 3.4Е+38	Действительное число (с плавающей точкой)	Single
double	64	от 5Е-324 до 1.7Е+308	Действительное число (с плавающей точкой) двойной точности	Double
decimal	128	от 1Е-28 до 7.9Е+28	Действительное число для выполнения особо точных (финансовых) расчетов	Decimal
char	16	от 0 до 65535	Символьное значение	Char
bool	8	значения true и false	Логическое значение	Boolean

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

В действительности значения базовых типов реализуются как экземпляры структур. Структуры мы рассмотрим немного позже. В таблице 1 для каждого базового типа указана структура, которая соответствует данному типу. Фактически идентификаторы базовых типов являются псевдонимами для названий структур. Например, для работы с целыми числами можно создать переменную базового типа int , что означает создание экземпляра структуры Int32 . То есть ситуация не самая тривиальная, но в большинстве случаев это не играет никакой роли.

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

Для чисел с плавающей точкой также можно использовать экспоненциальное (компьютерное) представление в виде мантиссы и показателя степени. Действительное число представляется в виде произведения мантиссы (действительное число) на 10 в целочисленной степени. Записать число в таком представлении можно следующим образом: указать мантиссу, затем символ Е (или е ) и целое число, определяющее показатель степени. Например, выражение 1.5Е-45 означает число 1,5*10 -45 , а выражение 3.4Е+38 соответствует числу 3.4*10 38 . Если показатель степени положительный, то знак + можно не указывать.

Для реализации действительных чисел используются типы float , double и decimal . Для значения типа float выделяется 32 бита, а под значение типа double выделяется 64 бита. Поэтому числа, реализованные как значения тина double , имеют большую "точность". Наименьшее по модулю float -число равно 1.5*10 -45 , а самое маленькое по модулю double -число равно 5*10 -324 . Верхняя граница для значений типа double составляет величину 1.7*10 308 , а float -значения ограничены сверху числом 3.4*10 38 . В этом смысле тип double является более предпочтительным.

Есть и другая причина для приоритетного использования типа double по сравнению с типом float . Ее мы обсудим немного позже.

Помимо типов float и double в языке C# есть тип decimal . Под значение типа decimal выделяется 128 битов, что в два раза больше, чем для типа double . Но главное назначение такой мощной "поддержки" - обеспечить высокую точность вычислений, выполняемых со значениями типа decimal . Обычно необходимость в высокой точности операций возникает при финансовых расчетах. Поэтому обычно тип decimal упоминают как специальный тип, предназначенный для поддержки высокоточных финансовых вычислений.

Для работы с символьными значениями предназначен тип char . Значением переменной типа char может быть отдельный символ (буква). Для хранения такого значения в памяти выделяется 16 битов.

Значения типа char кодируются так же, как и целые числа - имеем дело с 16 битами, заполненными нулями и единицами. Аналогичным образом кодируются, например, значения типа ushort . Поэтому технически char -значение можно рассматривать как неотрицательное числовое значение, которое попадает в диапазон целых чисел от 0 до 65535. Но обрабатывается такое значение несколько иначе (по сравнению с обработкой целочисленных значений), а именно: по двоичному коду определяется число, и затем из кодовой таблицы берется символ с соответствующим кодом.

Наконец, тип bool предназначен для работы с логическими значениями. Поэтому этот тип обычно называют логическим . Переменная логического типа может принимать одно из двух значений: true (истина) или false (ложь). Значения логического типа используются в управляющих инструкциях - таких, как условный оператор или операторы цикла.

На следующем шаге мы рассмотрим литералы .

Типы данных в языке C++

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

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

Посмотрим сразу на список примитивных встроенных в C++ типов данных:

• int - тип данных для хранения целых чисел. Размер памяти от 2 до 4 байт
• float - тип данных для хранения чисел с "плавающей точкой", т.е. десятичных чисел (десятичных дробей). Размер памяти 4 байта
• double - тип данных для хранения чисел с "плавающей точкой" двойной точности. Похож на тип данных float, но обеспечивает большую точность при расчётах и использовании десятичных дробей. Размер памяти 8 байт
• char - тип данных для хранения одного символа. Размер памяти 1 байт
• wchar_t - тип данных для хранения одного "расширенного" символа. Размер памяти 2 байта
• bool - логический тип данных, используется для хранения значений булева типа, т.е. тех, что могут принимать значения "истина" или "ложь". Размер памяти 1 байт
• void - тип данных, обозначающий "пустоту", или "отсутствие какого-то значения". Размер памяти 0 байт

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

Некоторые из базовых типов могут быть также изменены с помощью одного или нескольких модификаторов типа:

• signed - модификатор типа указывает, что тип является типом со знаком, т.е. может хранить как положительные, так и отрицательные значения.
• unsigned - модификатор типа указывает, что тип является беззнаковым, т.е. хранит только неотрицательные значения.
• short - применяется для хранения небольших числовых значений. Когда применяется к типу данных int, то урезает диапазон хранимых значений для типа int, а также размер памяти под хранимое значение с 4 байт до 2 байт
• long - применяется для хранения больших числовых значений. Когда применяется к типу данных int, то расширит диапазон хранимых значений для типа int, а также размер памяти под хранимое значение с 4 байт до 8 байт

Далее по тексту статьи мы узнаем, как это делается, а пока остановимся на тех примитивных типах данных, что описаны выше, и посмотрим на несколько примеров их использования.

Тип данных int

Тип данных int широко применяется там, где нужна работа с целыми числами. По умолчанию можно хранить в переменных типа int как положительные, так и отрицательные значения. Ниже показано простое объявление трёх разных переменных с типом int:

int daysInWeek = 7; int monthsInYear = 12; int currentYear = 2022; int someNegativeValue = -20;

Тип данных float

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

float bottleVolume = 0.5; float normalHumanTemperature = 36.6; float someNegativeFloatValue = -72.7;

Тип данных double

Как уже было сказано, тип данных double очень похож на float, за исключением того, что он использует больше памяти для хранения данных (8 байт вместо 4 байт для типа float). В остальном определения переменных с типом double выглядят почти так же, как и для вышеупомянутых типов:

double doubleVal1 = 1234.56789101112; double doubleVal2 = -77.1122334455667788;

Тип данных char

Тип данных char используется для хранения символов (от англ. characters, отсюда и название самого типа данных). Значения для этого типа данных заключаются с обеих сторон в одинарные кавычки ( ' ), например, давайте объявим пару переменных с этим типом данных:

char chA = 'A'; char chB = 'B'; char chQuestionMark = '?';

Тип данных bool

Тип данных bool может иметь всего одно из двух возможных значений - true или false. Значение true обозначает "истину", а false - "ложь". Посмотрим на пример:

bool isNegative = false; bool isDataEntered = true;

В примере выше объявили две переменных с типом bool. Одна из них isNegative инициализирована значением false и может, например, обозначать примерно такой смысл: "не является отрицательным" (если мы пишем какую-то логику, проверяющую числа на отрицательное значение). Вторая переменная isDataEntered инициализирована значением true (помним, что это значение соответствует "истине") и может, к примеру, обозначать что "данные введены". Если мы ей где-нибудь дальше в тексте присвоили бы значение false, это могло бы для нас означать "данные не введены".

Тип данных void

Тип данных void представляет отсутствие данных. Он обозначает буквально "ничто" или "нет значения". Тип данных void как правило используется при работе с функциями и указателями. Важным моментом, который нужно запомнить, является то, что мы не можем объявить переменную с типом void. (к слову, указатели с использованием типа void вполне допустимы в C++).

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

void functionReturningNothing() < // делаем здесь что-то. >

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

Тип данных	Размер памяти под тип данных	Диапазон принимаемых значений
int	4 байта	от -2 147 483 648 до 2 147 483 647
unsigned int	4 байта	от 0 до 4 294 967 295
signed int	4 байта	от -2 147 483 648 до 2 147 483 647
short int	2 байта	от -32 768 до 32 767
unsigned short int	2 байта	от 0 до 65 535
char	1 байт	от -127 до 127 или от 0 до 255
unsigned char	1 байт	от 0 до 255
signed char	1 байт	от -127 до 127
long int	8 байт	от -2 147 483 648 до 2 147 483 647
signed long int	8 байт	от -2 147 483 648 до 2 147 483 647
unsigned long int	8 байт	от 0 до 4 294 967 295
long long int	8 байт	от -(2^63) до (2^63)-1
unsigned long long int	8 байт	от 0 до 18 446 744 073 709 551 615
float	4 байта	относительное значение диапазона: является наименьшим типом с плавающей запятой в C++ (абсолютный размер встроенных типов с плавающей запятой не указан в стандарте языка C++)
double	8 байт	относительное значение диапазона: значения больше или равны типу float, но меньше, чем у long double (абсолютный размер встроенных типов с плавающей запятой не указан в стандарте языка C++)
long double	12 байт	относительное значение диапазона принимаемых значений: значения больше или равны размеру типа double (абсолютный размер встроенных типов с плавающей запятой не указан в стандарте языка C++)

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

unsigned char ch = 255; unsigned long int veryLongInt = 18446744073709551615; long double veryLongDoubleValue = 0.333333333333333333333333333333333333333333333333333;

Напоследок, мы можем написать небольшую программу на C++, которая выведет для нас размер выделяемой памяти под все описанные в статье типы данных C++. Обратите внимание на использования для этой цели специального оператора sizeof:

#include int main()

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

Size of 'int' data type: 4 bytes
Size of 'unsigned int' data type: 4 bytes
Size of 'signed int' data type: 4 bytes
Size of 'short int' data type: 2 bytes
Size of 'unsigned short int' data type: 2 bytes
Size of 'float' data type: 4 bytes
Size of 'double' data type: 8 bytes
Size of 'long double' data type: 8 bytes
Size of 'bool' data type: 1 bytes
Size of 'char' data type: 1 bytes
Size of 'unsigned char' data type: 1 bytes
Size of 'signed char' data type: 1 bytes
Size of 'wchar_t' data type: 2 bytes
Size of 'long int' data type: 4 bytes
Size of 'unsigned long int' data type: 4 bytes
Size of 'long long int' data type: 8 bytes
Size of 'unsigned long long int' data type: 8 bytes

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

Надеюсь, эта статья пригодится и будет полезна всем разработчикам, работающим с языком C++.

Напоследок отмечу, что если Вы работаете со средой C++ в среде разработки Microsoft Visual Studio, то более подробно о типах данных в языке C++ можно также почитать здесь.

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