Constante. Variabile.

1Obiectivele lucrării

• Scrierea constantelor întregi în bazele 10, 8 și 16 și folosirea sufixelor U și L
• Utilizarea constantelor reale, caracter și șir de caractere, inclusiv a secvențelor escape
• Declararea variabilelor cu tipul potrivit domeniului de valori
• Determinarea experimentală a dimensiunilor cu operatorul sizeof
• Distingerea domeniului de vizibilitate de durata de viață a unei variabile

2Constante

Constantele 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.

Constante întregi

Determinarea implicită a tipului

Tipul implicit poate fi forțat cu sufixe: U/u pentru unsigned, L/l pentru long, combinate în UL.

Constante caracter și secvențe escape

3Tipuri fundamentale de date

4Variabile

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ă

5Vizibilitate și durată de viață

6Simulator de execuție

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.

7Cod sursă

#include <stdio.h>
#include <limits.h>

int main(void)
{
    printf("Tip            Octeti   Minim              Maxim\n");
    printf("-------------------------------------------------------\n");
    printf("char           %2zu     %-18d %d\n", sizeof(char),  CHAR_MIN,  CHAR_MAX);
    printf("short          %2zu     %-18d %d\n", sizeof(short), SHRT_MIN,  SHRT_MAX);
    printf("int            %2zu     %-18d %d\n", sizeof(int),   INT_MIN,   INT_MAX);
    printf("long           %2zu     %-18ld %ld\n", sizeof(long), LONG_MIN, LONG_MAX);
    printf("float          %2zu\n", sizeof(float));
    printf("double         %2zu\n", 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 = %zu, sizeof(\"A\") = %zu\n", sizeof(c), 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;
}

8Atelier de cod

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.

#include <stdio.h>

int main(void)
{
    printf("char        %d octet(i)\n", (int)sizeof(char));
    printf("short       %d octet(i)\n", (int)sizeof(short));
    printf("int         %d octet(i)\n", (int)sizeof(int));
    printf("long long   %d octet(i)\n", (int)sizeof(long long));
    printf("float       %d octet(i)\n", (int)sizeof(float));
    printf("double      %d octet(i)\n", (int)sizeof(double));

    printf("\nConstante scrise in baze diferite:\n");
    printf("  67 zecimal = %d\n", 67);
    printf("  0103 octal = %d\n", 0103);
    printf("  0x43 hexa  = %d\n", 0x43);
    printf("  'C' este   = %d\n", 'C');
    return 0;
}

#include <stdio.h>

int main(void)
{
    short s = 32767;          /* valoarea maxima pentru short */
    printf("s        = %d\n", s);
    s = s + 1;
    printf("s + 1    = %d   <- a devenit negativ!\n", s);

    unsigned char u = 255;
    printf("\nu        = %d\n", u);
    u = u + 1;
    printf("u + 1    = %d   <- a revenit la zero\n", u);

    char c = 200;             /* 200 nu incape in char cu semn */
    printf("\nchar c   = %d\n", c);
    return 0;
}

9Sarcini de lucru

• Rulați programul de verificare a dimensiunilor și notați valorile obținute pe calculatorul din laborator.
• Scrieți valoarea 200 în bazele 10, 8 și 16 și verificați că afișarea este identică.
• Declarați o variabilă short cu valoarea maximă și adunați 1; explicați rezultatul.
• Comparați sizeof('A') în C cu sizeof('A') în C++ - rezultatele diferă, explicați de ce.
• Scrieți o funcție cu un contor static și apelați-o de cinci ori; afișați valoarea la fiecare apel.
• Declarați o variabilă locală fără inițializare, afișați-o și rulați programul de trei ori - observați dacă valoarea se schimbă.
• Folosiți toate secvențele escape din tabel într-un singur printf și observați efectul.

10Aplicație de aprofundare

11Întrebări de verificare

12Resurse

• Îndrumarul acestei lucrări (PDF)
• Pagina cursului - toate materialele