{"draftJsState":{"blocks":[{"data":{"image":{"id":"643a6cbadfd19701829186f0"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"buqri"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":256,"style":"BOLD"}],"text":"Каждая переменная имеет определенный тип. И этот тип определяет, какие значения может иметь переменная, какие операции с ней можно производить и сколько байт в памяти она будет занимать. В языке C++ определены следующие базовые типы данных: логический тип bool, целочисленные типы, типа чисел с плавающей точкой, символьные типы. Рассмотрим эти группы по отдельности.","type":"unstyled","key":"6hmk6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Логический тип","type":"header-two","key":"c6rkd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":16,"style":"BOLD"},{"length":4,"offset":58,"style":"BOLD"},{"length":5,"offset":82,"style":"BOLD"}],"text":"\nЛогический тип bool может хранить одно из двух значений: true (истинно, верно) и false (неверно, ложно). Например, определим пару переменных данного типа и выведем их значения на консоль:","type":"unstyled","key":"bhi6u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"#include \n \nint main()\n{\n bool isAlive {true};\n bool isDead {false};\n std::cout << \"isAlive: \" << isAlive << \"\\n\"; \n std::cout << \"isDead: \" << isDead << \"\\n\"; \n}","type":"blockquote","key":"re0h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Консольный вывод программы:","type":"unstyled","key":"359si"},{"data":{"image":{"id":"643a6ea86f99ba706bcbb903"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"84rna"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":25,"style":"BOLD"},{"length":4,"offset":54,"style":"BOLD"},{"length":5,"offset":70,"style":"BOLD"},{"length":5,"offset":234,"style":"BOLD"}],"text":"При выводе значения типа bool преобразуются в 1 (если true) и 0 (если false). Как правило, данный тип применяется преимущество в условных выражениях, которые будут далее рассмотрены.\n\nЗначение по умолчанию для переменных этого типа - false.","type":"unstyled","key":"14md7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Целочисленные типы","type":"header-two","key":"4ecbf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"\nЦелые числа в языке C++ представлены следующими типами:","type":"unstyled","key":"7elv5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":11,"offset":0,"style":"BOLD"}],"text":"signed char: представляет один символ. Занимает в памяти 1 байт (8 бит). Может хранить любой значение из диапазона от -128 до 127.","type":"unordered-list-item","key":"5j4us"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":13,"offset":0,"style":"BOLD"}],"text":"unsigned char: представляет один символ. Занимает в памяти 1 байт (8 бит). Может хранить любой значение из диапазона от 0 до 255.","type":"unordered-list-item","key":"13s23"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":0,"style":"BOLD"},{"length":11,"offset":255,"style":"BOLD"},{"length":4,"offset":296,"style":"BOLD"},{"length":11,"offset":388,"style":"BOLD"},{"length":13,"offset":407,"style":"BOLD"}],"text":"char: представляет один символ в кодировке ASCII. Занимает в памяти 1 байт (8 бит). Может хранить любое значение из диапазона от -128 до 127, либо от 0 до 255.\n\nНесмотря на то, что данный тип представляет тот же диапазон значений, что и вышеописанный тип signed char, но они не эквивалентны. Тип char предназначен для хранения числового кода символа и в реальности может представлять как signed byte, так и unsigned byte в зависимости от конкретного компилятора.\n","type":"unordered-list-item","key":"5r8uh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":5,"offset":0,"style":"BOLD"},{"length":9,"offset":135,"style":"BOLD"},{"length":16,"offset":146,"style":"BOLD"},{"length":13,"offset":163,"style":"BOLD"}],"text":"short: представляет целое число в диапазоне от –32768 до 32767. Занимает в памяти 2 байта (16 бит).\n\nДанный тип также имеет псевдонимы short int, signed short int, signed short.","type":"unordered-list-item","key":"ecnio"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":14,"offset":0,"style":"BOLD"},{"length":18,"offset":136,"style":"BOLD"}],"text":"unsigned short: представляет целое число в диапазоне от 0 до 65535. Занимает в памяти 2 байта (16 бит).\n\nДанный тип также имеет синоним unsigned short int.\n","type":"unordered-list-item","key":"6gu9u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":3,"offset":0,"style":"BOLD"},{"length":5,"offset":352,"style":"BOLD"},{"length":4,"offset":390,"style":"BOLD"},{"length":10,"offset":424,"style":"BOLD"},{"length":6,"offset":437,"style":"BOLD"}],"text":"int: представляет целое число. В зависимости от архитектуры процессора может занимать 2 байта (16 бит) или 4 байта (32 бита). Диапазон предельных значений соответственно также может варьироваться от –32768 до 32767 (при 2 байтах) или от −2 147 483 648 до 2 147 483 647 (при 4 байтах). Но в любом случае размер должен быть больше или равен размеру типа short и меньше или равен размеру типа long\n\nДанный тип имеет псевдонимы signed int и signed.\n","type":"unordered-list-item","key":"1qk2a"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":12,"offset":0,"style":"BOLD"},{"length":8,"offset":294,"style":"BOLD"}],"text":"unsigned int: представляет положительное целое число. В зависимости от архитектуры процессора может занимать 2 байта (16 бит) или 4 байта (32 бита), и из-за этого диапазон предельных значений может меняться: от 0 до 65535 (для 2 байт), либо от 0 до 4 294 967 295 (для 4 байт).\n\nИмеет псевдоним unsigned\n","type":"unordered-list-item","key":"1fsoi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":0,"style":"BOLD"},{"length":8,"offset":291,"style":"BOLD"},{"length":15,"offset":301,"style":"BOLD"},{"length":11,"offset":319,"style":"BOLD"}],"text":"long: в зависимости от архитектуры может занимать 4 или 8 байт и представляет целое число в диапазоне от −2 147 483 648 до 2 147 483 647 (при 4 байтах) или от −9 223 372 036 854 775 808 до +9 223 372 036 854 775 807 (при 8 байтах). Занимает в памяти 4 байта (32 бита) или.\n\nИмеет псевдонимы long int, signed long int и signed long\n","type":"unordered-list-item","key":"e9d98"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":13,"offset":0,"style":"BOLD"},{"length":8,"offset":136,"style":"BOLD"}],"text":"unsigned long: представляет целое число в диапазоне от 0 до 4 294 967 295. Занимает в памяти 4 байта (32 бита).\n\nИмеет синоним unsigned long int.\n","type":"unordered-list-item","key":"5qsco"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":0,"style":"BOLD"},{"length":13,"offset":163,"style":"BOLD"},{"length":21,"offset":178,"style":"BOLD"},{"length":16,"offset":201,"style":"BOLD"}],"text":"long long: представляет целое число в диапазоне от −9 223 372 036 854 775 808 до +9 223 372 036 854 775 807. Занимает в памяти 8 байт (64 бита).\n\nИмеет псевдонимы long long int, signed long long int и signed long long.\n","type":"unordered-list-item","key":"a4bdg"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":18,"offset":0,"style":"BOLD"}],"text":"unsigned long long: представляет целое число в диапазоне от 0 до 18 446 744 073 709 551 615. Занимает в памяти, как правило, 8 байт (64 бита).\n","type":"unordered-list-item","key":"8funf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":22,"offset":16,"style":"BOLD"}],"text":"Имеет псевдоним unsigned long long int.\n\nДля представления чисел в С++ применятся целочисленные литералы со знаком или без, типа -10 или 10. Например, определим ряд переменных целочисленных типов и выведем их значения на консоль: ","type":"unstyled","key":"fcs88"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"#include \n \nint main()\n{\n signed char num1{ -64 };\n unsigned char num2{ 64 };\n short num3{ -88 };\n unsigned short num4{ 88 };\n int num5{ -1024 };\n unsigned int num6{ 1024 };\n long num7{ -2048 };\n unsigned long num8{ 2048 };\n long long num9{ -4096 };\n unsigned long long num10{ 4096 };\n std::cout << \"num1 = \" << num1 << std::endl;\n std::cout << \"num2 = \" << num2 << std::endl;\n std::cout << \"num3 = \" << num3 << std::endl;\n std::cout << \"num4 = \" << num4 << std::endl;\n std::cout << \"num5 = \" << num5 << std::endl;\n std::cout << \"num6 = \" << num6 << std::endl;\n std::cout << \"num7 = \" << num7 << std::endl;\n std::cout << \"num8 = \" << num8 << std::endl;\n std::cout << \"num9 = \" << num9 << std::endl;\n std::cout << \"num10 = \" << num10 << std::endl;\n}","type":"blockquote","key":"cbam5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Консольный вывод программы:","type":"unstyled","key":"2bavl"},{"data":{"image":{"id":"643a6f0b8bc7441bb9209edd"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"foovs"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":3,"offset":80,"style":"BOLD"},{"length":3,"offset":232,"style":"BOLD"},{"length":1,"offset":390,"style":"BOLD"},{"length":1,"offset":396,"style":"BOLD"},{"length":4,"offset":414,"style":"BOLD"},{"length":9,"offset":421,"style":"BOLD"},{"length":1,"offset":446,"style":"BOLD"},{"length":1,"offset":448,"style":"BOLD"},{"length":2,"offset":452,"style":"BOLD"},{"length":2,"offset":455,"style":"BOLD"}],"text":"Но стоит отметить, что все целочисленные литералы по умолчанию представляют тип int. Так, выше переменным разных типов присваивались различные числа - 64, -64, 88, -88, 1024 и т.д. Но все эти целочисленные литералы представляют тип int.\n\nОднако мы можем использовать целочисленные литералы и других типов. Целочисленные литералы без знака (которые представляют unsigned-типы) имеют суффикс u или U. Литералы типов long и long long имеют суффиксы L/l и LL/ll соответственно: ","type":"unstyled","key":"7r2ke"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"#include \n \nint main()\n{\n unsigned int num6{ 1024U }; // U - unsigned int\n long num7{ -2048L }; // L - long\n unsigned long num8{ 2048UL }; // UL - unsigned long\n long long num9{ -4096LL }; // LL - long long\n unsigned long long num10{ 4096ULL };// ULL - unsigned long long\n std::cout << \"num6 = \" << num6 << std::endl;\n std::cout << \"num7 = \" << num7 << std::endl;\n std::cout << \"num8 = \" << num8 << std::endl;\n std::cout << \"num9 = \" << num9 << std::endl;\n std::cout << \"num10 = \" << num10 << std::endl;\n}","type":"blockquote","key":"5t34c"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Консольный вывод программы:","type":"unstyled","key":"dbnpe"},{"data":{"image":{"id":"643a6f7219c01e7b0bf8aed7"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"b8cdi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Тем не менее использовать суффиксы необязательно, поскольку, как правило, компилятор может успешно преобразовать целочисленный литерал типа (который технически представляет тип int) к нужному типу без потери информации.\n\nЕсли число большое, то при вводе мы можем где-то ошибиться. Чтобы упростить читабельность чисел, начиная со стандарта C++14 в язык была добавлена возможность разделения разрядов числа с помощью одинарной кавычки ' ","type":"unstyled","key":"5e8ef"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"#include \n \nint main()\n{\n int num{ 1'234'567'890 };\n std::cout << \"num = \" << num << \"\\n\"; // num = 1234567890\n}","type":"blockquote","key":"62h7e"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Консольный вывод программы:","type":"unstyled","key":"3131d"},{"data":{"image":{"id":"643a6fc575fca230e6fcf05f"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"dccch"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Различные системы исчисления","type":"header-two","key":"9tu24"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":2,"offset":266,"style":"BOLD"},{"length":2,"offset":273,"style":"BOLD"}],"text":"\nПо умолчанию все стандартные целочисленные литералы представляют числа в привычной нам десятичной системе. Однако C++ также позволяет использовать и числа в других системах исчисления.\n\nЧтобы указать, что число - шестнадцатеричное, перед числом указывается префикс 0x или 0X. Например: ","type":"unstyled","key":"3sule"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"int num1{ 0x1A}; // 26 - в десятичной\nint num2{ 0xFF }; // 255 - в десятичной\nint num3{ 0xFFFFFF }; //16777215 - в десятичной","type":"blockquote","key":"al3k7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":1,"offset":72,"style":"BOLD"}],"text":"\nЧтобы указать, что число - восьмеричное, перед числом указывается ноль 0. Например:","type":"unstyled","key":"4k1j4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"int num1{ 034}; // 26 - в десятичной\nint num2{ 0377 }; // 255 - в десятичной","type":"blockquote","key":"e7jd3"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":2,"offset":42,"style":"BOLD"},{"length":2,"offset":49,"style":"BOLD"}],"text":"\nБинарные литералы предваряются префиксом 0b или 0B: ","type":"unstyled","key":"esbn4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"int num1{ 0b11010}; // 26 - в десятичной\nint num2{ 0b11111111 }; // 255 - в десятичной\nВсе эти типы литералов также поддерживают суффиксы U/L/LL:\nunsigned int num1{ 0b11010U}; // 26 - в десятичной\nlong num2{ 0377L }; // 255 - в десятичной\nunsigned long num3{ 0xFFFFFFULL }; //16777215 - в десятичной","type":"blockquote","key":"b6sht"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Числа с плавающей точкой","type":"header-two","key":"3j87g"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":8,"offset":121,"style":"BOLD"},{"length":18,"offset":132,"style":"BOLD"},{"length":11,"offset":375,"style":"BOLD"}],"text":"\nДля хранения дробных чисел в C++ применяются числа с плавающей точкой. Число с плавающей точкой состоит из двух частей: мантиссы и показателя степени. Оба могут быть как положительными, так и отрицательными. Величина числа – это мантисса, умноженная на десять в степени экспоненты.\n\nНапример, число 365 может быть записано в виде числа с плавающей точкой следующим образом:\n3.650000E02","type":"unstyled","key":"8ms5p"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":1,"offset":169,"style":"BOLD"},{"length":20,"offset":434,"style":"BOLD"}],"text":"\nВ качестве разделителя целой и дробной частей используется символ точки. Мантисса здесь имеет семь десятичных цифр - 3.650000, показатель степени - две цифры 02. Буква E означает экспоненту, после нее указывается показатель степени (степени десяти), на которую умножается часть 3.650000 (мантисса), чтобы получить требуемое значение. То есть, чтобы вернуться к обычному десятичному представлению, нужно выполнить следующую операцию:\n3.650000 × 102 = 365","type":"unstyled","key":"475bq"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":13,"offset":42,"style":"BOLD"}],"text":"\nДругой пример - возьмем небольшое число:\n-3.650000E-03","type":"unstyled","key":"8an1t"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"\nВ данном случае мы имеем дело с числом –3.65 × 10-3, что равно –0.00365. Здесь мы видим, что в зависимости от значения показателя степени десятичная точка \"плавает\". Собственно поэтому их и называют числами с плавающей точкой.\n\nОднако хотя такая запись позволяет определить очень большой диапазон чисел, не все эти числа могут быть представлены с полной точностью; числа с плавающей запятой в целом являются приблизительными представления точного числа. Например, число 1254311179 выглядело бы так: 1.254311E09. Однако если перейти к десятичной записи, то это будет 1254311000. А это не то же самое, что и 1254311179, поскольку мы потеряли три младших разряда.\n\nВ языке C++ есть три типа для представления чисел с плавающей точкой:\n","type":"unstyled","key":"96vk5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":5,"offset":0,"style":"BOLD"}],"text":"float: представляет вещественное число одинарной точности с плавающей точкой в диапазоне +/- 3.4E-38 до 3.4E+38. В памяти занимает 4 байта (32 бита).","type":"unordered-list-item","key":"bp1ks"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":6,"offset":0,"style":"BOLD"}],"text":"double: представляет вещественное число двойной точности с плавающей точкой в диапазоне +/- 1.7E-308 до 1.7E+308. В памяти занимает 8 байт (64 бита).","type":"unordered-list-item","key":"2g7m5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":11,"offset":0,"style":"BOLD"}],"text":"long double: представляет вещественное число двойной точности с плавающей точкой не менее 8 байт (64 бит). В зависимости от размера занимаемой памяти может отличаться диапазон допустимых значений.\n","type":"unordered-list-item","key":"ank48"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":5,"offset":224,"style":"BOLD"},{"length":6,"offset":418,"style":"BOLD"},{"length":11,"offset":599,"style":"BOLD"}],"text":"В своем внутреннем бинарном представлении каждое число с плавающей запятой состоит из одного бита знака, за которым следует фиксированное количество битов для показателя степени и набор битов для хранения мантиссы. В числах float 1 бит предназначен для хранения знака, 8 бит для экспоненты и 23 для мантиссы, что в сумме дает 32 бита. Мантисса позволяет определить точность числа в виде 7 десятичных знаков.\n\nВ числах double: 1 знаковый бит, 11 бит для экспоненты и 52 бит для мантиссы, то есть в сумме 64 бита. 52-разрядная мантисса позволяет определить точность до 16 десятичных знаков.\n\nДля типа long double расклад зависит от конкретного компилятора и реализации этого типа данных. Большинство компиляторов предоставляют точность до 18 - 19 десятичных знаков (64-битная мантисса), в других же (как например, в Microsoft Visual C++) long double аналогичен типу double.\n\nВ C++ литералы чисел с плавающими точками представлены дробными числами, которые в качестве разделителя целой и дробной частей применяют точку:","type":"unstyled","key":"2sf6c"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"double num {10.45};","type":"blockquote","key":"cncb0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"\nДаже если переменной присваивается целое число, чтобы показать, что мы присваиваем число с плавающей точкой, применяется точка: ","type":"unstyled","key":"d0bcv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"double num1{ 1 }; // 1 - целочисленный литерал\ndouble num2{ 1. }; //1. - литерал числа с плавающей точкой","type":"blockquote","key":"bsc8q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":1,"offset":254,"style":"BOLD"},{"length":2,"offset":256,"style":"BOLD"},{"length":2,"offset":278,"style":"BOLD"},{"length":1,"offset":281,"style":"BOLD"}],"text":"\nТак, здесь число 1. представляет литерал числа с плавающей точкой, и в принципе аналогичен 1.0.\n\nПо умолчанию все такие числа с точкой расцениваются как числа типа double. Чтобы показать, что число представляет другой тип, для float применяется суффикс f/F, а для long double - l/L: ","type":"unstyled","key":"9gdf9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"float num1{ 10.56f }; // float\nlong double num2{ 10.56l }; // long double","type":"blockquote","key":"9tr63"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"\nВ качестве альтернативы также можно применять экспоненциальную запись: ","type":"unstyled","key":"6rops"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"double num1{ 5E3 }; // 5E3 = 5000.0\ndouble num2{ 2.5e-3 }; // 2.5e-3 = 0.0025","type":"blockquote","key":"22j0m"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":8,"offset":1120,"style":"BOLD"}],"text":"\nРазмеры типов данных\nПри перечислении типов данных указывался размер, который он занимает в памяти. Но стандарт языка устанавливает лишь минимальные значения, которые должны быть. Например, для типов int и short минимальное значение - 16 бит, для типа long - 32 бита, для типа long double - 64 разряда. При этом размер типа long должен быть не меньше размера типа int, а размер типа int - не меньше размера типа short, а размер типа long double должен быть не меньше double. А разработчики компиляторов могут выбирать предельные размеры для типов самостоятельно, исходя из аппаратных возможностей компьютера.\n\nК примеру, компилятор g++ Windows для long double использует 16 байт. А компилятор в Visual Studio, который также работает под Windows, и clang++ под Windows для long double используют 8 байт. То есть даже в рамках одной платформы разные компиляторы могут по разному подходить к размерам некоторых типов данных. Но в целом используются те размеры, которые указаны выше при описании типов данных.\n\nОднако бывают ситуации, когда необходимо точно знать размер определенного типа. И для этого в С++ есть оператор sizeof(), который возвращает размер памяти в байтах, которую занимает переменная:","type":"unstyled","key":"b5acd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"#include \n \nint main()\n{\n long double number {2};\n std::cout << \"sizeof(number) =\" << sizeof(number);\n}","type":"blockquote","key":"b10as"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Консольный вывод программы:","type":"unstyled","key":"2vk3q"},{"data":{"image":{"id":"643a70708bc7441bb9237a7d"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"bh9uu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":19,"offset":39,"style":"ITALIC"}],"text":"Консольный вывод при компиляции в g++:\nsizeof(number) = 16","type":"unstyled","key":"359id"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Символьные типы","type":"header-two","key":"eui9n"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"\nВ C++ есть следующие символьные типы данных:\n","type":"unstyled","key":"3n0a6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":0,"style":"BOLD"}],"text":"char: представляет один символ в кодировке ASCII. Занимает в памяти 1 байт (8 бит). Может хранить любое значение из диапазона от -128 до 127, либо от 0 до 255.","type":"unordered-list-item","key":"fbjaj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":0,"style":"BOLD"}],"text":"wchar_t: представляет расширенный символ. На Windows занимает в памяти 2 байта (16 бит), на Linux - 4 байта (32 бита). Может хранить любой значение из диапазона от 0 до 65 535 (при 2 байтах), либо от 0 до 4 294 967 295 (для 4 байт).","type":"unordered-list-item","key":"6c1qs"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":0,"style":"BOLD"}],"text":"char8_t: представляет один символ в кодировке Unicode. Занимает в памяти 1 байт. Может хранить любой значение из диапазона от 0 до 256.","type":"unordered-list-item","key":"776gf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":8,"offset":0,"style":"BOLD"}],"text":"char16_t: представляет один символ в кодировке Unicode. Занимает в памяти 2 байта (16 бит). Может хранить любой значение из диапазона от 0 до 65 535.","type":"unordered-list-item","key":"c4k4r"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":8,"offset":0,"style":"BOLD"}],"text":"char32_t: представляет один символ в кодировке Unicode. Занимает в памяти 4 байта (32 бита). Может хранить любой значение из диапазона от 0 до 4 294 967 295","type":"unordered-list-item","key":"1fjsi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"char","type":"header-two","key":"1kuvp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":17,"style":"BOLD"}],"text":"\nПеременная типа char хранит числовой код одного символа и занимает один байт. Стандарт языка С++ не определяет кодировку символов, которая будет использоваться для символов char, поэтому производители компиляторов могут выбирать любую кодировку, но обычно это ASCII.\n\nВ качестве значения переменная типа char может принимать один символ в одинарных кавычках, либо числовой код символа:","type":"unstyled","key":"2hcqp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"#include \n \nint main()\n{\n char a1 {'A'};\n char a2 {65};\n std::cout << \"a1: \" << a1 << std::endl;\n std::cout << \"a2: \" << a2 << std::endl; \n}","type":"blockquote","key":"drt1t"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Консольный вывод программы:","type":"unstyled","key":"b0nes"},{"data":{"image":{"id":"643a70d84d6f403382e6a99b"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"5jtou"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":703,"style":"BOLD"},{"length":7,"offset":713,"style":"BOLD"},{"length":5,"offset":901,"style":"BOLD"},{"length":6,"offset":908,"style":"BOLD"},{"length":6,"offset":917,"style":"BOLD"}],"text":"В данном случае переменные a1 и a2 будут иметь одно и то же значение, так как 65 - это числовой код символа \"A\" в таблице ASCII. При выводе на консоль с помощью cout по умолчанию отображается символ.\n\nКроме того, в C++ можно использовать специальные управляющие последовательности, которые предваряются слешем и которые интерпретируются особым образом. Например, \"\\n\" представляет перевод строки, а \"\\t\" - табуляцию.\n\nОднако ASCII обычно подходит для наборов символов языков, которые используют латиницу. Но если необходимо работать с символами для нескольких языков одновременно или с символами языков, отличных от английского, 256-символьных кодов может быть недостаточно. И в этом случае применяется Unicode.\n\nUnicode (Юникод) — это стандарт, который определяет набор символов и их кодовых точек, а также несколько различных кодировок для этих кодовых точек. Наиболее часто используемые кодировки: UTF-8, UTF-16 и UTF-32. Разница между ними заключается в том, как представлена кодовая точка символа; числовое же значение кода для любого символа остается одним и тем же в любой из кодировок. Основные отличия:\n","type":"unstyled","key":"psch"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":5,"offset":0,"style":"BOLD"},{"length":5,"offset":127,"style":"BOLD"},{"length":5,"offset":207,"style":"BOLD"}],"text":"UTF-8 представляет символ как последовательность переменной длины от одного до четырех байт. Набор символов ASCII появляется в UTF-8 как однобайтовые коды, которые имеют те же значения кодов, что и в ASCII. UTF-8 на сегодняшний день является самой популярной кодировкой Unicode.","type":"unordered-list-item","key":"2br3q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":6,"offset":0,"style":"BOLD"}],"text":"UTF-16 представляет символы как одно или два 16-битных значения.","type":"unordered-list-item","key":"5guku"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":6,"offset":0,"style":"BOLD"},{"length":7,"offset":110,"style":"BOLD"},{"length":7,"offset":119,"style":"BOLD"},{"length":8,"offset":128,"style":"BOLD"},{"length":8,"offset":139,"style":"BOLD"},{"length":8,"offset":149,"style":"BOLD"},{"length":8,"offset":160,"style":"BOLD"},{"length":7,"offset":194,"style":"BOLD"}],"text":"UTF-32 представляет все символы как 32-битные значения\n\nВ C++ есть четыре типа для хранения символов Unicode: wchar_t, char8_t, char16_t и char32_t (char16_t и char32_t были добавлены в C+11, а char8_t - в C++20).\n","type":"unordered-list-item","key":"42jud"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"wchar_t","type":"header-three","key":"ajlrt"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":5,"style":"BOLD"},{"length":7,"offset":153,"style":"BOLD"},{"length":4,"offset":178,"style":"BOLD"},{"length":7,"offset":289,"style":"BOLD"}],"text":"\nТип wchar_t — это основной тип, предназначенный для наборов символов, размер которых выходит за пределы одного байта. Собственно отсюда и его название: wchar_t - wide (широкий) char. происходит от широкого символа, потому что этот символ «шире», чем обычный однобайтовый символ. Значения wchar_t определяются также как и символы char за тем исключением, что они предваряются символов \"L\":","type":"unstyled","key":"f069k"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"wchar_t a1 {L'A'};","type":"blockquote","key":"cq4fo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"\nТакже можно передать код символа","type":"unstyled","key":"544nj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"wchar_t a1 {L'A'};","type":"blockquote","key":"5f4jh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":288,"style":"BOLD"},{"length":9,"offset":320,"style":"BOLD"},{"length":10,"offset":339,"style":"BOLD"}],"text":"\nЗначение, заключенное в одинарные кавычки, представляет собой шестнадцатеричный код символа. Обратная косая черта указывает на начало управляющей последовательности, а x после обратной косой черты означает, что код шестнадцатеричный.\n\nСтоит учитывать, что для вывода на консоль символов wchar_t следует использовать не std::cout, а поток std::wcout:","type":"unstyled","key":"9lsji"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"#include \n \nint main()\n{\n char h = 'H';\n wchar_t i {L'i'};\n std::wcout << h << i <<'\\n';\n}","type":"blockquote","key":"es4is"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Консольный вывод программы:","type":"unstyled","key":"bvn7n"},{"data":{"image":{"id":"643a714ab9ff2b009f4b1c84"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"4m2jj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":47,"style":"BOLD"},{"length":7,"offset":61,"style":"BOLD"},{"length":9,"offset":78,"style":"BOLD"},{"length":7,"offset":103,"style":"BOLD"},{"length":7,"offset":177,"style":"BOLD"},{"length":6,"offset":425,"style":"BOLD"},{"length":6,"offset":526,"style":"BOLD"},{"length":7,"offset":753,"style":"BOLD"},{"length":8,"offset":762,"style":"BOLD"},{"length":8,"offset":773,"style":"BOLD"},{"length":5,"offset":851,"style":"BOLD"},{"length":6,"offset":858,"style":"BOLD"},{"length":6,"offset":869,"style":"BOLD"},{"length":7,"offset":984,"style":"BOLD"},{"length":8,"offset":993,"style":"BOLD"},{"length":8,"offset":1004,"style":"BOLD"}],"text":"При этом поток std::wcout может работать как с char, так и с wchar_t. А поток std::cout для переменной wchar_t вместо символа будет выводить его числовой код.\n\nПроблема с типом wchar_t заключается в том, что его размер сильно зависит от реализации и применяемой кодировки. Кодировка обычно соответствует предпочтительной кодировке целевой платформы. Так, для Windows wchar_t обычно имеет ширину 16 бит и кодируется с помощью UTF-16. Большинство других платформ устанавливают размер в 32 бита, а в качестве кодировки применяют UTF-32. С одной стороны, это позволяет больше соответствовать конкретной платформе. Но с другой стороны, затрудняет написание кода, переносимого на разные платформы. Поэтому в общем случае часто рекомендуется использовать типы char8_t, char16_t и char32_t. Значения этих типов предназначены для хранения символов в кодировке UTF-8, UTF-16 или UTF-32 соответственно, а их размеры одинаковы на всех распространенных платформах.\n\nДля определения символов типов char8_t, char16_t и char32_t применяются соответственно префиксы u8, u и U:","type":"unstyled","key":"56sgs"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"char8_t c{ u8'l' };\nchar16_t d{ u'l' };\nchar32_t e{ U'o' };","type":"blockquote","key":"dj5k1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":52,"style":"BOLD"},{"length":8,"offset":60,"style":"BOLD"},{"length":8,"offset":69,"style":"BOLD"},{"length":8,"offset":116,"style":"BOLD"},{"length":9,"offset":125,"style":"BOLD"}],"text":"\nСтоит отметить, что для вывода на консоль значений char8_t/char16_t/char32_t пока нет встроенных инструментов типа std:cout/std:wcout.","type":"unstyled","key":"7ftgr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Спецификатор auto","type":"header-two","key":"ag19l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":4,"offset":222,"style":"BOLD"}],"text":"\nИногда бывает трудно определить тип выражения. В этом случае можно предоставить компилятору самому выводить тип объекта. И для этого применяется спецификатор auto. При этом если мы определяем переменную со спецификатором auto, эта переменная должна быть обязательно инициализирована каким-либо значением:","type":"unstyled","key":"32qat"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"auto number = 5; // number имеет тип int\nauto sum {1234.56}; // sum имеет тип double\nauto distance {267UL}; // distance имеет тип unsigned long","type":"blockquote","key":"4k13j"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"\nНа основании присвоенного значения компилятор выведет тип переменной. Неинициализированные переменные со спецификатором auto не допускаются:","type":"unstyled","key":"5ki1v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"auto number;","type":"blockquote","key":"8knap"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":42,"offset":0,"style":"BOLD"}],"text":"Не забывайте подписываться и ставить лайк!","type":"header-three","key":"9vu4m"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"vfTA0Cv1pTfBUXjJOrlH"}],"entityMap":{}},"mentions":[]}