Стандартни типове данни c. Типове с плаваща запетая

Типът данни дефинира набор от стойности, набор от операции, които могат да бъдат приложени към тези стойности и как се съхраняват стойностите и как се изпълняват операциите.

Процесът на проверка и поставяне на ограничения върху типовете използвани данни се нарича проверка на типа или въвеждане на програмни данни. Разграничават се следните видове писане:

• Статично типизиране - контролът на типа се извършва по време на компилация.
• Динамично въвеждане - проверката на типа се извършва по време на изпълнение.

Поддържа език C статично въвеждане, а типовете на всички данни, използвани в една програма, трябва да бъдат посочени преди тя да бъде компилирана.

Има прости, съставни и други типове данни.

Прости данни

Простите данни могат да бъдат разделени на

• цели числа,
• истински,
• символичен
• логично.

Съставни (комплексни) данни

• Масивът е индексирана колекция от елементи от един и същи тип.
• Типът низ е масив, който съхранява низ от знаци.
• Конструкция - комплект различни елементи(записни полета), съхранявани като едно цяло и осигуряващи достъп до отделни полета от структурата.

Други типове данни

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

Програма, написана на език C, работи с данни различни видове. Всички данни имат име и тип. Данните се достъпват в програмата чрез техните имена (идентификатори).

Идентификаторът е последователност, съдържаща не повече от 32 знака, която може да включва всякакви букви от латинската азбука a - z, A - Z, цифри 0 - 9 и долна черта (_). Първият знак на идентификатора не трябва да е число.

Въпреки че е разрешено име до 32 знака, само първите 8 знака са значими. Освен името, всички данни имат тип. Индикацията за типа е необходима, за да се знае колко място има RAMще заемат този обект.

Компилаторът C се придържа към стриктно съвпадение на главни и малки букви в имената на идентификатори и токени.

Целочислени данни

Целочислените данни могат да бъдат представени със знак или без знак.

Цели числа без знакса представени като последователност от битове в диапазона от 0 до 2 n -1, където n е броят на заетите битове.

Цели числа със знакса представени в диапазона -2 n-1 …+2 n-1 -1. В този случай най-значимият бит от данните се присвоява на знака на числото (0 съответства на положително число, 1 на отрицателно).

Основни типове и размери на целочислени данни:

Реални данни

Реален типе предназначен да представя реални числа. Реалните числа са представени в битовата мрежа на машината в стандартизирана форма.

Нормализирана форма на числотопредполага наличието на една значима цифра (не 0) преди разделянето на целите и дробните части. Това представяне се умножава по основата на бройната система до съответната степен. Например числото 12345,678 в нормализирана форма може да бъде представено като

12345,678 = 1,2345678 10 4

Числото 0,009876 в нормализирана форма може да бъде представено като

0,009876 = 9,876·10 -3

IN двоична системаВ нотация значимата цифра преди десетичния разделител може да бъде равна само на 1. Ако числото не може да бъде представено в стандартизирана форма (например числото 0), значимата цифра преди десетичния разделител е 0.

Значещите цифри на числото, стоящи в нормализиран вид след разделителя на целите и дробните части, се наричат ​​мантиса на числото.

Като цяло, реално число в битовата мрежа компютърможе да се представи като 4 полета.

• знак— бит, който определя знака на реално число (0 за положителни числа, 1 - за отрицателно).
• степен— определя степента на 2, по която искате да умножите число в нормализирана форма. Тъй като степента на 2 за число в нормализирана форма може да бъде положителна или отрицателна, нулевата степен на 2 в представянето на реално число съответства на стойност на отместване, която се определя като

  където n е броят на цифрите, разпределени за представяне на степента на число.

• цяло- бит, който винаги е равен на 1 за нормализирани числа, така че в някои типови представяния този бит се пропуска и се приема за равен на 1.
• мантиса— значими цифри от представянето на число, стоящи след разделителя на целите и дробните части в стандартизиран вид.

Има три основни типа представяне на реални числа в езика C:

Както се вижда от таблицата, типовете float и double нямат целочислен бит. В този случай диапазонът на представяне на реално число се състои от два диапазона, разположени симетрично спрямо нулата. Например обхватът на представяне на числата с плаваща замък може да бъде представен като:

Пример: Представете числото -178.125 в 32-битова мрежа (тип плаващ).

За да представим число в двоичната бройна система, трансформираме поотделно целите и дробните части:

178 10 = 10110010 2 .

0,125 10 = 0,001 2 .

178.125 10 = 10110010.001 2 =1.0110010001 2 111

За да конвертирате в нормализирана форма, изместете 7 бита наляво).

За да определите степента на число, използвайте смяна:

0111111+00000111 = 10000110 .

По този начин числото -178.125 ще бъде представено в битовата мрежа като

Тип символ

Типът знак съхранява кода на знака и се използва за показване на знаци в различни кодировки. Знаковите данни са посочени в кодове и по същество представляват цяло число. За съхраняване на кодове на символи в езика C се използва тип char.

Булев тип

Булевият тип се използва в логически операции, се използва в тестове на алгоритмични условия и в цикли и има две значения:

• вярно - вярно
• невярно — — невярно

Програмата трябва да декларира всички използвани данни, като посочи тяхното име и тип. Описание на данните трябва да предхожда използването им в програмата.

Пример за декларация на обект

int n; // Променлива n от целочислен тип
двойно а; // Променлива a реален типдвойна точност

За съхраняване на реални числа се използват типовете данни float (единична точност) и double (двойна точност). Значението на знаците "+" и "-" за реалните типове е същото като за целочислените типове. Последните водещи нули вдясно от десетичната запетая се игнорират. Следователно записите +523,5, 523,5 и 523,500 представляват една и съща стойност.

Има два формата, използвани за представяне на реални числа:

фиксирана точка

[знак][цяла част].[дробна част]

Например: –8.13; .168 (същото като 0,168); 183. (същото като 183.0).

плаваща запетая (експоненциална форма) мантиса E/e ред

Например: 5.235e+02 (5.235 x 102 = 523.5); –3,4E-03 (–3,4 x 10-03 = – 0,0034)

В повечето случаи се използва двоен тип; той осигурява по-висока точност от плаващия тип. Максимална прецизност и най-голям диапазон от числа се постигат с помощта на типа long double.

Стойност с модификатор тип float отнема 4 байта. От тях 1 бит се разпределя за знака, 8 бита за експонентата и 23 бита за мантисата. Имайте предвид, че най-значимият бит на мантисата винаги е 1, така че не е запълнен и следователно обхватът на модула на променлива с плаваща запетая е приблизително 3,14E–38 до 3,14E+38.

Двойна стойност заема 8 байта в паметта. Форматът му е подобен на float формата. Битовете на паметта са разпределени както следва: 1 бит за знака, 11 бита за експонентата и 52 бита за мантисата. Като се вземе предвид пропуснатият висок бит на мантисата, обхватът на модулите на стойностите на променливите с двойна точност е от 1.7E–308 до 1.7E+308.

Дълга двойна стойност е същата като двойна стойност.

Например:

6. Знаков тип данни (тип char)

В стандарта C++ няма тип данни, който може да се счита за наистина характерен. За представяне на символна информация има два типа данни, подходящи за тази цел: char и wchar_t.

Променливата char е проектирана да съхранява само един знак (например буква или интервал). В компютърната памет знаците се съхраняват като цели числа. Съответствието между символите и техните кодове се определя от таблица за кодиране, която зависи от компютъра и операционната система. Почти всички таблици за кодиране имат главни букви и малки буквиЛатинска азбука, цифри 0, ..., 9 и някои специални знаци. Най-разпространената таблица за кодиране е ASCII (американски Стандартен кодза обмен на информация - американски стандартен код за обмен на информация).

Тъй като знаците се съхраняват като цели числа в паметта на компютъра, типът char всъщност е подмножество на типа int.

1 байт се разпределя за стойност на тип знак.

Типът char може да се използва със спецификаторите със знак и без знак. Типът данни Signed char може да съхранява стойности в диапазона от -128 до 127. Когато се използва неподписан типстойностите на char могат да варират от 0 до 255. Кодирането е ASCII. Символите с кодове от 0 до 31 са служебни символи и имат независимо значение само в I/O изрази.

Стойности от тип char също се използват за съхраняване на числа от определени диапазони.

Типът wchar_t е проектиран да работи с набор от знаци, за които 1 байт не е достатъчен за кодиране, например в Unicode кодирането. Размерът на типа wchar_t е 2 байта. Ако е необходимо да се използват низови константи от типа wchar_t в програма, те се записват с префикс L, например L "Word".

Например:

char r=("A","B","C","D","E","F","\0");

IN този разделЩе бъдат разгледани основните типове данни в C++, които също се наричат ​​вградени. Езикът за програмиране C++ е разширяем език за програмиране. Терминът разширяем означава, че в допълнение към вградените типове данни можете да създавате свои собствени типове данни. Ето защо в C++ има огромно количествотипове данни. Ще проучим само основните.

Таблица 1 - Типове данни на C++

Тип	байт	Диапазон от приети стойности
целочислен (булев) тип данни
bool	1	0 / 255
целочислен (знаков) тип данни
въглен	1	0 / 255
цели типове данни
кратко вътр	2	-32 768 / 32 767
unsigned short int	2	0 / 65 535
вътр	4
unsigned int	4	0 / 4 294 967 295
дълго вътр	4	-2 147 483 648 / 2 147 483 647
unsigned long int	4	0 / 4 294 967 295
типове данни с плаваща запетая
плавам	4	-2 147 483 648.0 / 2 147 483 647.0
дълга плувка	8
двойно	8	-9 223 372 036 854 775 808 .0 / 9 223 372 036 854 775 807.0

Таблица 1 показва основните типове данни в C++. Цялата таблица е разделена на три колони. Първата колона показва запазена дума, която ще определи, всяка своя, тип данни. Втората колона показва броя на байтовете, разпределени за променлива със съответния тип данни. Третата колона показва диапазона приемливи стойности. Моля, обърнете внимание, че в таблицата всички типове данни са подредени от най-малкия до най-големия.

тип данни bool

Първият в таблицата е типът данни bool — целочислен тип данни, тъй като обхватът на валидните стойности е цели числа от 0 до 255. Но както вече забелязахте, в скоби се казва булев тип данни и това също е вярно. защото boolизползвани изключително за съхраняване на резултатите от булеви изрази. Булев израз може да има един от два резултата: вярно или невярно. вярно - ако логически израз true, false - ако логическият израз е false.

Но тъй като диапазонът от валидни стойности на типа данни bool е от 0 до 255, беше необходимо по някакъв начин да съвпадне даден диапазонс логически константи true и false, дефинирани в езика за програмиране. Така константата true е еквивалентна на всички числа от 1 до 255 включително, докато константата false е еквивалентна само на едно цяло число - 0. Да разгледаме програма, използваща типа данни bool.

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

IN ред 9декларирана променлива тип bool , който се инициализира на 25. Теоретично, следредове 9, в булева променлива трябва да съдържа числото 25, но всъщност тази променлива съдържа числото 1. Както казах, числото 0 е невярна стойност, числото 1 е истинска стойност. Въпросът е, че в променлива like bool може да съдържа две стойности - 0 (false) или 1 (true). Докато под тип данни bool е разпределен цял байт, което означава, че променлива от тип bool може да съдържа числа от 0 до 255. За да се определят неверни и истински стойности, са необходими само две стойности 0 и 1: „За какво са другите 253 стойности?“

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

True = 1 За да продължите, натиснете произволен клавиш. . .

Фигура 1 - тип данни bool

Тип данни char

Типът данни char е целочислен тип данни, който се използва за представяне на знаци. Тоест всеки знак отговаря на определено число от диапазона. Типът данни char се нарича още символен тип данни, тъй като графичното представяне на знаци в C++ е възможно благодарение на char. За представяне на знаци в C++, на типа данни char се разпределя един байт, един байт съдържа 8 бита, след което повдигаме две на степен 8 и получаваме стойността 256 - броя на знаците, които могат да бъдат кодирани. По този начин, използвайки типа данни char, можете да покажете всеки от 256 знака. Всички кодирани знаци са представени в .

ASCII (от англ. Американски стандарт Код за Information Interchange е американски стандартен код за обмен на информация.

Помислете за програма, използваща типа данни char.

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

И така, в ред 9променлива с имесимвол , му се присвоява стойността на символа"а" ( ASCII код). IN ред 10оператор cout отпечатва знака, съдържащ се в променливатасимвол IN ред 11декларира низов масив с иметониз , а размерът на масива е посочен имплицитно. Низът се съхранява в низов масив"уебсайт" . Моля, обърнете внимание, че когато запазихме символа в променлива катовъглен , след което след знака за равенство поставяме единични кавички, в които сме написали символа. При инициализиране на низов масив с определен низ се поставят двойни кавички след знака за равенство, в който е записан определен низ. Подобно на обикновен символ, низовете се извеждат с помощта на оператора cout , ред 12. Резултатът от програмата е показан на фигура 2.

Символ = низ = сайт За да продължите, натиснете произволен клавиш. . .

Фигура 2 - тип данни char

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

Целочислените типове данни се използват за представяне на числа. Има шест от тях в таблица 1: short int, unsigned short int, int, unsigned int, long int, unsigned long int . Всички те имат собствен размер на паметта и диапазон от допустими стойности. В зависимост от компилатора, размерът на заетата памет и обхватът на приетите стойности може да варира. В таблица 1 всички диапазони от приети стойности и размери на заетата памет са взети за компилатора MVS2010. Освен това, всички типове данни в таблица 1 са подредени в нарастващ ред според размера на заетата памет и диапазона от приети стойности. Диапазонът на приетите стойности, по един или друг начин, зависи от размера на заетата памет. Съответно, колкото по-голям е размерът на заетата памет, толкова по-голям е обхватът на приетите стойности. Освен това обхватът на приетите стойности се променя, ако типът данни е деклариран с неподписан префикс. Префиксът без знак означава, че типът данни не може да съхранява стойности със знак, след което диапазонът от положителни стойности се удвоява, например типовете данни short int и unsigned short int.

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

кратко — префиксът съкращава типа данни, към който се прилага, като намалява размера на паметта, която заема;

дълго — префиксът разширява типа данни, към които се прилага, като увеличава размера на паметта, която заема;

unsigned—префиксът удвоява диапазона от положителни стойности, докато диапазонът от отрицателни стойности не може да се съхранява в този тип данни.

Така че по същество имаме един целочислен тип за представяне на цели числа: типът данни int. Благодарение на префиксите short, long, unsigned се появява определено разнообразие от типове данни int, които се различават по размера на заетата памет и (или) диапазона на приетите стойности.

Типове данни с плаваща запетая

В C++ има два типа данни с плаваща запетая: float и double. Типовете данни с плаваща запетая са предназначени да съхраняват числа с плаваща запетая. Типовете данни float и double могат да съхраняват както положителни, така и отрицателни числа с плаваща запетая. Типът данни float има отпечатък от паметта, който е наполовина по-малък от този на двойния тип данни, което означава, че диапазонът от приети стойности също е по-малък. Ако типът данни float е деклариран с дългия префикс, тогава диапазонът от приети стойности ще бъде равен на диапазона от приети стойности на двойния тип данни. По принцип типовете данни с плаваща запетая са необходими за решаване на проблеми с изчисления с висока точност, например парични транзакции.

И така, разгледахме основните точки относно основните типове данни в C++. Всичко, което остава, е да се покаже откъде идват всички тези диапазони от приети стойности и размерите на заетата памет. И за това ще разработим програма, която ще изчисли основните характеристики на всички видове данни, обсъдени по-горе.

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

Тази програма е публикувана, за да можете да видите характеристиките на типовете данни във вашата система. Няма нужда да разбирате кода, тъй като програмата използва контролни изрази, с които най-вероятно все още не сте запознати. За повърхностно запознаване с програмния код, ще обясня някои точки по-долу. Оператор sizeof() Изчислява броя байтове, разпределени за тип данни или променлива. функция pow(x,y) издига смисълах на степен у , тази функция е достъпна от заглавния файл . манипулатори fixed и setprecision(). достъпен от заглавния файл . Първият е фиксиран , предава стойности във фиксирана форма към изходния поток. Манипулатор setprecision(n) показва n десетични знаци. Максималната стойност на даден тип данни се изчислява по следната формула:

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

Пример за това как работи програмата може да се види на Фигура 3. Първата колона показва основните типове данни в C++, втората колона показва размера на паметта, разпределена за всеки тип данни, а третата колона показва максималната стойност, която съответства типът данни може да съдържа. Минималната стойност се намира подобна на максималната. За типове данни с неподписан префикс минималната стойност е 0.

Тип данни байт максимална стойност bool = 1 255.00 short int = 2 32767.00 unsigned short int = 2 65535.00 int = 4 2147483647.00 unsigned int = 4 4294967295.00 long int = 4 2147483647.0 0 unsigned long int = 4 4294967295.00 float = 4 2147483647.00 двойно = 8 9223372036854775808.00 За да продължите, натиснете произволен клавиш. . .

Фигура 3 - Типове данни на C++

Ако, например, на променлива от тип short int е присвоена стойност 33000, тогава битовата решетка ще препълни, тъй като максималната стойност в променлива от тип short int е 32767. Тоест, някаква друга стойност ще бъде съхранена в променлива от тип short int, най-вероятно ще бъде отрицателен. Тъй като засегнахме типа данни int, струва си да се отбележи, че можете да пропуснете ключовата дума int и да напишете, например, само кратко. Компилаторът ще интерпретира такъв запис като short int. Същото важи и за префиксите long и unsigned. Например:

// стенограма за тип данни int short a1; // същото като short int long a1; // същото като long int unsigned a1; // същото като unsigned int unsigned short a1; // същото като unsigned short int

Последна актуализация: 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

кратко : Представлява цяло число в диапазона от –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 байта). Но във всеки случай размерът трябва да е по-голям или равен на размера на късия тип и по-малък или равен на размера на дългия тип

Този тип има синоними 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:

#включи 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 ще изведе своя цифров код вместо знак.

Стандартът C++11 добави типовете char16_t и char32_t, които са ориентирани към използване на Unicode. Нишките за работа с тези типове обаче все още не са внедрени на ниво ОС. Следователно, ако трябва да покажете стойностите на променливи от тези типове на конзолата, трябва да преобразувате променливите в типове char или wchar_t:

#включи 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:

Кратко a = -10; unsigned short b= 10; int c = -30; unsigned int d = 60; дълго е = -170; unsigned long f = 45; дълъг дълъг g = 89;

Видове числа с плаваща запетая

Типовете числа с плаваща запетая и дробни числа са представени чрез float, double и long double:

Float a = -10.45; двойно b = 0,00105; дълго двойно c = 30.890045;

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

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

Има обаче ситуации, когато е необходимо да се знае точно размера на определен тип. И за това C++ има оператор sizeof(), който връща размера на паметта в байтове, които променливата заема:

#включи int main() (дълго двойно число = 2; std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

Конзолен изход при компилиране в g++:

sizeof(число) = 12

В същото време, когато дефинирате променливи, е важно да разберете, че стойността на променливата не трябва да надхвърля границите, очертани за нейния тип. Например:

Кратко число без знак = -65535;

Компилаторът на G++, когато компилира програма с този ред, ще генерира грешка, заявяваща, че стойността -65535 не е в обхвата на валидните стойности за неподписан кратък тип и ще бъде съкратена.

Във Visual Studio компилацията може да продължи без грешки, но числовата променлива ще получи стойност 2 - резултат от преобразуването на числото -65535 в неподписан кратък тип. Тоест отново резултатът няма да е точно това, което се очаква. Стойността на една променлива е просто колекция от битове в паметта, които се интерпретират според определен тип. И за различните типове един и същи набор от битове може да се интерпретира по различен начин. Следователно е важно да се вземат предвид диапазоните на стойностите за даден тип, когато се присвоява стойност на променлива.

автоматичен спецификатор

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

Автоматично число = 5;

Въз основа на присвоената стойност, компилаторът ще направи извод за типа на променливата. Неинициализираните променливи с автоматичния спецификатор не са разрешени.

Типове данни

Типовете данни са особено важни в C#, защото това е строго типизиран език. Това означава, че всички операции подлежат на стриктна проверка на типа от компилатора и незаконните операции не се компилират. Следователно стриктната проверка на типа елиминира грешките и повишава надеждността на програмите. За да се наложи проверка на типа, всички променливи, изрази и стойности трябва да бъдат от определен тип. В този език за програмиране изобщо няма такова нещо като променлива без тип. Освен това типът на стойността определя операциите, които могат да се извършват върху нея. Операция, която е законна за един тип данни, може да не е валидна за друг.

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

Тези типове се съхраняват на различни места в паметта: типове стойности се съхраняват в област, известна като стека, а референтните типове се съхраняват в област, известна като управлявана купчина.

Нека да разгледаме стойностни типове.

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

C# дефинира девет цели числа: char, byte, sbyte, short, ushort, int, uint, long и ulong. Но типът char се използва предимно за представяне на символи и следователно се третира отделно. Останалите осем цели числа са за числени изчисления. По-долу са техните диапазони от числа и битова дълбочина:

C# цели числа

Тип	Тип CTS	Размер на бита	Обхват
байт	System.Byte	8	0:255
sbyte	System.SByte	8	-128:127
кратко	System.Int16	16	-32768: 32767
ushort	System.UInt16	16	0: 65535
вътр	System.Int32	32	-2147483648: 2147483647
uint	System.UInt32	32	0: 4294967295
дълго	System.Int64	64	-9223372036854775808: 9223372036854775807
ulong	System.UInt64	64	0: 18446744073709551615

Както показва таблицата по-горе, C# дефинира както знакови, така и неподписани варианти на различните цели числа. Типовете цели числа със знак се различават от своите неподписани двойници по начина, по който интерпретират най-значимия бит на цялото число. По този начин, ако една програма зададе стойност на цяло число със знак, C# компилаторът ще генерира код, който използва най-значимия бит от цялото число като флаг за знак. Числото се счита за положително, ако флагът на знака е 0, и за отрицателно, ако е 1.

Отрицателните числа почти винаги се представят чрез метода на допълване на двете, при който всички двоични цифри на отрицателното число първо се обръщат и след това 1 се добавя към това число.

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

Така че, ако стойността трябва да се съхранява без знак, можете да изберете за нея uint тип, за големи стойности със знак - дълъг тип, а за големи стойности без знак - тип ulong. Като пример по-долу е дадена програма, която изчислява разстоянието от Земята до Слънцето в сантиметри. За да съхрани такава голяма стойност, той използва дълга променлива:

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

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

Дълъг x = 0x12ab;

Ако има някаква несигурност дали дадена целочислена стойност е от тип int, uint, long или ulong, тогава по подразбиране int се приема. За да посочите изрично какъв друг тип цяло число трябва да има дадена стойност, следните знаци могат да бъдат добавени към число:

Uint ui = 1234U; дълъг l = 1234L; ulong ul = 1234UL;

U и L също могат да бъдат написани с малки букви, въпреки че малка L може лесно да бъде визуално объркана с числото 1 (едно).

Типове с плаваща запетая

Типовете с плаваща запетая ви позволяват да представяте числа с дробна част. В C# има два типа типове данни с плаваща запетая: плавамИ двойно. Те представляват числови стойности съответно с единична и двойна точност. По този начин ширината на плаващия тип е 32 бита, което приблизително съответства на диапазона на представяне на числа от 5E-45 до 3.4E+38. А ширината на двойния тип е 64 бита, което приблизително съответства на диапазона на представяне на числа от 5E-324 до 1.7E+308.

Типът данни с плаваща запетая е предназначен за по-малки стойности с плаваща запетая, които изискват по-малка точност. Двойният тип данни е по-голям от float и предлага по-висока степен на точност (15 бита).

Ако стойност, която не е цяло число, е твърдо кодирана в изходния код (например 12.3), тогава компилаторът обикновено приема, че е предвидена двойна стойност. Ако стойността трябва да бъде посочена като плаваща единица, ще трябва да добавите знака F (или f) към нея:

Поплавък f = 12.3F;

Десетичен тип данни

Осигурен е също десетичен тип за представяне на числа с плаваща запетая с висока точност. десетичен знак, който е предназначен за използване във финансови изчисления. Този тип има ширина от 128 бита за представяне на числови стойности, вариращи от 1E-28 до 7,9E+28. Вероятно знаете, че обикновената аритметика с плаваща запетая е предразположена към грешки при десетично закръгляване. Тези грешки се елиминират чрез използване на десетичен тип, който позволява числата да бъдат представени до 28 (и понякога 29) знака след десетичната запетая. Тъй като този тип данни може да представлява десетични стойности без грешки при закръгляване, той е особено полезен за финансови изчисления:

Използване на системата; използване на System.Collections.Generic; използване на System.Linq; използване на System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( // *** Изчисляване на цената на инвестиция с *** // *** фиксирана норма на възвръщаемост*** десетични пари, процент; int i; const байт години = 15; пари = 1000.0m; процент = 0.045m;

Резултатът от тази програма ще бъде:

Символи

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