Phenquestions
Memoria unui computer este o serie de celule. Fiecare celulă are dimensiunea unui octet, este în mod normal spațiul ocupat de un caracter vest-european. Dimensiunea unui obiect este dată în octeți. Acest articol oferă un rezumat al tipurilor C ++. Ar trebui să aveți deja cunoștințe de bază despre C ++, pentru a înțelege acest articol.
Conținutul articolului
- Tipuri fundamentale
- Modalități de construire a tipurilor de compuși
- Matrice
- Enumerare
- Clasă
- Uniune
- Referințe
- Funcții
- Alte tipuri de compuși
- Concluzie
Tipuri fundamentale
Tipurile fundamentale sunt tipurile scalare.
bool
Un tip boolean sau tip bool are o valoare adevărată sau falsă pentru 1 sau 0. Adevărat sau fals ocupă un octet.
char, char nesemnat și char semnat
O literă este de obicei pentru un personaj din Europa de Vest. De obicei ocupă un octet. Există, de asemenea, un caracter nesemnat și semnat, care este fiecare un număr întreg de opt biți. Caracterele nesemnate nu implică valori negative, în timp ce caracterele semnate implică valori negative. Tipul de valoare pe care o deține un caracter depinde de compilator și poate fi doar un caracter nesemnat. Aceste trei tipuri de caractere sunt numite tipuri de caractere înguste și fiecare ocupă un octet.
Întreg
Există cinci tipuri întregi standard nesemnate și cinci tipuri întregi standard semnate. Cele cinci tipuri întregi nesemnate sunt: „unsigned char”, „unsigned short int”, „unsigned int”, „unsigned long int” și „unsigned long long int”. Cele cinci tipuri întregi semnate corespunzătoare sunt: „semnat caracter”, „scurt int”, „int”, „lung int” și „lung lung int”.
„Unsigned char” este același tip cu tipurile înguste de caractere (vezi mai sus). „Caracter semnat” este celălalt tip de tipuri înguste de caractere (vezi mai sus).
Cu compilatorul g ++, „unsigned char” sau „semnat char” ocupă un octet; „Unsigned short int” sau „short int” ocupă doi octeți; „Unsigned int” sau „int” ocupă patru octeți; „Unsigned long int” sau „long int” ocupă 8 octeți; „Unsigned long long int” sau „long long int” încă ocupă 8 octeți (de acum).
char16_t, char32_t, wchar_t
Atunci când aveți de-a face cu personaje din Europa de Vest, tipul de caractere este suficient în multe situații. Cu toate acestea, atunci când este vorba despre chineză și alte limbi orientale, este nevoie de char16_t sau char32_t sau wchar_t. Cu compilatorul g ++, char16_t ocupă doi octeți; char32_t ocupă patru octeți și wchar_t ocupă și patru octeți.
Bool, char, char16_t, char32_t, wchar_t, semnat și tipurile întregi nesemnate, formează un alt set, numit tipuri integrale (întregi).
În acest moment al articolului, au fost menționate două tipuri colective: tipuri înguste de caractere și tipuri integrale.
Tipuri cu virgulă mobilă
Să presupunem că numerele 457.000 și 457.230 sunt aceeași citire, măsurată de două instrumente de măsurare diferite. 457.230 este mai precis decât 457.000, deoarece valoarea este mai detaliată (implică locuri mai mici: + 200 plus 30). Un număr cu virgulă mobilă este un număr cu o parte fracționată (zecimală). Deși numerele din computer sunt o secvență de biți, unele numere în virgulă mobilă sunt mai precise decât celelalte.
Unele instrumente de măsurare efectuează măsurători în pași minimi, să zicem 10 unități. Un astfel de instrument ar avea următoarele citiri: 10, 20, 30, 40, ... 100, 110, 130, 140, ... 200, 210, 220, 230, 240 și așa mai departe. Deși numerele din computer sunt o succesiune de biți, numerele cu virgulă mobilă variază în câțiva pași minimi (mult mai mici de 10 unități).
C ++ are trei tipuri cu virgulă mobilă, care sunt: float, double și long double. Pentru orice compilator, dublul trebuie să aibă o precizie mai mare decât cea a plutitorului sau cel puțin cea a plutitorului; dublul lung trebuie să aibă o precizie mai mare decât cea a dublului sau cel puțin cea a dublului.
Există un al treilea nume colectiv: tip aritmetic. Acesta este numele pentru tipurile integrale și cu virgulă mobilă. Rețineți că acesta este și numele pentru toate tipurile scalare, așa cum s-a explicat până acum.
Cu compilatorul g ++, numărul de octeți pentru un float este de patru; numărul de octeți pentru un dublu este de opt; numărul de octeți pentru un dublu lung este de șaisprezece.
void Type
Cu compilatorul g ++, dimensiunea tipului de gol este de un octet. Octetul nu are oficial biți, ceea ce înseamnă că locația sa are conținut gol.
Modalități de construire a tipurilor de compuși
Tipurile compuse sunt tipuri non-fundamentale. Aceasta înseamnă că tipurile de compuși sunt tipuri non-scalare. Această secțiune explică elementele de bază ale tipurilor de compuși.
Matrice
Următorul segment de cod arată o matrice de inți și o matrice de caractere:
int arrInt [] = 1, 2, 3, 4, 5;char arrCha [] = 'a', 'b', 'c', 'd', 'e';
cout << arrInt[2] <<" <
Enumerare
O enumerare este un tip, cu constante numite. Luați în considerare următorul segment de cod:
enum a = 3, b, c;cout << b <<'\n';
Ieșirea este: 4. Prima linie a segmentului de cod este o enumerare, iar a, b sau c este un enumerator.
Clasă
O clasă este o unitate generalizată din care pot fi create (instanțiate) multe obiecte ale aceleiași unități generalizate. Următorul program prezintă o clasă și două obiecte, instanțiate din aceasta. Un astfel de obiect este diferit de un obiect scalar.
#includefolosind spațiul de nume std;
clasa TheCla
public:
int num = 5;
int fn ()
return num;
;
int main ()
TheCla obj1;
TheCla obj2;
cout << obj1.num << " << obj2.num <<'\n';
retur 0;
Ieșirea este: 5 5. Numele clasei este TheCla, iar numele celor două obiecte sunt obj1 și obj2. Rețineți punctul și virgula imediat după descrierea (definiția) clasei. Rețineți cum cele două obiecte au fost instanțiate în funcția main ().
Notă: num este un membru de date și fn este o funcție de membru.
Uniune
struct
O structură este ca un tablou, dar în loc să aibă perechi index / valoare, are perechi nume / valoare. Numele pot fi scrise în orice ordine. Următorul program prezintă o structură și utilizarea acesteia:
#includefolosind spațiul de nume 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';
retur 0;
Ieșirea este:
5, 2.3, a
Numele structului este TheCla. obj1 și obj2 sunt două obiecte diferite ale struct.
Uniune
Următorul program arată o uniune și utilizarea acesteia:
#includefolosind spațiul de nume std;
uniunea TheCla
int num;
float flt = 2.3;
char ch;
obj1, obj2;
int main ()
cout << obj2.flt <<'\n';
retur 0;
Ieșirea este: 2.3. Uniunea este similară cu o struct. Principala diferență între o structură și o uniune este că, pentru o structură, un singur membru poate avea o valoare (inițializată) în același timp. În programul de mai sus, membrul, flt are o valoare de 2.3. Fiecare dintre ceilalți membri, num sau ch, poate avea o valoare următoare numai dacă valoarea pentru flt este abandonată.
Referințe
O referință este un sinonim pentru un identificator. Următorul segment de cod arată cum să obțineți o referință la un identificator:
int id = 5;int & ref1 = id;
int & ref2 = id;
cout << id << " << ref1 << " << ref2 <<'\n';
Ieșirea este: 5 5 5. ref1 și ref2 sunt sinonime cu id.
lvalue Reference și rvalue Reference
Referințele de mai sus sunt referințe de valoare. Următorul cod arată referința valorii:
int && ref = 5;cout << ref <<'\n';
Ieșirea este: 5. Această referință este creată fără a identifica nicio locație din memorie. Pentru a realiza acest lucru, este nevoie de dublu &, i.e., &&.
Pointer
Un indicator nu este într-adevăr o entitate C ++. Cu toate acestea, oferă o schemă mai bună pentru tratarea referințelor. Următorul cod arată cum poate fi creat un pointer:
int ptdId = 5;int ptdId = 5;
int * ptrId;
ptrId = &ptdId;
cout << *ptrId <<'\n';
Ieșirea este: 5. Rețineți diferența de nume între ptdId și ptdId. ptdId este obiectul ascuțit și ptrId este obiectul pointer. & ptdId returnează adresa obiectului ascuțit care este atribuit ptrId. Pentru a returna valoarea obiectului ascuțit, utilizați * ptrId.
Funcții
Funcția de bază și apelul acesteia
Următorul cod prezintă o definiție de bază a funcției și apelul acesteia:
#includefolosind spațiul de nume std;
int fn (int num)
cout<<"seen"<<'\n';
return num;
int main ()
int ret = fn (5);
cout << ret <<'\n';
retur 0;
Ieșirea este
definirea funcției
5
Apelul funcției este fn (5). Numele funcției este fn.
Referință și indicator către o funcție
& fn returnează adresa în memorie a funcției al cărei nume este fn. Următoarea declarație declară un pointer către o funcție:
int (* func) ();Aici, func este numele indicatorului către funcție. Prima pereche de paranteze diferențiază acest indicator de funcție de un indicator de obiect scalar. func poate fi făcut să țină adresa unei funcții identificate prin fn, după cum urmează:
func = &fn;Următorul program pune în funcțiune referința funcției și indicatorul:
#includefolosind spațiul de nume std;
int fn (int num)
/ * câteva afirmații * /
return num;
int main ()
int (* func) (int);
func = &fn;
int ret = func (5);
cout << ret <<'\n';
retur 0;
Ieșirea este: 5. Rețineți că atât fn cât și func au fiecare parametrul int în declarație.
Alte tipuri de compuși
Tipurile de compuși de bază de mai sus sunt compuse în sine. Ele sunt, de asemenea, utilizate pentru a construi tipuri compuse elaborate.
typedef
Cuvântul rezervat typedef este utilizat pentru a înlocui o secvență de tipuri cu un singur nume (pentru secvență). Următorul segment de cod ilustrează acest lucru:
typedef unsigned long int IduIL;
IduIL myInt = 555555555555555555;cout << myInt <<'\n';
Ieșirea este 555555555555555555. În cod, IduIL a devenit un tip care înseamnă „unsigned long int”.
Legarea structurată
Legarea structurată este o caracteristică care face posibil ca numele să fie date subobiectelor. Următorul cod ilustrează acest lucru pentru matrice:
int arr [3] = 1, 2, 3;auto [x, y, z] (arr);
cout << x <<"<< y <<"<< z <<'\n';
Ieșirea este 1 2 3. Deci, valorilor: 1, 2, 3 li s-au dat numele, x, y, z. Rețineți utilizarea și poziția cuvântului rezervat, auto. De asemenea, rețineți utilizarea parantezelor pătrate.
Bit-Field
Memoria este o secvență de celule. Fiecare celulă ia un octet. De asemenea, fiecare octet este format din opt biți. Un grup de biți, nu neapărat opt biți, poate fi setat și schimbat. Un astfel de grup se numește câmp de biți. Aceste grupuri ar sta unul lângă altul. Dacă grupurile nu vor alcătui un tip, să spunem 16 biți pentru o scurtă int, se adaugă biți de umplere. Următorul cod ilustrează acest lucru cu struct:
struct DatawkDay nesemnat scurt: 3; // 3 biți
lunar scurt nesemnat: 6; // 6 biți
nesemnat scurt lun: 5; // 5 biți
nesemnat anul scurt: 8; // 8 biți pentru 2 cifre pe an
dte;
dte.wkDay = 1; dte.Luni = 2; dte.lun = 2; dte.an = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';
Ieșirea este: 2/2/21. Numărul total de biți pentru wkDay, MonDay și mon este 3 + 6 + 5 = 14. Deci, s-ar adăuga doi biți de umplere pentru a alcătui 16 biți pentru întregul scurt de 2 octeți (16 biți). Următorii 8 biți încep următorul scurt int, care este apoi completat cu 8 biți de umplere.
Notă: Evitați utilizarea câmpurilor de biți; folosiți-l doar pentru cercetare.
Spațiu de nume
Un spațiu de nume este un set de nume, care nu ar trebui să intre în conflict cu aceleași nume ale altor seturi de nume. Următorul program ilustrează utilizarea aceluiași nume din două spații de nume diferite, aplicate în spațiul de nume al funcției main ():
#includefolosind spațiul de nume std;
spațiul de nume NS1
int myInt = 8;
float flt;
spațiu de nume 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';
retur 0;
Ieșirea este:
9
8
2.5
4.8
Există două conflicte cu aceleași nume int și două conflicte cu aceleași nume float în cod.
Șablon și specializare șablon
Schema șablon permite utilizarea unui substituent pentru diferite tipuri scalare posibile. Specializarea este alegerea unui anumit tip scalar. Următorul cod ilustrează acest lucru pentru o funcție:
#includefolosind spațiul de nume std;
șablon nul funcții (T cha, U nu)
cout << "I need bread for " << cha << no << '.' << '\n';
int main ()
func ('$', 3);
retur 0;
Ieșirea este:
„Am nevoie de pâine pentru 3 dolari.”
Pachet de parametri șablon
Compilatoarele trebuie să implementeze pe deplin această caracteristică - consultați mai târziu.
Concluzie
Tipurile C ++ există în două categorii: tipuri fundamentale și tipuri compuse. Tipurile fundamentale sunt tipurile scalare. Tipurile compuse de bază sunt matrici, enumerări, clase, uniuni, referințe, indicatori și funcții. Aceste tipuri de compus de bază sunt utilizate pentru a construi tipuri de compuși elaborate, care sunt typedef, legături structurate, câmpuri de biți, spațiu de nume și caracteristici șablon.
Chrys
