Tipuri fundamentale

Structura unui program C

Tipuri fundamentale

Definirea variabilelor

Functii de citire/scriere

Quiz

Exercitii

Structura unui
program C
Un program C este compus dintr-o ierarhie de functii, orice program
trebuind sa contina cel putin functia main, prima care se executa la
lansarea programului C.
Un program C are, in principiu, urmatoarea structura:

directive preprocesor

definitii de tipuri

prototipuri de functii -- un prototip

declara tipul unei functii ( tipul valorii
returnate ) si tipurile parametrilor
transmisi functiei

definitii de variabile globale

definitii de functii

Intr-o prima faza, programele C care vor fi concepute vor contine doar
functia main ( care va fi void, deci nu va returna nici un rezultat si nu va
primi parametri, deci si lista parametrilor va fi void ).Structura acestor
programe va fi:

directive preprocesor

definitii de tipuri

definitii de variabile globale

definitia functiei main

Definitia unei functii are urmatoarea forma:

tip_rezultat_returnat nume_functie (lista_parametri){

/*antetul functiei*/
definirea variabilelor locale
prelucrari /* instructiuni */
} /* intre { } corpul functiei */
Daca functia nu returneaza nici un rezultat si nu primeste parametri,
definitia va fi:

void nume_functie (void) /*antetul functiei*/

definirea variabilelor locale
prelucrari /* instructiuni */
} /* intre { } corpul functiei */
Antetul unei functii urmat de ; se numeste prototipul functiei - reprezinta
informatia despre interfata functiei - ce tip de rezultat returneaza si care
sunt tipurile datelor primite, ale parametrilor formali.
prototip -- antet;
Cel mai simplu program C este urmatorul, in care nu sunt definite tipuri,
variabile globale sau locale si de asemenea in main nu se face nici o
prelucrare:

void main (void){

}

Iata un alt exemplu de program C, dintre cele mai simple, care contine
doar functia main si realizeaza afisarea unor date:
/* program foarte simplu - acesta este un comentariu */
#include <stdio.h>

/* directiva preprocesor - include un

fisier header cu prototipurile functiilor I/E */

#define mesaj "Buna ziua!" /* directiva preprocesor ce def
constanta simbolica mesaj */
int nr=5,crt;
/* de definesc doua variabile
globale, nr este initializata */
void main(void){
/* antet main - functia nu returneza
nici un rezultat si nu primeste parametri */
/* intre {} corpul lui main */
/* nu se definesc variabile locale */
/* prelucrari - aici trei instructiuni expresie*/
puts(mesaj);
/* apel functie ce tipareste un sir */
crt=1;
/* variabilei globale crt i se atribuie
valoarea 1 */
printf("Cursul de C/C++ e in saptamana %d si
va tine %d\n",crt,nr);
/* apel functie de tiparire cu format
*/
getchar();
/* !! se va astepta o tastare inainte de
revenirea in mediu */
} /* terminare main */

/* Rulati programul !
Pe ecran va apare:
Buna ziua!
Cursul de C/C++ e in saptamana 1 si va tine 5
Modificati programul pentru a tipari la inceput un mesaj personalizat :
Buna dimineata / ziua / seara, numele_dvs!
iar la sfarsit
Succes!
Comentati linia marcata cu !! punand in fata //
Rulati din nou, care e deosebirea?
Cum puteti sa revedeti ecranul cu rezultate - User Screen?
Sa observam ca liniile care compun corpul unei functii, se scriu de
obicei decalat fata de antet, pentru o mai buna lizibilitate a
programului */

Tipuri
fundamentale
Un tip de date reprezinta o multime de valori pe care sunt definite anumite

operatii.
Limbajul C defineste urmatoarele tipuri:

fundamentale ( aritmetice ) - intregi, reale, enumerare, void

derivate - tablou, functie, pointer, structura, uniune.

Majoritatea limbajelor de nivel inalt definesc tipurile de mai sus. Noutatea o

constituie tipulvoid. In schimb limbajul C nu defineste tipurile multime, sir
de caractere ( existente in PASCAL ).
Tipul void
Tipul void poate insemna:

nimic - cand se foloseste pentru functii care nu returneaza nici un

rezultat

orice - cand se foloseste pentru pointeri care indica spre entitati cu

tip neprecizat.
Interesant, nu?, doua notiuni filozofic opuse...

Tipuri intregi
La baza clasificarii tipurilor intregi stau doua criterii:

dimensiunea memoriei utilizate pentru reprezentarea unei valori: 1

octet -char, 2 octeti - int, 4 octeti - long

modalitatea de tratare a valorii:

cu semn - signed: este modul implicit, bitul cel

mai semnificativ este considerat bit de semn;
valoarea 0 a acestuia inseamna o valoare pozitiva,
iar 1, o valoare negativa; reprezentarea valorilor se
face in complement de 2

fara semn - unsigned: toti bitii reprezentarii fac

parte din valoarea numarului.

Mai jos sunt este prezentat un tablou al tipurilor intregi, pentru fiecare tip
fiind precizate valoarea minima si maxima, scrise in zecimal, hexazecimal
si binar:
nr
Tip intreg octeti /
nr biti
char
1
8
(signed

valoare minima
zecimal
hexazecimal binar
-128
0x80
-27

valoare minima
zecimal
hexazecimal binar
127
0x7F
27-1

char)
unsigned
char
int ( signed
int )
2
unsigned
int
long
(signed
4
long)
unsigned
long

0
0x0
-32768
0x8000
0

16
0x0

32

0
-215
0

-2147483648
0x80000000 -231
0
0x0
0

255
0xFF
32767
0x7FFF
65535
0xFFFF

28-1
215-1
216-1

2147483647
0x7FFFFFFF 231-1
4294967295
0xFFFFFFFF 232-1

Tipurile char(signed char)si unsigned char sunt cele pentru care

se aloca cel mai mic spatiu de memorie, 1 octet. De cele mai multe ori
valorile de aceste tipuri se interpreteaza ca reprezentand coduri de
caractere, dar se folosesc si pentru memorarea intregilor de valori mici,
pentru economie de spatiu de memorie - daca o variabila trebuie sa retina un
numar de apartament, de exemplu, poate fi declarata de tipul char.
Constantele intregi se reprezinta implicit in baza 10 si de tipul signedcare
pentru reprezentare cere spatiu minim - intre paranteze apare tipul implicit
al fiecarei constante: -10000 ( int), 65000 ( long ).
Pentru reprezentarea contantelor fara semn se foloseste sufixul u sau U:
32780 ( long), 32780u ( unsigned int ).
Pentru reprezentarea constantelor in hexazecimal se foloseste prefixul 0x
sau 0X: 0x8adf ( int ), 0x1F111 ( long ).
Pentru reprezentarea constantelor in octal se foloseste prefixul 0: 0721
( int ), 07111111 ( long ).
Constantele caracter au fost prezentate la paragraful referitor la Atomii
lexicali, in modulul Elemente de baza. Fiecare constanta caracter ocupa 2
octeti de memorie, primul are toti cei 8 biti de valoare 0, iar al doilea
reprezinta codul ASCII al caracterului.
Tipuri reale
Valorile reale sunt reprezentate in virgula mobila. Trebuie semnalat faptul
ca nu toate numerele reale pot fi reprezentate, intrucat memorarea valorilor
reale, fiind realizata pe un numar anume de biti, nu poate retine decat o
parte dintre cifrele semnificative. Deci numai anumite valori reale au
reprezentarea exacta in calculator, restul confundandu-se cu reprezentarea
cea mai apropiata.
Exista trei tipuri reale: float, double, long double, cu caracteristici
prezentate in tabelul de mai jos. Valorile minime si maxime sunt date in
modul; pentru fiecare dintre tipurile reale, pot fi reprezentate valori intre [valmax, valmax], iar toate valorile intre (-valmin,valmin) se confunda cu
zero.

Tip real
float

nr octeti/
nr biti
4
32

valoare
minima
3.4E-38

valoare
maxima
3.4E38

nr cifre
semnificative
6

double
long
double

64

1.7E-308

1.7E308

15

10

80 3.4E-4932 1.1E4932

18

Constantele reale sunt implicit de tipul double; sufixul f sau F aplicat unei
constante, o face de tipul float, iar l sau L de tipul long double.
O constanta reala ( double, pentru celelate doua tipuri reale, se adauga
sufixul corespunzator ) se reprezinta sub forma
mantisa
sau perechea
mantisa parte_exponent
unde mantisa=parte_intr.parte_zecimala ( oricare din cele doua parti poate
lipsi, dar nu ambele )
exponent=eval_exponent sau Eval_exponent
Valoarea constantei este produsul dintre mantisa si 10 la puterea data de
exponent.
In tabelul de mai jos apar cateva exemple de constante reale:

Constante de Constante de
tip float
tip double
1.f
1.
.241f
.241
-12.5e5f
-12.5e5
98.E-12f
98.E-12

Constante de tip
long double
1.L
.241l
-12.5e5l
98.E-12L

Dimensiunea memoriei in octeti ocupata de un tip de date, variabila,

constanta, este data de operatorul sizeof ( asupra caruia se va reveni la
capitolul Operatori ). Iata mai jos un program C foarte simplu, care permite
afisarea spatiului de memorie ocupat de diferite entitati:

/* program pentru verificarea spatiului de memorie ocupat de

diferite entitati */
/* efectul operatorul sizeof este aplicat la compilare, asa incat
valoarea returnata poate fi evaluata intr-o fereastra de evaluare a
mediului TC++ ( deschisa cu CTRL/F4 ) fara a mai rula un program
*/
/* incercati sa gasiti datele pe care le va tipari programul, rulati-l
doar dupa aceea! */
#include <stdio.h>
#include <conio.h>
void main (void){
puts("Dimensiunea in octeti ocupata de:");
printf("int\t\t%d\n",sizeof(int));
printf("char\t\t%d\n",sizeof(char));

printf("long\t\t%d\n",sizeof(long));
printf("float\t\t%d\n",sizeof(float));
printf("double\t\t%d\n",sizeof(double));
printf("long double\t%d\n",sizeof(long
double));
printf("32780\t\t%d\n",sizeof(32780));
printf("32780u\t\t%d\n",sizeof(32780u));
printf("-10000\t\t%d\n",sizeof(-10000));
printf("'a'\t\t%d\n",sizeof('a'));
printf("07111111\t%d\n",sizeof(07111111));
printf("22l\t\t%d\n",sizeof(22l));
printf("1.f\t\t%d\n",sizeof(1.f));
printf(".241\t\t%d\n",sizeof(.241));
printf("98.E-12L\t\t%d\n",sizeof(98.E-12L));
getche();

/* linie ce e bine sa incheie orice program

! */
/* functia are prototipul in conio.h; se va astepta tastarea unui
caracter, pentru a nu "disparea"
ecranul utilizator cu afisarile realizate de program; ecranul poate fi
vizualizat tastand Alt/F5 */
}
Tipul enumerare
Tipul enumerare este un caz particular al tipurilor intregi. Se utilizeaza
pentru a realiza o reprezentare comoda si sugestiva a unor obiecte ale
caror valori sunt identificate printr-un numar finit de nume simbolice. Tipul
enumerare declara constante simbolice, carora li se asociaza coduri
numerice de tip intreg, astfel:
enum nume_tip { lista_constante_simbolice }; /* nume_tip poate lipsi */
Compilatorul asociaza constantelor enumerate cate un cod intreg din
succesiunea incepand cu 0.
Exemple:
enum zile_lucr { luni, marti, miercuri, joi,
vineri };
/* luni e asociat cu 0, marti cu 1, ..., vineri cu 4 */
/* se pot defini variabile de tipul zile_lucr, ca mai jos, variabila zi */
enum zile_lucr zi=marti;
Daca se doreste o alta codificare a constantelor din enumerare decat cea
implicita, pot fi folosite in enumerare elemente de forma:
nume_constanta=valoare_intreaga;

Constantelor simbolice ce urmeaza unei astfel de initializari li se asociaza

numerele intregi urmatoare:
enum transport { tren, autocar=5, autoturism,
avion }; /* tren e asociat cu 0, autocar cu 5, autoturism cu 6, avion cu
7 */
Definirea tipurilor utilizator
Cuvantul cheie typedefpermite definirea de tipuri utilizator si anume
echivalarea unor tipuri ( in general structurate, cu definitii lungi ) cu nume
utilizator ( identificatori ):
typedef tip_echivalat nume_de_tip;
Exemple in care apar definite tipurile caracter, real, Zile_lucr, profesie:
typedef char caracter;
typedef long double real;
typedef enum zile_lucr Zile_lucr;
/* definirea variabilei zi se poate face in una din variantele: */
enum zile_lucr zi;
Zile_lucr zi;
typedef enum { inginer=1, profesor, avocat } profesie;
profesie profesia_mea=inginer; /* definirea variabilei
profesia_mea */

Definirea
variabilelor
Variabila este o entitate folosita pentru memorarea unei valori de tipul
asociat variabilei. O variabila se caracterizeaza printr-un nume, un tip, o
valoare. Oricarei variabile i se aloca ( rezerva ) un spatiu de memorie care
corespunzator tipului variabilei.
Definirea variabilelor se poate face inainte de a functiilor, caz in care
sunt globale, deci pot fi folosite de functii, sau in corpul functiilor, inainte de
prelucrari, caz in care sunt localefunctiei respective ( vezi Structura unui
program C ). Numele unei variabile este unic ( nu pot exista mai multe
variabile cu acelasi nume ), dar o variabila locala poate avea numele uneia
globale, caz in care in interiorul functiei, e valabila noua semnificatie a
numelui.
Definirea variabilelor se face:

tip lista_declaratori;
/* tip poate fi oricare din tipurile
elementare de mai sus sau derivate */
lista_declaratori -- cuprinde unul sau mai multi declaratori,
despartiti prin virgula
declarator -- nume_variabila sau
nume_variabila=expresie_de_initializare /
* in expresie_de_initializare pot
apare doar constante sau variabile initializate */
Exemple:
char c1;
char car1='a',car2=car1+1; /* car2 se initializeaza cu 'b' */
float real=1.74, coef;
In definirea
tip lista_declaratori;
tip poate fi precedat sau urmat de cuvantul cheie const, caz in care
variabilele astfel definite trebuie sa fie initializate si nu-si pot modifica
valoarea:
const int coef1=-2, coef2=14;
coef1=5; /* modificarea valorii unei variabile declarate cu const e
gresita, apare eroare in compilare */

Functii de
citire si scriere
In limbajul C, nu exista instructiuni de intrare/iesire ( citire/scriere ), tocmai
pentru a mari portabilitatea limbajului. Pentru a realiza citiri de la tastatura
si scrieri pe ecran, se apeleaza functii de intrare/iesire din biblioteca
mediului de programare.
Mai jos se vor prezenta functiile de I/E cele mai uzuale, primele avand
prototipul in stdio.h, urmatoarele in conio.h; utilizarea lor intr-un
program, va presupune deci, includerea respectivelor fisiere header.
Functii de I/E cu prototip in stdio.h
De remarcat ca functiile de citire din aceasta categorie, realizeaza o citire
cu buffer. Aceasta inseamna faptul ca toate codurile caracterelor tastate
pana la Enter ( inclusiv ) sunt introduse intr-un buffer de intrare ( pentru
Enter codul 10 corespunzator lui '\n' ), de unde sunt extrase pentru
prelucrare de catre functiile de intrare; daca in buffer exista caractere
neprelucrate, la apelul unei functii de intrare, acestea vor prelua codurile
din buffer, numai dupa epuizarea acestora asteptandu-se o noua tastare.

int getchar(void);

Functia returneaza codul unui caracter citit de la tastatura sau valoarea

EOF ( constanta simbolica definita in stdio.h, avand valoarea -1 ) daca s-a
tastat Ctrl/Z.
int putchar(int c);

Functia tipareste pe ecran caracterul transmis ca parametru; returneaza

codul caracterului sau EOF in cazul unei erori.
int printf(format,arg1,arg2,...);

Functia afiseaza pe ecran valorile expresiilor din lista argumentelor,

conform formatului specificat; argumentele pot fi constante, variabile,
expresii. Formatul este un sir de caractere care trebuie sa includa cate un
descriptor de format pentru fiecare din argumente. Caracterele din format
care nu fac parte din descriptori se tiparesc pe ecran. Daca nu apare nici
un argument, pe ecran se tiparesc doar caracterele din sirul format. Functia
returneaza numarul de valori tiparite sau EOF in cazul unei erori.
Descriptori de format

Descriptor
%c
%d %i

Reprezentare
caracter
intreg in zecimal
intreg in zecimal fara
%u
semn
%o
intreg in octal
%x
intreg in hexazecimal
%ld %li
cu semnificatiile de mai
%lu
sus,
%lo %lx
pentru intregi lungi
float;pentru %e - o cifra
%f %e
la partea intreaga
%lf %le
double
%Lf %Le
long double

int scanf(format,adr1,adr2,...);

Functia citeste informatiilem tastate pe care le interpreteaza conform

specificatorilor din format, memorand valorile citite la adresele transmise ca
parametri. Formatul este un sir de caractere care trebuie sa includa cate un
descriptor de format pentru fiecare dintre valorile citite. Adresele sunt
pointeri sau adresele variabilelor ale caror valori se citesc; adresa unei
variabile se obtine folosind operatorul de adresare &, astfel:

&nume_variabila
Functia returneaza numarul de valori citite sau EOF daca s-a tastat Ctrl/Z.
Valorile intregi sau reale consecutive introduse de la tastatura trebuie
separate de cel putin un Enter sau spatiu.
int puts(const char * sir);

Functia tipareste sirul primit ca parametru, apoi un NL, cursorul trecand la

inceputul randului urmator. Returneaza codul ultimului caracter din sir.
Functii de I/E cu prototip in conio.h
void clrscr(void);

Functia sterge ecranul, aducand cursorul in coltul din stanga-sus. Se

apeleaza de obicei la inceputul unui program.
int getche(void);

Citeste un caracter ( asteapta apasarea unei taste, chiar daca in buffer-ul

de intrare mai sunt caractere neprelucrate ), returnand codul si afisand
caracterul pe ecran. Returneaza EOF la tastarea lui Ctrl/Z, respectiv CR
( '\r', cu codul 13 ) la tastarea lui Enter.
int getch(void);

Analog cu functia de mai sus, dar caracterul nu se transmite in ecou ( nu se

afiseaza pe ecran ).
Se obisnuieste ca programele sa se termine cu un
apel getche sau getch, asteptandu-se astfel tastarea unui caracter pentru a nu "disparea" ecranul utilizator cu afisarile realizate de program;
ecranul poate fi revizualizat din mediul TC tastand Alt/F5.

Quiz
Daca la autotestele de mai jos, alegeti varianta corecta, pasul urmator
sunt Exercitiile!
Daca nu, revedeti putin notitele de mai sus :-)
1.Cum se defineste corect o variabila suma de tip intreg?

2.Care varianta reprezinta definirea unei constante simbolice TRUE avand

valoarea 1?

3.Daca un program contine liniile:

int i; char c;
scanf("%d"%c",&i,&c);
iar la rulare se tasteaza
23 XEnter
ce valoare va lua variabila c?
4.Care varianta de mai jos scrie pe ecran O zi buna!, cursorul trecand
apoi la randul urmator?
puts("O zi bun\x61!\");
printf("O zi bun\141!\n");
printf("O zi buna!\n");
5.Care este valoarea expresiei sizeof(long double)?

Exercitii
1.Pentru cate un intreg citit de la tastatura, sa se afiseze valoarea lui si a
opusului in zecimal, hexazecimal, octal; programul se va modifica astfel
incat sa permita citirea in zecimal, hexazecimal, respectiv octal.
Incercati sa gasiti valorile care vor fi tiparite inainte de rulare!
La executia programului se vor introduce
- valorile extreme: 32767, -32768
- valori pozitive si negative din domeniul int precum si care depasesc
tipul int
- valorile 0, 1, -1.
#include <stdio.h>
void main(void){
int i;
printf("i\thexa\toctal\t-i\thexa\toctal\n");
while(1){ /* ciclu "infinit" din care se iese tastand Ctrl/Break */
putchar(':');scanf("%d",&i); /* formatul se va modifica la %x,
%o */
printf("%d\t%x\t%o\t%d\t%x\t%o\n",i,i,i,-i,-i,-i);
}
}
2.Sa se afiseze valorile extreme in zecimal, octal, hexa pentru toate tipurile
intregi.

#include <stdio.h>
void main(void){
char Mc=0x7F,mc=0x80;
unsigned char Muc=0xFF,muc=0;
int Mi=0x7FFF,mi=0x8000;
unsigned Mui=0xFFFF,mui=0;
long Ml=0x7FFFFFFF,ml=0x80000000;
long Mul=0xFFFFFFFF,mul=0;
clrscr();
printf("tip\tmax\thexa\toctal\tmin\thexa\toctal\n");
printf("char\t%d\t%x\t%o\t%d\t%x\t
%o\n",Mc,Mc,Mc,mc,mc,mc);
printf("u char\t%u\t%x\t%o\t%u\t%x\t
%o\n",Muc,Muc,Muc,muc,muc,muc);
printf("int\t%d\t%x\t%o\t%d\t%x\t
%o\n",Mi,Mi,Mi,mi,mi,mi);
printf("u int\t%u\t%x\t%o\t%u\t%x\t
%o\n",Mui,Mui,Mui,mui,mui,mui);
printf("l int\t%ld\t%lx\t%lo\t%ld\t%lx\t
%lo\n",Ml,Ml,Ml,ml,ml,ml);
printf("lu int\t%lu\t%lx\t%lo\t%lu\t%lx\t
%lo\n",Mul,Mul,Mul,mul,mul,mul);
getche();
}
3 Se citesc triplete de numere reale; sa se tipareasca suma si produsul lor.
Se va observa :
- separarea numerelor introduse prin blancuri sau terminator de linie
- tastarea de numerele pozitive sau negative, ca intregi, cu zecimale sau cu
exponent
- numarul de cifre semnificative si deci aproximarea numerelor ( de
exemplu pentru tastarea numerelor 0.0000001 1 1 )
- daca descriptorii se transforma in %e, numerele pot fi furnizate la fel,
tiparirea e diferita.
#include <stdio.h>
void main(void){
float r1,r2,r3;
while(1){
putchar(':');scanf("%e%e%e",&r1,&r2,&r3);
printf("suma=%e\tprodus=%e\n",r1+r2+r3,r1*r2*r3);
}

4 La rularea programului de mai jos, faceti observatii referitoare la valorile

citite, separarea lor, functionarea lui scanf, getchar, getche:

#include <stdio.h>
void main(void){
int i;
char c;
float r;
while(1){
printf("i,c,r:");scanf("%d%c%f",&i,&c,&r);
printf("intreg=%d|car=%c(cod=%d)|real=
%f\n",i,c,c,r);
printf("c,i,r:");scanf("%c%d%f",&c,&i,&r);
printf("intreg=%d|car=%c(cod=%d)|real=
%f\n",i,c,c,r);
printf("r,i,c:");scanf("%f%d%c",&r,&i,&c);
printf("intreg=%d|car=%c(cod=%d)|real=
%f\n",i,c,c,r);
printf("r,i,c:");scanf("%f%d",&r,&i);c=getchar();
printf("intreg=%d|car=%c(cod=%d)|real=
%f\n",i,c,c,r);
printf("r,i,c:");scanf("%f%d",&r,&i);c=getche();
printf("intreg=%d|car=%c(cod=%d)|real=
%f\n",i,c,c,r);
}
}
5 Ce apare pe ecran la tiparirea ( incercare pe hartie, apoi rulare ):
int i=5;float r=23.789e-4;c='C';
printf("\t%cUN\x65!\a\a\n",c-1);
printf("%d %d %e\n",c+1,i,r);
6 Sa se scrie programul care, apeland o singura data printf, tipareste pe
ecran ( analog pentru un apel puts ) - aici un mic ajutor, vezi rezovarea:
Informatii 100% corecte:
I.Ionescu / 24 ani \ zis "a lu' Vasile"
printf("Informatii 100%% corecte:\n\I.Ionescu / 24 ani \\ zis \"a lu'
Vasile\"\n");
puts("Informatii 100% corecte:\n\I.Ionescu / 24 ani \\ zis \"a lu' Vasile\"");
7. Analog cu 6. pentru ca pe ecran sa apara urmatorul text ( printr-un singur
apel printf sau puts ):
Caractere speciale:
slash /; backslash \; procent%;
ghilimele "; apostrof '.

8.Rulati programul de mai jos, observand utilizarea tipurilor enum si

declararea tipurilor utilizator cu typedef( ce credeti ca se va tipari ca
valoare a variabilei amestec ?) :
#include <stdio.h>
#include <conio.h>
void main(void){
enum zile_lucr { luni, marti, miercuri, joi,
vineri };
/* luni e asociat cu 0, ...,vineri cu 4 */
enum transport { tren, avion=5, autocar,
autoturism };
/* tren e asociat cu 0, autocar cu 6,
autoturism cu 7 */
typedef enum zile_lucr Zile_lucr;
typedef enum { inginer=1, profesor, avocat }
profesie;
/* se pot defini variabile de tipurile enum */
enum zile_lucr zi1=marti;
Zile_lucr zi2=joi;
enum transport voi_merge_cu=autocar;
profesie profesia_mea=inginer; /* definirea variabilei
profesia_mea */
int amestec;
printf("val
printf("val
printf("val
printf("val

zi1=%d\n",zi1);
zi2=%d\n",zi2);
voi_merge_cu=%d\n",voi_merge_cu);
profesia_mea=%d\n",profesia_mea);

amestec=zi1*zi2+vineri+'d'+avion+voi_merge_cu-'a'+profe
sia_mea;
printf("val amestec=%d\n",amestec);
getch();
}
9. Scrieti programul care citeste de la tastatura doua caractere
reprezentand initialele unei persoane si anul nasterii, afisand
Persoana X.Y. are varsta de Z ani

<<Pagina Materiale

Copyright 2001-2002. Carmen Holotescu