Variabilele sunt folosite pentru a stoca diverse date în limbaje de programare. O variabilă este o zonă de memorie care are un nume, altfel numit identificator.
Dăruind numele variabilei, programatorul denumește în același timp zona de memorie în care se vor scrie valorile variabilei pentru stocare cu același nume.
Este un stil bun să numești variabilele în mod semnificativ. Este permisă folosirea literelor mici și majuscule, cifre și un caracter de subliniere, care este considerată o literă în C. Primul caracter trebuie să fie o literă și nu trebuie să existe spații în numele variabilei. În versiunile moderne ale compilatoarelor, lungimea numelui este practic nelimitată. Numele variabilei nu poate corespunde cuvintelor cheie rezervate. Capitalele și litere mici numele variabilelor diferă, variabile oŞi O- variabile diferite.
Cuvinte cheie rezervate auto double int struct break else lung comutare registru tupedef char extern return void case float unsigned implicit pentru uniunea semnată do if sizeof volatile continue enumerarea scurtă
În C, toate variabilele trebuie declarate. Aceasta înseamnă că, în primul rând, la începutul fiecărui program sau funcție trebuie să furnizați o listă cu toate variabilele utilizate și, în al doilea rând, să indicați tipul fiecăreia dintre ele.
Când o variabilă este declarată, compilatorul îi alocă spațiu de memorie în funcție de tipul acesteia. Prin mijloace standard AVR GCC funcționează cu tipuri de date char(tip de caracter) și int(tip întreg).
Tipuri variabile |
Tastați char
char- este cel mai economic tip. Tipul de caracter poate fi semnat sau nesemnat. Notat în consecință ca „ semnat char„ (tip semnat) și „ nesemnat char" (tip nesemnat). Tipul semnat poate stoca valori în intervalul de la -128 la +127. Unsigned - de la 0 la 255. O variabilă char are 1 octet de memorie (8 biți).
Cuvinte cheie (modificatoare) semnatŞi nesemnat indicați modul în care este interpretat bitul zero al variabilei declarate, adică dacă este specificat cuvântul cheie fără semn, atunci bitul zero este interpretat ca parte a unui număr, în caz contrar bitul zero este interpretat ca semnat.
Tastați int
Valoare întreagă int Pot fi scurt(scurt) sau lung(lung).
Cuvânt cheie (modificator) scurt plasat după cuvinte cheie semnat sau nesemnat. Astfel, se disting următoarele tipuri: signed short int, unsigned short int, signed long int, unsigned long int.
Variabila de tip semnat scurt int(întreg scurt cu semn) poate lua valori de la -32768 la +32767, unsigned short int(întreg scurt fără semn) - de la 0 la 65535. Pentru fiecare dintre ei sunt alocați exact doi octeți de memorie (16 biți).
La declararea unei variabile de tip semnat scurt int cuvinte cheie semnatŞi scurt poate fi omis, iar un astfel de tip de variabilă poate fi declarat simplu int. De asemenea, este posibil să declarați acest tip cu un singur cuvânt cheie scurt.
Variabilă unsigned short int poate fi declarat ca nesemnat int sau scurt nesemnat.
Pentru fiecare dimensiune semnat lung int sau nesemnat lung int Sunt alocați 4 octeți de memorie (32 de biți). Valorile variabilelor de acest tip pot fi în intervalele de la -2147483648 la 2147483647 și, respectiv, de la 0 la 4294967295.
Există și variabile precum lung lung int, pentru care sunt alocați 8 octeți de memorie (64 de biți). Ele pot fi, de asemenea, semnate sau nesemnate. Pentru un tip semnat, intervalul de valori este de la -9223372036854775808 la 9223372036854775807, pentru un tip nesemnat - de la 0 la 18446744073709551615. Un tip semnat poate fi declarat pur și simplu prin două cuvinte cheie lung lung.
Tip | Gamă | Gama hexagonală | Dimensiune |
nesemnat char | 0 ... 255 | 0x00...0xFF | 8 biți |
semnat char sau doar char |
-128 ... 127 | -0x80...0x7F | 8 biți |
unsigned short int sau doar nesemnat int sau scurt nesemnat |
0 ... 65535 | 0x0000 ... 0xFFFF | 16 biți |
semnat scurt int sau semnat int sau doar scurt sau int |
-32768 ... 32767 | 0x8000...0x7FFF | 16 biți |
nesemnat lung int sau doar nesemnat lung |
0 ... 4294967295 | 0x00000000 ... 0xFFFFFFFF | 32 de biți |
semnat lung sau doar lung |
-2147483648 ... 2147483647 | 0x80000000 ... 0x7FFFFFFF | 32 de biți |
nesemnat lung lung | 0 ... 18446744073709551615 | 0x0000000000000000 ... 0xFFFFFFFFFFFFFFFFFF | pe 64 de biți |
semnat lung lung sau doar lung lung |
-9223372036854775808 ... 9223372036854775807 | 0x8000000000000000 ... 0x7FFFFFFFFFFFFFFF | pe 64 de biți |
Variabilele sunt declarate într-o declarație. O instrucțiune de declarație constă dintr-o specificație de tip și o listă de nume de variabile separate prin virgulă. Trebuie să existe un punct și virgulă la sfârșit.
O declarație variabilă are următorul format:
[modificatoare] type_specifier identificator [, identificator] ...
Modificatori- cuvinte cheie semnat, nesemnat, scurt, lung.
Specificator de tip- cuvânt cheie char sau int, care determină tipul variabilei declarate.
Identificator- numele variabilei.
Exemplu: char x;
int a, b, c; nesemnat long long y;, o, În acest fel variabilele vor fi declarate, x, b c nesemnat long long y; y o, În acest fel variabilele vor fi declarate, x. La o variabilă b se vor putea scrie valori de la -128 la 127. În variabile
- de la -32768 la +32767. La o variabilă
- de la 0 la 18446744073709551615. nesemnat long long y; Inițializarea valorii unei variabile la declarare
Este mai bine să evitați amestecarea variabilelor inițializate într-o singură declarație, adică este mai bine să declarați variabilele inițializate pe linii separate.
constante |
O variabilă de orice tip poate fi declarată nemodificabilă. Acest lucru se realizează prin adăugare cuvânt cheie const la specificatorul de tip. Variabile cu tip const sunt date numai pentru citire, ceea ce înseamnă că variabilei nu i se poate atribui o nouă valoare. Dacă după cuvânt const Dacă nu există un specificator de tip, atunci constantele sunt tratate ca valori semnate și li se atribuie un tip int sau lung intîn funcție de valoarea constantei: dacă constanta este mai mică de 32768, atunci i se atribuie tipul int, altfel lung int.
Exemplu: const long int k = 25; const m = -50;// implicit const int m=-50 const n = 100000;
// implicit const long int n=100000 |
Misiunea
Semnul „=" este folosit pentru atribuire în C. Se evaluează expresia din dreapta semnului de atribuire, iar valoarea rezultată este atribuită variabilei din stânga semnului de atribuire. În acest caz, valoarea anterioară stocată în variabilă este ștearsă și înlocuită cu una nouă.
Operatorul „=" nu trebuie înțeles ca egalitate.
De exemplu, expresia a = 5; ar trebui citit ca „atribuiți variabila a la 5”. Exemple: x = 5 + 3;// adăugați valorile 5 și 3, // atribuiți rezultatul variabilei x (scrieți variabilei x) b = a + 4;// adăugați 4 la valoarea stocată în variabila a, // atribuiți rezultatul rezultat variabilei b (scrieți variabilei b) b = b + 2;
// adăugați 2 la valoarea stocată în variabila b, // atribuiți rezultatul rezultat variabilei b (scrieți variabilei b)
În partea dreaptă, valoarea variabilei poate fi folosită de mai multe ori: c = b * b + 3 * b; Exemplu: x = 3;// variabilei x i se va atribui valoarea 3 y = x + 5;// numărul 5 va fi adăugat la valoarea stocată în variabila x, // rezultatul rezultat va fi scris în variabila y z = x * y;// valorile variabilelor x și y vor fi înmulțite, // rezultatul va fi scris în variabila z z = z - 1;
// 1 va fi scăzut din valoarea stocată în variabila z // rezultatul va fi scris în variabila z Astfel, în variabila z
numărul 23 va fi stocat Cu excepţia operator simplu
atribuiri "=", în C există mai mulți operatori de atribuire combinați: "+=", "-=", "*= Exemple: x += y;// la fel ca x = x + y; - se adaugă x și y // și se scrie rezultatul la variabila x // la fel ca x = x - y; - se scade valoarea y din x // si se scrie rezultatul in variabila x x *= y; // la fel ca x = x * y; - înmulțiți x cu y // și scrieți rezultatul în variabila x x /= y; // la fel ca x = x / y; - împărțiți x la y // și scrieți rezultatul în variabila x x %= y; // la fel ca x = x % y; // calculează rest întreg
din împărțirea x la y // și scrieți rezultatul în variabila x |
Creșteți și descreșteți Dacă trebuie să modificați valoarea unei variabile la 1, atunci utilizați sau creştere.
scăderea Creştere
- operația de creștere a valorii stocate într-o variabilă cu 1. Exemplu: x++;// valoarea variabilei x va fi mărită cu 1
$WinAVR = ($_GET["avr"]); if($WinAVR) include($WinAVR);?> Decrementează
- operatia de scadere a valorii stocate intr-o variabila cu 1. Exemplu: x--;
// valoarea variabilei x va fi redusă cu 1
Creșterea și descreșterea sunt operatori de atribuire. Când utilizați decrementarea și creșterea împreună cu operatorul de atribuire "=", utilizați notația postfix (x++) sau prefix (++x). Prefixul este executat mai întâi.
Exemple: y = x++; nesemnat long long y; Să presupunem că în variabilă b valoarea 5 a fost stocată nesemnat long long y; se va scrie valoarea 5, după care valoarea variabilei b va fi majorat cu 1. Astfel, in nesemnat long long y; va fi 5, iar în
- 6. y = --x; nesemnat long long y; Dacă în nesemnat long long y; Dacă valoarea 5 a fost stocată, atunci decrementarea va fi efectuată mai întâi b la 4 și apoi această valoare va fi atribuită variabilei nesemnat long long y;Şi b. Astfel,
i se va atribui valoarea 4. În această lecție vei învăța Alfabetul limbajului C++ , și, de asemenea, ce tipuri de date
linie nouă În testarea programului puteți utiliza comentarii
Date în C++ Pentru a rezolva o problemă, orice program prelucrează unele date. Ele pot fi de diferite tipuri: numere întregi și reale, caractere, șiruri de caractere, matrice. În C++, datele sunt de obicei descrise la începutul funcției. LA limbile includ:
Pentru a genera alte tipuri de date, de bază și așa-zise specificatorii. C++ definește patru specificatori de tip de date:
Variabila de tip intîn memoria computerului poate ocupa fie 2, fie 4 octeți. Depinde de dimensiunea biților procesorului. În mod implicit, toate tipurile întregi sunt considerate semnate, adică specificatorul semnat poate să nu fie specificat. Specificator nesemnat vă permite să reprezentați numai numere pozitive. Mai jos sunt câteva intervale de valori de tip întreg
Tip | Gamă | Dimensiune |
int | -2147483648…2147483647 | 4 octeți |
nesemnat int | 0…4294967295 | 4 octeți |
semnat int | -2147483648…2147483647 | 4 octeți |
scurt int | -32768…32767 | 2 octeți |
lung int | -2147483648…2147483647 | 4 octeți |
unsigned short int | 0…65535 | 2 octeți |
Un număr în virgulă mobilă este reprezentat sub forma mE +- p, unde m este mantisa (număr întreg sau fracționar cu virgulă zecimală), p este exponentul (întreg). De obicei valori precum plutire ocupă 4 octeți și dubla 8 octeți. Tabel cu intervale de valori reale:
plutire | 3.4E-38…3.4E+38 | 4 octeți |
dubla | 1.7E-308…1.7E+308 | 8 octeți |
dublu lung | 3.4E-4932…3.4E+4932 | 8 octeți |
Variabila de tip bool poate lua doar două valori adevărat ( adevărat ) sau fasle ( minciună ). Orice valoare care nu este egală cu zero este interpretată ca adevărat. Sens fals reprezentat în memorie ca 0.
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, cum ar fi tip de bază pentru pointeri și în operațiunile de turnare a tipului.
În C++, există două tipuri de conversie a tipurilor de date: explicită și implicită.
#include „stdafx.h” #include
#include „stdafx.h” #include folosind namespace std; int main() int i = 5 ; float f = 10,12; cout<< i / f ; sistem ("pause>>void" ); returnează 0; |
Cea mai mare prioritate este acordată tipului în care se pierde cea mai mică cantitate de informații. Nu ar trebui să folosiți în exces conversia de tip implicit, deoarece pot apărea diverse situații neprevăzute.
Turnarea tipului poate fi efectuată și folosind următoarele operații:
static_cast<>() const_cast<>() reinterpret_cast<>() dynamic_cast<> ()
static_cast<> () const_cast<> () reinterpret_cast<> () dynamic_cast<> () |
static_cas- convertește tipurile de date aferente. Acest operator aruncă tipuri în conformitate cu regulile obișnuite, care pot fi necesare atunci când compilatorul nu efectuează conversie automată. Sintaxa va arăta astfel:
Tastați static_cast<Тип>(obiect);
Folosind static_cast, nu puteți elimina constanța dintr-o variabilă, dar următorul operator o poate face. const_cast- se foloseste numai atunci cand este necesara indepartarea constanței unui obiect. Sintaxa va arăta astfel:
Tipconst_cast< Tip> (obiect);
reinterpret_cast- folosit pentru a converti diferite tipuri, întreg în pointer și invers. Dacă vedeți un cuvânt nou „index” - nu vă alarmați! Acesta este, de asemenea, un tip de date, dar nu vom lucra cu el în curând. Sintaxa de aici este aceeași cu cea a operatorilor discutați anterior:
Tipreinterpreta_turnați< Tip> (obiect);
dynamic_cast- folosit pentru conversie dinamică tipează, implementează turnarea de pointeri sau referințe. Sintaxă:
Tipdinamic _turnați< Tip> (obiect);
Sunteți deja familiarizat cu unele dintre aceste „personaje de control” (de exemplu, cu \n). Toate încep cu o bară oblică inversă și sunt, de asemenea, înconjurate de ghilimele duble.
Imagine |
Cod hexadecimal |
Nume |
Sunete beeper |
||
Întoarce-te cu un pas |
||
Traducerea paginii (format) |
||
Alimentare de linie |
||
Retur cu transportul |
||
Tabulare orizontală |
||
Filă verticală |
||
short int, unsigned short int, int, unsigned int, long, unsigned long.
plutitor, dublu, dublu lung.
char (caracter semnat), caracter nesemnat, wchar_t.
bool.
enumerare.
În C++ principalul tipuri de numere întregi date: 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:
2 -100 398Tipurile 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.
Ca urmare, sub variabila nesemnat long long y; va fi alocat un spațiu de memorie de 4 octeți. Mărimea memoriei alocate pentru o variabilă depinde de caracteristicile computerului, tip sistem de operareși setările compilatorului.
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.
int x; x = 239;Raspunsul 2. Introducerea unui număr într-o variabilă în timpul descrierii acesteia (inițializarea inițială).
int x = 239;Tipurile de date cu virgulă mobilă vă permit să reprezentați valori dintr-un set de numere reale. De exemplu:
8.35 -990.399 239.0.C++ are următoarele tipuri de date de bază în virgulă mobilă:
plutitor, dublu, dublu lung.
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.
Un exemplu de descriere a variabilelor tipurilor float, double, long double:
plutitor f; dublu d; lung dublu ld;Un exemplu de introducere a datelor numerice în variabile cu virgulă mobilă:
float f = -9928,45; // initializarea initiala dublu d; lung dublu ld; d = 0,445332; // operator de atribuire ld = 3892923898239,030903; // operator de atribuirePentru a face acest lucru, se folosește operația de turnare tip. Între paranteze trebuie să indicați numele tipului la care este distribuită distribuția.
plutire a; int b; a = 8,457; b = (int ) a; // b = 8Când utilizați operațiuni de turnare a tipurilor, trebuie să țineți cont de restricțiile impuse 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 listă depășește o valoare într-o variabilă de tip short int:
scurt int i; plutitor f; f = 3990099,8; i = (int )f; // i = -7597 - preaplinExemplu de turnare de la int la dublu:
int i; dublu d; i = 982; d = (dublu)i; // d = 982,0Datele 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:
cod int; simbol char; simbol = "f" ; cod = (int )simbol; // cod = 102Datele 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.
Variabilele de tip bool pot lua doar două valori:
adevărat - adevăr,
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 cifrele valori adevărate si fals:
int rezultat; bool b; rezultat = (int)adevărat; // rezultat = 1 b = fals; rezultat = (int )b; // rezultat = 0Fragment de cod care convertește tipurile int și float în bool:
int i; plutitor f; bool b; i = 6; b = (bool )i; // b = Adevărat f = 0,0; b = (bool )f; // b = FalsOperația sizeof() este utilizată pentru aceasta.
Un fragment de cod care definește dimensiunea unor tipuri de date:
int d; d = dimensiunea(car); // d = 1 d = sizeof(unsigned int); // d = 4 d = sizeof(float); // d = 4 d = dimensiunea(dublu); // d = 8Pentru a determina valoarea maximă permisă sau minimă permisă a unei variabile de un anumit tip în . NET Framework Sunt utilizate proprietățile MaxValue și MinValue.
Exemple de determinare a valorilor limită ale variabilelor de diferite tipuri.
Pentru variabile de tip int:
// tastați int int i; lung MaxInt; lung MinInt; MaxInt = (lung )i.MaxValue; // MaxInt = 2147483647 MinInt = (lung )i.MinValue; // MinInt = -2147483648Pentru variabile de tip short int:
// tastați short int short int si; int MaxInt; int MinInt; MaxInt = (int )si.MaxValue; // MaxInt = 32767 MinInt = (int )si.MinValue; // MinInt = -32768Pentru variabile de tip unsigned int:
// tastați unsigned int unsigned int ui; unsigned int MaxInt; unsigned int MinInt; MaxInt = ui.MaxValue; // MaxInt = 4294967295 MinInt = ui.MinValue; // MinInt = 0Pentru variabilele float:
// tip float plutitor f; float MaxF; plutitor MinF; MaxF = f.MaxValue; // MaxF = 3,402823E+38 MinF = f.MinValue; // MinF = -3,402823E+38Pentru variabile de tip double:
// tip double dublu d; dublu MaxD; dublu minte; Max = d.MaxValue; // Max = 1,79769313486232E+308 Min = d.MinValue; // Min = -1,79769313486232E+308Pentru variabile de tip char:
// tip char char c; int MaxC; int MinC; Max = (int )c.MaxValue; // Max = 127 Min = (int )c.MinValue; // Min = -128Tipul de enumerare este un tip de date de 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:
enumerarea lunilor ( ianuarie, februarie, martie, aprilie, mai, iunie, iulie, august, septembrie, octombrie, noiembrie, decembrie) mn; mn = ianuarie; // mn = 0 mn = martie; // mn = 2 mn = septembrie; // mn = 8Exemplul 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 valoarea întreagă 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:
mn = (număr luni)2; // mn = martie mn = (număr luni)11; // mn = decembrieTipul de date void este utilizat în următoarele cazuri:
Exemplu. MyFun() este o funcție fără parametri care nu returnează nicio valoare (returnează tipul void ) și nu acceptă parametri.
public : void MyFun(void ) { // corp de funcție // ... reveni; // întoarce de la o funcție care nu returnează o valoare } // apelează o funcție din program ... MyFun(); ...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:
„Utilizarea ilegală a tipului nul”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.
... wchar_t t; // Pentru variabila t sunt alocați 2 octeți de memorie t = „s”; ...Tipurile de date din C sunt o clasă de date ale căror valori au caracteristici similare. Tipul definește reprezentarea internă a datelor în memorie. Cele mai de bază tipuri de date: logice, întregi, numere în virgulă mobilă, șiruri de caractere, pointeri.
Cu tastarea dinamică, o variabilă este asociată cu un tip în momentul inițializării. Se pare că o variabilă din diferite părți ale codului poate avea diferite tipuri. Tastare dinamică suportă Java Script, Python, Ruby, PHP.
Tastarea statică este opusul tastării dinamice. Când este declarată, o variabilă primește un tip care nu se schimbă ulterior. Limbajele C și C++ sunt doar atât. Această metodă este cea mai convenabilă pentru scrierea unui cod complex, iar multe erori sunt eliminate în etapa de compilare.
Limbile sunt împărțite în mod neoficial în tastate puternic și tip slab. Tastarea puternică înseamnă că compilatorul va arunca o eroare dacă tipurile așteptate și reale nu se potrivesc.
x = 1 + „2”; //eroare - nu puteți adăuga un simbol la un număr
Un exemplu de tastare slabă.
Verificarea coerenței tipului este efectuată de sistemul de siguranță a tipului. O eroare de tastare apare, de exemplu, atunci când încercați să utilizați un număr ca funcție. Există limbi netipizate. Spre deosebire de cele tastate, acestea vă permit să efectuați orice operație asupra fiecărui obiect.
Variabilele, indiferent de tipul lor, au propriul domeniu de aplicare și durata de viață.
Cursuri de memorie:
Toate variabilele din limbajul C sunt locale în mod implicit. Ele pot fi utilizate numai într-o funcție sau bloc. Când funcția se finalizează, valoarea lor este distrusă.
O variabilă statică este de asemenea locală, dar poate avea o valoare diferită în afara blocului său, iar valoarea este reținută între apelurile de funcție.
Variabila externă este globală. Este disponibil în orice parte a codului și chiar într-un alt fișier.
Specificatorii tipului de date în C pot să nu fie specificați în următoarele cazuri:
Pentru a indica tipuri simple specificatorii int, char, float sau double sunt specificati. Modificatorii nesemnat, semnat, scurt, lung, lung lung pot fi înlocuiți cu variabile.
În mod implicit, toate numerele sunt semnate, prin urmare, pot fi doar în intervalul de numere pozitive. Pentru a defini o variabilă de tip char ca semnată, scrieți signed char. Long, long long și short indică cât spațiu de memorie este alocat pentru stocare. Cel mai mare este lung lung, cel mai mic este scurt.
Char este cel mai mic tip de date din C. Numai 1 octet de memorie este alocat pentru stocarea valorilor. Tip variabil caracterul este de obicei atribuit simbolurilor, mai rar numerelor. Valorile caracterelor sunt cuprinse între ghilimele.
Tipul int stochează numere întregi, dimensiunea acestuia este nedefinită - este nevoie de până la 4 octeți de memorie, în funcție de arhitectura computerului.
O conversie explicită a unei variabile fără semn este specificată după cum urmează:
Cea implicită arată așa:
Float și dublu definiți numerele cu un punct. Numerele flotante sunt reprezentate ca -2,3 sau 3,34. Double este folosit pentru o mai mare precizie - mai multe cifre sunt indicate după separatorul întreg și fracționar. Acest tip ocupă mai mult spațiu de memorie decât float.
Void are o valoare goală. Definește funcții care nu returnează nimic. Acest specificator specifică o valoare goală în argumentele metodei. Pointerii, care pot accepta orice tip de date, sunt, de asemenea, definiți ca nuli.
Folosit în teste de stare și bucle. Are doar două semnificații:
Valorile booleene pot fi convertite într-o valoare int. Adevărat este echivalent cu unu, fals este echivalent cu zero. Conversia tipului este posibilă numai între bool și int, altfel compilatorul va arunca o eroare.
if (x) ( //Eroare: „Nu se poate converti implicit tipul „int” în „bool””
if (x != 0) // Modul C#
Matricele sunt tipuri complexe de date în C. PL nu funcționează cu șiruri în același mod ca Javascript sau Ruby. În C, toate șirurile sunt matrice de elemente cu o valoare de caracter. Liniile se termină cu un octet nul „
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.
Scopul principal al oricărui program este prelucrarea datelor. Date diverse tipuri stocate și prelucrate diferit. În orice limbaj algoritmic Fiecare constantă, variabilă, expresie sau funcție trebuie să aibă un anumit tip.
Tipul de date definește:
Pe baza acestor caracteristici, programatorul selectează tipul fiecărei mărimi 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 întreg, real, caracter și valori logice. Pe baza acestor tipuri, programatorul poate introduce o descriere compozit tipuri. Acestea includ matrice, enumerari, functii, structuri, referinte, pointeri, uniuni si clase.
Tipurile de date de bază (standard) sunt adesea numite aritmetice deoarece pot fi utilizate în operatii aritmetice. Pentru a descrie principalele tipuri, sunt definite următoarele:
Primele patru tipuri sunt numite întregi ( întreg ), ultimele două - tipuri de virgulă mobilă . Codul pe care compilatorul îl generează pentru procesarea 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:
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 - î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 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.
Nota
Tipurile short int, long int, signed int și unsigned int pot fi abreviate la short, long, signed și, respectiv, unsigned.
O valoare a tipului de caracter i se alocă un număr de octeți suficient pentru a găzdui orice caracter din setul de caractere pentru a acestui calculator, care a determinat denumirea 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.
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. Constante de șir Tipurile wchar_t sunt scrise cu prefixul L, de exemplu, L „Porți”.
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.
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 portabil diverse platforme programele nu pot face presupuneri despre dimensiunea unui tip 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)
Nota
Valorile minime și maxime permise pentru tipurile întregi sunt dependente de implementare și sunt date în fișierul antet
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.
Î: 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 cele lansate mai târziu procesoare Intel au plin compatibil cu invers din 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 posibilitatea 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 orice tip de computer poate să nu fie portabil pe alte platforme, așadar caz general Ar trebui evitate dependențele de caracteristicile specifice ale tipurilor de date.
Tip | Gama de valori | Dimensiune (octet) |
bool | adevărat și fals | 1 |
semnat char | -128 … 127 | 1 |
nesemnat char | 0 … 255 | 1 |
semnat scurt int | -32 768 … 32 767 | 2 |
unsigned short int | 0 … 65 535 | 2 |
semnat lung int | -2 147 483 648 … 2 147 483 647 | 4 |
nesemnat lung int | 0 … 4 294 967 295 | 4 |
plutire | 3.4e-38 … 3.4e+38 | 4 |
dubla | 1.7e-308 … 1.7C+308 | 8 |
dublu lung | 3.4e-4932 … 3.4e+4932 | 10 |
Pentru tipurile reale, tabelul arată valorile absolute ale valorilor minime și maxime.