Част 3. Основните типове данни
Както видяхме досега обектите са съставени от два вида компоненти - обектните променливи и функциите на класа. В тази лекция ще се спрем по-специално на обектните променливи и техния тип.
В C++ има седем предефинирани основни типове данни, които са дадени в таблица 1. Програмистът не трябва да се грижи за тяхната дефиниция и може директно да декларира променливи от тези типове:
char
alphanumeric;
short
day_of_week;
int
count;
float
pi;
double
volume;
long
double war_budget;
Таблица 1. C++
типове данни.
--------------------------------------------------------------------------------
Име на типа
съхранява (на английски)
пример
--------------------------------------------------------------------------------
char
символ (character)
'a', 'B', '$', '9', '\n'
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). Променливите или константите от този тип съхраняват точно един символ. Изразите по-долу дефинират три променливи от тип символ.
char
alphanumeric;
char
letter;
char
number;
А трите израза по-долу присвояват стойности на съответните променливи.
alphanumeric
= 'a';
letter
= alphanumeric;
number
= '1';
Двата израза 'a' и '1' са константи от тип символ и съдържат символ, заграден в апостроф (single quote): втората константа съвсем не е числото едно, а просто символ, който изобразява това число. Целочислената стойност на това число е различна от едно и тя е равна на 49. Т.е. ако запишем number = 49; то ще имаме същият ефект, като присвояването number = '1';.
Някои специални символи могат да се въведат с помощта на обратно наклонената черта (back slash) и част от тях са дадени в таблица 2.
Таблица 2. Някои специални символи
(escape sequence) в C++.
--------------------------------------------------------------------------------
Специален символ
Реален символ
--------------------------------------------------------------------------------
'\n'
Нов ред, клавиша ритърн (New line)
'\t'
Клавиша табулация (Tab)
'\b'
Обратно (Backspace)
'\r'
Каретата обратно (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
--------------------------------------------------------------------------
Ето пример за използване на променливи от трите типа
short
NumAtoms;
int
MilesDriven;
long
population;
NumAtoms
= 109;
MilesDriven
= 1024;
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 числа
-------------------------------------------------------------------
Ето няколко примера за декларация на различни променливи от тези типове и последващото им присвояване на стойности:
pi_float;
double
pi_double;
long
double pi_long_double;
pi_float
= 3.1415;
pi_double
= 3.14159265358979;
pi_long_double
= 3.141592653589793238;
Тези 6 израза могат да се съкратят на три по следния начин:
float
pi_float
= 3.1415;
double
pi_double =
3.14159265358979;
long
double pi_long_double = 3.141592653589793238;
Това също може да се извърши и с целочислените променливи, които разгледахме по-горе:
short
NumAtoms = 109;
int
MilesDriven = 1024;
long
population = 243345566L;
5. Разделители (whitespaces). Компилаторът не възразява, ако вместо един интервал сложите повече интервали. Обикновенно това се прави за по-прегледен код, който се възприема по-лесно: вижте по-горе трите дефиниции на числото пи (p). Интервалите (spaces), табулациите ( tabsnew lines) представляват така наречените разделители, които отделят различните оператори и ключови думи в програмата. Те се игнорират от компилатора и правят кода много по-разбираем и четлив.
6. Коментари (comments). Последно ще се спрем на коментарите при програмите. Това са специални символи, които означават текст, който не трябва да се компилира от компилатора. Със символите /* се започва коментар, а с */ - се завършва, т.е. всичко написано между тях не се компилира от компилатора. Друг начин е използване на две наклонени черти, //, след които всичко написано не се компилира. За примери вижте в програмата, дадено по-долу.
Ето накрая и една елементарна програма, която илюстрира някои от казаните неща за типовете данни:
//
test.cpp
//
демострира целочислни типове, типове с плаваща запетая и коментари
//
demonstrates integers, floating points and comments
#include
<iostream.h>
// for cout and endl
#include
<conio.h>
// for getch()
void
main(int argc, char* argv[] )
{
// изкарване на екрана на '1' и '2', разделени с табулация
cout << '1' << '\t' << '2' << '\n'
// забележете липсата на точка и запетая
// и последващо изкарване на нов ред на екрана на '3' и '4', разделени
с табулация
<< '3' << '\t' << '4' << '\n' << endl;
// шестнадесетично означаване на '1' и '2', и октично за '3' и '4'
cout << '\x31' << '\t' << '\x32' << '\n' <<
'\63' << '\t' << '\64' << '\n' << endl;
int k, i = 4;
cout << "i = " << i << " k = " << k << endl;
k = 2*k + 3;
i = k;
cout << "i = " << i << " k = " << k << endl;
char number1, number2;
number1 = '1';
number2 = 49;
cout << number1 << '\t' << number2 << endl;
float x = -.000234;
cout << "x = " << x << endl;
float y = -2.34E-4;
cout << "y = " << y << endl;
// тази функция чака натискането на клавиш от клавиатурата
getch();
}
// main()
Формалните дефиниции на новите понятия (на английски и български) в тази и предишните лекции може да намерите в този материал.
Автор: Проф. Процесор Аритметиков
Keywords: С++,
OOP programming , C++ , Classes , Inheritance , Reusability , Creating
New Data Types , Polymorphism and Overloading
Ключови думи: клас
, обект, обектно ориентирано програмиране,