Tipurile char, short, int și long. Tipuri de date și variabile Tipuri de date numerice în c

Această foaie de cheat oferă informații despre principalele tipuri de date ale limbajului de programare C++ și caracteristicile implementării acestora. De asemenea, la sfârșitul înregistrării există un tabel cu intervalele de valori ale acestor tipuri.

Conceptul tipului de date

Scopul principal al oricărui program este prelucrarea datelor. Diferite tipuri de date sunt stocate și procesate diferit. În orice limbaj algoritmic, fiecare constantă, variabilă, expresie sau funcție trebuie să aibă un anumit tip.

Tipul de date definește:

• Reprezentare internă a datelor în memoria computerului;
• setul de valori pe care cantitățile de acest tip le pot lua;
• operaţii şi funcţii care pot fi aplicate cantităţilor de acest tip.

Pe baza acestor caracteristici, programatorul selectează tipul fiecărei cantități utilizate în program pentru a reprezenta obiecte reale. O declarație de tip obligatorie permite compilatorului să verifice validitatea diferitelor constructe de program. Tipul de valoare determină instrucțiunile mașinii care vor fi utilizate pentru prelucrarea datelor.

Toate tipurile de limbaj C++ pot fi împărțite în de bază Și compozit . Limbajul C++ definește șase principal tipuri de date pentru a reprezenta valori întregi, reale, caractere și logice. Pe baza acestor tipuri, programatorul poate introduce o descriere compozit tipuri. Acestea includ matrice, enumerari, functii, structuri, referinte, pointeri, uniuni si clase.

Tipuri de date de bază în C++

Tipurile de date de bază (standard) sunt adesea numite aritmetice deoarece pot fi utilizate în operații aritmetice. Pentru a descrie principalele tipuri, sunt definite următoarele:

1. int(int);
2. char(char);
3. wchar_t(widechar);
4. bool(boolean);
5. float(real);
6. dublu (dublă precizie reală).

Primele patru tipuri sunt numite întregi ( întreg ), ultimele două - tipuri de virgulă mobilă . Codul pe care compilatorul îl generează pentru gestionarea valorilor întregi este diferit de codul pentru valorile în virgulă mobilă.

Sunt patru specificator de tip , clarificând reprezentarea internă și intervalul de valori ale tipurilor standard:

• scurt (scurt);
• lung lung);
• semnat(semnat);
• nesemnat.

Tip întreg (int)

Mărimea tipului int nu este definită de standard, dar depinde de computer și de compilator. Pentru un procesor pe 16 biți, 2 octeți sunt alocați pentru valori de acest tip, pentru un procesor pe 32 biți - 4 octeți.

Specificatorul scurt dinaintea numelui tipului indică compilatorului că trebuie alocați 2 octeți pentru număr, indiferent de capacitatea procesorului. Specificatorul lung înseamnă că valoarea întreagă va ocupa 4 octeți. Deci, pe un computer pe 16 biți, echivalentele sunt int și short int, iar pe un computer pe 32 de biți echivalentele sunt int și long int.

Reprezentarea internă valori de tip întreg - un număr întreg în cod binar. Când se utilizează specificatorul cu semn, bitul cel mai semnificativ al numărului este interpretat ca fiind cu semn (0 este un număr pozitiv, 1 este un număr negativ). Specificatorul nesemnat permite reprezentarea numai a numerelor pozitive, deoarece bitul cel mai semnificativ este tratat ca parte a codului numărului. Astfel, intervalul de valori de tip int depinde de specificatori. Intervalele de valori ale valorilor de tip întreg cu diverși specificatori pentru computerele compatibile cu IBM PC sunt prezentate în tabelul „Intervalele de valori ale tipurilor de date simple” de la sfârșitul intrării.

În mod implicit, toate tipurile de numere întregi sunt considerate semnate, ceea ce înseamnă că specificatorul semnat poate fi omis.

Constantelor găsite într-un program li se atribuie un tip sau altul în funcție de tipul lor. Dacă din anumite motive programatorul nu este mulțumit de acest tip, el poate indica în mod explicit tipul necesar folosind sufixele L, l (lung) și U, u (fără semn). De exemplu, constanta 32L va fi de tip lung și va ocupa 4 octeți. Puteți utiliza sufixele L și U în același timp, de exemplu, 0x22UL sau 05Lu.

Notă

Tipurile short int, long int, signed int și unsigned int pot fi abreviate la short, long, signed și, respectiv, unsigned.

Tip de caracter (car)

Valoarea unui tip de caracter este alocat un număr de octeți suficient pentru a găzdui orice caracter din setul de caractere pentru un computer dat, ceea ce determină numele tipului. De obicei, acesta este de 1 octet. Tipul char, ca și alte tipuri de numere întregi, poate fi semnat sau nesemnat. Valorile semnate pot stoca valori în intervalul -128 la 127. Folosind specificatorul nesemnat, valorile pot varia de la 0 la 255. Acest lucru este suficient pentru a stoca orice caracter din setul de caractere ASCII de 256 de caractere. Valorile tipului char sunt, de asemenea, folosite pentru a stoca numere întregi care nu depășesc limitele intervalelor specificate.

Tip de caracter extins (wchar_t)

Tipul wchar_t este proiectat să funcționeze cu un set de caractere pentru care 1 octet nu este suficient pentru a codifica, de exemplu, Unicode. Mărimea acestui tip este dependentă de implementare; de regulă, corespunde tipului scurt. Constantele șir de caractere de tip wchar_t sunt scrise cu prefixul L, de exemplu, L»Gates».

tip boolean (bool)

Valorile booleene pot lua numai valorile adevărate și false, care sunt cuvinte rezervate. Forma internă de reprezentare a valorii false este 0 (zero). Orice altă valoare este interpretată ca adevărată. Când este convertit într-un tip întreg, true are valoarea 1.

Tipuri în virgulă mobilă (float, double și long double)

Standardul C++ definește trei tipuri de date pentru stocarea valorilor reale: float, double și long double.

Tipurile de date în virgulă mobilă sunt stocate diferit în memoria computerului decât tipurile de date întregi. Reprezentarea internă a unui număr real constă din două părți - mantisa și exponentul. Pe computerele compatibile cu IBM PC, valorile float ocupă 4 octeți, dintre care o cifră binară este alocată pentru semnul mantisei, 8 biți pentru exponent și 23 pentru mantise. Mantisa este un număr mai mare de 1,0 dar mai mic de 2,0. Deoarece cifra principală a mantisei este întotdeauna 1, aceasta nu este stocată.

Pentru valorile duble care ocupă 8 octeți, 11 și 52 de biți sunt alocați pentru exponent și respectiv mantisă. Lungimea mantisei determină precizia numărului, iar lungimea exponentului determină intervalul acestuia. După cum puteți vedea din tabelul de la sfârșitul intrării, cu același număr de octeți alocați pentru valorile float și long int, intervalele valorilor lor permise diferă foarte mult datorită formei de reprezentare internă.

Specificatorul lung dinaintea unui nume de tip dublu indică faptul că sunt alocați 10 octeți pentru valoarea acestuia.

Constantele în virgulă mobilă sunt de tip dublu în mod implicit. Puteți specifica în mod explicit tipul unei constante folosind sufixele F, f (float) și L, l (lung). De exemplu, constanta 2E+6L va fi de tip long double, iar constanta 1.82f va fi de tip float.

Pentru a scrie programe care sunt portabile pe platforme, nu puteți face presupuneri despre dimensiunea tipului int. Pentru a-l obține, trebuie să utilizați dimensiunea operației, rezultatul căreia este dimensiunea tipului în octeți. De exemplu, pentru sistemul de operare MS-DOS, dimensiunea (int) va avea ca rezultat 2, dar pentru Windows 98 sau OS/2 rezultatul va fi 4.

Standardul ANSI nu specifică intervale de valori pentru tipurile de bază; sunt definite doar relațiile dintre dimensiunile acestora, de exemplu:

sizeof(float) ≤ slzeof(double) ≤ sizeof(long double)
sizeof(char) ≤ slzeof(short) ≤ sizeof(int) ≤ sizeof(lung)

Notă

Valorile minime și maxime permise pentru tipurile întregi sunt dependente de implementare și sunt date în fișierul antet (), caracteristici ale tipurilor reale - în dosar (), precum și în șablonul de clasă numeric_limits

tip void

Pe lângă cele enumerate, principalele tipuri de limbaj includ tipul de gol, dar setul de valori de acest tip este gol. Este folosit pentru a defini funcții care nu returnează o valoare, pentru a specifica o listă goală de argumente ale funcției, ca tip de bază pentru pointeri și în operațiunile de turnare a tipului.

Intervalele de valori ale tipurilor de date simple în C++ pentru computerele IBM compatibile cu PC

Î: Ce înseamnă termenul computer compatibil IBM PC?
R: Un computer compatibil IBM PC este un computer care este aproape arhitectural de IBM PC, XT și AT. Calculatoarele IBM compatibile cu PC-uri sunt construite pe microprocesoare compatibile cu Intel 8086 (și, după cum știți, toate procesoarele Intel ulterioare sunt complet compatibile cu 8086). De fapt, acestea sunt aproape toate computere moderne.

Au fost introduse diferite tipuri de tipuri întregi și reale, care diferă în intervalul și acuratețea reprezentării datelor, pentru a oferi programatorului oportunitatea de a utiliza cel mai eficient capacitățile echipamentelor specifice, deoarece viteza calculelor și cantitatea de memorie depind de alegerea tipului. Dar un program optimizat pentru un tip de computer poate să nu fie portabil pe alte platforme, așa că, în general, ar trebui să evitați să vă bazați pe caracteristicile specifice ale tipurilor de date.

Pentru tipurile reale, tabelul arată valorile absolute ale valorilor minime și maxime.

Răspuns:

1. Tipuri de date întregi:

short int, unsigned short int, int, unsigned int, long, unsigned long.

1. Tipuri de date în virgulă mobilă (corespunzător tipurilor reale):

plutitor, dublu, dublu lung.

1. Tip de date caracter:

char (caracter semnat), caracter nesemnat, wchar_t.

1. Tipul de date boolean:

bool.

1. Tip de date enumerate (introdus în Visual C++):

enumerare.

2. Care sunt caracteristicile utilizării tipurilor de date întregi?

În C++, principalele tipuri de date întregi sunt: ​​short int, unsigned short int, int, unsigned int, long (long int), unsigned long (unsigned long int).

Aceste tipuri de date reprezintă valori dintr-un set de numere întregi. De exemplu:

Tipurile de date care încep cu prefixul fără semn pot conține numai numere pozitive.

Datele de tip short int, unsigned short int ocupă jumătate din spațiul de memorie decât datele de tip int, unsigned int.

Datele de tip long, unsigned long ocupă de două ori mai mult spațiu de memorie decât datele de tip int, unsigned int.

3. Cum se descrie o variabilă numită x de tip întreg într-un program?

Răspuns:

Ca urmare, sub variabila X va fi alocat un spațiu de memorie de 4 octeți. Mărimea memoriei alocate pentru o variabilă depinde de caracteristicile computerului, de tipul sistemului de operare și de setările compilatorului.

4. Cum se scrie numărul 239 într-o variabilă de tip întreg?

Pentru a face acest lucru, utilizați operatorul de atribuire, care este notat cu simbolul „=”.

Raspunsul 1. Introducerea unui număr într-o variabilă după descrierea acesteia.

Raspunsul 2. Introducerea unui număr într-o variabilă în timpul descrierii acesteia (inițializarea inițială).

5. Care sunt caracteristicile tipurilor de date în virgulă mobilă?

Tipurile de date cu virgulă mobilă vă permit să reprezentați valori dintr-un set de numere reale. De exemplu:

C++ are următoarele tipuri de date de bază în virgulă mobilă: float, double, long double.

O variabilă de tip double ocupă de 2 ori mai mult spațiu în memoria computerului decât o variabilă de tip float.

De asemenea, o variabilă de tip dublu lung ocupă de 2 ori mai mult spațiu în memoria computerului decât o variabilă de tip dublu.

6. Cum se descrie o variabilă care ia o valoare în virgulă mobilă?

Un exemplu de descriere a variabilelor tipurilor float, double, long double:

7. Cum se scrie valori numerice într-o variabilă în virgulă mobilă?

Un exemplu de introducere a datelor numerice în variabile cu virgulă mobilă:

8. Cum se transformă o variabilă float într-un tip int?

Pentru a face acest lucru, se utilizează operația de turnare de tip. În paranteze trebuie să indicați numele tipului la care este distribuită distribuția.

Când utilizați operațiuni de turnare a tipurilor, trebuie să țineți cont de restricțiile care se aplică tipurilor care ocupă mai puțin spațiu în memoria computerului.

De exemplu, o variabilă de tip short int poate reprezenta un interval mai mic de numere decât variabilele de tip float sau double. Următoarea listare depășește o valoare într-o variabilă de tip short int:

9. Cum se transformă o variabilă de la tipul int la tipul double?

Exemplu de turnare de la int la dublu:

10. Care sunt caracteristicile utilizării datelor de caractere (date de caractere) într-un program?

Datele de tip char reprezintă valoarea caracterului codului introdus de la tastatură. Codul simbolului este un număr întreg.

De exemplu, codul caracterului „f” este 102.

Un fragment de cod care calculează codul caracterului:

Datele de tip char sunt aceleași numere întregi. Datele de tip char ocupă 1 octet în memoria computerului.

Relația caracter-cod este localizată în tabelul de simboluri Windows. Caracterele cu coduri de la 0 la 127 sunt caractere rezervate BIOS. Acestea includ cele mai frecvent utilizate simboluri, simboluri numerice și simboluri latine. Aceste caractere nu pot fi modificate.

Caracterele cu coduri de la 128 la 255 sunt caractere regionale care sunt legate de un anumit alfabet al computerului pe care este instalat sistemul de operare Windows.

11. Care sunt caracteristicile utilizării tipului de date bool (tip logic)?

Variabilele de tip bool pot lua doar două valori:

Adevarul adevarat,

fals - fals.

Aceste variabile sunt folosite pentru a testa expresiile booleene. Valoarea numerică a adevăratului este 1. Valoarea numerică a lui false este 0.

Fragment de cod care definește valorile numerice adevărat și fals:

Fragment de cod care convertește tipurile int și float în bool:

12. Cum se determină dimensiunea memoriei ocupată de o variabilă de un anumit tip?

Operația sizeof() este utilizată pentru aceasta.

Un fragment de cod care definește dimensiunea unor tipuri de date:

13. Cum sunt inițializate variabilele de diferite tipuri?

14. Cum se determină valoarea maximă admisibilă (minima admisibilă) a unei variabile de un anumit tip?

Pentru a determina valoarea maximă sau minimă pentru o variabilă de un anumit tip, biblioteca .NET Framework utilizează proprietățile MaxValue și MinValue.

Exemple de determinare a valorilor limită ale variabilelor de diferite tipuri.

Pentru variabile de tip int:

Pentru variabile de tip short int:

Pentru variabile de tip unsigned int:

Pentru variabilele float:

Pentru variabile de tip double:

Pentru variabile de tip char:

15. Care sunt caracteristicile utilizării tipului de enumerare?

Tipul enumerare este un tip de date enumerare. Specifică valori mnemonice pentru seturi de valori întregi. Fiecare valoare mnemonică are un conținut specific și este reprezentată de un număr întreg.

Un exemplu de utilizare a tipului enum pentru a reprezenta lunile anului:

Exemplul de mai jos descrie o variabilă numită mn de tip enum months. Valorile mnemonice pentru luni (ianuarie, februarie, …) încep de la 0 (0, 1, 2, …). Mnemonicul ianuarie este valoarea întreagă 0, mnemonicul februarie este numărul întreg 1 și așa mai departe.

Deci, folosind tipul enum, mnemonicii pot fi folosite în textul programului pentru o mai bună claritate a codului sursă.

Puteți scrie și așa:

16. Care sunt caracteristicile tipuluigol în programe peC++ ?

Tipul de date void este utilizat în următoarele cazuri:

• dacă trebuie să descrii o funcție care nu returnează nicio valoare (vezi exemplu);
• dacă trebuie să descrii o funcție care nu primește parametri (vezi exemplul).

Exemplu. MyFun() este o funcție fără parametri care nu returnează nicio valoare (returnează tipul void ) și nu acceptă parametri.

17. Este posibil să se declare o variabilă de tipgol intr-un program?

Acest lucru nu este posibil deoarece tipul void nu este asociat cu o valoare.

Declararea unei variabile de tip void are ca rezultat o eroare de compilare cu următorul mesaj:

18. Care sunt caracteristicile tipuluiwchar_ t VVizual C++ ?

Variabilele de tip char (vezi paragrafele anterioare) sunt folosite pentru a stoca caractere ASCII pe 8 biți.

Tipul wchar_t este folosit pentru a stoca caractere care fac parte din seturi mari de caractere. De exemplu, alfabetul chinezesc are un număr mare de caractere. 8 cifre nu sunt suficiente pentru a reprezenta întregul set de caractere chinezești. Prin urmare, dacă trebuie să utilizați programul pe piața internațională, este recomandabil să înlocuiți tipul char cu wchar_t.

Exemplu folosind tipul wchar_t.

Tipul întreg char ocupă 1 octet (8 biți) în memorie și vă permite să exprimați 2^8 valori = 256 în 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 scurt întreg 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 la 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 -32.768 și 32.767.

scurt

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

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 de memorie și vă permite să exprimați valori întregi de la 0 la 4.294.967.295.

lung

Tipul întreg 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 ocupă, de asemenea, 8 octeți și poate stoca valori de la 0 la 18.446.744.073.709.551.615.

Exemple:

Deoarece tipurile întregi fără semn nu sunt concepute pentru a stoca valori negative, încercarea de a seta o valoare negativă poate avea consecințe neașteptate. Un script nevinovat ca acesta va duce la o buclă nesfârșită:

Calea corectă ar fi:

Rezultat:

Tipuri de date

Tipurile de date sunt deosebit de importante în C#, deoarece este un limbaj puternic tipizat. Aceasta înseamnă că toate operațiunile sunt supuse unei verificări stricte de tip de către compilator, iar operațiunile ilegale nu sunt compilate. În consecință, verificarea strictă a tipului elimină erorile și crește fiabilitatea programelor. Pentru a impune verificarea tipului, toate variabilele, expresiile și valorile trebuie să fie de un anumit tip. Nu există deloc o variabilă „fără tip” în acest limbaj de programare. Mai mult, tipul unei valori determină operațiunile care pot fi efectuate asupra acesteia. O operațiune care este legală pentru un tip de date poate să nu fie valabilă 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ă, iar tipurile de referință sunt stocate într-o zonă cunoscută sub numele de 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 primul rând 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 numere și adâncimea de biți:

După cum arată tabelul de mai sus, C# definește atât variante semnate, cât și nesemnate ale diferitelor tipuri de numere întregi. Tipurile de numere întregi semnate diferă de omologii lor nesemnați în modul în care interpretează bitul cel mai semnificativ al întregului. Astfel, dacă un program specifică o valoare întreagă cu semn, compilatorul C# va genera cod care folosește cel mai semnificativ bit 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 două, prin care toate cifrele binare ale numărului negativ sunt mai întâi inversate și apoi 1 este adăugat la acel număr.

Probabil cel mai comun tip de număr întreg în programare este tip int. Variabilele de tip int sunt adesea folosite pentru controlul buclei, indexarea matricei și calcule matematice de uz general. Când aveți nevoie de o valoare întreagă cu o gamă mai mare de reprezentări decât tipul int, există o serie de alte tipuri întregi disponibile în acest scop.

Deci, dacă valoarea trebuie stocată fără semn, atunci puteți selecta pentru aceasta tip uint, pentru valori mari semnate - tip lung, iar pentru valori mari nesemnate - tastați 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ă lungă:

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ții zecimale sau hexazecimale. În acest din urmă caz, este necesar un prefix 0x:

Long x = 0x12ab;

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

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

U și L pot fi scrise și cu litere mici, deși un L mic poate fi ușor confundat vizual cu numărul 1 (unu).

Tipuri în 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. Ele reprezintă valori numerice cu precizie simplă și, respectiv, dublă. Astfel, lățimea tipului 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 lățimea 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 destinat valorilor 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ă în codul sursă este codificată o valoare non-întreg (de exemplu, 12.3), atunci compilatorul presupune de obicei că este intenționată o valoare dublă. Dacă valoarea trebuie specificată ca un float, va trebui să îi adăugați caracterul F (sau f):

Float f = 12,3F;

Tip de date zecimal

De asemenea, este furnizat un tip zecimal pentru a reprezenta numere în 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 obișnuită în virgulă mobilă este predispusă la erori de rotunjire zecimală. Aceste erori sunt eliminate prin utilizarea tipului zecimal, care permite reprezentarea numerelor cu 28 (și uneori 29) zecimale. Deoarece acest tip de date poate reprezenta valori zecimale fără erori de rotunjire, 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)) ( // *** Calculul costului unei investiții cu *** // *** rata fixă ​​de rentabilitate*** zecimală bani, procent; int i; const byte ani = 15; bani = 1000,0 m; procente = 0,045 m; pentru (i = 1; i

Rezultatul acestui program va fi:

Simboluri

În C#, caracterele sunt reprezentate nu în cod de 8 biți, ca în multe alte limbaje de programare, cum ar fi C++, ci în cod de 16 biți, numit Unicode. Setul de caractere Unicode 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ă, au alfabete relativ mici, unele alte limbi, cum ar fi chineza, folosesc seturi de caractere destul de mari care nu pot fi reprezentate în codul de 8 biți. Pentru a depăși această limitare, C# definește tip char, care reprezintă valori nesemnate de 16 biți, cuprinse între 0 și 65 535. Cu toate acestea, setul de caractere ASCII standard pe 8 biți este un subset al Unicode, care variază de la 0 la 127. Prin urmare, caracterele ASCII sunt încă valabile în C# .

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 asupra ei ș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 și fals. Amprenta de memorie pentru acest tip nu este definită cu precizie.

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 de la -128 la 127

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

wchar_t : Reprezintă un caracter larg. Pe Windows ocupă 2 octeți (16 biți) de memorie, pe Linux ocupă 4 octeți (32 biți). Poate stoca orice valoare din intervalul de la 0 la 65.535 (pentru 2 octeți) sau de la 0 la 4.294.967.295 (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 65.535

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 4.294.967.295

scurt : Reprezintă un număr întreg în intervalul –32768 până la 32767. Ocupă 2 octeți (16 biți) de 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) de memorie.

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

int: reprezintă un număr întreg. În funcție de arhitectura procesorului, acesta poate ocupa 2 octeți (16 biți) sau 4 octeți (32 biți). Intervalul valorilor limită poate varia în consecință de la –32768 la 32767 (cu 2 octeți) sau de la -2.147.483.648 la 2.147.483.647 (cu 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, acesta poate ocupa 2 octeți (16 biți) sau 4 octeți (32 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 până 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 -2.147.483.648 până la 2.147.483.647. 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 sinonimul unsigned long int .

long long: reprezintă un număr întreg în intervalul -9.223.372.036.854.775.808 până la +9.223.372.036.854.775.807. Ocupă de obicei 8 octeți (64 de biți) de 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 18.446.744.073.709.551.615. Ocupă de obicei 8 octeți (64 de biți) de memorie.

Are sinonimul unsigned long long int .

float : Reprezintă un număr real cu o singură precizie în virgulă mobilă î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 real 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 în virgulă mobilă cu precizie dublă de cel puțin 8 octeți (64 de biți). În funcție de dimensiunea memoriei ocupate, intervalul de valori valide poate varia.

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 de numere în virgulă mobilă (float, double, long double).

Tipuri de caractere

Tipurile folosite pentru a reprezenta caracterele în aplicație sunt char, wchar_t, char16_t și char32_t.

Să definim mai multe variabile:

Char c="d"; wchar_t d="c";

O variabilă char ia ca valoare un caracter între ghilimele simple: 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ă, ar trebui să utilizați nu std::cout, ci fluxul std::wcout:

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

În acest caz, fluxul std::wcout poate funcționa atât cu char cât și cu wchar_t. Și fluxul std::cout pentru variabila wchar_t va scoate codul său numeric în loc de un caracter.

Standardul C++11 a adăugat tipurile char16_t și char32_t, care sunt orientate spre utilizarea Unicode. Cu toate acestea, firele pentru lucrul cu aceste tipuri nu au fost încă implementate la nivel de sistem de operare. Prin urmare, dacă trebuie să afișați valorile variabilelor de aceste tipuri pe consolă, trebuie să convertiți variabilele în tipurile 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, la ieșire, variabilele sunt precedate de o operație de turnare la tipul char - (char), datorită căreia valorile variabilelor b, c și d sunt convertite în tipul char și pot fi scoase la consola folosind fluxul std::cout.

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 de numere în virgulă mobilă

Tipurile de numere în virgulă mobilă și fracțională sunt reprezentate prin float, double și long double:

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

Dimensiunile tipurilor de date

Lista de mai sus arată pentru fiecare tip dimensiunea pe care o ocupă în memorie. Cu toate acestea, merită remarcat faptul că dezvoltatorii de compilatoare pot alege limitele de dimensiune pentru tipuri în mod independent, î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 - 32 de biți, pentru tipul long dublu. Î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++ pentru Windows folosește 12 octeți pentru dubluri lungi, iar compilatorul încorporat în Visual Studio și rulează și sub Windows folosește 8 octeți pentru dubluri lungi. Adică, chiar și în cadrul aceleiași platforme, diferiți compilatori pot avea abordări diferite ale dimensiunilor anumitor tipuri de date. Dar, în general, se folosesc dimensiunile indicate mai sus atunci când descriem tipurile de date.

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

#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 conturate pentru tipul acesteia. De exemplu:

Număr scurt nesemnat = -65535;

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

În Visual Studio, compilarea poate continua fără erori, dar variabila număr va primi valoarea 2 - rezultatul conversiei numărului -65535 într-un tip scurt nesemnat. Adică, din nou, rezultatul nu va fi exact cel așteptat. Valoarea unei variabile este doar o colecție 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 poate fi dificil să se determine tipul de expresie. Și conform celor mai recente standarde, puteți lăsa compilatorul să deducă tipul obiectului în sine. Și specificatorul automat este folosit pentru asta. 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.