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

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

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

В языке C# есть следующие примитивные типы данных:

    bool : хранит значение true или false (логические литералы). Представлен системным типом System.Boolean

    Bool alive = true; bool isDead = false;

    byte : хранит целое число от 0 до 255 и занимает 1 байт. Представлен системным типом System.Byte

    Byte bit1 = 1; byte bit2 = 102;

    sbyte : хранит целое число от -128 до 127 и занимает 1 байт. Представлен системным типом System.SByte

    Sbyte bit1 = -101; sbyte bit2 = 102;

    short : хранит целое число от -32768 до 32767 и занимает 2 байта. Представлен системным типом System.Int16

    Short n1 = 1; short n2 = 102;

    ushort : хранит целое число от 0 до 65535 и занимает 2 байта. Представлен системным типом System.UInt16

    Ushort n1 = 1; ushort n2 = 102;

    int : хранит целое число от -2147483648 до 2147483647 и занимает 4 байта. Представлен системным типом System.Int32 . Все целочисленные литералы по умолчанию представляют значения типа int:

    Int a = 10; int b = 0b101; // бинарная форма b =5 int c = 0xFF; // шестнадцатеричная форма c = 255

    uint : хранит целое число от 0 до 4294967295 и занимает 4 байта. Представлен системным типом System.UInt32

    Uint a = 10; uint b = 0b101; uint c = 0xFF;

    long : хранит целое число от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 и занимает 8 байт. Представлен системным типом System.Int64

    Long a = -10; long b = 0b101; long c = 0xFF;

    ulong : хранит целое число от 0 до 18 446 744 073 709 551 615 и занимает 8 байт. Представлен системным типом System.UInt64

    Ulong a = 10; ulong b = 0b101; ulong c = 0xFF;

    float : хранит число с плавающей точкой от -3.4*10 38 до 3.4*10 38 и занимает 4 байта. Представлен системным типом System.Single

    double : хранит число с плавающей точкой от ±5.0*10 -324 до ±1.7*10 308 и занимает 8 байта. Представлен системным типом System.Double

    decimal : хранит десятичное дробное число. Если употребляется без десятичной запятой, имеет значение от ±1.0*10 -28 до ±7.9228*10 28 , может хранить 28 знаков после запятой и занимает 16 байт. Представлен системным типом System.Decimal

    char : хранит одиночный символ в кодировке Unicode и занимает 2 байта. Представлен системным типом System.Char . Этому типу соответствуют символьные литералы:

    Char a = "A"; char b = "\x5A"; char c = "\u0420";

    string : хранит набор символов Unicode. Представлен системным типом System.String . Этому типу соответствуют символьные литералы.

    String hello = "Hello"; string word = "world";

    object : может хранить значение любого типа данных и занимает 4 байта на 32-разрядной платформе и 8 байт на 64-разрядной платформе. Представлен системным типом System.Object , который является базовым для всех других типов и классов.NET.

    Object a = 22; object b = 3.14; object c = "hello code";

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

Using System; namespace HelloApp { class Program { static void Main(string args) { string name = "Tom"; int age = 33; bool isEmployed = false; double weight = 78.65; Console.WriteLine($"Имя: {name}"); Console.WriteLine($"Возраст: {age}"); Console.WriteLine($"Вес: {weight}"); Console.WriteLine($"Работает: {isEmployed}"); } } }

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

Имя: Tom Возраст: 33 Вес: 78,65 Работает: False

Использование суффиксов

При присвоении значений надо иметь в виду следующую тонкость: все вещественные литералы рассматриваются как значения типа double . И чтобы указать, что дробное число представляет тип float или тип decimal , необходимо к литералу добавлять суффикс: F/f - для float и M/m - для decimal.

Подобным образом все целочисленные литералы рассматриваются как значения типа int . Чтобы явным образом указать, что целочисленный литерал представляет значение типа uint, надо использовать суффикс U/u , для типа long - суффикс L/l , а для типа ulong - суффикс UL/ul :

Uint a = 10U; long b = 20L; ulong c = 30UL;

Использование системных типов

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

Int a = 4; System.Int32 b = 4;

Неявная типизация

Ранее мы явным образом указывали тип переменных, например, int x; . И компилятор при запуске уже знал, что x хранит целочисленное значение.

Однако мы можем использовать и модель неявной типизации:

Var hello = "Hell to World"; var c = 20; Console.WriteLine(c.GetType().ToString()); Console.WriteLine(hello.GetType().ToString());

Для неявной типизации вместо названия типа данных используется ключевое слово var . Затем уже при компиляции компилятор сам выводит тип данных исходя из присвоенного значения. В примере выше использовалось выражение Console.WriteLine(c.GetType().ToString()); , которое позволяет нам узнать выведенный тип переменной с. Так как по умолчанию все целочисленные значения рассматриваются как значения типа int , то поэтому в итоге переменная c будет иметь тип int или System.Int32

Эти переменные подобны обычным, однако они имеют некоторые ограничения.

Во-первых, мы не можем сначала объявить неявно типизируемую переменную, а затем инициализировать:

// этот код работает int a; a = 20; // этот код не работает var c; c= 20;

Во-вторых, мы не можем указать в качестве значения неявно типизируемой переменной null:

// этот код не работает var c=null;

Так как значение null, то компилятор не сможет вывести тип данных.

double или decimal

Из выше перечисленного списка типов данных очевидно, что если мы хотим использовать в программе числа до 256, то для их хранения мы можем использоват переменные типа byte . При использовании больших значений мы можем взять тип short, int, long. То же самое для дробных чисел - для обычных дробных чисел можно взять тип float, для очень больших дробных чисел - тип double. Тип decimal здесь стоит особняком в том плане, что несмотря на большую разрядность по сравнению с типом double, тип double может хранить большее значение. Однако значение decimal может содержать до 28 знаков после запятой, тогда как значение типа double - 15-16 знаков после запятой.

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

Последнее обновление: 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 не допускаются.

Типы данных

Типы данных имеют особенное значение в C#, поскольку это строго типизированный язык. Это означает, что все операции подвергаются строгому контролю со стороны компилятора на соответствие типов, причем недопустимые операции не компилируются. Следовательно, строгий контроль типов позволяет исключить ошибки и повысить надежность программ. Для обеспечения контроля типов все переменные, выражения и значения должны принадлежать к определенному типу. Такого понятия, как "бестиповая" переменная, в данном языке программирования вообще не существует. Более того, тип значения определяет те операции, которые разрешается выполнять над ним. Операция, разрешенная для одного типа данных, может оказаться недопустимой для другого.

В C# имеются две общие категории встроенных типов данных: типы значений и ссылочные типы . Они отличаются по содержимому переменной. Концептуально разница между ними состоит в том, что тип значения (value type) хранит данные непосредственно, в то время как ссылочный тип (reference type) хранит ссылку на значение.

Эти типы сохраняются в разных местах памяти: типы значений сохраняются в области, известной как стек , а ссылочные типы - в области, называемой управляемой кучей .

Давайте разберем типы значений.

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

В C# определены девять целочисленных типов: char, byte, sbyte, short, ushort, int, uint, long и ulong . Но тип char применяется, главным образом, для представления символов и поэтому рассматривается отдельно. Остальные восемь целочисленных типов предназначены для числовых расчетов. Ниже представлены их диапазон представления чисел и разрядность в битах:

Целочисленные типы C#
Тип Тип CTS Разрядность в битах Диапазон
byte System.Byte 8 0:255
sbyte System.SByte 8 -128:127
short System.Int16 16 -32768: 32767
ushort System.UInt16 16 0: 65535
int System.Int32 32 -2147483648: 2147483647
uint System.UInt32 32 0: 4294967295
long System.Int64 64 -9223372036854775808: 9223372036854775807
ulong System.UInt64 64 0: 18446744073709551615

Как следует из приведенной выше таблицы, в C# определены оба варианта различных целочисленных типов: со знаком и без знака. Целочисленные типы со знаком отличаются от аналогичных типов без знака способом интерпретации старшего разряда целого числа. Так, если в программе указано целочисленное значение со знаком, то компилятор C# сгенерирует код, в котором старший разряд целого числа используется в качестве флага знака. Число считается положительным, если флаг знака равен 0, и отрицательным, если он равен 1.

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

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

Так, если значение нужно сохранить без знака, то для него можно выбрать тип uint , для больших значений со знаком - тип long , а для больших значений без знака - тип ulong . В качестве примера ниже приведена программа, вычисляющая расстояние от Земли до Солнца в сантиметрах. Для хранения столь большого значения в ней используется переменная типа long:

Using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 { class Program { static void Main(string args) { long result; const long km = 149800000; // расстояние в км. result = km * 1000 * 100; Console.WriteLine(result); Console.ReadLine(); } } }

Всем целочисленным переменным значения могут присваиваться в десятичной или шестнадцатеричной системе обозначений. В последнем случае требуется префикс 0x:

Long x = 0x12ab;

Если возникает какая-то неопределенность относительно того, имеет ли целое значение тип int, uint, long или ulong, то по умолчанию принимается int. Чтобы явно специфицировать, какой другой целочисленный тип должно иметь значение, к числу можно добавлять следующие символы:

Uint ui = 1234U; long l = 1234L; ulong ul = 1234UL;

U и L можно также указывать в нижнем регистре, хотя строчную L легко зрительно спутать с цифрой 1 (единица).

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

Типы с плавающей точкой позволяют представлять числа с дробной частью. В C# имеются две разновидности типов данных с плавающей точкой: float и double . Они представляют числовые значения с одинарной и двойной точностью соответственно. Так, разрядность типа float составляет 32 бита, что приближенно соответствует диапазону представления чисел от 5E-45 до 3,4E+38. А разрядность типа double составляет 64 бита, что приближенно соответствует диапазону представления чисел от 5E-324 до 1,7Е+308.

Тип данных float предназначен для меньших значений с плавающей точкой, для которых требуется меньшая точность. Тип данных double больше, чем float, и предлагает более высокую степень точности (15 разрядов).

Если нецелочисленное значение жестко кодируется в исходном тексте (например, 12.3), то обычно компилятор предполагает, что подразумевается значение типа double. Если значение необходимо специфицировать как float, потребуется добавить к нему символ F (или f):

Float f = 12.3F;

Десятичный тип данных

Для представления чисел с плавающей точкой высокой точности предусмотрен также десятичный тип decimal , который предназначен для применения в финансовых расчетах. Этот тип имеет разрядность 128 бит для представления числовых значений в пределах от 1Е-28 до 7,9Е+28. Вам, вероятно, известно, что для обычных арифметических вычислений с плавающей точкой характерны ошибки округления десятичных значений. Эти ошибки исключаются при использовании типа decimal, который позволяет представить числа с точностью до 28 (а иногда и 29) десятичных разрядов. Благодаря тому что этот тип данных способен представлять десятичные значения без ошибок округления, он особенно удобен для расчетов, связанных с финансами:

Using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 { class Program { static void Main(string args) { // *** Расчет стоимости капиталовложения с *** // *** фиксированной нормой прибыли*** decimal money, percent; int i; const byte years = 15; money = 1000.0m; percent = 0.045m; for (i = 1; i

Результатом работы данной программы будет:

Символы

В C# символы представлены не 8-разрядным кодом, как во многих других языках программирования, например С++ , а 16-разрядным кодом, который называется юникодом (Unicode) . В юникоде набор символов представлен настолько широко, что он охватывает символы практически из всех естественных языков на свете. Если для многих естественных языков, в том числе английского, французского и немецкого, характерны относительно небольшие алфавиты, то в ряде других языков, например китайском, употребляются довольно обширные наборы символов, которые нельзя представить 8-разрядным кодом. Для преодоления этого ограничения в C# определен тип char , представляющий 16-разрядные значения без знака в пределах от 0 до 65 535. При этом стандартный набор символов в 8-разрядном коде ASCII является подмножеством юникода в пределах от 0 до 127. Следовательно, символы в коде ASCII по-прежнему остаются действительными в C#.

Ответ:
  1. Целочисельные типы данных:

short int , unsigned short int , int , unsigned int , long , unsigned long .

  1. Типы данных с плавающей запятой (соответствуют вещественным типам):

float , double , long double .

  1. Символьный тип данных:

char (signed char ), unsigned char, wchar_t .

  1. Логический тип данных:

bool .

  1. Перечислимый тип данных (введен в Visual C++ ):

enum .

2. Какие особенности использования целочисленных типов данных?

В C++ основные целочисленные типы данных: short int , unsigned short int , int , unsigned int , long (long int ), unsigned long (unsigned long int ).

Эти типы данных представляют значения из множества целых чисел. Например:

2 -100 398

Типы данных, которые начинаются из приставки unsigned , могут содержать только положительные числа.

Данные типа short int , unsigned short int занимают в два раза меньше места в памяти чем данные типа int , unsigned int .

Данные типа long , unsigned long занимают в два раза больше места в памяти чем данные типа int , unsigned int .

3. Как в программе описать переменную с именем x целого типа?

Ответ:
int x; // целое со знаком

В результате под переменную x будет выделено место в памяти размером 4 байта. Размер памяти, которая выделяется под переменную зависит от характеристик компьютера, типа операционной системы и настроек компилятора.

4. Как в переменную целого типа записать число 239?

Для этого используется оператор присваивания, который обозначается символом ‘= ‘.

Ответ 1. Внесение числа в переменную после ее описания.

int x; x = 239;

Ответ 2. Внесение числа в переменную во время ее описания (начальная инициализация).

int x = 239;

5. Какие особенности типов данных с плавающей запятой?

Типы данных с плавающей запятой разрешают представлять значения из множества вещественных чисел. Например:

8.35 -990.399 239.0.

В C++ есть следующие базовые типы данных с плавающей запятой: float , double , long double .

Переменная типа double занимает в 2 раза больше места в памяти компьютера чем переменная типа float .

Так же переменная типа long double занимает в 2 раза больше места в памяти компьютера, чем переменная типа double .

6. Как описать переменную, которая принимает значение с плавающей запятой?

Пример описания переменных типа float , double , long double :

float f; double d; long double ld;

7. Как в переменную с плавающей запятой записать числовые значения?

Пример внесения числовых данных в переменные типы с плавающей запятой:

float f = -9928.45; // начальная инициализация double d; long double ld; d = 0.445332; // оператор присваивания ld = 3892923898239.030903; // оператор присваивания

8. Как перевести переменную типа float в тип int ?

Для этого используется операция приведения типов. В скобках нужно указать название типа к которому происходит приведение.

float a; int b; a = 8.457; b = (int ) a; // b = 8

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

Например, переменная типа short int может представлять меньший диапазон чисел, чем переменные типов float , double . В следующему листинге происходит переполнение значения в переменной типа short int :

short int i; float f; f = 3990099.8; i = (int )f; // i = -7597 - переполнение

9. Как перевести переменную из типа int в тип double ?

Пример приведения с int в double :

int i; double d; i = 982; d = (double )i; // d = 982.0

10. Какие особенности использования данных типа char (символьных данных) в программе?

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

Например, код символа ‘f’ равен значению 102 .

Фрагмент кода, в котором вычисляется код символа:

int code; char symbol; symbol = "f" ; code = (int )symbol; // code = 102

Данные типа char есть теми же целыми числами. Данные типа char занимают в памяти компьютера 1 байт.

Соотношение «символ-код» размещается в таблице символов Windows. Символы с кодами от 0 до 127 – это зарезервированные символы BIOS. Они включают наиболее употребляемые символы, символы цифр, символы латинской азбуки. Эти символы изменить нельзя.

Символы с кодами от 128 до 255 – это региональные символы, которые привязанные к конкретной азбуке того компьютера на котором установленная операционная система Windows.

11. Какие особенности использования данных типа bool (логический тип)?

Переменные типа bool могут принимать только два значения:

true – истина,

false – ложь.

Эти переменные используются для проверки логических выражений. Числовое значение true равно 1 . Числовое значение false равно 0 .

Фрагмент кода, который определяет числовые значения true и false :

int result; bool b; result = (int )true ; // result = 1 b = false ; result = (int )b; // result = 0

Фрагмент кода, который превращает типы int и float в bool :

int i; float f; bool b; i = 6; b = (bool )i; // b = True f = 0.0; b = (bool )f; // b = False

12. Как определить размер памяти, который занимает переменная данного типа?

Для этого используется операция sizeof() .

Фрагмент кода, который определяет размер некоторых типов данных:

int d; d = sizeof (char ); // d = 1 d = sizeof (unsigned int ); // d = 4 d = sizeof (float ); // d = 4 d = sizeof (double ); // d = 8

13. Каким образом осуществляется инициализация переменных разных типов?

int d = 28; float z = (float )2.85; char c = "k" ; String ^s = "Hello!" ; double r = -8.559;

14. Каким образом определить максимально допустимое (минимально допустимое) значение переменной определенного типа?

Чтобы определить максимально допустимое или минимально допустимое значение переменной некоторого типа в библиотеке .NET Framework используются свойства MaxValue и MinValue .

Примеры определения предельных значений переменных разных типов.

Для переменных типа int :

// тип int int i; long MaxInt; long MinInt; MaxInt = (long )i.MaxValue; // MaxInt = 2147483647 MinInt = (long )i.MinValue; // MinInt = -2147483648

Для переменных типа short int :

// тип short int short int si; int MaxInt; int MinInt; MaxInt = (int )si.MaxValue; // MaxInt = 32767 MinInt = (int )si.MinValue; // MinInt = -32768

Для переменных типа unsigned int :

// тип unsigned int unsigned int ui; unsigned int MaxInt; unsigned int MinInt; MaxInt = ui.MaxValue; // MaxInt = 4294967295 MinInt = ui.MinValue; // MinInt = 0

Для переменных типа float :

// тип float float f; float MaxF; float MinF; MaxF = f.MaxValue; // MaxF = 3.402823E+38 MinF = f.MinValue; // MinF = -3.402823E+38

Для переменных типа double :

// тип double double d; double MaxD; double MinD; Max = d.MaxValue; // Max = 1.79769313486232E+308 Min = d.MinValue; // Min = -1.79769313486232E+308

Для переменных типа char :

// тип char char c; int MaxC; int MinC; Max = (int )c.MaxValue; // Max = 127 Min = (int )c.MinValue; // Min = -128

15. Какие особенности использования типа enum ?

Тип enum – это перечислительный тип данных. В нем задаются мнемонические значения для множеств целых значений. Каждое мнемоническое значение имеет определенное содержание и представляется целым числом.

Пример использования типа enum для обозначения месяцев года:

enum months { January, February, March, April, May, June, July, August, September, October, November, December } mn; mn = January; // mn = 0 mn = March; // mn = 2 mn = September; // mn = 8

В приведенном примере описывается переменная с именем mn типа enum months . Мнемонические значения месяцев (January , February , …) начинаются с 0 (0 , 1 , 2 , …). Мнемоническому значению January соответствует целое значение 0 , мнемоническому значению February соответствует целое значение 1 , и т.д.

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

Можно написать и так:

mn = (enum months)2; // mn = March mn = (enum months)11; // mn = December

16. Какие особенности применения типа void в программах на C ++ ?

Тип данных void используется в следующих случаях:

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

Пример . Функция MyFun() без параметров, которая не возвращает никакого значения (возвращает тип void ) и не получает параметров.

public : void MyFun(void ) { // тело функции // ... return; // возврат из функции, которая не возвращает значения } // вызов функции из программы ... MyFun(); ...

17. Можно ли объявлять переменную типа void в программе?

Нельзя, так как тип void не связан со значением.

Объявление переменной типа void приводит к ошибке компиляции с выводом сообщения:

"Illegal use of type void "

18. Какие особенности применения типа wchar _ t в Visual C ++ ?

Переменные типа char (смотрите предыдущие пункты) используются для сохранения 8-разрядных ASCII -символов.

Тип wchar_t используется для сохранения символов, которые входят в состав больших символьных наборов. Например, в китайской азбуке есть огромное количество символов. 8 разрядов недостаточно, чтобы представить весь набор символов китайской азбуки. Поэтому, если нужно использовать программу на международном рынке, целесообразно заменить тип char на wchar_t .

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

... wchar_t t; // для переменной t выделяется 2 байта памяти t = "s"; ...

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

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

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

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

Для формирования других типов данных используют основные типы + так называемые спецификаторы . Типы данных, созданные на базе стандартных типов с использованием спецификаторов, называют составными типами данных . В C++ определены четыре спецификатора типов данных:
  1. short - короткий;
  2. long - длинный;
  3. signed-знаковый;
  4. unsigned-беззнаковый.
Производные типы – это:
  • массивы,
  • функции,
  • классы,
  • указатели,
  • ссылки,
  • структуры,
  • объединения.

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

Данные типа char в памяти компьютера всегда занимают 1 байт. Это связа­но с тем, что обычно под величину символьного типа отводят столько памяти, сколько необходимо для хранения любого из 256 символов клавиатуры.
Сим­вольный тип может быть со знаком или без знака .
В величинах со знаком signed char можно хранить значения в диапазоне от -128 до 127. Соответствен­но значения переменных типа unsigned char могут находиться в диапазоне от 0 до 255.
Тип данных Диапазон значений Размер
char -128...+127 1 байт
unsigned char 0...255 1 байт
signed char -128...127 1 байт

При работе с символьными данными нужно помнить, что если в выражении встречается одиночный символ , он должен быть заключен в одинарные кавычки . Последовательность символов, то есть строка, при использовании в выражени­ях заключается в двойные кавычки . Например: ‘F’ , ‘3’ , “Иван”, “235”

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

Данные типа int в памяти компьютера могут занимать либо 2, 4 или 8 байт. Это зависит от разрядности процессора.
По умолчанию все целые типы считаются знаковыми, то есть спецификатор signed (знаковый) можно не указывать.
Спецификатор unsigned (беззнаковый) позволяет представлять только положительные числа.

Диапазоны значений целочисленных типов

Тип данных Диапазон значений Размер(байт)
int
signed int
signed long int 		-2147483648 ... 2147483647 4
unsigned int
unsigned long int 		0 ... 4294967295 4
short int
signed short int 		-32768 ... 32767 2
unsigned short int 0... 65535 2
long long int \(-(2^{63}-1)...(2^{63}-1)\) 8
unsigned long
long int 		\(0...(2^{64}-1)\) 8

Вещественный тип

Внутреннее представление вещественного числа в памяти компьютера отлича­ется от представления целого числа. Число с плавающей точкой представлено в экспоненциальной форме . $$\pm mE\pm p$$ где m - мантисса (целое или дробное число с десятичной точкой), р - порядок (целое число). Для того чтобы перевести чис­ло в экспоненциальной форме к обычному представлению с фиксированной точкой, необходимо мантиссу умножить на десять в степени порядок Например: \(-6.42E+2=-6,42*10^{2}\)

Диапазоны значений вещественных типов

Тип данных Диапазон значений Размер (байт)
float 3.4E-38 ... 3.4E+38 4
double 1.7E-308... 1.7E+308 8
long double 3.4E-4932 ... 3.4E+4932 10

Длина мантиссы определяет точность числа, а длина порядка его диапазон.
Данные типа float занимают 4 байт, из которых 1 двоичный разряд отводится под знак, 8 разрядов - под порядок и 23 - под мантиссу. По­-скольку старшая цифра мантиссы всегда равна 1, она не хранится.
Данные типа double занимают 8 байт, в них под порядок -11 разрядов и под мантиссу -52 разряда соответственно.
Спецификатор типа long перед именем типа double указывает, что под величину отводится 10 байт.

Логический тип

Переменная типа bool может принимать только два значения true (истина) или false (ложь). Любое значение, не равное нулю, интерпретируется как true, а при преобразовании к целому типу принимает значение, равное 1. Значение false представлено в памяти как 0.

Тип void (пустой)

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

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

Переменная - это поименованный участок памяти, в котором хранится значение определенного типа.
У переменной есть имя (идентификатор) и значение .
Имя служит для обращения к области памяти, в которой хранится значение.
Имя (идентификатор) - это совокупность букв, цифр и знаков подчёркивания, задающая имя переменной, название функции или ключевое слово в программе. Язык С/C++ чувствителен к регистру (т.е. Sum и sum будут восприниматься как две разные переменные).
где, тип – ключевое слово, определяющее объём памяти (число байтов), выделенный для хранения значения переменной (как объекта программы), (int – целый, float, double – вещественный, char – символьный, bool - логический);
имя – уникальный идентификатор переменной, задающий символический адрес объекта программы в памяти ЭВМ;
инициатор – начальное значение переменной, которое может отсутствовать в описании.
Например: Однотипные переменные можно сгруппировать, разделив «,». Описание переменных разного типа разделяется « ; ».
По месту обьявления переменные в языке С/С++ можно разделить на три класса:
  1. локальные- объяв­ляются внутри функции и доступны только в ней;
  2. глобальные - описываются до всех функций и доступны из любо­го места программы;
  3. формальные параметры функций описываются в списке параметров функции.
Пример:
Похожие статьи