<<Pagina Materiale

 
 
 Tipuri fundamentale 
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 */

Sus
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:
 
Tip intreg
nr octeti / nr biti
valoare minima
zecimal    hexazecimal     binar
valoare minima
zecimal       hexazecimal     binar
char (signed char)
unsigned char
1        8
-128                  0x80              -27
  0                   0x0                 0
127                  0x7F               27-1 
 255                 0xFF               28-1
int ( signed int )
unsigned int
2        16
-32768             0x8000          -215
       0                  0x0                  0
32767             0x7FFF           215-1 
65535             0xFFFF           216-1
long (signed long)
unsigned long
4        32
-2147483648  0x80000000   -231
   0                   0x0                 0
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
nr octeti/ nr biti
valoare minima
valoare maxima
nr cifre semnificative
float
4      32
3.4E-38
3.4E38
6
double
8      64
1.7E-308
1.7E308
15
long double
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 tip float
Constante de tip double
Constante de tip long double
1.f
1.
1.L
.241f
.241
.241l
-12.5e5f
-12.5e5
-12.5e5l
98.E-12f
98.E-12
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 */

Sus


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 */

Sus
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
Reprezentare
%c
caracter
%d  %i
intreg in zecimal
%u
intreg in zecimal fara semn
%o
intreg in octal
%x
intreg in hexazecimal
%ld  %li  %lu 
%lo  %lx
cu semnificatiile de mai sus, 
pentru intregi lungi
%f  %e
float;pentru %e  - o cifra 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.

Sus
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)?

Sus
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 zi1=%d\n",zi1);
  printf("val zi2=%d\n",zi2);
  printf("val voi_merge_cu=%d\n",voi_merge_cu);
  printf("val profesia_mea=%d\n",profesia_mea);
  amestec=zi1*zi2+vineri+'d'+avion+voi_merge_cu-'a'+profesia_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

Sus
<<Pagina Materiale


Copyright © 2001-2002. Carmen Holotescu
All rights reserved. Published by Timsoft