Cât deține int. Tipuri de date și variabile. Prefixe întregi

Această secțiune va acoperi principalele tipuri de date din C++, aceste tipuri de date sunt numite și tipuri de date încorporate. Limbajul de programare C++ este un limbaj de programare extensibil. Conceptul de extensibil înseamnă că, pe lângă tipurile de date încorporate, puteți crea propriile tipuri de date. Prin urmare, există un număr mare de tipuri de date în C++. Le vom studia doar pe cele principale.

Tabelul 1 - Tipuri de date C++

Tip	octet	Gama de valori acceptate
tip de date întreg (boolean).
bool	1	0 / 255
tip de date întreg (caracter).
char	1	0 / 255
tipuri de date întregi
scurt int	2	-32 768 / 32 767
unsigned short int	2	0 / 65 535
int	4
nesemnat int	4	0 / 4 294 967 295
lung int	4	-2 147 483 648 / 2 147 483 647
nesemnat lung int	4	0 / 4 294 967 295
tipuri de date în virgulă mobilă
pluti	4	-2 147 483 648.0 / 2 147 483 647.0
plutire lungă	8
dubla	8	-9 223 372 036 854 775 808 .0 / 9 223 372 036 854 775 807.0

Tabelul 1 prezintă principalele tipuri de date în C++. Întregul tabel este împărțit în trei coloane. Prima coloană conține un cuvânt rezervat care va defini fiecare tip de date. A doua coloană indică numărul de octeți care sunt alocați pentru o variabilă cu tipul de date corespunzător. A treia coloană arată intervalul de valori valide. Vă rugăm să rețineți că în tabel toate tipurile de date sunt aranjate de la cel mai mic la cel mai mare.

tipul de date bool

Primul din tabel este tipul de date bool — tipul de date întreg, deoarece intervalul de valori valide este numere întregi de la 0 la 255. Dar, după cum ați observat deja, este scris în paranteze - tip de date boolean, iar acest lucru este, de asemenea, adevărat. Deoarece bool folosit numai pentru a stoca rezultatele expresiilor booleene. O expresie booleană poate avea unul dintre cele două rezultate adevărate sau false. adevărat dacă expresia booleană este adevărată, false dacă expresia booleană este falsă.

Dar, deoarece intervalul de valori permise ale tipului de date bool este de la 0 la 255, a fost necesar să se compare cumva acest interval cu constantele logice adevărate și false definite în limbajul de programare. Astfel, constanta adevărată este echivalentă cu toate numerele de la 1 la 255 inclusiv, în timp ce constanta falsă este echivalentă cu un singur număr întreg - 0. Luați în considerare un program care utilizează tipul de date bool.

// data_type.cpp: definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include folosind namespace std; int main(int argc, char* argv) ( bool boolean = 25; // variabilă de tip bool numită boolean if (boolean) // dacă declarația condiție cout<< "true = " << boolean << endl; // выполнится в случае истинности условия else cout << "false = " << boolean << endl; // выполнится в случае, если условие ложно system("pause"); return 0; }

ÎN linia 9variabilă de tip declarată bool , care este inițializat la 25. Teoretic, dupălinia 9, într-o variabilă booleană ar trebui să conțină numărul 25, dar de fapt această variabilă conține numărul 1. După cum am spus, numărul 0 este o valoare falsă, numărul 1 este o valoare adevărată. Concluzia este că într-o variabilă de tip bool poate conține două valori - 0 (fals) sau 1 (adevărat). În timp ce sub tipul de date bool este alocat un octet întreg, ceea ce înseamnă că o variabilă de tip bool poate conține numere de la 0 la 255. Sunt necesare doar două valori 0 și 1 pentru a determina valori false și adevărate. Se pune întrebarea: „Pentru ce sunt celelalte 253 de valori?”.

Pe baza acestei situații, am convenit să folosim numerele de la 2 la 255 ca echivalent cu numărul 1, adică adevărat. Tocmai de aceea variabila booleană conține numărul 25 și nu 1. În rândurile 10-13 este declarată, care transferă controlul declarației în linia 11 dacă condiția este adevărată și operatorul în linia 13 dacă condiția este falsă. Vedeți rezultatul programului în Figura 1.

Adevărat = 1 Apăsați orice tastă pentru a continua. . .

Figura 1 - tipul de date bool

tipul de date char

Tipul de date char este un tip de date întreg care este folosit pentru a reprezenta caractere. Adică, fiecărui caracter îi corespunde un anumit număr din interval. Tipul de date char este numit și tip de date caracter, deoarece reprezentarea grafică a caracterelor în C++ este posibilă datorită char . Pentru a reprezenta caractere în C++, tipului de date char i se atribuie un octet, într-un octet - 8 biți, apoi ridicăm doi la puterea lui 8 și obținem valoarea 256 - numărul de caractere care pot fi codificate. Astfel, folosind tipul de date char, poate fi afișat oricare dintre cele 256 de caractere. Toate caracterele codificate sunt reprezentate în .

ASCII (din engleză American Standard Code for Information Interchange) este codul standard american pentru schimbul de informații.

Luați în considerare un program care utilizează tipul de date char.

// symbols.cpp: definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include folosind namespace std; int main(int argc, char* argv) ( simbolul char = "a"; // declarând o variabilă de tip char și inițialând-o cu simbolul "a" cout<< "symbol = " << symbol << endl; // печать символа, содержащегося в переменной symbol char string = "сайт"; // объявление символьного массива (строки) cout << "string = " << string << endl; // печать строки system("pause"); return 0; }

Deci in linia 9o variabilă numită simboluri , i se atribuie valoarea simbolului"A" ( cod ASCII). ÎN linia 10 operator cout tipărește caracterul conținut în variabilă simbol . ÎN linia 11o matrice de șiruri numităşir , iar dimensiunea matricei este setată implicit. Un șir este stocat într-o matrice de șiruri"site-ul web" . Rețineți că atunci când am salvat simbolul într-o variabilă, cum ar fi char , apoi după semnul egal punem ghilimele simple, în care am scris personajul. La inițializarea unei matrice de șiruri cu un șir de caractere, ghilimelele duble sunt plasate după semnul egal, în care este scris un șir de caractere. La fel ca un caracter obișnuit, șirurile sunt scoase folosind operatorul cout, linia 12. Rezultatul programului este prezentat în Figura 2.

Simbol = un șir = site web Apăsați orice tastă pentru a continua. . .

Figura 2 - Tipul de date char

Tipuri de date întregi

Tipurile de date întregi sunt folosite pentru a reprezenta numere. Există deja șase dintre ele în tabelul 1: short int , unsigned short int , int , unsigned int , long int , unsigned long int . Toate au propria lor dimensiune de memorie și interval de valori acceptate. În funcție de compilator, cantitatea de memorie utilizată și intervalul de valori acceptate pot varia. În tabelul 1, toate intervalele de valori acceptate și dimensiunile memoriei ocupate sunt luate pentru compilatorul MVS2010. Mai mult, toate tipurile de date din Tabelul 1 sunt aranjate în ordinea crescătoare a mărimii memoriei ocupate și a intervalului de valori acceptate. Gama de valori acceptate, într-un fel sau altul, depinde de dimensiunea memoriei ocupate. În consecință, cu cât dimensiunea memoriei ocupate este mai mare, cu atât intervalul de valori acceptate este mai mare. De asemenea, intervalul de valori acceptate se modifică dacă tipul de date este declarat cu prefixul nesemnat - fără semn. Prefixul unsigned înseamnă că tipul de date nu poate stoca valori semnate, iar apoi intervalul de valori pozitive este dublat, de exemplu, tipurile de date short int și unsigned short int .

Prefixe ale tipurilor de date întregi:

mic de statura — prefixul scurtează tipul de date la care se aplică prin reducerea dimensiunii memoriei pe care o ocupă;

lung — prefixul prelungește tipul de date la care este aplicat prin creșterea cantității de memorie pe care o ocupă;

nesemnat (nesemnat) - prefixul dublează intervalul de valori pozitive, în timp ce intervalul de valori negative nu poate fi stocat în acest tip de date.

Deci, de fapt, avem un tip întreg pentru a reprezenta numerele întregi - acesta este tipul de date int. Prefixele short , long , unsigned dau naștere la o varietate de tipuri de date int care diferă în ceea ce privește cantitatea de memorie ocupată și (sau) intervalul de valori acceptate.

Tipuri de date în virgulă mobilă

Există două tipuri de date în virgulă mobilă în C++: float și double . Tipurile de date în virgulă mobilă sunt concepute pentru a stoca numere în virgulă mobilă. Tipurile de date float și double pot stoca atât numere cu virgulă mobilă pozitive, cât și negative. Tipul de date float are jumătate din cantitatea de memorie ocupată de tipul de date dublu, ceea ce înseamnă că și intervalul de valori acceptate este mai mic. Dacă tipul de date float este declarat cu un prefix lung, atunci intervalul de valori acceptate va deveni egal cu intervalul de valori acceptate ale tipului de date dublu. Practic, tipurile de date în virgulă mobilă sunt necesare pentru rezolvarea problemelor cu o mare precizie de calcul, de exemplu, tranzacțiile cu bani.

Deci, am luat în considerare punctele principale privind tipurile de date de bază în C++. Rămâne doar să arătăm de unde provin toate aceste intervale de valori acceptate și dimensiunile memoriei ocupate. Și pentru aceasta vom dezvolta un program care va calcula principalele caracteristici ale tuturor tipurilor de date discutate mai sus.

// data_types.cpp: definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include // Biblioteca de manipulare I/O #include // fișier antet al funcțiilor matematice #include folosind namespace std; int main(int argc, char* argv) ( cout<< " data type " << "byte" << " " << " max value "<< endl // titluri de coloană <<"bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; system("pause"); return 0; }

Acest program este postat astfel încât să puteți vizualiza caracteristicile tipurilor de date din sistemul dumneavoastră. Nu ar trebui să înțelegeți codul, deoarece programul folosește instrucțiuni de control cu ​​care, cel mai probabil, nu sunteți încă familiarizați. Pentru o cunoaștere superficială a codului programului, voi explica mai jos câteva puncte. Operator dimensiunea() calculează numărul de octeți alocați pentru un tip de date sau variabilă. Funcţie pow(x,y) ridică valoarea x la puterea lui y , această funcție este disponibilă din fișierul antet . manipulatoare fixe și setprecision(). disponibil din fișierul antet . Primul este fix , transmite valori într-o formă fixă ​​fluxului de ieșire. Manipulator setprecision(n) afișează n zecimale. Valoarea maximă a anumitor tipuri de date este calculată folosind următoarea formulă:

Max_val_type = 2^(b * 8 - 1) - 1; // pentru tipurile de date cu numere negative și pozitive // ​​unde, b este numărul de octeți alocați în memorie pentru o variabilă cu acest tip de date // se înmulțește cu 8, deoarece există 8 biți într-un octet // scade 1 între paranteze , deoarece intervalul de numere trebuie înjumătățit pentru valorile pozitive și negative // ​​scade 1 la sfârșit, deoarece intervalul de numere începe de la zero // tipuri de date fără semn max_val_type = 2^(b * 8) - 1; // pentru tipurile de date cu doar numere pozitive // ​​explicațiile pentru formulă sunt similare, doar unul nu este scăzut din paranteză

Un exemplu de funcționare a programului poate fi văzut în Figura 3. Prima coloană arată principalele tipuri de date în C++, a doua coloană arată cantitatea de memorie alocată pentru fiecare tip de date, iar a treia coloană arată valoarea maximă pe care corespunzătoare tipul de date poate conține. Valoarea minimă se găsește similar cu cea maximă. În tipurile de date prefixate cu unsigned, valoarea minimă este 0.

Tip de date octet valoarea maximă bool = 1 255.00 char = 1 255.00 short int = 2 32767.00 unsigned short int = 2 65535.00 int = 4 2147483647.00 unsigned int = 4 4294967295 long = int. long int = 4 4294967295,00 float = 4 2147483647,00 dublu = 8 9223372036854775808.00 Apăsați orice tastă pentru a continua. . .

Figura 3 - Tipuri de date C++

Dacă, de exemplu, unei variabile de tip short int i se atribuie valoarea 33000, atunci grila de biți va depăși, deoarece valoarea maximă într-o variabilă de tip short int este 32767. Adică, o altă valoare va fi stocată într-o variabilă. de tip short int, cel mai probabil va fi negativ. Deoarece am atins tipul de date int, merită remarcat faptul că puteți omite cuvântul cheie int și puteți scrie, de exemplu, doar scurt . Compilatorul va interpreta o astfel de notație ca short int . Același lucru este valabil și pentru prefixele lungi și nesemnate. De exemplu:

// scurt pentru tipul de date int short a1; // la fel ca short int long a1; // la fel ca long int unsigned a1; // la fel ca unsigned int unsigned short a1; // la fel ca unsigned short int

Tipul întreg char ocupă 1 octet (8 biți) în memorie și vă permite să exprimați 2^8 valori \u003d 256 în notație binară. Tipul char poate conține atât valori pozitive, cât și negative. Intervalul de valori este de la -128 la 127.

uchar

Tipul întreg uchar ocupă, de asemenea, 1 octet în memorie, ca și tipul char, dar spre deosebire de acesta, uchar este destinat doar valorilor pozitive. Valoarea minimă este zero, iar valoarea maximă este 255. Primul u din numele tipului uchar este prescurtarea pentru unsigned.

mic de statura

Tipul întreg scurt are o dimensiune de 2 octeți (16 biți) și, în consecință, vă permite să exprimați un set de valori egal cu 2 cu puterea lui 16: 2^16=65 536. Deoarece tipul scurt este semnat și conține atât valori pozitive, cât și negative, valorile intervalului sunt cuprinse între -32768 și 32767.

scurt

Tipul scurt nesemnat este tipul ushort, care are și o dimensiune de 2 octeți. Valoarea minimă este 0, valoarea maximă este 65535.

int

Tipul întreg int are o dimensiune de 4 octeți (32 de biți). Valoarea minimă este -2 147 483 648, valoarea maximă este 2 147 483 647.

uint

Tipul întreg fără semn uint ocupă 4 octeți în memorie și permite exprimarea valorilor întregi de la 0 la 4294967295.

lung

Tipul întreg long are o dimensiune de 8 octeți (64 de biți). Valoarea minimă este -9 223 372 036 854 775 808, valoarea maximă este 9 223 372 036 854 775 807.

ulong

Tipul întreg ulong are, de asemenea, 8 octeți și poate stoca valori de la 0 la 18446744073709551615.

Exemple:

char ch= 12; scurt sh=- 5000; int in= 2445777;

Deoarece tipurile întregi fără semn nu sunt concepute pentru a stoca valori negative, încercarea de a seta o valoare negativă poate duce la consecințe neașteptate. Iată un script inocent care va duce la o buclă infinită:

Va fi corect asa:

Rezultat:

Ch= -128 u_ch= 128 ch= -127 u_ch= 129 ch= -126 u_ch= 130 ch= -125 u_ch= 131 ch= -124 u_ch= 132 ch= -123 u_ch= 133 ch= -122 u_ch= 134 ch= -121 u_ch= 135 ch= -120 u_ch= 136 ch= -119 u_ch= 137 ch= -118 u_ch= 138 ch= -117 u_ch= 139 ch= -116 u_ch= 140 ch= -115 u_ch= 141 ch= -114 u_ch= 142 ch= -113 u_ch= 143 ch= -112 u_ch= 144 ch= -111 u_ch= 145 ...

Ultima actualizare: 17.09.2017

Fiecare variabilă are un tip specific. Și acest tip determină ce valori poate avea o variabilă, ce operații pot fi efectuate cu ea și câți octeți în memorie va ocupa. Următoarele tipuri de date de bază sunt definite în limbajul C++:

bool : tip boolean. Poate lua una dintre cele două valori adevărat (adevărat) și fals (fals). Amprenta de memorie pentru acest tip nu este definită exact.

char : reprezintă un singur caracter ASCII. Ocupă 1 octet (8 biți) în memorie. Poate stoca orice valoare de la -128 la 127 sau de la 0 la 255

signed char : reprezintă un singur caracter. Ocupă 1 octet (8 biți) în memorie. Poate stoca orice valoare între -128 și 127

unsigned char : reprezintă un singur caracter. Ocupă 1 octet (8 biți) în memorie. Poate stoca orice valoare între 0 și 255

wchar_t : reprezintă un caracter larg. Pe Windows este nevoie de 2 octeți (16 biți) în memorie, pe Linux este nevoie de 4 octeți (32 de biți). Poate stoca orice valoare de la 0 la 65535 (pentru 2 octeți) sau de la 0 la 4294967295 (pentru 4 octeți)

char16_t : reprezintă un singur caracter Unicode. Ocupă 2 octeți (16 biți) în memorie. Poate stoca orice valoare de la 0 la 65535

char32_t : reprezintă un singur caracter Unicode. Ocupă 4 octeți (32 de biți) în memorie. Poate stoca orice valoare de la 0 la 4294967295

scurt : Reprezintă un număr întreg în intervalul de la -32768 la 32767. Ocupă 2 octeți (16 biți) în memorie.

Acest tip are și sinonime short int , signed short int , signed short .

unsigned short : Reprezintă un număr întreg în intervalul de la 0 la 65535. Ocupă 2 octeți (16 biți) în memorie.

Acest tip are, de asemenea, un sinonim pentru unsigned short int .

int : reprezintă un număr întreg. În funcție de arhitectura procesorului, acesta poate lua 2 octeți (16 biți) sau 4 octeți (32 biți). Intervalul valorilor limită, respectiv, poate varia de la -32768 la 32767 (pentru 2 octeți) sau de la -2 147 483 648 la 2 147 483 647 (pentru 4 octeți). Dar, în orice caz, dimensiunea trebuie să fie mai mare sau egală cu dimensiunea tipului scurt și mai mică sau egală cu dimensiunea tipului lung

Acest tip are sinonime semnate int și signed .

unsigned int : reprezintă un număr întreg pozitiv. În funcție de arhitectura procesorului, poate dura 2 octeți (16 biți) sau 4 octeți (32 de biți), iar din acest motiv, intervalul de valori limită poate varia: de la 0 la 65535 (pentru 2 octeți), sau de la 0 la 4.294.967.295 (pentru 4 octeți).

Nesemnat poate fi folosit ca sinonim pentru acest tip.

long : Reprezintă un număr întreg în intervalul −2147483648 până la 2147483647. Ocupă 4 octeți (32 de biți) de memorie.

Acest tip are și sinonime long int , signed long int și signed long

unsigned long : reprezintă un număr întreg în intervalul de la 0 la 4.294.967.295. Ocupă 4 octeți (32 de biți) de memorie.

Are un sinonim pentru unsigned long int .

long long : reprezintă un număr întreg în intervalul −9223372036854775808 până la +9223372036854775807. De obicei, 8 octeți (64 de biți) în memorie.

Are sinonime long long int , signed long long int și signed long long .

unsigned long long : reprezintă un număr întreg în intervalul de la 0 la 18446744073709551615. De obicei, 8 octeți (64 de biți) în memorie.

Are un sinonim pentru unsigned long long int.

float : reprezintă un număr obișnuit cu virgulă mobilă de precizie în intervalul +/- 3,4E-38 până la 3,4E+38. Ocupă 4 octeți (32 de biți) în memorie

dublu : reprezintă un număr cu virgulă mobilă cu precizie dublă în intervalul +/- 1,7E-308 până la 1,7E+308. Ocupă 8 octeți (64 de biți) în memorie

long double : reprezintă un număr real cu precizie dublă în virgulă mobilă de cel puțin 8 octeți (64 de biți). În funcție de dimensiunea memoriei ocupate, intervalul de valori valide poate diferi.

void : tip fără valoare

Astfel, toate tipurile de date, cu excepția void, pot fi împărțite în trei grupuri: caracter (char, wchar_t, char16_t, char32_t), întreg (short, int, long, long long) și tipuri în virgulă mobilă (float, double, long double).

Tipuri de caractere

O aplicație folosește tipurile char , wchar_t , char16_t și char32_t pentru a reprezenta caracterele.

Să definim câteva variabile:

Charc="d"; wchar_td="c";

O variabilă de tip char ia un caracter între ghilimele simple ca valoare: char c ="d" . De asemenea, puteți atribui un număr din intervalul specificat mai sus în listă: char c = 120 . În acest caz, valoarea variabilei c va fi caracterul care are codul 120 în tabelul de caractere ASCII.

Merită să luați în considerare faptul că pentru a scoate caractere wchar_t în consolă, nu ar trebui să utilizați std::cout, ci fluxul std::wcout:

#include int main() ( char a = "H"; wchar_t b = "e"; std::wcout<< a << b << "\n"; return 0; }

În același timp, fluxul std::wcout poate funcționa atât cu char cât și cu wchar_t. Și fluxul std::cout pentru variabila wchar_t își va afișa codul numeric în loc de un caracter.

Standardul C++11 a adăugat tipurile char16_t și char32_t, care sunt orientate Unicode. Cu toate acestea, la nivelul sistemului de operare, firele de execuție nu au fost încă implementate pentru a funcționa cu aceste tipuri. Prin urmare, dacă trebuie să afișați valorile variabilelor de aceste tipuri pe consolă, atunci trebuie să convertiți variabilele în tipuri char sau wchar_t:

#include int main() ( char a = "H"; wchar_t b = "e"; char16_t c = "l"; char32_t d = "o"; std::cout<< a << (char)b << (char)c << (char)d << "\n"; return 0; }

În acest caz, ieșirea precede variabilele cu un cast to char - (char) , astfel încât valorile variabilelor b, c și d sunt convertite în char și pot fi imprimate pe consolă folosind std:: cout stream.

Tipuri întregi

Tipurile întregi sunt reprezentate de următoarele tipuri: short , unsigned short , int , unsigned int , long , unsigned long , long long și unsigned long long :

a scurtă = -10; scurt nesemnat b= 10; int c = -30; unsigned int d = 60; lung e = -170; nesemnat lung f = 45; lung lung g = 89;

Tipuri în virgulă mobilă

Tipurile în virgulă mobilă și/sau fracționale sunt reprezentate de tipuri precum float , double și long double :

Float a = -10,45; dublu b = 0,00105; lung dublu c = 30,890045;

Dimensiuni tip de date

În lista de mai sus, pentru fiecare tip, este indicată dimensiunea pe care o ocupă în memorie. Cu toate acestea, merită remarcat faptul că dezvoltatorii de compilatoare pot alege singuri limitele de dimensiune pentru tipuri, în funcție de capacitățile hardware ale computerului. Standardul stabilește doar valorile minime care ar trebui să fie. De exemplu, pentru tipurile int și short valoarea minimă este de 16 biți, pentru tipul lung este de 32 de biți, pentru tipul dublu lung. În acest caz, dimensiunea tipului lung nu trebuie să fie mai mică decât dimensiunea tipului int, iar dimensiunea tipului int nu trebuie să fie mai mică decât dimensiunea tipului scurt, iar dimensiunea tipului dublu lung trebuie să fie fi mai mare decât dublu. De exemplu, compilatorul g++ sub Windows folosește 12 octeți pentru dublu lung, în timp ce compilatorul încorporat în Visual Studio și rulează și sub Windows folosește 8 octeți pentru dublu lung. Adică, chiar și în cadrul aceleiași platforme, diferiți compilatori pot aborda dimensiunile unor tipuri de date în moduri diferite. Dar, în general, se folosesc acele dimensiuni care sunt indicate mai sus atunci când descriem tipurile de date.

Cu toate acestea, există situații în care trebuie să știți exact dimensiunea unui anumit tip. Și pentru aceasta, C++ are operatorul sizeof(), care returnează dimensiunea memoriei în octeți pe care o ocupă o variabilă:

#include int main() (număr dublu lung = 2; std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

Ieșire din consolă la compilarea în g++:

dimensiunea (număr) = 12

În același timp, atunci când definiți variabile, este important să înțelegeți că valoarea unei variabile nu trebuie să depășească limitele care sunt conturate pentru tipul acesteia. De exemplu:

Număr scurt nesemnat = -65535;

Compilatorul G++, la compilarea unui program cu această linie, va da o eroare care afirmă că valoarea -65535 nu se află în intervalul de valori valide pentru tipul scurt fără semn și va fi trunchiată.

În Visual Studio, compilarea poate trece fără erori, dar variabila număr va fi setată la 2, rezultatul conversiei -65535 într-un scurt scurt nesemnat. Adică, din nou, rezultatul nu va fi exact cel așteptat. Valoarea unei variabile este doar un set de biți din memorie care sunt interpretați în funcție de un anumit tip. Și pentru diferite tipuri, același set de biți poate fi interpretat diferit. Prin urmare, este important să luați în considerare intervalele de valori pentru un anumit tip atunci când atribuiți o valoare unei variabile.

specificator automat

Uneori este dificil de determinat tipul unei expresii. Și conform celor mai recente standarde, puteți lăsa compilatorul să deducă tipul obiectului în sine. Și pentru asta este folosit specificatorul automat. Mai mult, dacă definim o variabilă cu specificatorul auto, această variabilă trebuie inițializată cu o anumită valoare:

Număr automat = 5;

Pe baza valorii atribuite, compilatorul va deduce tipul variabilei. Variabilele neinițializate cu specificatorul automat nu sunt permise.

Tipuri de date

Tipurile de date sunt de o importanță deosebită în C#, deoarece este un limbaj puternic tipizat. Aceasta înseamnă că toate operațiunile sunt strict verificate de tip de către compilator, iar operațiunile nevalide nu sunt compilate. Prin urmare, tastarea puternică ajută la eliminarea erorilor și la îmbunătățirea fiabilității programelor. Pentru a asigura verificarea tipului, toate variabilele, expresiile și valorile trebuie să fie de un anumit tip. Nu există o variabilă „fără tip” în acest limbaj de programare. Mai mult, tipul de valoare determină operațiunile care pot fi efectuate asupra acestuia. O operațiune care este permisă pentru un tip de date poate să nu fie permisă pentru altul.

Există două categorii generale de tipuri de date încorporate în C#: tipuri de valoriȘi tipuri de referință. Ele diferă în conținutul variabilei. Din punct de vedere conceptual, diferența dintre cele două este că un tip de valoare stochează date direct, în timp ce un tip de referință stochează o referință la o valoare.

Aceste tipuri sunt stocate în diferite locații din memorie: tipurile de valori sunt stocate într-o zonă cunoscută sub numele de stivă, în timp ce tipurile de referință sunt stocate într-o zonă numită heap gestionat.

Hai să aruncăm o privire tipuri de valori.

Tipuri întregi

C# definește nouă tipuri de numere întregi: char, byte, sbyte, short, ushort, int, uint, long și ulong. Dar tipul char este folosit în principal pentru a reprezenta caractere și, prin urmare, este tratat separat. Restul de opt tipuri de numere întregi sunt pentru calcule numerice. Mai jos sunt gama lor de reprezentare a numerelor și adâncimea de biți:

Tipuri întregi C#

Tip	tip CTS	Adâncime de biți	Gamă
octet	System.Byte	8	0:255
sbyte	Sistem.SByte	8	-128:127
mic de statura	System.Int16	16	-32768: 32767
scurt	System.UInt16	16	0: 65535
int	System.Int32	32	-2147483648: 2147483647
uint	System.UInt32	32	0: 4294967295
lung	System.Int64	64	-9223372036854775808: 9223372036854775807
ulong	System.UInt64	64	0: 18446744073709551615

După cum arată tabelul de mai sus, C# definește atât versiunile semnate, cât și cele nesemnate ale diferitelor tipuri de numere întregi. Tipurile de numere întregi semnate diferă de omologii lor fără semn în modul în care interpretează cel mai semnificativ bit al unui întreg. De exemplu, dacă un program specifică o valoare întreagă cu semn, compilatorul C# va genera cod care utilizează bitul de ordin înalt al întregului ca indicator de semn. Un număr este considerat pozitiv dacă semnul este 0 și negativ dacă este 1.

Numerele negative sunt aproape întotdeauna reprezentate prin metoda complementului a doi, în care toate cifrele binare ale unui număr negativ sunt mai întâi inversate, iar apoi se adaugă 1 acestui număr.

Probabil cel mai comun tip de număr întreg în programare este tastați int. Variabilele de tip int sunt adesea folosite pentru controlul buclei, indexarea matricei și matematica de uz general. Când aveți nevoie de o valoare întreagă cu un interval de reprezentare a numărului mai mare decât tipul int, atunci există o serie de alte tipuri de numere întregi în acest scop.

Deci, dacă valoarea trebuie stocată fără semn, atunci puteți alege pentru aceasta tipul uint, pentru valori mari semnate - tip lung, iar pentru valori mari nesemnate, tipul ulong. Ca exemplu, mai jos este un program care calculează distanța de la Pământ la Soare în centimetri. Pentru a stoca o valoare atât de mare, folosește o variabilă de tip long:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Text; namespace ConsoleApplication1 ( clasa Program ( static void Main(string args)) ( rezultat lung; const long km = 149800000; // distanță în km. rezultat = km * 1000 * 100; Console.WriteLine (rezultat); Console.ReadLine(); ) ) )

Tuturor variabilelor întregi li se pot atribui valori în notație zecimală sau hexazecimală. În acest din urmă caz, este necesar prefixul 0x:

Long x = 0x12ab;

Dacă există vreo incertitudine dacă o valoare întreagă este de tip int, uint, long sau ulong, atunci Mod implicit acceptat int. Pentru a specifica în mod explicit ce alt tip întreg ar trebui să aibă valoarea, următoarele caractere pot fi adăugate la număr:

Uint ui = 1234U; lung l = 1234L; ulong ul = 1234UL;

U și L pot fi scrise și cu litere mici, deși literele mici L pot fi confundate vizual cu numărul 1 (unu).

tipuri de virgulă mobilă

Tipurile cu virgulă mobilă vă permit să reprezentați numere cu o parte fracțională. Există două tipuri de tipuri de date în virgulă mobilă în C#: plutiȘi dubla. Acestea reprezintă valori numerice cu precizie simplă și, respectiv, dublă. Astfel, tipul float este de 32 de biți, ceea ce corespunde aproximativ intervalului de reprezentare a numerelor de la 5E-45 la 3.4E+38. Și adâncimea de biți a tipului dublu este de 64 de biți, ceea ce corespunde aproximativ intervalului de reprezentare a numerelor de la 5E-324 la 1.7E + 308.

Tipul de date float este pentru valori mai mici în virgulă mobilă care necesită mai puțină precizie. Tipul de date dublu este mai mare decât float și oferă un grad mai mare de precizie (15 biți).

Dacă o valoare care nu este un întreg este codificată în codul sursă (de exemplu, 12.3), atunci compilatorul presupune de obicei că se înțelege o valoare de tip double. Dacă o valoare trebuie să fie specificată ca float, va trebui să îi adăugați un caracter F (sau f):

Float f = 12,3F;

Tip de date zecimal

De asemenea, este furnizat un tip zecimal pentru a reprezenta numere cu virgulă mobilă de înaltă precizie. zecimal, care este destinat utilizării în calcule financiare. Acest tip are o lățime de 128 de biți pentru a reprezenta valori numerice cuprinse între 1E-28 și 7.9E+28. Probabil știți că aritmetica normală în virgulă mobilă este predispusă la erori de rotunjire zecimală. Aceste erori sunt eliminate prin utilizarea tipului zecimal, care permite reprezentarea numerelor cu o precizie de până la 28 (și uneori 29) zecimale. Deoarece poate reprezenta valori zecimale fără erori de rotunjire, acest tip de date este util în special pentru calculele financiare:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args)) ( // *** Calcularea costului unei investiții cu *** // *** rată fixă ​​de rentabilitate*** zecimal bani, procente; int i; const octet ani = 15; bani = 1000,0 m; procente = 0,045 m; pentru (i = 1; i

Rezultatul acestui program va fi:

Simboluri

În C#, caracterele nu sunt reprezentate de un cod de 8 biți, ca în multe alte limbaje de programare, cum ar fi C++, ci de un cod de 16 biți numit Unicode (Unicode). În Unicode, setul de caractere este atât de larg încât acoperă caractere din aproape fiecare limbă naturală din lume. În timp ce multe limbi naturale, inclusiv engleză, franceză și germană, sunt caracterizate de alfabete relativ mici, o serie de alte limbi, cum ar fi chineza, folosesc seturi de caractere destul de mari care nu pot fi reprezentate printr-un cod de 8 biți. Pentru a depăși această limitare, C# definește tip char A care reprezintă valori nesemnate de 16 biți între 0 și 65 535. Cu toate acestea, setul de caractere ASCII standard de 8 biți este un subset de Unicode între 0 și 127. Prin urmare, caracterele ASCII sunt încă valabile în C#.

Un tip de date în programare este o colecție de două seturi: un set de valori și un set de operații care le pot fi aplicate. De exemplu, tipul de date întreg nenegativ, care constă dintr-un set finit de numere naturale, poate fi aplicat la operațiile de adunare (+), înmulțire (*), împărțire întreg (/), rest (%) și scăderea (−).

Un limbaj de programare are de obicei un set de tipuri de date primitive - tipuri furnizate de limbajul de programare ca unitate de bază încorporată. În C++, creatorul limbajului numește astfel de tipuri tipuri fundamentale. Tipurile fundamentale din C++ sunt:

• boolean (bool);
• caracter (de exemplu, char);
• întreg (de exemplu int);
• virgulă flotantă (de ex. float);
• enumerari (definite de programator);
• gol .

Pe lângă cele de mai sus, sunt construite următoarele tipuri:

• pointeri (de exemplu, int*);
• matrice (de ex. char);
• referință (de exemplu, dublu&);
• alte structuri.

Să trecem la conceptul de literal (de exemplu, 1, 2.4F, 25e-4, ‘a’ etc.): un literal este o intrare în codul sursă al unui program care reprezintă o valoare fixă. Cu alte cuvinte, un literal este pur și simplu o reprezentare a unui obiect (valoare) de un anumit tip în codul programului. C++ are capacitatea de a scrie valori întregi, valori în virgulă mobilă, caractere, valori booleene, șiruri.

Un literal de tip întreg poate fi scris ca:

• al 10-lea sistem numeric. De exemplu, 1205;
• Al 8-lea sistem numeric în formatul 0 + număr. De exemplu, 0142;
• Al 16-lea sistem numeric în formatul 0x + număr. De exemplu, 0x2F .

24, 030, 0x18 sunt toate intrări ale aceluiași număr în sisteme numerice diferite.
Pentru a scrie numere în virgulă mobilă, se utilizează notația cu puncte: 0,1, .5, 4. - fie în
notație exponențială - 25e-100. Nu ar trebui să existe spații într-o astfel de înregistrare.

Numele cu care putem asocia valorile scrise de literali se numește variabilă. O variabilă este o locație numită sau adresabilă în memorie a cărei adresă poate fi folosită pentru a accesa date. Aceste date sunt scrise, suprascrise și șterse în memorie într-un anumit mod în timpul execuției programului. Variabila vă permite să accesați datele în orice moment și, dacă este necesar, să le modificați. Datele care pot fi preluate dintr-un nume de variabilă se numesc valoarea variabilei.
Pentru a utiliza o variabilă într-un program, aceasta trebuie declarată, iar dacă este necesar, poate fi definită (= inițializată). O declarație de variabilă în textul programului conține în mod necesar 2 părți: tipul de bază și declaratorul. Specificatorul și inițializatorul sunt părți opționale:

exemplu const int = 3; // aici const - specificator // int - tip de bază // exemplu - nume variabilă // = 3 - inițializator.

Numele variabilei este o secvență de caractere din litere ale alfabetului latin (minuscule și majuscule), numere și/sau litere de subliniere, dar primul caracter nu poate fi o cifră. Numele variabilei trebuie ales în așa fel încât să fie întotdeauna ușor de ghicit ce stochează, de exemplu, „monthPayment”. În abstract și în practică, vom folosi notația CamelCase pentru regulile de scriere a variabilelor. Numele unei variabile nu poate coincide cu cuvintele rezervate în limbă, exemple de astfel de cuvinte: if, while, function, goto, switch etc.

Declaratorul, pe lângă numele variabilei, poate conține caractere suplimentare:

• * - indicator; înaintea numelui
• *const - indicator constant; înaintea numelui
• & - link; înaintea numelui
• - matrice; după nume;
• () - funcție; după nume.

Un inițializator vă permite să definiți valoarea unei variabile imediat după declarație. Inițializatorul începe cu un literal egal (=) și apoi are loc procesul de setare a valorii variabilei. În general, semnul egal în C++ denotă o operație de atribuire; poate fi folosit pentru a seta și modifica valoarea unei variabile. Poate fi diferit pentru diferite tipuri.

Specificatorul specifică atribute suplimentare, altele decât tipul. Specificatorul const dat în exemplu vă permite să interziceți modificările ulterioare ale valorii variabilei. Astfel de variabile imuabile se numesc constante sau constante.

Declararea unei constante fără inițializare nu va funcționa din motive logice:

Const int EMPTY_CONST; // eroare, variabilă constantă neinițializată const int EXEMPLU = 2; // constantă cu valoarea 2 EXEMPLU = 3; // eroare, încercați să atribuiți o valoare unei variabile constante

Pentru denumirea constantelor, se obișnuiește să se folosească numai litere mari, separând cuvintele cu un caracter de subliniere.

Tipuri de date de bază în C++

În disecția fiecărui tip, cititorul trebuie să-și amintească să definească tipul de date.

1. Tipul întreg (char, short(int), int, long(int), long long)

Din nume este ușor de înțeles că setul de valori este format din numere întregi. De asemenea, setul de valori ale fiecăruia dintre tipurile enumerate poate fi semnat (semnat) sau nesemnat (nesemnat). Numărul de elemente conținute într-un set depinde de dimensiunea memoriei care este folosită pentru a stoca valoarea acelui tip. De exemplu, pentru o variabilă de tip char, este alocat 1 octet de memorie, astfel încât elementele totale vor fi:

• 2 8N = 2 8 * 1 = 256, unde N este cantitatea de memorie în octeți pentru a stoca valoarea

Într-un astfel de caz, intervalele de numere întregi disponibile sunt următoarele:

• - pentru caracter nesemnat
• [-128..127] - pentru caracter semnat

În mod implicit, o variabilă de tip întreg este considerată semnată. Pentru a indica în cod că o variabilă ar trebui să fie nesemnată, un semn semnat este atribuit tipului de bază din stânga, adică. nesemnat:

valori lungi nesemnate; // definește un tip întreg (lung) fără semn.

Tipurile enumerate diferă doar în ceea ce privește cantitatea de memorie necesară pentru stocare. Deoarece limbajul C++ este un standard de limbaj specific mașinii, acesta garantează doar următoarea condiție:

• 1 = dimensiune caracter ≤ dimensiune scurtă ≤ dimensiune int ≤ dimensiune lungă.

De obicei, dimensiunile tipurilor sunt următoarele: char - 1, short - 2, int - 4, long - 8, long long - 8 octeți.

Puteți efectua operații aritmetice cu valori de tip întreg: +, -, *, /, %; operatii de comparatie: ==, !=,<=, <, >, >=; operații pe biți: &, |, xor,<<, >>.
Majoritatea operațiunilor precum adunarea, înmulțirea, scăderea și operațiile de comparare sunt ușor de înțeles. Uneori, după efectuarea operațiilor aritmetice, rezultatul poate fi în afara intervalului de valori; în acest caz programul va da o eroare.
Împărțirea întregului (/) găsește partea întreagă a împărțirii unui număr întreg la altul. De exemplu:

• 6 / 4 = 1;
• 2 / 5 = 0;
• 8 / 2 = 4.

Simbolul procentual (%) denotă operația de determinare a restului împărțirii a două numere întregi:

• 6 % 4 = 2;
• 10 % 3 = 1.

Operațiile mai greu de înțeles sunt pe biți: & (ȘI), | (SAU), xor (SAU exclusiv),<< (побитовый сдвиг влево), >> (deplasare la dreapta pe biți).

Operațiile pe biți ȘI, SAU și XOR aplică operația logică corespunzătoare fiecărui bit de informație:

• 1 10 = 01 2
• 3 10 = 11 2
• 1 10 & 3 10 = 01 2 & 11 2 = 01 2
• 1 10 | 3 10 = 01 2 | 11 2 = 11 2
• 1 10 xor 3 10 = 01 2 xor 11 2 = 10 2

În procesarea imaginilor, pentru culoare sunt utilizate 3 canale: roșu, albastru și verde - plus transparență, care sunt stocate într-o variabilă de tip int, deoarece fiecare canal are un interval de valori de la 0 la 255. În hexazecimal, o valoare este scrisă după cum urmează: 0x180013FF; atunci valoarea 18 16 corespunde canalului roșu, 00 16 - albastru, 13 16 - verde, FF - canal alfa (transparență). Pentru a selecta un anumit canal dintr-un astfel de număr întreg, utilizați așa-numitul. masca, unde pozitiile care ne intereseaza sunt F 16 sau 1 2 . Adică, pentru a evidenția valoarea canalului albastru, trebuie să folosiți o mască, adică. pe biți și:

int blue_channel = 0x180013FF & 0x00FF0000;

După aceea, valoarea primită este deplasată la dreapta cu numărul necesar de biți.

O schimbare pe biți deplasează la stânga sau la dreapta cât mai mulți biți dintr-un număr sunt specificati în partea dreaptă a operației. De exemplu, numărul 39 pentru tipul char în formă binară este scris după cum urmează: 00100111. Apoi:

Char binaryExample = 39; // 00100111 char result = binaryExample<< 2; // сдвигаем 2 бита влево, результат: 10011100

Daca variabila este de tip fara semn, atunci rezultatul va fi numarul 156, pentru una cu semn este egal cu -100. Rețineți că pentru tipurile întregi cu semn, unitatea în ordinea înaltă a reprezentării biților este un semn că numărul este negativ. În acest caz, o valoare în formă binară formată din toate îi corespunde -1; dacă 1 este doar în cifra cea mai semnificativă, iar cifrele rămase sunt zerouri, atunci un astfel de număr are valoarea minimă pentru un anumit tip de valoare: pentru char este -128.

2. Tip virgulă mobilă (float, double (float))

Setul de valori în virgulă mobilă este un subset de numere reale, dar nu orice număr real poate fi reprezentat în binar, ceea ce duce uneori la greșeli stupide:

valoarea float = 0,2; valoare == 0,2; // eroare, valoarea nu va fi egală cu 0,2 aici.

Când lucrează cu variabile în virgulă mobilă, programatorul nu ar trebui să folosească operația de egalitate sau inegalitate, ci de obicei utilizează un test pentru a atinge un anumit interval:

Valoare - 0,2< 1e-6; // ok, подбирать интервал тоже нужно осторожно

Pe lângă operațiile de comparare, tipul în virgulă mobilă acceptă 4 operații aritmetice, care sunt pe deplin consecvente cu operațiile matematice cu numere reale.

3. Tip boolean (logic) (bool)

Constă doar din două valori: adevărat (adevărat) și fals (fals). Pentru a lucra cu variabile de acest tip se folosesc operatii logice: ! (NU), == (egalitate), != (inegalitate), && (ȘI logic), || (SAU logic). Rezultatul fiecărei operații poate fi găsit în tabelul de adevăr corespunzător. De exemplu:

X Y XOR0 0 0 0 1 1 1 0 1 1 1 0

4. Tip de caracter (char, wchar_t)

Tipul char nu este doar un tip întreg (de obicei, un astfel de tip se numește octet), ci și un tip de caracter, stocând numărul caracterului din tabel ca caracter ASCII. De exemplu, codul 0x41 corespunde caracterului „A”, iar 0x71 - „t”.

Uneori devine necesar să folosiți caractere care nu sunt fixate în tabelul ASCII și, prin urmare, necesită mai mult de 1 octet pentru a fi stocat. Există un caracter larg (wchar_t) pentru ei.

5.1. Matrice

Matricele vă permit să stocați un set secvențial de elemente de același tip. O matrice este stocată în memorie într-un bloc contiguu, deci nu puteți declara o matrice fără a specifica dimensiunea acestuia. Pentru a declara o matrice, după numele variabilei scrieți paranteze pătrate () indicând dimensiunea acesteia. De exemplu:

int myArray; // Matrice de 5 elemente de tip întreg

Pentru a inițializa o matrice, valorile sunt enumerate în acolade. Puteți inițializa în acest fel doar în momentul declarării variabilei. Apropo, în acest caz nu este necesar să specificați dimensiunea matricei:

int odds = (1, 3, 7, 9, 11); // Matricea este inițializată cu 5 valori

Pentru a accesa o anumită valoare dintr-o matrice (element de matrice), utilizați operația de acces la index () cu numărul elementului (numerele încep de la 0). De exemplu:

cote; // acces la primul element al matricei. Returnează valoarea 1 cotă; // acces la al treilea element. Returnează valoarea 7 cote = 13; // Atribuiți o nouă valoare celui de-al 5-lea element al cotelor matricei; // eroare de acces

5.3. Siruri de caractere

Pentru a scrie un șir, programatorii folosesc ideea că un șir este o serie consecutivă (matrice) de caractere. Pentru a identifica sfârșitul unei linii, se folosește un caracter special de sfârșit de linie: „\0”. Aceste caractere speciale, formate dintr-o bară oblică inversă și un caracter de identificare, se numesc caractere de control sau de evacuare. Mai există, de exemplu, „\n” - începutul unei noi linii, „\t” - tabelare. Pentru a înregistra o bară oblică inversă într-o linie, se folosește evadarea - o altă bară oblică este pusă înaintea semnului în sine: „\”. Escape este folosit și pentru a scrie ghilimele.

Să creăm o variabilă șir:

Car textExample = ('T', 'e', ​​​​'s', 't', '\0'); // este scris șirul „Test”.

Există o notație simplificată pentru inițializarea șirurilor:

Char textExample = "Test"; // Ultimul caracter nu este scris, dar dimensiunea este tot 5

Fără a intra în detalii, iată un alt tip de date util - șir. Siruri de caractere
de acest tip, de exemplu, puteți adăuga:

String salut = „Bună,”; stringname = "Max!"; șir hello_name = salut + nume; // Obține șirul „Hi, Max!”

6. Link

Int a = 2; // variabila „a” indică valoarea 2 int &b = a; // variabila „b” indică același loc cu „a” b = 4; // prin modificarea valorii lui b, programatorul schimbă valoarea lui a. Acum a = 4 int &c = 4; // eroare, nu puteți face asta, deoarece referinței nu i se poate atribui o valoare

7. Indicator

Pentru a trata acest tip de date, este necesar să ne amintim că setul de valori de acest tip este adresele celulelor de memorie de unde încep datele. Pointerul acceptă, de asemenea, operații de adunare (+), scădere (-) și dereferențiere (*).

Adresele 0x0 înseamnă că indicatorul este gol, adică. nu indică nicio dată. Această adresă are propriul său literal - NULL:

Int *nullPtr = NULL; // pointer nul

Adăugarea și scăderea unei adrese cu un număr întreg sau o altă adresă permite
deplasați-vă în memoria disponibilă pentru program.

Operația de obținere a datelor începând de la adresa stocată într-un pointer se numește dereferencing (*). Programul citește numărul necesar de celule de memorie și returnează valoarea stocată în memorie.

Int valueInMemory = 2; // setează o variabilă de tip întreg int *somePtr = // copiază adresa variabilei, aici & - returnează adresa variabilei somePtr; // adresa celulei de memorie, de exemplu, 0x2F *somePtr; // valoarea este stocată în 4 celule: 0x2F, 0x30, 0x31 și 0x32

Pentru pointeri, operația de atribuire, care din punct de vedere sintactic este aceeași cu operația de copiere, nu este disponibilă. Cu alte cuvinte, puteți copia adresa unui alt pointer sau adresa unei variabile, dar nu puteți determina singur valoarea adresei.

Pointerul în sine este stocat în memorie, ca și valorile variabilelor de alte tipuri, și are 4 octeți, astfel încât să puteți crea un pointer către un pointer.

8. Transferuri

Enumerările sunt singurul tip de bază definit de programator. În general, o enumerare este un set ordonat de constante numere întregi, numele enumerației fiind tipul de bază.

Enumcolor(ROSU, ALBASTRU, VERDE);

În mod implicit, ROȘU = 0, ALBASTRU = 1, VERDE = 2. Prin urmare, valorile pot fi comparate între ele, adică. ROȘU< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

Acces Enum(READ=1, WRITE=2, EXEC=4);

Este adesea convenabil să folosiți enumerari ale căror valori sunt o putere a doi, deoarece în reprezentare binară, un număr care este o putere a lui 2 va consta din prima unitate și zerouri. De exemplu:

8 10 = 00001000 2

Rezultatul adunării acestor numere indică întotdeauna clar care numere au fost adăugate:

37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10

Vidul

Sintactic, tipul gol este unul dintre tipurile fundamentale, dar poate fi folosit doar ca parte a unor tipuri mai complexe, deoarece obiectele de tip void nu există. De obicei, acest tip este folosit pentru a informa că o funcție nu are valoare returnată sau ca tip de bază al unui pointer către obiecte de tipuri nedefinite:

obiect gol; // eroare, nu există obiecte de tip void void // eroare, nu există referințe la void void *ptr; // ok, stochează un pointer către un tip necunoscut

Adesea vom folosi void în mod specific pentru a indica faptul că o funcție nu returnează nicio valoare. Un pointer de tip nul este gestionat atunci când programatorul își asumă întreaga responsabilitate pentru integritatea memoriei și modelarea corectă a tipului.

Distribuție

De multe ori este necesar să turnați valoarea unei variabile de un tip la altul. În cazul în care setul de valori ale tipului original este un subset de tip mai mare (de exemplu, int este un subset de long și long este un dublu), compilatorul poate implicit ( implicit) modificați tipul valorii.

int întreg = 2; plutitor plutitor = întreg; // plutitor = 2,0

Conversia tipului va fi efectuată cu pierderea de informații, deci va rămâne doar partea întreagă a numărului în virgulă mobilă, partea fracțională se va pierde.

Există posibilitatea conversiei explicite (explicite) a tipului, pentru aceasta, în stânga variabilei sau a unei valori a tipului inițial, scrieți în paranteze tipul la care se va face turnarea:

valoare int = (int) 2,5;

Operații unare și binare

Acele operații pe care le-am efectuat mai devreme se numesc binare: în stânga și în dreapta simbolului operației există valori sau variabile, de exemplu, 2 + 3. Pe lângă operațiile binare, limbajele de programare folosesc și operații unare. care se aplică variabilelor. Ele pot fi fie la stânga, fie la dreapta unei variabile, mai multe astfel de operații au fost întâlnite înainte - operația de dereferire (*) și luarea adresei unei variabile (&) sunt unare. Operatorii „++” și „-” măresc și scad valoarea unei variabile întregi cu 1, respectiv, și pot fi scriși fie în stânga, fie în dreapta variabilei.

C++ folosește, de asemenea, o notație scurtă pentru operațiile binare atunci când părțile din stânga și din dreapta ale unei expresii conțin aceeași variabilă, de exemplu. se efectuează o operație cu valoarea variabilei, iar rezultatul operației este stocat în aceeași variabilă:

A += 2; // la fel ca a = a + 2; b /= 5; // la fel ca b = b / 5; c &= 3; // la fel ca c = c & 3;