Dimensiunile tipurilor
Afișați pe un rând, despărțite prin spații, dimensiunea în octeți a tipurilor char, short, int, float și double, folosind operatorul sizeof.
1 2 4 4 8O constantă este o valoare fixă scrisă direct în cod; o variabilă este un nume asociat unei zone de memorie al cărei conținut se poate schimba. Tipul ales pentru fiecare determină cât spațiu ocupă, ce valori poate lua și ce operații se pot aplica.
U și LsizeofConstantele literale sunt valori fixe care nu pot fi modificate în timpul execuției. Tipul lor este determinat automat de compilator, pe baza valorii și a sintaxei folosite.
| Bază | Convenție de scriere | Exemple |
|---|---|---|
| Zecimală (10) | prima cifră diferită de 0 | 23, -555L, 3276L |
| Octală (8) | prima cifră este 0; cifrele 8 și 9 sunt ilegale | 067, -067, 067u |
| Hexazecimală (16) | prefix 0x sau 0X | 0x1F, 0xFFu, 0xAB3L |
int x = 010; nu înseamnă zece, ci opt - prefixul 0 declanșează
interpretarea în baza 8. Este o greșeală frecventă la scrierea datelor calendaristice sau a codurilor
cu zerouri nesemnificative.| Situație | Tip atribuit | Exemplu |
|---|---|---|
valoarea încape în domeniul int | int | 15, 23 |
depășește int, încape în long | long | 99999 |
depășește long | double | 98765432100 |
Tipul implicit poate fi forțat cu sufixe: U/u pentru unsigned,
L/l pentru long, combinate în UL.
| Secvență | Semnificație | Cod ASCII |
|---|---|---|
'\n' | linie nouă | 10 |
'\t' | tabulator orizontal | 9 |
'\r' | retur de car | 13 |
'\0' | caracter nul - marchează sfârșitul unui șir | 0 |
'\\' | backslash | 92 |
'\'' | apostrof | 39 |
'A' este o constantă caracter și ocupă
1 octet. "A" este un șir și ocupă 2 octeți: litera plus terminatorul
'\0'. Confuzia dintre ele produce erori greu de depistat.| Tip | Dimensiune tipică | Domeniu de valori | Specificator printf |
|---|---|---|---|
char | 1 octet | −128 … 127 | %c / %d |
unsigned char | 1 octet | 0 … 255 | %u |
short | 2 octeți | −32 768 … 32 767 | %hd |
int | 4 octeți | −2 147 483 648 … 2 147 483 647 | %d |
unsigned int | 4 octeți | 0 … 4 294 967 295 | %u |
long long | 8 octeți | ±9,2 · 10¹⁸ | %lld |
float | 4 octeți | ±3,4 · 10³⁸, ~7 cifre semnificative | %f |
double | 8 octeți | ±1,7 · 10³⁰⁸, ~15 cifre semnificative | %lf |
bool (C++) | 1 octet | true / false | - |
char ≤ short ≤ int ≤ long). Pe un microcontroler
pe 8 biți, int are 2 octeți; pe un PC obișnuit, 4. De aceea se verifică întotdeauna
cu sizeof.Declarația unei variabile rezervă spațiu în memorie și îi asociază un nume și un tip:
tip nume; // declarație simplă, valoare nedefinită tip nume = valoare; // declarație cu inițializare tip n1, n2, n3; // mai multe variabile de același tip const tip nume = valoare; // valoare care nu mai poate fi modificată
| Clasă | Unde este vizibilă | Cât trăiește | Valoare inițială implicită |
|---|---|---|---|
auto (locală) | în blocul în care e declarată | până la ieșirea din bloc | nedefinită |
static locală | în blocul în care e declarată | toată execuția programului | 0 |
| globală | în tot fișierul, după declarație | toată execuția programului | 0 |
extern | în alte fișiere sursă | toată execuția programului | 0 |
register | în blocul în care e declarată | până la ieșirea din bloc | nedefinită |
static locală este vizibilă doar
în funcția ei, dar nu este distrusă la ieșire: la următorul apel își regăsește valoarea.
Este mecanismul standard pentru contoare care trebuie să rețină starea între apeluri.Urmăriți pas cu pas cum se comportă o variabilă locală obișnuită față de una
declarată static, la trei apeluri succesive ale aceleiași funcții.
#include <stdio.h>
#include <limits.h>
int main(void)
{
printf("Tip\tOcteti\tMinim\t\tMaxim\n");
printf("----------------------------------------\n");
printf("char\t%d\t%d\t\t%d\n", (int)sizeof(char), CHAR_MIN, CHAR_MAX);
printf("short\t%d\t%d\t\t%d\n", (int)sizeof(short), SHRT_MIN, SHRT_MAX);
printf("int\t%d\t%d\t%d\n", (int)sizeof(int), INT_MIN, INT_MAX);
printf("long\t%d\t%ld\t%ld\n", (int)sizeof(long), LONG_MIN, LONG_MAX);
printf("float\t%d\n", (int)sizeof(float));
printf("double\t%d\n", (int)sizeof(double));
return 0;
}
#include <stdio.h>
int main(void)
{
int zecimal = 100; // baza 10
int octal = 0144; // baza 8 -> tot 100
int hexazecimal = 0x64; // baza 16 -> tot 100
printf("%d %d %d\n", zecimal, octal, hexazecimal); // 100 100 100
// aceeasi valoare afisata in baze diferite
printf("zecimal: %d octal: %o hexa: %X\n", 255, 255, 255);
// capcana zeroului din fata
int gresit = 010;
printf("010 inseamna %d, nu 10!\n", gresit); // 8
// caracter vs sir
char c = 'A';
char s[] = "A";
printf("sizeof('A') in C = %d, sizeof(\"A\") = %d\n", (int)sizeof(c), (int)sizeof(s));
return 0;
}
#include <stdio.h>
int main(void)
{
short mic = 32767; // valoarea maxima pentru short
printf("inainte: %d\n", mic);
mic = mic + 1; // depasire!
printf("dupa +1: %d\n", mic); // -32768, se trece la valoarea minima
unsigned char u = 255;
u = u + 1;
printf("unsigned char 255+1 = %u\n", u); // 0, revine la inceput
return 0;
}
Dimensiunile tipurilor și comportamentul la depășire nu se învață din tabele, ci văzându-le. Rulați programele de mai jos și modificați valorile ca să vedeți exact unde se rupe fiecare tip.
Aici scrieți voi codul. Butonul ✓ Verifică rulează programul pe mai multe seturi de date și vă arată imediat unde diferă rezultatul. La final trimiteți traseul ales, iar profesorul îl notează automat.
Fiecare exercițiu are programul deja început, iar comentariile vă spun ce mai trebuie adăugat. Scrieți codul, apăsați ✓ Verifică și citiți ce spune fiecare test picat. Dacă v-ați blocat, deschideți câte un indiciu. Puteți afișa și mesaje pentru utilizator (de tipul Introduceti n:), testul se uită la ce afișați la final.
Afișați pe un rând, despărțite prin spații, dimensiunea în octeți a tipurilor char, short, int, float și double, folosind operatorul sizeof.
1 2 4 4 8Declarați constanta const double PI = 3.14159265;. Citiți raza r a unui cerc și afișați lungimea cercului (2·PI·r) cu două zecimale.
16.28Citiți un număr întreg nenegativ n. Afișați-l pe un rând în baza 10, în baza 8 și în baza 16 (cu litere mici).
200200 310 c8Citiți un caracter c. Afișați pe un rând codul lui ASCII și caracterul care urmează după el în tabelul ASCII.
A65 BFuncția numara() trebuie să întoarcă de câte ori a fost apelată până acum. main o apelează de trei ori și afișează rezultatele. Completați funcția folosind o variabilă static. (Funcțiile se prezintă pe larg în Laboratorul 10; aici e suficient să completați corpul celei din schelet.)
1 2 3Problemele pornesc de la un main gol. Formatul ieșirii trebuie respectat exact (spațiile și rândurile noi nu contează, dacă enunțul nu spune altfel), deci nu afișați mesaje pentru utilizator. Testele vizibile acoperă doar cazurile simple; la notare se rulează și teste ascunse, alese să prindă cazurile limită.
Citiți două numere întregi a și b, fiecare între -32768 și 32767. Afișați pe un rând suma lor calculată într-un int, apoi aceeași sumă memorată într-o variabilă de tip short. Exemplu: pentru 30000 30000 se afișează 60000 -5536.
30000 3000060000 -5536O culoare se descrie prin trei componente r g b, fiecare între 0 și 255. Codul ei este numărul r · 65536 + g · 256 + b. Citiți componentele și afișați pe un rând codul în zecimal, apoi în forma folosită pe web: #RRGGBB, cu cifre hexazecimale mari. Exemplu: pentru 255 128 0 se afișează 16744448 #FF8000.
255 128 016744448 #FF8000Afișați exact cele trei rânduri de mai jos (între Nume: și "Ana" este un caracter TAB):
Nume: "Ana" Cale: C:\temp\nou Procent: 100%
Aici contează și spațiile: ieșirea se compară caracter cu caracter (doar spațiile de la capăt de rând se ignoră).
Nume: "Ana"
Cale: C:\temp\nou
Procent: 100%Citiți un număr real x. Afișați pe un rând: partea întreagă obținută prin conversie la int, valoarea rotunjită la cel mai apropiat întreg (jumătățile se rotunjesc departe de zero) și x cu două zecimale.
2.72 3 2.70short cu valoarea maximă și adunați 1; explicați rezultatul.sizeof('A') în C cu sizeof('A') în C++ - rezultatele diferă, explicați de ce.static și apelați-o de cinci ori; afișați valoarea la fiecare apel.printf și observați efectul.<limits.h>, valoarea maximă a tipului int de pe calculatorul vostru:
porniți de la 1 și dublați valoarea până când aceasta devine negativă, apoi ajustați. Comparați
rezultatul cu INT_MAX. Repetați pentru unsigned int.