BIBLIOGRAFIE

1. A l .   K e l l e y ,   I r a   P o h l  A Book On C. The Benjamin/Cummings Publishing Com

pany.

2. B r i a n   K e r n i g h a n ,   D e n n i s   R i t c h i e  The C Programming Language Prentice

Hall, 1978, 1988.

3. C i o c Î r 1 i e H., 111 e ş P., B a l i a  I. Limbajele de programare PASCAL şi PASCAL

concurent Editura Facla, 1985.

4. C r i s t e a V., A t h a n a s i u   I . ,   K a l i s z  E., P a n o i u A. Turbo Pascal 60. Editura

Teora, Bucureşti, 1992.
5. D a v i d o v i c i   A . ,   B ă r b a t  B. Limbaje de programare pentru sisteme tn timp real

Editura Tehnică, Bucureşti, 1986.

6. E m m e t   B e a m  Illustrated C Programming ANSI Standard Wordware Publishing

Inc., 1989.
7. F i n d l a y   W . ,   W a t t  D. PASCAL, An Introduction To Methodical Programming

Pitman Publishing, 1987.

8. G h e z z i   C . ,   J a z a v e r i  M. Programming Language Concepts John Willey Sons,

1987.

1
9. H e r b e r t  S c h i 1 d t C: The Complete Reference Me. Graw Hill, 1990.
10. H o r o w i t z  E., S a h n i S. Fundamentals of Data Structures in PASCAL Computer

Science Press, 1976.

11. I o r g a   V . ,   F ă t u  I. Programarea în limbajul Pascal Litografia I.P.B., 1987.

12. J e n s e n   K . ,   W i r t ' h  N. PASCALt User Manual and Report Springer­Verlag, 1975.

13. K i e r b u r t z  R. Structured Programming and Problem­Solving with PASCAL Computer

Science Press, 1976.

14. Les H a n c o c k ,   M o r r i s   K r i e g e r  The C Primer Me. Graw­Hill Book Company,

1986.

15. R o b e r t   L a f o r e .   Turbo C Programming For The IBM  H o w a r d  W. Sams & Com

pany, 1987.

16. Ş e r b ă n a ţ i L. D. Limbaje şi compilatoare. Programare în Pascal Litografia I.P.B., 1983
17. Ş e r b ă n a ţ i  L,. D. Limbaje de programare şi compilatoare Editura Academiei, Bucureşti,

1987.

18 Ş e r b ă n a ţ i   L .   D . ,   M o l d o v e a n u   F . ,   I o r g a   V . ,   V a l e r i u  P. Programarea
sistematică tn limbajele FORTRAN şi PASCAL Editura Tehnică, Bucureşti, 1984.

19. Y o u r d o n E., C o n s t a n t i n e  h. Structured Design Prentice Hall, 1979.
2 0....................................................Turbo C — Manual de utilizare
2 1....................................................Turbo G­}>­{* — Manual de utilizare
2 Borland C­f­f — Manual de utilizar

2
 eCUPRINS

PARTEA I. Limbajul de programare PASCAL

Cop. 1. Noţiuni introductive.......................................................................................................................

1.1. Hardware şi software........................................................................................................
1.2. Limbaje de programare.....................................................................................................
Cap. 2. Programe. Algoritmi. Elemente de programare structurată........................................................

2.1. Etapele realizării programelor .........................................................................................

2.2. Algoritmi. Definiţie ; caracteristici; reprezentare...........................................................

2.2.1. Noţiunea de algoritm...........................................................................................

2.2.2. Reprezentarea algoritmilor .................................................................................

2.3. Elemente de programare structurată . . ..........................................................................

2.3.1. Introducere. Definiţie. Scop ................................................................................
2.3.2. Structuri de control utilizate în programarea structurată . . .
Cap. 3. Notaţii şi vocabular........................................................................................................................

Cap. 4. Noţiunea de date ............................................................................................................................

4.1. Introducere .......................................................................................................................
4.2. Constante şi variabile...................................... .................................................................
Cap. 5. Nofiunea de tip. Tipuri standard..................................................................................................

5.1. Tipul integer......................................................................................................................

5.2. Tipul boolean (logic) ........................................................................................................

5.3. Tipul real ...........................................................................................................................
5.4. Tipul char (caracter) .........................................................................................................
Cap. 8. Structura generală a unui program PASCAL..............................................................................

Cap. 7. Operaţii de intrare/ieşire..............................................................................................................

7.1. Elemente generale.............................................................................................................

7.2. Reprezentarea operaţiilor de citire/scriere cu ajutorul fişierelor de intrare/

ieşire ..................................................................................................................................

7.3. Procedurile Read, ReadLn, Write, WriteLn.....................................................................

7.3.1. Procedura Read....................................................................................................

r 7.3.2. Procedura Readln...........................................................................................................
7.3.3. Procedurile Write şi Writeln................................................................................
Cap. 8. Instrucţiunile de bază ale limbajului PASCAL ...........................................................................

8.1. Instrucţiunea de atribuire (de asignare)..........................................................................

8.2. Instrucţiunea compusă (secvenţa)....................................................................................

8.3. Instrucţiunile repetitive.................................,..................................................................

8.3.1. Instrucţiunea While.............................................................................................

8.3.2. Instrucţiunea Repeat ..........................................................................................

8.3.3. Instrucţiunea For ................................................................................................

8.4. Instrucţiuni condiţionale ..................................................................................................

8.4.1. Instrucţiunea If ...................................................................................................
 8.4.2. Instrucţiunea Case ..............................................................................................
Cap. 9. Tipuri definite tn program (tipuri de date utilizator) ..................................................................

9.1. Tipul scalar ....................................................................................................................... .

9.1.1. Tipul enumerare .......................................................................................

94.2. Tipul subdomeniu ....................

9.2. Tipuri structurate do date.............................................................................................. 70
9.2.1. Tipul tablou (array)........................................................................................... 70
9.2.2. Tablouri împachetate........................................................................................ 74
9rf2 3 Tipul string (şir de caractere)................................................................................ 79
Cap. 10. Subprograme................................................................................................................................ 86
10.1. Funcţii.............................................................................................................................. 86
10.2. Proceduri.......................................................................................................................... 91
10.3. Proceduri şi date de tip structurat ................................................................................ 95
10.4. Ierarhizarea   pe   niveluri   a   procedurilor   şi   funcţiilor.   Domenii   de   valabilitate   ale
identificatorilor................................................................................................................. 97
10.5. Utilizarea funcţiilor şi procedurilorca parametri ai subprogramelor . 100
Cap. 11. Subprograme recursive................................................................................................................ 103
11.1. Recursivitate. Algoritmi recursivi.................................................................................. 103
11.2. Proceduri şi funcţii recursive............................................................................ 104
11.3. Execuţia programelor recursive..................................................................................... 106
11.4. Exemple de programe recursive..................................................................................... Ill
Cap. 12. Alte tipuri structurate de date..................................................................................................... 119
12.1. Tipul înregistrare (record)........................................................... .................................. 119
12.1.1. Instrucţiunea With............................................................................................ 122
12.1.2. înregistrarea cu variante ................................................................. . . % . 125
............. 12.2. Tipul fişier (file).............................................................................................................. 128
12.2.1. Citirea unui fişier secvenţial . ................................................................. 128
12.2.2. Scrierea unui fişier secvenţial ......................................................................... 129
12.2'.3. Proceduri standard pentru lucrul cu fişiere . . . . . . . . . 130
12.2.4. Buffere fişier..................................................................132
12.2.5. Fişiere text.................................................................... 135
12.3. Tipul mulţime (set) .......................................................................... 137
Cap. 13. Alocarea dinamică a memoriei     
  • •.143
13.1. Tipul indicator (pointer).................................................................................................. 143
13.2. Operaţii tipice întâlnite în prelucrarea listelor înlănţuite........................................... 148
Cap. 14. Instrucţiunea GOTO (salt necondiţionat) .................................................................................. 153
Cap. 15. Aspecte legate de structurarea programelor ...........................................J................................. 158
15.1­. Etapele generale de rezolvare a unei probleme. Puncte de reper în realizarea unui program . . .
.......................................................................................................y.................................. 158
15.1.1. Formularea problemei ...................................................................................... 159
15.1.2. Analiza problemei ....................................................... . . ............................... 159
1 t 15.1.3. Alegerea soluţiei ...................................................................................... 160
15.1.4* Specificaţia de proiectare şi implementarea...................................................... . 160
 15.2. Schiţa iniţială a programului ................................................................. 161
i 15.3. Programul complet ........................................................................................................
........................................................................................................164
Auexa : Diagrame de sintaxă PASCAL....................................................................................... 168

PARTEA   A   II­A.   Limbajul   de   programare   C   Cap.   16.  Privire   generală   asupra

limbajului C ..............................................................................................................................................._ 175
Cap. 17. Structiu­a programelor tn limbajul C. Tipuri de date, operatori şi expresii . . . 178
17.1. Structura programelor în limbajul G ................................................................ 178
17.2. Variabile, tipuri de variabile;declarare . . . . . . . . . . . . . . 1 8 1
 17.3.
■Jfyjtffi:„'’"7* 17.3. Formatele de scriere
funcţiei printf () ........................................................................184
‘".'/ţi* 17.4. Secvenţe escape ........................................................................................................... 187
• ]$Ţ£: . 17.5. Funcţia scanf .......................................................................................................188
. 17.6. Operatorul de adresare (&)...................................................................................... 190
} ,i 17.7. Operatori, expresii ................................................................................................■ . . . . 190
. 17.7.1 Operatori aritmctici ............................................................................... 190
O**' 17.7.2. Operatori de atribuiie aritmetică................................................... 191
17.7.3. Operatori de incrementare/decrementare . ..................................................192
17.7.4. Operatori relaţionali ......................................................................................193
17.8. Funcţia getche()................................................................................................................ 194
tţvS.

Cap. i8. Structuri de c&nirol tn limbajul C .................................................................................... 196
18.1. Structuri iterative (bucle) ..................................... 1..................................................... 196
18.1.1. Bucla for ..........................................................................................................196
18.1.2. Bucla while .....................................................................................................199
:
18.1.3. Bucla do while . . . ......................................................... 204
18.2. Structuri decizionale ..................................................................................................... 207
18.2.1. Structura if . ................................................................................................... 207
18.2.2. Structura if­else .............................................................................................210
18.2.3. Operatori logici .............................................................................................. 214
18.2.4. Precedenţa şi asociativitatea operatorilor .................................................... 215
18.2.5. Construcţia else­if ......................................................................................... 217
18.2.6. Structura switch. Instrucţiunile break şi continue . V . . . 219
18.2.7. Operatorul condiţional . . . . ............................... ... . 223
18.2.8. Instrucţiunea goto ......................................................................................... 224
18.2.9. Exerciţii.................................................. . . : ................................................. 225

Câp. 19. Funcţii . .............................. . . . . .......................,.. .

..............................227
' 1 • 19.1.­ Generalităţi ...................................................................... ............................................ 227
19.2. Structura programelor care utilizează funcţii ............................................................. 228
19.2.1. Definiţia funcţiilor ......................................................................................... 229
i 19.2.2L Apelul funcţiilor .................................................................................................... 229
19.2.3. Prototipul funcţiilor . ..................................................................................... 229
19.3. Variabile locale .............................................................................................................. • 230
19.4. Funcţii care returnează o valoare............................................................. 230
19.5. Funcţii cu parametri (argumente)..........................................231
1
 1 19.6. Transferul parametrilor multipli ............................................................ . .. 234
19.7. Funcţii cu parametri,care returnează o valoare .......................................................... 235
19.8. Utilizarea mai multor funcţii într­un program . ­. . . . . . . .• 237
19.9. Standardul ANSI al limbajului C faţă de versiunea „Kernighan şi Ritchie"
iniţială.............................................................................................................................. 239
19.10 Variabile externe ................................................................................................. . .; r 240
19.11. Directive către preprocesor ..............................................................................* •• 242
19.11.1. Directiva # define ........................................................................................... 242
19.11.2. Macroinstrucţiuni............................................................................................ 243
1 3 19.11.3. Directiva #include.............................................................................................. 246
19.12. Prototipuri pentru funcţiile de bibliotecă...................................................................... 246
19.13. Funcţii şi operatori la nivel de bit.................................................................................. 247
19.14. Clase de alocare pentru variabile.................................................................................. . 249

Cap. 20. Tablouri şi pointeri ...................................................................................................................... 253
20.1. Tablouri cu o dimensiune.....................................................................................253
20.2. Pointeri. Declararea pointerilor..................................................................................... . 258
 20.3. Aritmetica pointerilor ...................................................................................................   •
261Pointeri şi tablouri cu o dimensiune.......................................................................

20.4. Tablouri de pointeri.....................................................................  i > . . . .  .

20.5. Pointeri către pointeri....................................................................................................
20.6. Pointeri către tablouri cu o dimensiune...........................................................  . . .
20.7. Pointeri şi tablouri cu mai multe dimensiuni............................................................. .
20.8. Transmiterea unui tablou cu mai multe dimensiuni la o funcţie . ..

20.9. Calificatorul const aplicat la pointeri...........................................................................

20.10. Argumente în linia de comandă ...................................................................................

20.11. Funcţii care Întorc pointeri ..........................................................................................

20.12. Pointeri către funcţii......................................................................................................

20.13. Declaraţia typedef .........................................................................................................
20.14. Funcţii polimorfice (facultativ)......................................................................................

Cap. 21. Structuri ......................................................................................................................................

21.1. Definirea şi iniţializarea structurilor. Accesul la membri..........................................

21.2. Pointer! către structuri şi accesul prin pointeri. Atribuiri de structuri

21.3. Structuri şi funcţii....................................................................................................

21.4. Structuri ca elemente ale unor alte tipuri de date. Structuri cu auto­
 referire ..........................................................................................................................

21.5. Tablouri de structuri.....................................................................................................
21.6. Uniuni. Câmpuri de biţi ...................................................•’........................................
Cap. 22. Intrări/ieşiri şi ţuacjii de bibliotecă ...........................................................................................

22.1. Generalităţi........................................................ ................................... ......................

22.12. Intrări/ieşiri standard: (stdio.li)....................................................................................

22.2.1. Accesul la fişiere....................................................................... .....................

22.2.2. Distincţia dintre modurile text şi binar la MS­DOS....................................

22.2.3..............................................................................................................................  Funcţii   de
intrare/ieşire cu conversie de formal...........................................................................

22.2.4.  Funcţii de intrare/ieşire la nivel de caracter . . . . . . . .

22.2.5. Funcţii de intrare/ieşire orientate pe Înregistrări ■ .................................

22.2.6. Funcţii de control al poziţiei In fişier şi de eroare.......................................

22.2.7. Programe de intrare/ieşire ............................................................................

22.3. Testarea apartenenţei la clase de caractere: Retype.li)> ...........................................

22.4. Funcţii pentru operaţii cu şiruri de oaractere: (string.h)............................................

22.5. Funcţii matematice: <[matli.h)> >......................................................... ......................

22.6. Funcţii utilitare: (stdiib.h^...................................... . .....................................
 22.7. Macroinstrucţiuni pentru funcţii cu număr variabil de argumente:

(stdarg.h).......................................................................................................................

22.8. Funcţii pentru gestiunea timpului (data şi ora): (time.li^..........................................
22.9. Limite dependente de implementare: (limits.h,^ (float.h^ . . . .
Răspunsuri şl rezolvări ..............................................................................................................................

Bibliografie264

267

270

273
273  278 280 280 282 285 288 290

293

293

296
297

302

304
306

310

310
310

310

313

315

319

319

319  320

327

328

329
330

333

335
338
 INSTRUCŢIU
NE

PARTEA A II­A

LIMBAJUL DE PROGRAMARE C

CAPITOLUL 16 PRIVIRE GENERALĂ ASUPRA LIMBAJULUI C

.14
 Limbajul   C   a   fost   creat   şi   implementat   pentru   prima   dată   în   anul   1972   de  Dennis   Ritchie  de   la  AT  &   T   Bell
Laboratories  pe  echipamente  DEC—PDP­11,  care  utilizau  sistemul  de  operare  UNIX.  Limbajul  C  este   rezultatul  unui
proces  de  dezvoltare  care  a  început  cu   un   limbaj  mai   vechi   numit  BCPL,   apărut   prima  oară  în   Europa.   BCPL  a  fost
dezvoltat de Martin Richards şi a influenţat limbajul numit B creat de Ken Thomson. Limbajul B a condus la dezvoltarea
limbajului C în anul 1970. Un număr de ani versiunea standard a limbajului C era versiunea furnizată odată cu sistemul
de operare UNIX. Ea este descrisă în cartea „The C Programming Language" de Berian Kernighan şi Dennis Ritchie (1978)
şi   reeditată   în   1988.   O   dată   cu   dezvoltatea   microcalculatoarelor   au   fost   create   un   număr   mare   de   implementări   ale
limbajului C. Un element foarte important constă în compatibilitatea codului sursă a celor mai multe implementări. Totuşi,
deoarece nu exista nici un standard, erau multe discrepanţe. Pentru a corecta această situaţie, ANSI (American National
Standard Institute) a înfiinţat în 1983 un comitet pentru a crea un standard şi a defini limbajul C odată pentru totdeauna.
Astfel a apărut standardul ANSI în 1988 pentru limbajul C, care diferă de versiunea iniţială în anumite privinţe. Care sunt
caracteristicile de bază ale limbajului C ?

Limbajul C  este un  limbaj de nivel media.  Asta nu înseamnă că el este mai ,,slab“ decît limbajele de nivel înalt

BASIC sau Pascal, sau că el este similar cu limbajele de asamblare care ridică probleme de programare utilizatorilor.
Limbajul   C   se   numeşte   de   nivel   mediu   deoarece   cl   combină   avantajele   limbajelor   de   nivel   înalt   cu   funcţionalitatea
limbajelor de asamblare. în tabelul următor se arată locul limbajului C printre limbajele de programare.

9 Limbaje de nivel înalt: Ada
Modula­2
Pascal

COBOL

FORTRAN

BASIC

• Limbaje de nivel mediu : C
FORTH

Macro­asembler

• Limbaje de nivel inferior : Limbaje de asamblare.
Ca limbaj de nivel mediu, C permite manipularea biţilor, octeţilor şi adreselor —elemente de bază cu care operează
calculatorul. Codul C este foarte portabil. Portabilitatea constă în posibilitatea de adaptare a software­ului pe diferite
tipuri de calculatoare. Ca toate limbajele de nivel înalt suportă conceptul de tipuri de date (întreg, caracter, real). Limbajul
C are posibilitatea să lucreze cu tipuri de date diverse  (char,  int,  float, double)  şi permite orice fel de conversii (într­o
expresie pot apărea tipuri de date diferite). In versiunea originală de C, nu se făcea un test de compatibilitate între para ­
metrii formali ai unei funcţii şi argumentele reale utilizate la apelul funcţiei. Astfel, de exemplu, se putea apela o funcţie
utilizând un  pointer  ca parametru formal, fără a genera eroare dacă argumentul actual al funcţiei era un real. Eroarea
apărea  doar  în faza execuţiei,  creînd  mari probleme  Ia depanarea  programelor.  De aceea standardul ANSI  a  introdus
conceptul de prototip funcţie care permite să fie raportate asemenea erori potenţiale încă din faza de compilare.

Limbajul C are doar 32 de cuvinte cheie. Spre comparare, limbajul BASIC pentru IBM­PC conţine în jur de 159 de
cuvinte cheie.

Limbajul C este un  limbaj structurat,  ca şi alte limbaje (ALGOL, Pascal, Modula­2). El însă nu permite crearea şi

declararea unor funcţii în interiorul altor funcţii. Trăsătura caracteristică a limbajelor structurate este compartimentarea
codului şi datelor. Aceasta este capacitatea limbajului de a extrage şi de a ascunde de restul programului instrucţiunile şi
informaţiile necesare pentru a realiza o sarcină specifică.

Un mod de a realiza această comparimentare constă în folosirea subrutinelor (funcţiilor) care lucrează cu variabile
locale (temporare). Folosind variabilele locale se pot scrie subrutine astfel încât evenimentele care se petrec în interiorul lor
nu   dau   naştere   la   efecte   secundare   în   alte   părţi   din   program.   Această   capacitate   uşurează   programelor   C   partajarea
15
secţiunilor de cod. Astfel, dezvoltând funcţii separate trebuie doar să ştii ce face funcţia, nu cum face funcţia. Să precizăm
că folosirea excesivă a variabilelor globale (variabile recunoscute în tot programul) poate cauza efecte secundare nedorite
(oricine programează în BASIC este conştient de această problemă).
 Un limbaj Structurat permite o mare varietate de posibilităţi de programare prin construcţiile pe care le suportă. în
cadrul limbajului structurat instrucţiunea goto este prohibită. Să dăm exemple de limbaje structurate şi nestructurate:

— nestmdurale: FORTRAN, COBOL, BASIC
— structurate: Pascal, Ada, C, Modula­2
Componenta structurală principală a limbajului C este funcţia­subrutina independentă a limbajului C. în limbajul C,
funcţiile sunt blocuri în care se desfăşoară toată activitatea programului. Ele permit definirea şi programarea separată a
sarcinilor distincte ple unui program, permiţâDdu­i acestuia să fie modular.

O funcţie odată creată, se va executa corect în diferite situaţii fără a da naştere la efecte secundare în alte părţi ale 
programului. Capacitatea de a crea funcţii independente este importantă mai ales în programele mari, unde altfel pot 
apărea influenţe r.ccidestale intre diferite părţi ale programului

16
 .Un alt mod de structurare şi compartimentare a programelor în limbajul C constă în
folosirea blocurilor de program  (code block).  Un astfel de bloc este format dintr­un grup de
instrucţiuni   înlănţuite   logic   şi   tratate   ca   o   unitate.   în   limbajul   C   un   astfel   de   bloc   este
constituit dintr­un ş.ir de instrucţiuni incluse între acolade ({bloc}). Cu ajutorul unor astfel
de blocuri implementarea multor algoritmi se poate face cu claritate, eleganţă şi eficieniă.

Un factor determinant în răspândirea limbajului C în rândul programatorilor consta în
posibilitatea utilizării lui cu succes în locul limbajului de asamblare, care este greu de folosit
în aplicaţii (conţine un număr  mare de instrucţiuni elementare şi nu este structurat).  în
plus, programele elaborate în limbaj de asamblare nu sînt portabile.

Limbajul   C   este   singurul   limbaj   de   programare   structurat   care   permite   un   control

riguros   al   hardware­ului   şi   al   perifericelor   (facilitate   oferită   de   limbajele   de   asamblare).
Limbajul C a fost folosit iniţial pentru scrierea programelor de sistem (sisteme de operare,
editoare,   compilatoare,  etc.),  dar   odată   cu   creşterea   popularităţii   lui,   programatorii   au
început să­l folosească şi la scrierea programelor de aplicaţii datorită în special eficienţei şi
portabilităţii crescute a unor astfel de programe.

în   concluzie,   limbajul   C   este   un  limbaj   agreat   de   programatori,  permiţân­   du­le

acestora   să   alcătuiască   cu   uşurinţă   în   mod   sistematic   programe   complexe.   Fiecare
programator îşi poate crea o bibliotecă de funcţii pe măsura personalităţii fiecăruia, care pot
fi folosite în diferite situaţii.

Datorită acestor calităţi incontestabile limbajul C a devenit limbajul de bază şi pentru
programarea aplicaţiilor de timp real.
 12 — Programarea calculatoarelor — ed. J5STRUCTURA
PROGRAMELOR ÎN LIMBAJUL C. TIPURI DE
DATE, OPERATORI ŞI EXPRESII

17.1. STRUCTURA PROGRAMELOR ÎN LIMBAJUL C

La fel ca în orice activitate de programare, prima acţiune pe care trebuie să o
întreprindă   programatorul   este   să   scrie   cu   ajutorul   unui   editor   programul,   în
conformitate cu regulile sintactice şi semantice aferente acestui limbaj. Se elaborează
astfel aşa­numitul  „program  sursă“,  care  pentru  a fi executat  trebuie  să parcurgă o
serie de etape:

— etapa de compilare care are două componente:

* rezolvarea directivelor către preprocesor prin expandarea în co­ dul­sursă
a unor forme reduse determinate de aceste directive (dacă există);

<• * transpunereaprogramului sursăîn „program obiect1';

— etapa de Iink­cdîtarc care presupune legarea programului obiect obţinut mai
sus   cu   bibliotecile   de   sistem   şi   transformarea   lui   într­im  „program
cxccutabil“;

— etapa de lansare în cxccuţie.
Modul în care se execută aceste acţiuni este specific tipului de calculator

* şi de sistem de operare care conţine limbajul de programare. în cele ce urmează nu vom
insista   asupra   acestor   elemente,   noi   având   în   vedere   problemele   generale   de
programare   pentru   elaborarea   programului   sursă,   probleme   valabile,   indiferent   de
maşina pe care se lucrează.

Să   scriem   şi   să   comentăm   un   program   foarte   simplu   scris   în   C,   pentru   a

desprinde o serie de reguli generale referitoare la structura acestor programe.

Exemplu 17.1

nain()
{
printf ("Noi invăţăm limbajul C!u);

18
 }Presupunând parcurse in mod corect etapele de compilare şi link­editare

a programului, la lansarea lui în execuţie va apare mesajul:
Noi Învăţăm limbajul Cl

O primă observaţie importantă pe care trebuie să o facem este aceca că orice program în C
este compus dintr­o serie de entităţi numite funcţii". O funcţie, pentru a o deosebi de un
cuvânt cheie oarecare al limbajului, se notează cu numele funcţiei, urmat de două paranteze
rotunde: mirue funeţieQ;

• Funcjia main() este aceea către care sistemul de operare transferă controlul atunci
când   se   lansează   în   execuţie   programul.   în   anumite   situaţii,   in   interiorul   parantezelor
aceste funcţii pot exista şi parametri. începutul şi sfârşitul corpului funcţiei formează un
bloc   marcat   de   paranteze   acolade.   Aceste   paranteze   au   un   rol   similar   instrucţiunilor
BEGIN  şi  END  din   Pascal.   Aşa   cum   vom   vedea   în   continuare,   parantezele   acolade   se
utilizează şi pentru delimitarea altor blocuri întîlnite de exemplu în structurile interative
sau decizionale.

Linia de program:

printf („Noi învăţăm limbajul C!“);
(corpul funcţiei main()) formează o instrucţiune şi ea este obligatoriu terminată cu semnul
(;). Trebuie făcută observaţia că spaţiile albe  (blank, tab, newline)  sunt invizibile pentru
compilator. Astfel, programul mai putea fi scris astfel:

main(){printf („Noi învăţăm limbajul Cl“);}

Prin   delimitarea   blocurilor   cu   ajutorul   parantezelor   acolade   programul   devine   mai

uşor de citit, şi de interpretat. O sinteză a celor spuse mai sus este prezentată în figura
17.1.

numele funcţiei (parantezele

pot include parametru)

s. N

v main () \
/  , \ semn de terminare
/ /' • ,• u• A* O uneiinstructiuni(i)
}/ printf ( Noi invatam limbaj ulC! ) ; • , ' '

y >——­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­v­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­/

hh\/
\

/ \

instrucţiune

\
 K
fTmcofuî^
■ funcţianumita main( )
Fi,g. 17.1.

în programul de mai sus, „printf()“ este numele unei funcţii, la fel ca mainQ, dar care
are argumente între paranteze şi anume un şir de caractere. Aceasta este o funcţie sistem
(nu este creată de programator) foarte versatilă, care permite afişarea la consolă (display) a
constantelor, variabilelor şi caracterelor.