Основните типове данни

Както видяхме досега обектите са съставени от два вида компоненти - обектните променливи и функциите на класа. В тази лекция ще се спрем по-специално на обектните променливи и техния тип.

В C++ има седем предефинирани основни типове данни, които са дадени в таблица 1. Програмистът не трябва да се грижи за тяхната дефиниция и може директно да декларира променливи от тези типове:

  1. char alphanumeric;
  2. short day_of_week;
  3. int count;
  4. float pi;
  5. double volume;
  6. long double war_budget;

Таблица 1. C++ типове данни.
--------------------------------------------------------------------------------
Име на типа      съхранява (на английски)         пример
--------------------------------------------------------------------------------
char             символ (character)               `a`, `B`, `$`, `9`, ` `
short            малки цели числа                 7, 30,000, -222
int              средни цели числа                също като short или като long
long             големи цели числа                1,234,567,890, -987,654,111
float            малки реални числа               13.7, 199.99, -6.2, 0.000231
double           големи реални числа              7,553.393.95,47, -0.046754364
long double      извънаредно големи реални числа  9,312,455,679,012,354.436
--------------------------------------------------------------------------------

!Оператор за присвояване (Assignment Operator). Знакът равно, =, който ще срещнете в следващия текст, предизвиква стойността на променливата или израза, които са отдясно да бъде присвоена на променливата, която се намира отляво на знака. Това е оператор, включен в израз, а не равенство. Т.е. ако имаме присвояването a = 2*a - 3;  това съвсем не означава, че a е равно на 3, а просто новата стойност на a е равна на два пъти старата, намалена с три! Забележете разликата с езика Pascal, където = означава логически оператор, а операторът за присвояване е := , две точки и равно. В C++ операторът за логическо равенсто е ==, двойно равно.

1. Тип символ (char). Променливите или константите от този тип съхраняват точно един символ. Изразите по-долу дефинират три променливи от тип символ.

  1. char alphanumeric;
  2. char letter;
  3. char number;

А трите израза по-долу присвояват стойности на съответните променливи.

  1. alphanumeric = `a`;
  2. letter = alphanumeric;
  3. number = `1`;

Двата израза `a` и `1` са константи от тип символ и съдържат символ, заграден в апостроф (single quote): втората константа съвсем не е числото едно, а просто символ, който изобразява това число. Целочислената стойност на това число е различна от едно и тя е равна на 49. Т.е. ако запишем number = 49; то ще имаме същият ефект, като присвояването number = `1`;.

Някои специални символи могат да се въведат с помощта на обратно наклонената черта (back slash) и част от тях са дадени в таблица 2.

Таблица 2. Някои специални символи (escape sequence) в C++.
--------------------------------------------------------------------------------
Специален символ     Реален символ
--------------------------------------------------------------------------------
` `                 Нов ред, клавиша ритърн (New line)
` `                 Клавиша табулация (Tab)
``                 Обратно (Backspace)
` `                 Каретата обратно (Carriage return)
`e`                 Клавиша <Esc>  [escape (hex 1B)]
`f`                 Нов формуляр (лист) [formfeed (hex 0C)]
`\`                 (Back slash)
`\xhh`              символ с хексадесетичен код hh (character with hex code hh)
`\ddd`              символ с октичен код ddd (character with octal code ddd)
---------------------------------------------------------------------------------

Променливите от тип символ се използват за съхранение на изключително малки числа, по-точно от -128 до 127, и заемат 8 бита (1 байт) в паметта на компютъра.

2. Целочислени типове (integers). Тези променливи позволяват съхранението на по-големи целочислени числа: обхватът на стойностите е даден в таблица 3. Типът символ също е включен в таблицата, тъй като по традиция той се води целочислен тип.

Таблица 3. Целочислените типове в C++.
--------------------------------------------------------------------------
Тип    размер                интервал на стойностите
--------------------------------------------------------------------------
char   1 byte (8 bits)                -128 до 127
short  2 bytes (16 bits)           -32,768 до 32,767
int    като short на 16 битовите системи, и като long на 32-bit systems
long   4 bytes (32 bits)    -2,147,483,648 до 2,147,483,647
--------------------------------------------------------------------------

Ето пример за използване на променливи от трите типа

  1. short NumAtoms;
  2. int MilesDriven;
  3. long population;
  4. NumAtoms  = 109;
  5. MilesDriven = 1024;
  6. population = 243345566L;

Числовите константи, които стоят отдясно на изразите за присвояване, се пишат без разделителните запетаи (както е прието в някои страни - 243,345,566) или без интервалите между всеки три цифри (както понякога у нас се означават големите числа -- 243 345 566). Символът L в последното присвояване служи да се обозначи, че константата 243345566 е от тип long.

3. Неотрицателни целочислени типове (unsigned integers). При добавяне на unsigned пред тях от горните типове се получават нови четири целочислени типа, които могат да имат само неотрицателни стойности (т.е. вкючително нула). Те са дадени в таблица 4.
 

Таблица 4. Неотрицателни целочислените типове в C++.
--------------------------------------------------------------------
тип               размер                  интервал на стойностите
--------------------------------------------------------------------
unsigned char    1 byte (8 bits)                   0 до 255
unsigned short   2 bytes (16 bits)              0 до 65,535
unsigned int     като unsigned short на 16 битовите системи,
                 и като unsigned long на 32-те
unsigned long   4 bytes (32 bits)       0 до 4,294,967,295
--------------------------------------------------------------------

Само с unsigned се означа типа unsigned int. По подразбиране, без думата unsigned целочислените типове са със знак, но те могат да се означат така и с използване на думата signed, но това на практика никога не се прави от програмистите.

4. Типове с плаваща запетая (floating point). Те се използват за означаване на реални числа, т.е. числа които имат целочислена част отляво на десетичния знак и дробна част, отдясно на десетичния знак, например 5.237, -123.98709, -.000234, 9876543. и т.н. Тези числа освен по този начин могат да се запишат и в експоненциална форма като 5.237E0, -1.2398709e2, -2.34E-4 и 9.876543e6>. Е идва от exponent и няма значение дали е с малка или голяма буква, то просто означава 10 на едикоя си степен.

Трите типа са дадени в таблица 5, където се вижда техния обхват и колко значещи цифри имат. Трябва да се отбележи, че има голяма разлика между множеството на реалните числа от математиката и това на числата от, да кажем, double. Докато между всеки две реални числа винаги може да се намери друго реално число, без значение колко са близки те по стойност, то това не е така при компютрите. Ако се замислите върху казаното и анализирате данните от последните две колони в таблица 5 ще откриете, че числата от някакъв тип с плаваща запетая се сгъстяват до нулата и се разреждат далеч от нулата - например двете числа от тип float 1.12345 и 1.12344се различават само с 0.00001, докато числата  1.12345е38 и 1.12344е38 се различават с милиарди милиарди ... милиарди (1033). Тази разлика не е само от теоретично значение, а дава и някои усложнения при програмиране на различните математически алгоритми.

Таблица 5. Типовете с плаваща запетая.
-------------------------------------------------------------------
тип          размер               обхват                 точност
-------------------------------------------------------------------
float         4 bytes (32 bits)   10-38 to 1038          5 числа
double        8 bytes (64 bits)   10-308 to 10308       15 числа
long double  10 bytes (80 bits)   10-4932 to 104932     19 числа
-------------------------------------------------------------------

Ето няколко примера за декларация на различни променливи от тези типове и последващото им присвояване на стойности:

  1. pi_float;
  2. double pi_double;
  3. long double pi_long_double;
  4. pi_float = 3.1415;
  5. pi_double = 3.14159265358979;
  6. pi_long_double = 3.141592653589793238;

Тези 6 израза могат да се съкратят на три по следния начин:

  1. float pi_float             = 3.1415;
  2. double pi_double           = 3.14159265358979;
  3. long double pi_long_double = 3.141592653589793238;

Това също може да се извърши и с целочислените променливи, които разгледахме по-горе:

  1. short NumAtoms = 109;
  2. int MilesDriven = 1024;
  3. long population = 243345566L;

5. Разделители (whitespaces). Компилаторът не възразява, ако вместо един интервал сложите повече интервали. Обикновенно това се прави за по-прегледен код, който се възприема по-лесно: вижте по-горе трите дефиниции на числото пи (p). Интервалите (spaces), табулациите ( tabsnew lines) представляват така наречените разделители, които отделят различните оператори и ключови думи в програмата. Те се игнорират от компилатора и правят кода много по-разбираем и четлив.

6. Коментари (comments). Последно ще се спрем на коментарите при програмите. Това са специални символи, които означават текст, който не трябва да се компилира от компилатора. Със символите /* се започва коментар, а с */ - се завършва, т.е. всичко написано между тях не се компилира от компилатора. Друг начин е използване на две наклонени черти, //, след които всичко написано не се компилира. За примери вижте в програмата, дадено по-долу.

Ето накрая и една елементарна програма, която илюстрира някои от казаните неща за типовете данни:

  1. // test.cpp
  2. // демострира целочислни типове, типове с плаваща запетая и коментари
  3. // demonstrates integers, floating points and comments
  4. #include <iostream.h>                   // for cout and endl
  5. #include <conio.h>                      // for getch()
  6. void main(int argc, char* argv[] )
  7. {
  8.   // изкарване на екрана на `1` и `2`, разделени с табулация
  9.   cout << `1` << ` ` << `2` << `
  10. `    // забележете липсата на точка и запетая
  11.   // и последващо изкарване на нов ред на екрана на `3` и `4`, разделени с табулация
  12.        << `3` << ` ` << `4` << `
  13. ` << endl;
  14.   // шестнадесетично означаване на `1` и `2`, и октично за `3` и `4`
  15.   cout << `x31` << ` ` << `x32` << `
  16. ` << `63` << ` ` << `64` << `
  17. ` << endl;
  18.   int k, i = 4;
  19.   cout << "i = " << i << " k = " << k << endl;
  20.   k = 2*k + 3;
  21.   i = k;
  22.   cout << "i = " << i << " k = " << k << endl;
  23.   char number1, number2;
  24.   number1 = `1`;
  25.   number2 = 49;
  26.   cout << number1 << ` ` << number2 << endl;
  27.   float x = -.000234;
  28.   cout << "x = " << x << endl;
  29.   float y = -2.34E-4;
  30.   cout << "y = " << y << endl;
  31.   // тази функция чака натискането на клавиш от клавиатурата
  32.   getch();
  33. }   // main()

Проф. Процесор Аритметиков, Програмен език C++. [Част 03], Списание "Коснос", брой 11, 2007 г