C ++ típusok

A C ++ entitás érték, objektum, referencia, függvény, felsoroló, típus, osztálytag, bitmező, strukturált kötés, névtér, sablon, sablonspecializáció vagy paramétercsomag. Az entitás lehet egy vagy több típus. A C ++ típusoknak két kategóriája van: az alapvető és az összetett típusok. A skalár számtani vagy mutató objektumtípus. Az alapvető típusok skalárok, míg a többi entitástípus összetett típus.

A számítógép memóriája sejtek sorozata. Minden cellának egy bájtja van, ez általában egy nyugat-európai karakter által elfoglalt hely. Az objektum méretét bájtokban adják meg. Ez a cikk összefoglalja a C ++ típusokat. A cikk megértéséhez már rendelkeznie kell a C ++ alapismereteivel.

A cikk tartalma

- Alapvető típusok
- A vegyülettípusok felépítésének módjai
- Tömbök
- Felsorolás
- Osztály
- Unió
- Hivatkozások
- Funkciók
- Egyéb vegyülettípusok
- Következtetés

Alapvető típusok

Az alapvető típusok skaláris típusok.

bool

A logikai típusú vagy logikai típus értéke 1 vagy 0 értéke true vagy false. Az igaz vagy hamis egy bájtot foglal el.

char, aláíratlan char és aláírt char

A char általában egy nyugat-európai jellegű. Tipikusan egy bájtot foglal el. Van egy aláíratlan és aláírt karakter is, amelyek mindegyike nyolc bites egész szám. Az aláíratlan karakterek nem tartalmaznak negatív értékeket, míg az aláírt karakterek negatív értékeket tartalmaznak. Az, hogy egy karakter milyen értékkel rendelkezik, a fordítótól függ, és lehet, hogy csak egy előjel nélküli karakter. Ezt a három karaktertípust szűk karaktertípusnak nevezzük, és mindegyik egy bájtot foglal el.

Egész szám

Öt előjel nélküli szabványos egész típusú és öt aláírt szabványos egész típusú típus létezik. Az öt előjel nélküli egész típusú típus: „unsigned char”, „unsigned short int”, „unsigned int”, „unsigned long int” és „unsigned long long int”. Az öt megfelelő előjelű egész számtípus: „jelzett char”, „rövid int”, „int”, „long int” és „long long int”.

Az „előjel nélküli karakter” azonos a keskeny karaktertípusokkal (lásd fent). Az „aláírt karakter” a keskeny karaktertípusok másik típusa (lásd fent).

A g ++ fordítóval az „előjel nélküli karakter” vagy az „aláírt karakter” egy bájtot foglal el; Az „előjel nélküli rövid int” vagy a „rövid int” két bájtot foglal el; Az „aláíratlan int” vagy az „int” négy bájtot foglal el; Az „előjel nélküli hosszú int” vagy a „hosszú int” 8 bájtot foglal el; Az „aláíratlan hosszú hosszú int” vagy a „hosszú hosszú int” még mindig 8 bájtot foglal el (a jelenlegi állapot szerint).

char16_t, char32_t, wchar_t

Nyugat-európai karakterekkel foglalkozva a char típus sok helyzetben elegendő. Ha azonban kínai és más keleti nyelvekkel foglalkozunk, akkor a char16_t vagy char32_t vagy wchar_t szükséges. A g ++ fordítóval a char16_t két bájtot foglal el; A char32_t négy bájtot foglal el, a wchar_t pedig szintén négy bájtot foglal el.

A bool, a char, a char16_t, a char32_t, a wchar_t, az aláírt és az előjel nélküli egész típusú típusok egy másik halmazt alkotnak, az integrál (egész) típusokat.

A cikk ezen a pontján két kollektív típust említettek: a keskeny karaktertípusokat és az integrált típusokat.

Lebegőpontos típusok

Tegyük fel, hogy a 457 000 és a 457 230 szám ugyanaz, két különböző mérőműszerrel mérve. A 457 230 pontosabb, mint a 457 000, mert az érték részletesebb (kisebb helyekre vonatkozik: + 200 plusz 30). A lebegőpontos szám egy törtrészes (tizedes) részű szám. Noha a számítógép számai bitek sorozata, néhány lebegőpontos szám pontosabb, mint a többi.

Egyes mérőeszközök méréseket végeznek minimális lépésekben, mondjuk 10 egységben. Egy ilyen műszer a következő olvasmányokkal rendelkezik: 10, 20, 30, 40,… 100, 110, 130, 140,… 200, 210, 220, 230, 240 stb. Noha a számítógép számai bitek sorozata, a lebegőpontos számok bizonyos minimális lépésekben mozognak (jóval kisebbek, mint 10 egység).

A C ++ három lebegőpontos típussal rendelkezik: úszó, kettős és hosszú kettős. Bármely fordító számára a dupla pontosságának nagyobbnak kell lennie, mint az úszó vagy legalább az úszó pontossága; A hosszú dupla pontosságának nagyobbnak kell lennie, mint a dupla, vagy legalább a dupla pontosságának.

Van egy harmadik gyűjtőnév: számtani típus. Ez a neve az integrál és a lebegőpontos típusoknak. Ne feledje, hogy ez az összes skaláris típus neve is, ahogyan azt eddig elmagyarázták.

A g ++ fordítóval az úszó bájtjainak száma négy; a dupla bájtjainak száma nyolc; a hosszú dupla bájtjainak száma tizenhat.

érvénytelen Type

A g ++ fordítóval a void típus mérete egy bájt. A bájtnak hivatalosan nincs bitje, vagyis helyének üres tartalma van.

A vegyülettípusok felépítésének módjai

Az összetett típusok nem alapvető típusok. Ez azt jelenti, hogy az összetett típusok nem skaláris típusok. Ez a szakasz az összetett típusok alapjait ismerteti.

Tömbök

A következő kódszegmens egy tömböt mutat be és egy karakterjelet:

int arrInt [] = 1, 2, 3, 4, 5;
char arrCha [] = 'a', 'b', 'c', 'd', 'e';
cout << arrInt[2] <<" <A kimenet: 3 c.

Felsorolás

A felsorolás egy típus, megnevezett konstansokkal. Vegye figyelembe a következő kódszegmenst:

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

A kimenet: 4. A kódszegmens első sora felsorolás, a, b vagy c pedig felsoroló.

Osztály

Az osztály egy általánosított egység, amelyből ugyanazon általánosított egység sok objektuma létrehozható (példányosítható). A következő program egy osztályt és két objektumot mutat, belőlük példányosítva. Egy ilyen objektum különbözik a skaláris objektumtól.

#include
névtér használata std;
osztály TheCla

nyilvános:
int szám = 5;
int fn ()

visszatérési szám;

;
int main ()

TheCla obj1;
TheCla obj2;
cout << obj1.num << " << obj2.num <<'\n';
visszatér 0;

A kimenet: 5 5. Az osztály neve TheCla, a két objektum neve obj1 és obj2. Jegyezze fel a pontosvesszőt közvetlenül az osztály leírása (meghatározása) után. Vegye figyelembe, hogy a két objektum hogyan lett példányosítva a main () függvényben.

Megjegyzés: a num egy adattag, az fn pedig egy tagfüggvény.

Unió

strukturált

A struktúra olyan, mint egy tömb, de ahelyett, hogy index / érték párokkal rendelkezne, név / érték párokkal rendelkezik. A nevek tetszőleges sorrendben írhatók. A következő program bemutatja a struktúrát és annak használatát:

#include
névtér használata std;
strukturálja a TheCla

int szám = 5;
úszó flt = 2.3;
char ch = 'a';
obj1, obj2;
int main ()

cout << obj2.num <<", "<< obj2.flt <<", "<< obj2.ch <<'\n';
visszatér 0;

A kimenet:

5, 2.3, a

A struktúra neve TheCla. Az obj1 és az obj2 a struktúra két különböző objektuma.

Unió

A következő program bemutatja az uniót és annak használatát:

#include
névtér használata std;
szakszervezet TheCla

int szám;
úszó flt = 2.3;
char ch;
obj1, obj2;
int main ()

cout << obj2.flt <<'\n';
visszatér 0;

A kimenet: 2.3. Az unió hasonló a struktúrához. A fő különbség a struktúra és az unió között az, hogy egy struktúrához egyszerre csak egy tagnak lehet értéke (inicializálva). A fenti programban a tag, flt értéke 2.3. A többi tagnak, num vagy ch, csak akkor lehet értéke, ha elhagyjuk az flt értékét.

Hivatkozások

A referencia az azonosító szinonimája. A következő kódszegmens bemutatja, hogyan lehet hivatkozást szerezni egy azonosítóra:

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

A kimenet: 5 5 5. A ref1 és a ref2 az id szinonimája.

lvalue Reference és rvalue Reference

A fenti hivatkozások értékértékek. A következő kód mutatja az értékértéket:

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

A kimenet: 5. Ez a hivatkozás anélkül jön létre, hogy a memóriában bármilyen helyet azonosítana. Ennek elérése érdekében kettős & szükséges, azaz.e., &&.

Mutató

A mutató valójában nem C ++ entitás. Jobb rendszert biztosít azonban a referenciák kezeléséhez. A következő kód megmutatja, hogyan hozható létre mutató:

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

A kimenet: 5. Vegye figyelembe a ptdId és a ptdId közötti névbeli különbséget. A ptdId a hegyes objektum, a ptrId pedig a mutató objektum. A & ptdId visszaadja a ptrId-hez rendelt hegyes objektum címét. A hegyes objektum értékének visszaadásához használja a * ptrId parancsot.

Funkciók

Alapfunkció és annak hívása

A következő kód bemutatja az alapvető funkciódefiníciót és annak hívását:

#include
névtér használata std;
int fn (int szám)

cout<<"seen"<<'\n';
visszatérési szám;

int main ()

int ret = fn (5);
cout << ret <<'\n';
visszatér 0;

A kimenet az

függvény meghatározása

A függvényhívás fn (5). A függvény neve fn.

Hivatkozás és mutató egy függvényre

Az & fn visszaadja a címet annak a függvénynek a memóriájában, amelynek neve fn. A következő utasítás deklarálja a függvény mutatóját:

int (* func) ();

Itt a func a függvény mutatójának neve. Az első zárójelpár megkülönbözteti ezt a függvénymutatót egy skaláris objektummutatótól. A func beállítható az fn által azonosított függvény címének megtartására az alábbiak szerint:

func = &fn;

A következő program működésbe hozza a függvény hivatkozást és mutatót:

#include
névtér használata std;
int fn (int szám)

/ * néhány állítás * /
visszatérési szám;

int main ()

int (* func) (int);
func = &fn;
int ret = func (5);
cout << ret <<'\n';
visszatér 0;

A kimenet: 5. Vegye figyelembe, hogy az fn és a func egyaránt tartalmazza az int paramétert a deklarációban.

Egyéb vegyülettípusok

A fenti bázikus vegyülettípusok önmagukban vegyületek. Kidolgozott összetett típusok készítésére is használják őket.

typedef

A typedef fenntartott szó a típusok sorozatának egy névvel való helyettesítésére szolgál (a sorozat számára). A következő kódszegmens ezt szemlélteti:

typedef unsigned long int IduIL;

IduIL myInt = 55555555555555555555;
cout << myInt <<'\n';

A kimenet 555555555555555555. A kódban az IduIL olyan típus lett, amely az „unsigned long int” rövidítése.

Strukturált kötés

A strukturált kötés olyan funkció, amely lehetővé teszi a nevek adását az alobjektumoknak. A következő kód ezt szemlélteti a tömb esetében:

int arr [3] = 1, 2, 3;
auto [x, y, z] (arr);
cout << x <<"<< y <<"<< z <<'\n';

A kimenet 1 2 3. Tehát az 1, 2, 3 értékeknek megadtuk az x, y, z neveket. Vegye figyelembe a fenntartott, automatikus szó használatát és helyzetét. Vegye figyelembe a szögletes zárójelek használatát is.

Bit-mező

A memória sejtek sorozata. Minden sejt bájtot vesz fel. Ezenkívül mindegyik bájt nyolc bitből áll. A bitek csoportja, nem feltétlenül nyolc bit, beállítható és módosítható. Az ilyen csoportot bitmezőnek nevezzük. Ezek a csoportok egymás mellett feküdnének. Ha a csoportok nem alkotnak típust, mondjuk 16 bitet egy rövid int-hez, kitöltő biteket adunk hozzá. A következő kód ezt szemlélteti a struktúrával:

struct Dátum

aláíratlan rövid wkDay: 3; // 3 bit
aláíratlan rövid hétnap: 6; // 6 bit
aláíratlan rövid hét: 5; 5 bit
aláíratlan rövid év: 8; // 8 bit 2 jegyű évre
dte;
dte.wkDay = 1; dte.monDay = 2; dte.mon = 2; dte.év = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';

A kimenet: 2/2/21. A wkDay, MonDay és mon összes bitjeinek száma 3 + 6 + 5 = 14. Tehát két kitöltő bitet adunk hozzá, hogy a 2 bájt (16 bit) rövid egész számához 16 bit kerüljön. A következő 8 bit a következő rövid int-vel kezdődik, amelyet ezután 8 kitöltő bit tölt be.

Megjegyzés: Kerülje a bitmezők használatát; csak kutatásra használja.

Névtér

A névtér egy névkészlet, amely nem ütközhet más névsorok azonos neveivel. Az alábbi program szemlélteti ugyanazon nevek használatát két különböző névtérből, a main () függvény névterében alkalmazva:

#include
névtér használata std;
névtér NS1

int myInt = 8;
úszó flt;

névtér NS2

int myInt = 9;
úszó 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';
visszatér 0;

A kimenet:

2.5

4.8

Két egymással ütköző azonos név és két azonos úszó név van a kódban.

Sablon és sablon specializáció

A sablon séma lehetővé teszi a helyőrző használatát a különböző lehetséges skalár típusokhoz. A specializáció egy adott skaláris típus választása. A következő kód ezt szemlélteti egy függvény esetében:

#include
névtér használata std;
void func sablon (T cha, U no)

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

int main ()

func ('$', 3);
visszatér 0;

A kimenet:

- Kenyérre van szükségem 3 dollárért.”

Sablonparaméter-csomag

A fordítóknak még mindig végre kell hajtaniuk ezt a funkciót - lásd később.

Következtetés

A C ++ típusok két kategóriában léteznek: alaptípusok és összetett típusok. Az alapvető típusok skaláris típusok. Az összetett alaptípusok tömbök, felsorolások, osztályok, szakszervezetek, hivatkozások, mutatók és függvények. Ezeket az alapvegyület-típusokat a kidolgozott összetett típusok felépítéséhez használják, amelyek typedef, strukturált kötések, bitmezők, névtér és sablonok.

Chrys