Типове C ++

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

Паметта на компютъра е поредица от клетки. Всяка клетка има размера на един байт, обикновено това е пространството, заемано от западноевропейски характер. Размерът на обекта е даден в байтове. Тази статия дава обобщение на типовете C ++. Вече трябва да имате основни познания по C ++, за да разберете тази статия.

Съдържание на статията

- Основни типове
- Начини за конструиране на типове съединения
- Масиви
- Изброяване
- Клас
- Съюз
- Препратки
- Функции
- Други видове съединения
- Заключение

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

Фундаменталните типове са скаларни типове.

bool

Булев тип или тип bool има стойност true или false за 1 или 0. Вярно или невярно заема един байт.

char, неподписан char и подписан char

Символът обикновено е за един западноевропейски герой. Обикновено заема един байт. Има и неподписан и подписан знак, който е осем-битово цяло число. Неподписаните символи не включват отрицателни стойности, докато подписаните символи включват отрицателни стойности. Видът стойност, който притежава char, зависи от компилатора и може просто да е неподписан char. Тези три типа символи се наричат тесни типове символи и всеки заема един байт.

Цяло число

Има пет неподписани стандартни цели числа и пет подписани стандартни цели числа. Петте неподписани цели числа са: „неподписан char“, „неподписан къс int“, „неподписан int“, „неподписан дълъг int“ и „неподписан дълъг дълъг int“. Петте съответни типа подписани цели числа са: „подписан char“, „short int“, „int“, „long int“ и „long long int“.

„Неподписан знак“ е от същия тип като типовите типове символи (виж по-горе). „Подписан знак“ е другият тип от тесните типове символи (виж по-горе).

С компилатора на g ++ „unsigned char“ или „подписан char“ заема един байт; „Unsigned short int“ или „short int“ заема два байта; “Unsigned int” или “int” заема четири байта; „Unsigned long int“ или „long int“ заема 8 байта; „Unsigned long long int“ или „long long int“ все още заема 8 байта (към момента).

char16_t, char32_t, wchar_t

Когато се занимавате със западноевропейски символи, типът char е достатъчен в много ситуации. При работа с китайски и други източни езици обаче са необходими char16_t, или char32_t, или wchar_t. С компилатора g ++ char16_t заема два байта; char32_t заема четири байта, а wchar_t също заема четири байта.

Bool, char, char16_t, char32_t, wchar_t, подписаните и неподписаните цели числа образуват друг набор, наречен интегрални (цели числа) типове.

На този етап в статията бяха споменати два колективни типа: тесни типове символи и интегрални типове.

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

Да приемем, че числата 457 000 и 457 230 са еднакви показания, измерени от два различни измервателни уреда. 457 230 е по-точно от 457 000, защото стойността е по-подробна (включва по-малки места: + 200 плюс 30). Число с плаваща запетая е число с дробна (десетична) част. Въпреки че числата в компютъра са последователност от битове, някои числа с плаваща запетая са по-точни от другите.

Някои измервателни уреди правят измервания с минимални стъпки, да кажем 10 единици. Такъв инструмент ще има следните показания: 10, 20, 30, 40, ... 100, 110, 130, 140, ... 200, 210, 220, 230, 240 и т.н. Въпреки че числата в компютъра са последователност от битове, числата с плаваща запетая варират в някои минимални стъпки (много по-малки от 10 единици).

C ++ има три типа с плаваща запетая, които са: float, double и long double. За всеки компилатор, double трябва да има прецизността, която е по-висока от тази на float или поне тази на float; long double трябва да има точност, която е по-висока от тази на double или поне тази на double.

Има трето общо име: аритметичен тип. Това е името на интегрални и типове с плаваща запетая. Имайте предвид, че това е и името на всички скаларни типове, както беше обяснено досега.

С компилатора на g ++ броят на байтовете за поплавък е четири; броят на байтовете за двойно е осем; броят на байтовете за дълъг дубъл е шестнадесет.

void Тип

С компилатора на g ++ размерът на типа void е един байт. Байтът официално няма битове, което означава, че местоположението му има празно съдържание.

Начини за конструиране на типове съединения

Съставните типове са не-фундаментални типове. Това означава, че съставните типове са не скаларни типове. Този раздел обяснява основите на типовете съединения.

Масиви

Следният кодов сегмент показва масив от ints и масив от символи:

int arrInt [] = 1, 2, 3, 4, 5;
char arrCha [] = 'a', 'b', 'c', 'd', 'e';
Cout << arrInt[2] <<" <Резултатът е: 3 c.

Изброяване

Изброяването е тип с имена на константи. Помислете за следния кодов сегмент:

enum a = 3, b, c;
Cout << b <<'\n';

Резултатът е: 4. Първият ред на кодовия сегмент е изброяване, а a, b или c е изброител.

Клас

Класът е обобщена единица, от която могат да бъдат създадени (инстанцирани) много обекти от една и съща обобщена единица. Следващата програма показва клас и два обекта, създадени от него. Такъв обект се различава от скаларен обект.

#include
използване на пространство от имена std;
клас TheCla

публично:
int num = 5;
int fn ()

номер на връщане;

;
int main ()

TheCla obj1;
TheCla obj2;
Cout << obj1.num << " << obj2.num <<'\n';
връщане 0;

Резултатът е: 5 5. Името на класа е TheCla, а имената на двата обекта са obj1 и obj2. Забележете точката с точка и запетая непосредствено след описанието (дефиницията) на класа. Обърнете внимание как двата обекта са били създадени във функцията main ().

Забележка: num е член на данни, а fn е член функция.

Съюз

структура

Структурата е като масив, но вместо да има двойки индекс / стойност, тя има двойки име / стойност. Имената могат да бъдат написани в произволен ред. Следващата програма показва структура и нейното използване:

#include
използване на пространство от имена std;
struct TheCla

int num = 5;
float flt = 2.3;
char ch = 'a';
obj1, obj2;
int main ()

Cout << obj2.num <<", "<< obj2.flt <<", "<< obj2.ch <<'\n';
връщане 0;

Резултатът е:

5, 2.3, а

Името на структурата е TheCla. obj1 и obj2 са два различни обекта на структурата.

Съюз

Следващата програма показва обединение и неговото използване:

#include
използване на пространство от имена std;
съюз TheCla

int num;
float flt = 2.3;
char ch;
obj1, obj2;
int main ()

Cout << obj2.flt <<'\n';
връщане 0;

Резултатът е: 2.3. Съюзът е подобен на структура. Основната разлика между структурата и обединението е, че за структура само един член може да има стойност (инициализирана) по всяко време. В горната програма членът flt има стойност 2.3. Всеки от останалите членове, num или ch, може да има стойност следваща само ако стойността за flt е изоставена.

Препратки

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

int id = 5;
int & ref1 = id;
int & ref2 = id;
Cout << id << " << ref1 << " << ref2 <<'\n';

Резултатът е: 5 5 5. ref1 и ref2 са синоними на id.

lvalue справка и rvalue справка

Горните препратки са препратки lvalue. Следният код показва препратка към rvalue:

int && ref = 5;
Cout << ref <<'\n';

Резултатът е: 5. Тази справка се създава, без да се идентифицира място в паметта. За да се постигне това, е необходимо двойно &, т.е.д., &&.

Показалец

Указателят всъщност не е C ++ обект. Той обаче предоставя по-добра схема за справяне с референции. Следният код показва как може да се създаде указател:

int ptdId = 5;
int ptdId = 5;
int * ptrId;
ptrId = &ptdId;
Cout << *ptrId <<'\n';

Резултатът е: 5. Обърнете внимание на разликата в името между ptdId и ptdId. ptdId е посоченият обект, а ptrId е указателният обект. & ptdId връща адреса на посочения обект, който е присвоен на ptrId. За да върнете стойността на посочения обект, използвайте * ptrId.

Функции

Основна функция и нейното повикване

Следният код показва основна дефиниция на функцията и нейното повикване:

#include
използване на пространство от имена std;
int fn (int номер)

Cout<<"seen"<<'\n';
номер на връщане;

int main ()

int ret = fn (5);
Cout << ret <<'\n';
връщане 0;

Изходът е

дефиниция на функция

Извикването на функцията е fn (5). Името на функцията е fn.

Справка и указател към функция

& fn връща адреса в паметта на функцията, чието име е fn. Следният оператор декларира указател към функция:

int (* func) ();

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

func = &fn;

Следващата програма въвежда справка за функция и указател в действие:

#include
използване на пространство от имена std;
int fn (int номер)

/ * някои твърдения * /
номер на връщане;

int main ()

int (* func) (int);
func = &fn;
int ret = func (5);
Cout << ret <<'\n';
връщане 0;

Резултатът е: 5. Имайте предвид, че и fn, и func имат параметъра int в декларацията.

Други видове съединения

Горните основни типове съединения са съставни сами по себе си. Те също се използват за конструиране на сложни типове съединения.

typedef

Запазената дума typedef се използва за замяна на поредица от типове с едно име (за поредицата). Следният кодов сегмент илюстрира това:

typedef unsigned long int IduIL;

IduIL myInt = 555555555555555555;
Cout << myInt <<'\n';

Изходът е 55555555555555555555. В кода IduIL се превърна в тип, който означава „unsigned long int“.

Структурирано подвързване

Структурираното обвързване е функция, която прави възможно имената да се дават на подобекти. Следният код илюстрира това за масива:

int arr [3] = 1, 2, 3;
автоматично [x, y, z] (arr);
Cout << x <<"<< y <<"<< z <<'\n';

Резултатът е 1 2 3. И така, стойностите: 1, 2, 3 са получили имената, x, y, z. Обърнете внимание на употребата и позицията на запазената дума, автоматично. Също така обърнете внимание на използването на квадратните скоби.

Битово поле

Паметта е последователност от клетки. Всяка клетка взема байт. Също така, всеки байт се състои от осем бита. Може да се задава и променя група битове, не непременно осем бита. Такава група се нарича битово поле. Тези групи щяха да лежат една до друга. Ако групите не съставят тип, да кажем 16 бита за кратко int, се добавят битове за подплата. Следният код илюстрира това със структурата:

struct Дата

неподписан кратък wkDay: 3; // 3 бита
неподписан кратък понеделник: 6; // 6 бита
неподписан кратък пн: 5; // 5 бита
неподписан кратък год: 8; // 8 бита за 2-цифрена година
dte;
dte.wkDay = 1; dte.monDay = 2; dte.mon = 2; dte.yr = 21;
Cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';

Изходът е: 2/2/21. Общият брой битове за wkDay, MonDay и mon е 3 + 6 + 5 = 14. Така че, два бита за подплата ще бъдат добавени, за да се получат 16 бита за краткото цяло число от 2 байта (16 бита). Следващите 8 бита започват следващия кратък int, който след това се запълва с 8 бита за подплата.

Забележка: Избягвайте да използвате битови полета; използвайте го само за изследвания.

Пространство от имена

Пространството от имена е набор от имена, който не трябва да влиза в конфликт със същите имена на други набори от имена. Следващата програма илюстрира използването на едни и същи имена от две различни пространства от имена, приложени в пространството от имена на функцията main ():

#include
използване на пространство от имена std;
пространство от имена NS1

int myInt = 8;
float flt;

пространство от имена NS2

int myInt = 9;
float flt;

int main ()

Cout << NS1::myInt << '\n';
Cout << NS2::myInt << '\n';
NS1 :: flt = 2.5;
NS2 :: flt = 4.8;
Cout << NS1::flt << '\n';
Cout << NS2::flt << '\n';
връщане 0;

Резултатът е:

2.5

4.8

В кода има две противоречащи еднакви имена на int и две противоречащи си имена с плаваща запетая.

Шаблон и шаблонна специализация

Схемата на шаблона позволява използването на заместител за различни възможни скаларни типове. Специализацията е избор на определен скаларен тип. Следният код илюстрира това за функция:

#include
използване на пространство от имена std;
шаблон void func (T cha, U no)

Cout << "I need bread for " << cha << no << '.' << '\n';

int main ()

func ('$', 3);
връщане 0;

Резултатът е:

„Имам нужда от хляб за 3 долара.”

Пакет с параметри на шаблона

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

Заключение

Типовете C ++ съществуват в две категории: основни типове и съставни типове. Фундаменталните типове са скаларни типове. Основните типове съединения са масиви, изброявания, класове, обединения, препратки, указатели и функции. Тези основни типове съединения се използват за изграждане на сложни типове съединения, които са typedef, структурирани обвързвания, битови полета, пространство от имена и характеристики на шаблона.

Chrys