Programarea Calculatoarelor Si Limbaje de Programare PDF

Dumitru Dragomir
PROGRAMAREA CALCULATOARELOR
I LIMBAJE DE PROGRAMARE
Editura Fundaiei Universitare Dunrea de Jos

Galai 2006
Dumitru Dragomir
PROGRAMAREA CALCULATOARELOR
I LIMBAJE DE PROGRAMARE
Editura Fundaiei Universitare Dunrea de Jos

Galai 2006
UNIVERSITATEA DUNREA DE JOS DIN GALAI

FACULTATEA DE NAVE
Editura Fundaiei Universitare Dunrea de Jos din Galai
este acreditat de CNCSIS
Refereni tiinifici
Prof. Dr. Ing. Viorel Mnzu
Prof. Dr. Ing. Leonard Domnioru
Editura Fundaiei Universitare

Dunrea de Jos, Galai, 2006
ISBN : 973 - 627 - 260 5
www.editura.ugal.ro
editura@ugal.ro
Programarea calculatoarelor i limbaje de programare
CUPRINS
Introducere ...........................................................................................................................1
Cap.1. Elemente de baz n informatic ............................................................................3
.1.1. Definiii de baz ......................................................................................................3
.1.2. Sisteme de numeraie...............................................................................................3
.1.3. Reprezentarea informaiei n calculator...................................................................5
.1.4. Codificarea informaiei n calculator.......................................................................5
.1.5. Reprezentarea datelor ..............................................................................................6
.1.6. Structura fizic (hardware) a unui calculator ..........................................................9
.1.7. Structura operaional a unui sistem de calcul ......................................................13
.1.8. Organizarea funcional a unui sistem de calcul ...................................................15
.1.9. Dispozitive periferice ............................................................................................17
1.9.1. Dispozitive de intrare........................................................................................17
1.9.2. Dispozitive de ieire..........................................................................................19
1.9.3. Memoriile externe.............................................................................................23
.1.10. Organizarea datelor n memoria extern. Fiiere ................................................25
1.10.1. Structurarea fiierelor .....................................................................................25
1.10.2. Operaii cu fiiere............................................................................................26
1.10.3. Tipuri de fiiere...............................................................................................28
.1.11. Noiuni privind structura software a calculatorului.............................................29
1.11.1. Ierarhia programelor .......................................................................................29
.1.12. Elemente de ingineria programrii ......................................................................30
1.12.1. Generaliti......................................................................................................30
1.12.2. Modularizarea .................................................................................................30
1.12.3. Teorema fundamental a ingineriei programrii ............................................31
1.12.4. Date, tipuri i structuri de date........................................................................32
1.12.5. Structuri de programe. Programare structurat...............................................33
1.12.6. Metode de programare ....................................................................................37
.1.13. Programe i limbaje de programare.....................................................................37
1.13.1. Portabilitatea programelor ..............................................................................38
1.13.2. Fazele de elaborare a unui program executabil. .............................................39
Cap.2. Limbajul C..............................................................................................................43
2.1. Caractere.................................................................................................................43
2.2. Atomi lexicali .........................................................................................................43
2.2.1. Identificatori......................................................................................................43
2.2.2. Numere..............................................................................................................43
2.2.3. Constante ..........................................................................................................44
2.2.4. Delimitatori de comentariu ...............................................................................44
2.2.5. Cuvinte cheie ....................................................................................................44
2.2.6. Operatori ...........................................................................................................44
2.2.6.1. Operatori unari ..........................................................................................44
2.2.6.2. Operatori binari .........................................................................................45
2.2.6.3. Operatorul ternar condiional ....................................................................48
2.2.6.4. Operatorul de atribuire simpl i compus ...............................................49
2.2.7. Precedena operatorilor .....................................................................................50
II
Cuprins
2.3. Tipuri de date standard ...........................................................................................50

2.3.1. Tipuri de baz ...................................................................................................50
2.3.2. Modificatori de tipuri........................................................................................51
2.3.2. Stocare n memorie i domenii de valori ..........................................................51
2.3.4. Tipul enumeraie ...............................................................................................51
2.3.5. Tipul structur...................................................................................................52
2.3.6. Tipul uniune......................................................................................................53
2.3.7. Date nemodificabile. Declaraia const ..............................................................53
2.3.8. Declaraia typedef .............................................................................................54
2.4. Conversii de tipuri de date......................................................................................54
2.4.1. Conversia automat de tip.................................................................................54
2.4.2. Conversia explicit de tip. Operatorul cast.......................................................54
2.5. Instruciuni..............................................................................................................55
2.5.1. Instruciunea expresie .......................................................................................55
2.5.2. Instruciunea de decizie ....................................................................................56
2.5.3. Instruciunea de selecie....................................................................................56
2.5.4. Instruciunea de ciclare for ...............................................................................57
2.5.5. Instruciunea de ciclare cu test iniial, while.....................................................57
2.5.6. Instruciunea de ciclare cu test final, do-while .................................................58
2.5.7. Instruciunea continue.......................................................................................58
2.5.8. Instruciunea de salt, goto .................................................................................58
2.6. Tablouri ..................................................................................................................59
2.7. Adrese i pointeri....................................................................................................60
2.7.1. Definiia pointerilor ..........................................................................................60
2.7.2. Utilizarea variabilelor pointer...........................................................................61
2.7.3. Iniializarea variabilelor pointer........................................................................61
2.7.4. Relaia dintre pointeri i tablouri ......................................................................61
2.7.5. Pointeri ctre pointeri........................................................................................62
2.7.6. Aritmetica pointerilor .......................................................................................62
2.8. Funcii.....................................................................................................................63
2.8.1. Prototipul unei funcii .......................................................................................63
2.8.2. Definirea unei funcii ........................................................................................63
2.8.3. Apelul unei funcii ............................................................................................63
2.8.4. Instruciunea return ...........................................................................................64
2.8.5. Funcia main .....................................................................................................64
2.8.6. Exemplu de folosire a funciilor ntr-un program C .........................................64
2.8.7. Transferul argumentelor funciilor....................................................................65
2.9. Directive preprocesor .............................................................................................69
2.9.1. Directiva include...............................................................................................69
2.9.2. Directiva define.................................................................................................70
2.9.3. Directiva undef .................................................................................................70
2.9.4. Directive de compilare condiionat .................................................................70
Cap.3. Elemente de limbaj C++ ........................................................................................72
3.1. Operaii de intrare/ieire cu consola .......................................................................72
3.2. Suprancrcarea funciilor ......................................................................................72
3.3. Utilizarea argumentelor prestabilite .......................................................................73
3.4. Alocarea dinamic a memoriei ...............................................................................73
III
3.5. Conceptul de clas..................................................................................................73

3.5.1. Structura n C++ ...............................................................................................74
3.5.2. Clasa n C++ .....................................................................................................76
3.5.3. Funcii speciale ale clasei. Constructori i destructori......................................76
3.5.4. Autoreferina unui obiect al clasei. Cuvntul cheie this ...................................80
3.5.5. Membrii statici ai clasei....................................................................................80
3.5.6. Funcii prietene .................................................................................................80
3.5.7. Supradefinirea operatorilor ...............................................................................81
Cap.4. Programarea n limbajul C sub sistemul DOS ....................................................83
.4.1. Structura unui program C ......................................................................................83
.4.2. Fiiere antet ...........................................................................................................83
.4.3. Funcii de bibliotec standard................................................................................83
4.3.1. Funcii de conversie a datelor ...........................................................................84
4.3.2. Funcii matematice............................................................................................84
4.3.3. Funcii de intrare/ieire ale consolei .................................................................86
4.3.3.1. Funcii de intrare de la tastatur ................................................................86
4.3.3.2. Funcii de acces la ecranul text .................................................................87
4.3.4. Funcii de intrare/ieire standard.......................................................................88
4.3.4.1. Intrri/ieiri standard .................................................................................88
4.3.4.2. Intrri/ieiri n flux (de la/spre fiiere)......................................................91
4.3.5. Funcii de lucru cu iruri de caractere...............................................................95
4.3.6. Funcii de clasificare i conversie a caracterelor ..............................................95
4.3.7. Funcii de acces la directoare i dispozitive......................................................96
4.3.8. Funcii de alocare a memoriei...........................................................................97
4.3.9. Funcii grafice DOS ..........................................................................................98
Cap.5. Elemente de operabilitate sub Windows ............................................................107
5.1. Relaia calculator mediu de execuie .................................................................107
5.2. Sarcini i tehnici de realizare a sarcinilor.............................................................108
5.2.1. Interdependena sarcinilor...............................................................................108
5.2.2. Tehnica unitasking..........................................................................................109
5.2.3. Tehnica multitasking.......................................................................................112
5.3. Mediul obiectual...................................................................................................112
5.3.1. Tehnica de programare orientat pe obiect.....................................................112
5.4. Mediu de programare ...........................................................................................115
5.4.1. Medii de programare integrate, medii integrate de dezvoltare a aplicaiilor ..116
5.4.2. Elaborarea unui program n limbaj C ntr-un mediu de programare integrat .117
Cap. 6. Mediul Visual BASIC pentru EXCEL ..............................................................119
6.1. Generaliti ...........................................................................................................119
6.2. Obiecte i colecii .................................................................................................119
6.2.1. Utilizarea obiectelor........................................................................................120
6.2.2. Variabile obiect...............................................................................................120
6.2.3. Proprieti care reprezint obiecte ..................................................................121
6.2.4. Adresarea obiectelor .......................................................................................121
6.2.5. Folosirea sau manipularea proprietilor obiectelor .......................................122
6.2.6. Activarea obiectelor........................................................................................122
IV
Cuprins
6.3. Tipuri de date........................................................................................................123

6.4. Constante i variabile ...........................................................................................123
6.4.1.Constante .........................................................................................................123
6.4.2. Variabile..........................................................................................................124
6.4.3. Vizibilitatea constantelor i variabilelor .........................................................126
6.4.4. Durata de via variabilelor.............................................................................126
6.5. Tipuri de date definite de utilizator ......................................................................127
6.6. Expresii.................................................................................................................127
6.7. Conversii de tip.....................................................................................................128
6.7.1. Conversia de tip automat...............................................................................128
6.7.2. Conversia de tip explicit ...............................................................................129
6.8. Enunurile Visual BASIC .....................................................................................130
6.9. Comentarii ............................................................................................................130
6.10. Proceduri.............................................................................................................131
6.10.1. Subrutine.......................................................................................................131
6.10.2. Subrutine.......................................................................................................132
6.10.3. Apelul procedurilor.......................................................................................133
6.11. Foile pentru module............................................................................................133
6.12. Structuri de control al execuiei n Visual BASIC .............................................134
6.12.1. Structura bialternan....................................................................................134
6.12.2. Structura monoalternan..............................................................................134
6.12.3. Structura multialternan (selectoare)...........................................................134
6.12.4. Structura repetitiv contorizat explicit........................................................135
6.12.5. Structura repetitiv contorizat implicit .......................................................136
6.12.6. Structura repetitiv condiionat anterior .....................................................136
6.12.7. Structura repetitiv condiionat posterior....................................................137
6.12.8. Instruciunea de salt ......................................................................................137
6.13. Pseudoprocedura.................................................................................................138
Cap. 7. Resurse de interfaare grafic............................................................................139
7.1. Generaliti ...........................................................................................................139
7.2. Tehnici de interaciune .........................................................................................140
7.2.1. Dispozitive logice de intrare ...........................................................................140
7.2.1.1. LOCATOR..............................................................................................140
7.2.1.2. STROKE .................................................................................................140
7.2.1.3. VALUATOR...........................................................................................141
7.2.1.4. CHOICE..................................................................................................141
7.2.1.5. PICK........................................................................................................141
7.2.1.6. STRING ..................................................................................................142
7.2.2. Modurile de operare ale dispozitivelor logice de intrare ................................142
7.2.2.1. Modul Cerere ..........................................................................................142
7.2.2.2. Modul Eantionare ..................................................................................142
7.2.2.3. Modul Eveniment....................................................................................143
7.3. Resurse de dialog..................................................................................................143
7.3.1. Crearea unei cutii de dialog definit de utilizator...........................................143
7.3.2. Controlul interactiv al proprietilor obiectelor ..............................................145
7.3.4. Controlul programat al proprietilor obiectelor.............................................145
7.4. Integrarea unei aplicaii n mediul de aplicaie.....................................................147
7.4.1. Generaliti......................................................................................................147
7.4.2. Controlul prin program al obiectelor aplicaiei suport....................................148
7.4.3. Personalizarea aplicaiei .................................................................................149
Cap.8. Limbajul FORTRAN. Versiunea FTN95...........................................................151
8.1. Prezentare general...............................................................................................151
8.2. Convenii sintactice generale................................................................................151
8.3. Tipuri de date, declarare, iniializare ....................................................................152
8.4. Parametrizarea ......................................................................................................153
8.5. Atribuirea implicit a tipului ................................................................................154
8.6. Tipuri de date definite de utilizator (date structurate) ..........................................154
8.7. Operatori i expresii .............................................................................................155
8.7.1. Operatori unari................................................................................................155
8.7.2. Operatori binari...............................................................................................155
8.7.3. Precedena operatorilor ...................................................................................155
8.7.4. Operatori n expresii numerice .......................................................................155
8.7.5. Conversia de tip ..............................................................................................156
8.7.6. Operatori la nivel de caracter..........................................................................156
8.7.7. Operatori relaionali........................................................................................156
8.7.8. Operatori logici ...............................................................................................156
8.8. Tablouri ................................................................................................................157
8.8.1. Tablouri de mrime fix .................................................................................157
8.8.2. Tablouri de mrime variabil..........................................................................158
8.9. Structuri de control ...............................................................................................158
8.9.1. Instruciunea de salt necondiionat, GO TO ...................................................158
8.9.2. Instruciunea alternativ, IF ............................................................................158
8.9.3. Blocul de alternative IF...................................................................................159
8.9.4. Blocul alternativ multipl SELECT CASE...................................................159
8.9.5. Ciclul repetitiv contorizat DO.........................................................................160
8.9.6. Ciclul DO indefinit .........................................................................................160
8.9.7. Ciclul DO WHILE ..........................................................................................161
8.9.8. Ciclul DO implicit ..........................................................................................161
8.9.9. Etichetarea (numirea) structurilor de control..................................................161
8.10. Uniti de program i proceduri..........................................................................162
8.10.1. Generaliti....................................................................................................162
8.10.2. Programe principale......................................................................................162
8.10.3. Subrutine.......................................................................................................162
8.10.4. Instruciunea STOP.......................................................................................163
8.10.5. Funcii ...........................................................................................................163
8.10.6. Argumente reale i formale. Argumente opionale.......................................163
8.10.7. Conservarea valorilor. Atributul SAVE........................................................165
8.10.8. Module de program.......................................................................................165
8.10.9. Vizibilitatea datelor din module. Atributele PUBLIC i PRIVATE ............166
8.10.10. Fiiere externe. Directiva INCLUDE .........................................................166
8.11. Operaii de intrare/ieire .....................................................................................167
8.11.1. Instruciunea FORMAT................................................................................167
8.11.2. Instruciuni pentru transferul datelor ............................................................169
8.11.2.1. Instruciunea READ ..............................................................................169
VI
Cuprins
8.11.2.2. Instruciunea WRITE ............................................................................170

8.11.2.3. Instruciunea PRINT .............................................................................170
8.11.2.4. Instruciunea OPEN ..............................................................................170
8.11.2.5. Instruciunea CLOSE ............................................................................172
8.11.2.6. Instruciunea INQUIRE ........................................................................172
8.11.2.7. Instruciunile de poziionare n fiier BACKSPACE i REWIND .......174
8.12. Variabile pointer i inte .....................................................................................175
8.12.2. Asocierea pointerilor cu intele. Dezasocierea pointerilor............................176
8.12.3. Alocarea dinamic a memoriei pentru tablouri.............................................178
8.13. Mediul PLATO3 IDE .........................................................................................178
8.13.1. Generaliti....................................................................................................178
8.13.2. Construirea i rularea unui proiect................................................................179
Cap.9. Limbajul AutoLISP pentru AutoCAD...............................................................182
9.1. Generaliti ...........................................................................................................182
9.2. Lista ca structur de baz n AutoLISP. Funcii...................................................182
9.2.1. Lista ................................................................................................................182
9.2.2. Funcia ............................................................................................................183
9.3. Evaluarea n AutoLISP.........................................................................................184
9.3.1. REP ciclul de funcional baz n AutoLISP.................................................184
9.3.2. Evaluarea simbolurilor....................................................................................185
9.4. Convenii sintactice n AutoLISP .........................................................................185
9.5. Funcii primitive n AutoLISP..............................................................................185
9.6. Predicate de baz n AutoLISP.............................................................................187
9.7. Funcii de test logic n AutoLISP .........................................................................189
9.8. Funciile READ i EVAL.....................................................................................189
9.9. Funcii alternativ.................................................................................................190
9.10. Expresii ciclice ...................................................................................................190
9.11. Funcia program..................................................................................................191
9.12. Funcii de test numeric .......................................................................................191
9.13. Funcii de prelucrare a listelor ............................................................................191
9.14. Funcii numerice.................................................................................................192
9.15. Comenzi definite de utilizator ............................................................................194
9.16. Comunicarea prin AutoLISP ..............................................................................194
9.16.1. Funcii de conversie valoric ........................................................................194
9.16.2. Funcii de operare asupra irurilor de caractere............................................195
9.16.3. Funcii de intrare/ieire .................................................................................195
9.16.4. Realizarea dialogului dintre AutoCAD i AutoLISP....................................198
9.17. Accesul la baza de date a entitilor AutoCAD..................................................200
9.17.1. Funcii de manipulare a entitilor grafice....................................................200
9.17.2. Funcii de acces la tabela de simboluri .........................................................202
9.17.3. Funcii pentru manipularea seturilor de selecie ...........................................202
Cap.10. Aplicaii de programare n C i C++ ................................................................204
10.1. Elaborarea unui program n limbaj C ntr-un mediu de programare integrat.....204
10.1.1. Generaliti asupra mediului de lucru...........................................................204
10.1.2. Lansarea n lucru a compilatorului de C.......................................................205
10.1.3. Utilizarea meniului mediului de programare ................................................205
VII
10.1.4. Aplicaie........................................................................................................208
10.2. Programe simple n C .........................................................................................209
10.3. Folosirea structurilor ca tipuri de date complexe ...............................................211
10.4. Aplicaii simple n C++ ......................................................................................212
10.5. Aplicaii de utilizare a tablourilor.......................................................................213
10.6. Aplicaii la transmiterea tablourilor ca pointeri..................................................214
10.7. Alocarea dinamic a memoriei ...........................................................................215
10.8. Funcii de acces la ecranul text...........................................................................218
10.9. Accesul la ecranul grafic ....................................................................................220
10.10. Aplicaie grafic pentru construcia diagramelor .............................................223
10.11. Aplicaie grafic la utilizarea claselor ..............................................................227
Cap.11. Aplicaii n mediul de programare Visual Basic sub EXCEL........................232
11.1. Generaliti privind lucrul n EXCEL ................................................................232
11.1.1. Structura documentelor EXCEL...................................................................232
11.1.2. Coninutul celulelor ......................................................................................232
11.1.3. Utilizarea formulelor i funciilor .................................................................233
11.1.3.1. Formule .................................................................................................233
11.1.3.2. Exemplu de utilizare a formulelor. Calculul perimetrului i suprafeei
cercului.................................................................................................................234
11.1.3.3. Funcii EXCEL predefinite ...................................................................234
11.1.4. Formatarea celulelor .....................................................................................234
11.1.5. Macro comenzi i macro funcii ...................................................................235
11.1.5.1. nregistrarea macro-comenzilor ............................................................235
11.1.5.2. Execuia unei macro-comenzi ...............................................................235
11.1.5.3. Definirea unei macro-funcii .................................................................236
11.1.5.4. Asocierea unei macro-comenzi cu un element de interaciune.............236
11.2. Utilizarea programului EXCEL pentru crearea unui document de calcul simplu:
calculul variaiilor unor funcii i crearea unei diagrame centralizatoare .....................237
11.2.1. Intrarea n program .......................................................................................237
11.2.2. Operaii elementare frecvente.......................................................................237
11.2.2.1. Operaii de selectare..............................................................................237
11.2.2.2. Operaia de mutare a unei entiti (foaie, celul, rnd, coloan)...........238
11.2.2.3. Operaia de copiere a unei entiti.........................................................238
11.2.2.4. Operaia de inserare a unei entiti........................................................238
11.2.2.5. Operaia de tergere a unei entiti........................................................238
11.2.2.6. Intrarea n regimul de editare intracelular ...........................................238
11.2.3. Aranjarea convenabil a documentului.........................................................238
11.2.4. Crearea tabelului ...........................................................................................239
11.2.5. Crearea diagramei centralizatoare ................................................................239
11.2.6. Crearea de macrocomenzi prin nregistrare ..................................................241
11.2.6.1. Comutare de la foaie de lucru la foaie de diagram..............................241
11.2.6.2. Comutarea de la foaia de diagram la foaia de lucru ............................242
11.2.7. Crearea de obiecte de interaciune grafic....................................................242
11.2.7.1. Crearea unui buton de comutare din foaia de lucru n foaia cu
diagrama ....................................................................................................... 242
11.2.7.2. Crearea unui buton de comutare din foaia cu diagrama n foaia de
lucru .....................................................................................................................242
VIII
Cuprins
11.2.7.3. Crearea unei cutii de dialog pentru comutarea de la tabel la

diagram..............................................................................................................243
11.2.8. Salvarea fiierului .........................................................................................244
11.3. Folosirea nregistrrilor de macrocomenzi n construirea aplicaiilor................245
11.3.1. Fazele de realizare a unei aplicaii prin folosirea nregistratorului de macrocomenzi ..245
11.3.2. Definirea problemei ......................................................................................245
11.3.3. Rezolvarea neprogramat .............................................................................245
11.3.4. Rezolvarea programat. Automatizarea aplicaiei ........................................247
11.4. Folosirea funciilor definite de utilizator sub EXCEL .......................................250
11.4.1. Baze teoretice................................................................................................250
11.4.2. Realizarea aplicaiei sub EXCEL .................................................................251
11.5. Folosirea obiectelor simple de interaciune grafic din EXCEL........................254
11.5.1. Crearea tabelului funciei..............................................................................254
11.5.2. Generarea diagramei funciei........................................................................255
11.5.3. Crearea unui duplicat al tabelului funciei prin metoda referinelor.............255
11.5.4. Crearea unei cutii de dialog pentru interaciune ...........................................255
11.5.5. Crearea macrocomenzilor de interaciune ....................................................256
11.5.6. Realizarea legturilor de interaciune ...........................................................258
11.6. Folosirea obiectelor de interaciune grafic programabile din EXCEL .............259
11.6.1. Definirea temei .............................................................................................259
11.6.2. Construirea foii de calcul..............................................................................259
11.6.2.1. Atribuiri de nume pentru domenii de celule .........................................259
11.6.2.2. Completarea coninutului celulelor .......................................................260
11.6.3. Construirea diagramei funciei......................................................................261
11.6.4. Construirea cutiei de dialog ..........................................................................261
11.6.5. Crearea subrutinelor de comand ale instrumentelor de dialog....................263
11.6.6. Finalizarea aplicaiei .....................................................................................265
11.7. Aplicaie de folosire programat a instrumentelor pentru rezolvarea i
aproximarea funciilor ...................................................................................................266
11.7.1. Definirea temei .............................................................................................266
11.7.2. Rezolvarea neprogramat .............................................................................266
11.7.2.1. Crearea fiierului...................................................................................266
11.7.2.2. Completarea tabelului ...........................................................................266
11.7.2.3. Crearea diagramei funciei ....................................................................267
11.7.2.4. Determinarea soluiilor din intervalul de definiie ................................267
11.7.3. Automatizarea aplicaiei prin programare ....................................................268
11.7.3.1. Crearea elementelor de control .............................................................268
11.7.3.2. Crearea modulelor de program .............................................................270
11.7.4. Asamblarea aplicaiei....................................................................................272
11.7.5. Protecia aplicaiei.........................................................................................272
11.7.6. Observaii finale............................................................................................273
11.8. Aplicaie la integrarea ecuaiilor difereniale prin metode Euler .......................273
11.8.1. Obiectivul lucrrii .........................................................................................273
11.8.2. Crearea aplicaiei ..........................................................................................274
11.8.2.1. Completarea tabelului ...........................................................................274
11.8.2.2. Crearea diagramei .................................................................................275
11.8.3. Crearea unui instrument de informare ..........................................................275
11.8.3.1. Crearea unei cutii de dialog ..................................................................275
IX
11.8.4. Crearea subrutinelor obiectelor de interaciune.................................................276

11.8.5. Integrarea aplicaiei ...........................................................................................278
Cap.12. Aplicaii n FORTRAN ......................................................................................279
12.1. Calculul unei plutiri drepte folosind FORTRAN ...............................................279
12.1.1. Definirea temei .............................................................................................279
12.1.2. Etape de lucru ...............................................................................................279
12.2. Lucrul cu fiiere n FORTRAN..........................................................................283
12.2.1. Definirea temei .............................................................................................283
12.2.2. Etape de lucru ...............................................................................................283
12.3. Conversia datelor ntre fiiere n FORTRAN.....................................................285
12.3.1. Definirea temei .............................................................................................285
12.3.2. Etape de lucru ...............................................................................................286
12.4. Aplicaii interactive sub Windows n FORTRAN..............................................292
12.4.1. Definirea temei .............................................................................................292
12.4.2. Etape de lucru ...............................................................................................292
Cap.13. Aplicaii n AutoLISP ........................................................................................296
13.1. Desenarea unor drapele folosind AutoLISP .......................................................296
13.1.1. Scrierea programului AutoLISP ...................................................................296
13.1.2. Explicaii privind funcionarea programului.................................................296
13.1.3. ncrcarea i utilizarea programului .............................................................297
13.2. Calculul aproximativ al soluiilor unei ecuaii ...................................................297
13.2.3. Exploatarea programului...............................................................................299
13.3. Desenul seciunii printr-un arbore cu canal de pan...........................................299
13.3.3. Utilizarea programului..................................................................................301
13.4. Generarea unui fiier de date ..............................................................................301
13.5. Desenarea unei diagrame cu date citite din fiier ...............................................302
Bibliografie .......................................................................................................................304
Introducere
Lucrarea de fa i propune s acopere, nevoile programatorului de aplicaie inginereasc
care, spre deosebire de informaticianul de specialitate pur, are de fcut fa unor sarcini
practice izvorte, cel mai adesea, din specificul interdisciplinar al programelor folosite n
activitatea de proiectare.
ntr-o asemenea conjunctur profesional, programatorul de aplicaie este mai puin
solicitat de sarcini de profunzime informatic i mai mult de nevoia de a acoperi o arie
aplicativ cu extindere mare. ntr-adevr, fiind obligat s lucreze cu mai multe programe n
cadrul aceleiai teme de proiectare, una dintre sarcinile mari consumatoare de efort este aceea
de a realiza o serie de aciuni cum ar fi:
- Suplinirea lipsurilor unui produs soft prin crearea de programe de aplicaie n mediul de
dezvoltare integrat oferit de produsul soft respectiv;
- Atunci cnd produsul soft nu conine un mediu integrat de dezvoltare a aplicaiilor,
crearea unui instrument adiional folosind resurse externe produsului soft n cauz;
- Interfaarea diverselor produse soft folosite, prin instrumente de tip import/export de date
ntre aplicaii diferite folosind convertoare de date existente sau create prin aciuni de
programare, transfer de comenzi ntre aplicaii prin tehnici specifice aplicaiilor folosite.
Aciunile enumerate mai sus sunt numai cteva dintre posibilele opiuni de urmat i ele
evideniaz necesitatea cunoaterii mai multor limbaje i tehnici de programare n medii de
lucru diferite.
Din acest motiv autorul i-a propus s expun cteva dintre limbajele mai des folosite de
ctre programatorii de aplicaie inginereasc, optnd pentru limbajele C, C++, Visual Basic
for Applications (VBA) n Excel, Fortran i AutoLISP.
Raiunile acestei alegeri sunt urmtoarele:
- Larga rspndire a limbajului C la acest moment;
- Uurina n manipulare a limbajului Visual Basic n Excel i gradul mare de
compatibilitate a acestuia cu dialectele folosite n AutoCAD i MicroStation V8;
- Tezaurul acumulat de programatorii de Fortran n cei peste 50 de ani de la apariia acestui
limbaj, tezaur concretizat n imense biblioteci de programe, multe dintre ele uor accesibile;
- Flexibilitatea i puterea limbajului AutoLISP ca generator de funcii de comand n
AutoCAD menite s lrgeasc posibilitile acestuia, i posibilitatea interfarii lui uoare cu
dialectul VBA din AutoCAD.
Dumitru Dragomir
Evident c, prin aceast alegere, lucrarea nu epuizeaz domeniul de opiuni ale

programatorului de aplicaie inginereasc dar poate constitui un ghid pentru formarea unei
orientri corecte.
Pentru a veni n ajutorul cititorului acestei lucrri au fost incluse i o serie de aplicaii n
sprijinul materialului de baz.
Autorul i exprim sperana de a fi putut mprti ceva din experiena de peste 30 de ani
n programarea aplicativ acelora care au nevoie de ndrumare n acest domeniu.
Autorul
Capitolul 1. Elemente de baz n informatic

.1.1. Definiii de baz
Informaia este un mesaj obiectiv (concret) care elimin nedeterminrile n cunoatere.
Informaia variaz n funcie de contextul la care se refer.
Se poate vorbi despre:
- Natura informaiei, legat de domeniul la care se refer;
- Canalul (sau uneori suportul) informaiei, reprezentnd modalitatea de transmitere a
informaiei.
Orice proces de transmitere a unei informaii presupune existena a doi parteneri:
- un emitor de informaie;
- un receptor de informaie.
Informatica reprezint un complex de discipline prin care se asigur prelucrarea raional
a informaiilor prin intermediul mainilor automate.
Ca urmare a dezvoltrii sale ca tiin, informatica este divizat n urmtoarele subdomenii:
- Arhitectura calculatoarelor, disciplin care se ocup cu organizarea componentelor
fizice (hardware) ale calculatoarelor;
- Sisteme de operare, disciplin care se ocup cu organizarea programelor care
controleaz resursele i aciunile calculatorului;
- Algoritmi i structuri de date, disciplin care se ocup cu metodele de obinere a
aplicaiilor, reprezentarea informaiilor, optimizarea aplicaiilor;
- Limbaje de programare, disciplin care se ocup cu regulile care guverneaz notaiile
de reprezentare a algoritmilor i structurilor de date;
- Ingineria programrii, disciplin care se ocup cu automatizarea i eficientizarea
activitilor de proiectare i realizare a aplicaiilor;
- Calcule numerice i simbolice, disciplin care se ocup cu elaborarea de modele
matematice destinate simulrii obiectelor i fenomenelor reale;
- Sisteme de gestiune a bazelor de date, disciplin care se ocup cu organizarea
cantitilor mari de date;
- Inteligen artificial, disciplin care se ocup cu simularea comportamentelor
inteligente;
- Animaie i robotic, disciplin care se ocup cu generarea i prelucrarea imaginilor i,
respectiv, acionarea roboilor.
.1.2. Sisteme de numeraie

n general se vorbete despre un "sistem de numeraie n baza q" ca despre un sistem care
are urmtoarele caracteristici:
1. Folosete un alfabet cu un numr de q simboluri diferite ntre ele, numite cifre, care
formeaz un ir de numere consecutive;
2. Prima cifr din ir este 0;
3. Cifra cu valoarea cea mai mare este cu o unitate mai mic dect baza sistemului, deci are
valoarea q-1;
4. n funcie de poziia lor n numrul N, cifrele se nmulesc cu puteri cresctoare ale bazei
q, obinndu-se dezvoltarea numrului N dup puterile bazei n forma:
N(q) = an an-1 an-2 a2 a1 a0 = an qn + an-1 qn-1 + an-2 qn-2 + + a2 q2 + a1 q1 + a0 q0
Notaia N(q) arat c numrul N este scris n baza q.
Iat, mai jos, cteva exemple de sisteme de numeraie:
Sistemul zecimal, folosete alfabetul 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, baza fiind q=10.

De exemplu:
N(10) = 723(10) = 7 102 + 2 101 + 3 100 = 7 100 + 2 10 + 3 1
Sistemul binar, folosete alfabetul 0, 1, baza fiind q=2.
De exemplu:
N(2) = 1011(2) = 1 23 + 0 22 + 1 21 + 1 20 = 8 + 0 + 2 + 1 = 11(10)
Sistemul binar este folosit la reprezentarea informaiei la nivelul de baz al calculatorului,
acolo unde informaia este tradus prin mrimi care nu pot avea dect dou valori (curentul
circul sau nu circul, exist impuls electric sau nu exist, cmpul magnetic are un sens sau
sensul contrar, starea logic este adevrat sau fals).
El are avantajul de a reflecta n modul cel mai direct corespondena dintre valoarea
numeric i starea datelor (informaiei) n calculator. Are ns dezavantajul de a necesita la
scrierea pe hrtie un spaiu cu att mai mare cu ct valoarea reprezentat este mai mare.
Sistemul octal, folosete alfabetul 0, 1, 2, 3, 4, 5, 6, 7, baza fiind q=8.
De exemplu:
N(8) = 125(8) = 1 82 + 2 81 + 5 80 = 64 + 16 + 5 = 85(10)
Sistemul hexazecimal, folosete alfabetul 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, baza
fiind q=16.
De exemplu:
N(16) = 2A3B(16) = 2 163 + 10 162 + 3 161 + 11 160 = 2 4096 + 10 256 +3 16 + 11 =
= 10811(10)
Sistemul hexazecimal a fost conceput pentru a economisi spaiu de scriere la reprezentarea
numerelor mari.
De asemenea, aa cum se va vedea n continuare, ntre el i sistemul binar cu care se afl
ntr-o relaie de multiplicitate, exist o coresponden care se poate folosi la conversia dintrun sistem n altul.
Conversia din baza 2 n baza 16
Acest tip de conversie este des folosit de ctre programatorii care lucreaz direct cu
adresele fizice de memorie pentru a converti valorile numerice dintr-un sistem n altul.
Fie numrul binar:
1111(2) = 1 23 + 1 22 + 1 21 + 1 20 = 8 + 4 + 2 + 1 = 15(10)
Dar 15 este numrul cel mai mare reprezentabil printr-o singur cifr n baza 16, aceast
cifr fiind F.
Aadar, o grupare de 4 cifre binare poate, folosind diferite combinaii de 0 i 1 s
reprezinte o cifr binar din sistemul hexazecimal.
n acest caz, pentru un numr oarecare n baza 2, se poate defini o procedur de
convertire la baza 16 dup cum urmeaz:
- Se completeaz numrul binar la stnga cu zerouri pn cnd se obine un multiplu de 4
al numrului de cifre;
- Se separ grupe de cte 4 cifre binare care se convertesc la forma hexazecimal.
De exemplu:
Fie numrul 101101. Etapele de convertire sunt:
- Completarea cu zerouri produce numrul 00101101;
- Separarea pe grupe de cte 4 cifre binare produce grupele 0010, cu valoarea zecimal 2 i
reprezentarea hexazecimal prin simbolul 2, i 1101 cu valoarea zecimal 13 i reprezentarea
hexazecimal prin simbolul D.
Aadar numrul 101101(2) = 2D(16)
n practica informatic nu se mai folosete notaia (2) pentru baza binar, dar pentru baza
16 se folosete postfixarea cu litera H (de la hexazecimal).
Deci, se obinuiete s se scrie:
101101 = 2DH
.1.3. Reprezentarea informaiei n calculator

Forma cea mai simpl sub care se poate reprezenta informaia, form numit informaie
elementar, este evenimentul cu dou stri: Adevrat sau Fals.
Din punct de vedere electric aceasta corespunde situaiei unui comutator care se poate afla
ntr-una din situaiile din figura 1.3.1.
nchis (curentul circul), starea logic echivalent fiind Adevrat;
Deschis (curentul nu circul), starea logic echivalent fiind Fals.
Fig.1.3.1
Acestor dou stri logice li se asociaz valorile numerice:
1 pentru Adevrat, i
0 pentru Fals.
De aici rezult c sistemul binar ca sistem de numeraie, este sistemul care se potrivete cel
mai bine nevoilor de reprezentare a informaiei n calculator deoarece corespondena dintre el
i logica elementar binar este direct.
Informaia elementar se mai numete i BIT (de la BInary digiT cifr binar). Bit-ul
poate avea strile 0 sau 1 i mai este denumit atom de informaie.
BYTE-ul (sau octetul) reprezint o grupare de 8 bii i este o unitate de baz a msurrii
cantitii de informaie.
Multiplii byte-ului se obin folosind ca factori de multiplicare:
210 = 1024 byte = 1 Kbyte
220 = 1024 Kbyte = 1 Mbyte
230 = 1024 Mbyte = 1 Gbyte
n concluzie, calculatorul este un ansamblu de circuite electronice i componente mecanice
care poart denumirea de parte fizic (HARDWARE parte tare) dar i un set de programe
(metode de prelucrare a informaiei) i de date care poart denumirea de parte logic
(SOFTWARE parte moale).
.1.4. Codificarea informaiei n calculator

Pentru codificarea informaiei n calculator se folosete codul ASCII (American Standard
Code for Information Interchange Codul american standard pentru interschimb de
informaii). Acest cod este un cod pe 8 bii (sau pe un octet). El se mparte n dou seciuni:
- Codul ASCII pentru caractere de baz. Acesta folosete numai primii 7 bii realiznd
128 de caractere, dintre care:
= codurile 00H 1FH (0 31) reprezint caractere de control. De exemplu:
00H NUL;
07H BEL avertizare sonor;
09H HT caracterul TAB tabulator orizontal;
0DH CR caracterul Cariage Return salt la nceput de rnd;
10H DEL caracterul Delete tergerea caracterului curent;
08H BS caracterul Back Space tergerea caracterului anterior;

1BH ESC caracterul Escape abandonarea procedurii curente;
etc.
= codurile 20H 2FH, 3AH 40H, 5BH 60H, 7BH 7FH semne speciale;
= codurile 30H 39H cifrele 0 9;
= codurile 41H 5AH literele mari ale alfabetului latin;
= codurile 61H 7AH literele mici ale alfabetului latin;
- Codul ASCII pentru setul de caractere extins, folosete toi cei 8 bii ai octetului
realiznd alte 128 de caractere, i anume:
= 48 de caractere strine, cum ar fi:
caracterele strine de limba englez, provenite din alfabetele europene;
simboluri monetare cent, lir, yen, pesetas, franc;
semne speciale de punctuaie;
= 48 de caractere pentru construirea de chenare (caractere semigrafice);
= 32 de caractere pentru grupul caracterelor tiinifice:
litere greceti;
simboluri matematice speciale: integrala, ridicarea la ptrat, rdcina ptrat.
.1. 5. Reprezentarea datelor

Data este informaia prelucrat de calculator. Ea este un model de reprezentare a
informaiei accesibil unitii de prelucrare a calculatorului.
Din punct de vedere logic, data poate fi reprezentat printr-un triplet de forma:
d=(i, v, a)
unde:
d = data:
i = identificatorul datei;
v = valoarea datei;
a = atributele asociate datei.
Identificatorul datei este un simbol (nume) asociat datei pentru a o distinge de alte date i
pentru a se putea face referiri la ea n timpul procesului de prelucrarea a datelor. n cazul
bazelor de date simple constnd dintr-o simpl enumerare a unor date din aceeai familie (de
acelai tip), identificatorul poate fi subneles, confundndu-se cu indicele numeric al datei n
baz. Necesitatea unui identificator (simplu sau compus) apare n bazele de date complicate
coninnd date de naturi diferite i/sau cu structurare pe mai multe nivele, eventual cu
apartenen la diferite clase de apartenen (sau cu proprietari diferii).
Valoarea datei este proprietatea datei de a fi exprimabil ntr-un sistem de uniti de
msur i ntr-un anumit domeniu de valori. Datele pot fi variabile (modificabile n timpul
execuiei programului) sau constante (nemodificabile).
Atributele datei sunt proprieti ale datei care determin modul n care ea poate fi tratat
n cursul procesului de prelucrare.
Ca exemple de atribute se pot meniona:
- tipul datei:
= tip numeric (ntreg sau real);
= tip logic (valorile adevrat sau fals);
= tip alfanumeric (caractere sau iruri de caractere).
- precizia reprezentrii interne, este legat de capacitatea limitat de stocare a unei date de
un anumit tip numeric. Astfel, pot exista:
= date numerice reale n simpl precizie;
= date numerice reale n dubl precizie (stocate ntr-o zon de memorie de lungime
dubl).
Reprezentarea datelor alfanumerice (caractere)
Pentru reprezentarea datelor alfanumerice se folosete codul ASCII.
De exemplu, caracterul A avnd codul hexazecimal 41H are codul binar 01000001 iar
caracterul a are codul hexazecimal 61H sau n binar 01100001. Toate aceste caractere
necesit un singur octet pentru a fi reprezentate.
Reprezentarea numerelor
n funcie de tipul lor, numerele pot fi reprezentate n cadrul urmtoarelor convenii:
A. Reprezentarea numerelor ntregi fr semn. Aici se pot deosebi urmtoarele cazuri:
= Reprezentarea pe un singur octet. n acest sistem pot fi reprezentate numere ntre
valorile binare 00000000 i 11111111 respectiv de la 00H pn la FFH, adic ntre 0 i
255;
= Reprezentarea pe doi octei, de la 0000H pn la FFFFH, adic de la 0 la 65535.
B. Reprezentarea numerelor ntregi cu semn. Aici se deosebesc dou cazuri:
a. Reprezentarea prin mrime i semn (reprezentare n cod direct). n aceast
convenie se folosete bitul de rang cel mai nalt ca indicator de semn, cu
semnificaiile:
0 nu exist semn, adic numrul este pozitiv, i
1 exist semn, adic numrul este negativ.
Folosind un singur octet (byte), bitul 7 este folosit ca indicator de semn iar biii
6,5,,1,0 sunt folosii pentru reprezentarea direct a valorii numrului.
De exemplu codul binar
11111111 reprezint numrul 127
iar codul binar
01111111 reprezint numrul +127
Dezavantajul acestui sistem este acela c nate o ambiguitate i anume numrul 0 are
dou reprezentri, adic 00000000 pentru + 0 i 10000000 pentru 0.
Din acest motiv, ct i din altele, apar dificulti la modelarea operaiilor matematice
cu ajutorul circuitelor electronice, fiind necesare dou proceduri aritmetice diferite:
una pentru adunare i alta pentru scdere, plus o procedur de identificare a semnului
pentru a se lua decizia privind procedura aritmetic de aplicat.
De aceea se prefer o adoua variant, i anume:
b. Reprezentarea numerelor negative n cod complementar fa de 2.
Fie Nn un numr ntreg nenegativ reprezentat prin n cifre binare.
Complementul fa de 2 al lui Nn este N n :
N n = 2n N n
De exemplu, fie numrul 10 i numrul 3. Ele se reprezint astfel:

10 = 00001010 (reprezentare direct)
-3 = 28 00000011 = 100000000
00000011
011111101
complementul fa de 2 al numrului 3
n acest caz, operaia 10 + (-3) este:
00001010 +
11111101
100000111
Se neglijeaz bitul de rangul 8 (al noulea bit, cel care a rezultat 1) i rezult numrul
binar 00000111 adic numrul zecimal 7. Se observ c prin acest procedeu se
folosete o singur operaie de adunare direct, att la adunare ct i la scdere.

n concluzie, cu ajutorul a n cifre binare se pot reprezenta numere ntregi N
domeniul:
-2n-1 N 2n-1 - 1
Aadar:
- numerele ntregi cu semn reprezentabile pe 1 octet (pe 8 bii) se pot reprezenta
intervalul:
- 28-1 = 27 = - 128
N
28-1 1 = 127
- numerele ntregi cu semn reprezentabile pe 2 octei (pe 16 bii) se pot reprezenta
intervalul:
- 216-1 = 215 = - 32768
N
216-1 1 = 32767
- numerele ntregi cu semn reprezentabile pe 4 octei (pe 32 bii) se pot reprezenta
intervalul:
- 232-1 = 231 = - 2147483648 N
232-1 1 = 2147483647
n
n
n
Semn numr
Semn exponent
C. Reprezentarea numerelor reale n virgul mobil.

Aceast reprezentare se inspir din reprezentarea numerelor zecimale n notaie tiinific.
De exemplu, n notaie tiinific, numrul 12.5 se poate scrie:
12.5 = 125 10-1 = + 125 E 1
La ultima form de scriere se disting :
- un simbol pentru semnul numrului (+ sau minus);
- mantisa n acest caz 125;
- semnul exponentului (aici -);
- valoarea exponentului (aici 1).
n cazul unei reprezentri pe 4 octei (32 de bii) se folosesc:
1 bit pentru semnul numrului, cu valoarea 0 pentru plus i 1 pentru minus;
1 bit pentru semnul exponentului;
7 bii pentru valoarea exponentului;
23 bii pentru mantis.
Harta repartiiei biilor n cuprinsul cuvntului (grupului) de 4 octei este urmtoarea:
Valoarea
exponentului
Valoarea mantisei
Aadar, mrimea numrului reprezentat n virgul mobil i precizia reprezentrii lui

depind de numril de octei pe care se face reprezentarea.
Ca i n cazul numerelor ntregi, i la numerele n virgul mobil exist posibilitatea
stocrii pe lungimi extinse (dubla precizie).
D. Reprezentarea numerelor reale n virgul fix.
Am lsat intenionat la urm aceast modalitate de reprezentare. Aici se presupune
existena imaginar a unei virgule care desparte numrul de bii folosii n dou grupuri, unul
pentru partea ntreag i altul pentru cea fracionar. Pe lng faptul c acest mod de
reprezentare creaz complicaii constructive, modelul de reprezentare variind la diferite

calculatoare, domeniul de variaie al numerelor este mult mai restrns iar precizia de
reprezentare nu este nici pe departe satisfctoare, i din acest motiv n prezent nu mai este
folosit.
Reprezentarea altor tipuri de date.
Imaginile i sunetele pot constitui i ele stocuri de date. n acest caz exist dou ci
principiale de reprezentare:
A. Prin coduri de definiie, reprezentnd combinaii de caractere alfanumerice i coduri
numerice.
De exemplu, ntr-o baz de date, o combinaie de valori numerice de forma:
frecven (n cicli/secund), durat (n milisecunde)
poate constitui codificarea unui sunet, ca mai jos:
1000, 2000
care ar putea nsemna definirea unui sunet cu frecvena de 1000 Hz cu o durat de 2
secunde
Pentru imagini, o combinaie de forma:
LINE 0, 0, 12, 5
ar putea semnifica trasarea unei linii ntre punctele de coordonate x=0, y=0 i x=12, y=5,
pe un ecran pentru care, anterior, a fost stabilit o zon de lucru i o scar de reprezentare.
B. Prin digitizare, care nseamn transformarea datelor de stocat n succesiuni de bii
codificate dup anumite reguli.
De exemplu, pentru imagini este foarte frecvent folosit formatul de stocare BMP (BitMaP
sau hart de bii).
.1. 6. Structura fizic (hardware) a unui calculator
CPU
ROM
RAM
Magistral
Module de interfa
cu consola
Tastatur
Display
Module de interfa
cu discurile
Floppy HDD
Module de
interfa paralel
Extensie de
magistral
Module de
interfa serial
CD
Fig.1.6.1
Pe blocuri funcionale principale, calculatorul prezint urmtoarele componente principale:
- CPU (Central Processing Unit) unitatea central de prelucrare, este partea din
calculator care coordoneaz i controleaz toate funciile de transfer i prelucrare a semnalelor
electrice care reprezint comenzi i date. Ea identific instruciunile dintr-un program, execut
operaii aritmetice i activeaz circuitele electronice anex crora le transmite ordine de
activitate prin intermediul magistralei;
- Magistrala, reprezint un fascicol de n8 conductori electrici paraleli (n=1,2,4,8) pe care
circul semnalele electrice care reprezint comenzi i date;
10
- Memoria calculatorului, este de dou tipuri:

= ROM (Read Only Memory) memorie care poate fi numai citit. Aceasta este
memoria permanent care nu se terge la oprirea calculatorului. Ea conine un set de
programe de baz care se execut la pornirea calculatorului, ajutnd la iniializarea modului
su de funcionare;
= RAM (Random Access Memory) memorie cu acces aleatoriu. Aceasta este
memoria dinamic, adic o memorie din care se poate citi dar se poate i scrie. Ea se terge
la oprirea calculatorului, motiv pentru care se mai numete i memorie volatil. n aceast
zon de memorie se ncarc programele care se execut n timpul funcionrii calculatorului.
De asemenea, aceast memorie poate servi i ca stoc temporar pentru acele date cu frecven
mare de utilizare, pentru a se economisi timp cnd este necesar folosirea acestor date;
- Modulele de interfaare cu dispozitivele periferice. n aceast categorie intr
urmtoarele dispozitive:
= modulele de interfa cu consola. Consola este dispozitivul de intrare/ieire standard
al calculatorului (care nu poate lipsi), format din tastatur ca dispozitiv de intrare
(introducere a datelor) i display ca dispozitiv de ieire (extragere a datelor). n aceste
module se include i placa grafic, coninnd memoria video care deservete ecranul;
= modulele de interfa cu discurile. Discurile sunt destinate stocrii permanente a
informaiei. Accesul la ele se face pe cale magneto-mecanic (pentru discurile
magnetice), mecanico-optic (pentru compact discuri).
Deoarece intervine o component mecanic, accesul al informaia stocat pe aceste discuri se
realizeaz mult mai lent mult mai lent dect la memoria electronic (RAM) dar capacitatea de
stocare este mult mai mare iar informaia nu se terge la oprirea calculatorului, motiv pentru
care discurile sunt folosite pentru stocarea permanent a informaiei.
Pe discuri se poate att citi ct i scrie (cu excepia CD-urilor din categoria celor
nerescriptibile).
Discurile magnetice sunt de dou tipuri:
Floppy-discuri, de capacitate mic, circa 1,44 MB, dar portabile;
Hard-discuri, de capacitate foarte mare, 10-20 GB sau mai mari, dar neportabile.
Unitile de citire corespunztoare pentru aceste discuri sunt:
FDD (Floppy Disk Drive) la care discul este amovibil (extractabil din unitate);
HDD (Hard Disk Drive) la care discul este intern, inamovibil.
=modulele de interfa paralel i serial.
Interfaa paralel se realizeaz prin cabluri care conin n principal 8 conductori
pentru date i ali civa conductori pentru semnale de control i sincronizare. Datele
sunt transmise n serii de cte 8 bii n paralel;
Interfaa serial se realizeaz prin cabluri care, n afara conductorilor pentru semnale
de control i sincronizare, conin un singur conductor pentru date. Informaia se
transmite n trenuri de cte 8 impulsuri succesive, cte unul pentru fiecare bit de
informaie.
- Extensia de magistral, este o prelungire a magistralei, conductorii acesteia fiind
conectai la o serie de "slot-uri" (socluri speciale) pe care se pot implanta (plug) alte module
de interfaare suplimentare, de exemplu cele pentru obinerea sonorizrilor (placa de sunet),
pentru comunicaia telefonic (fax-modem), sau pentru conectarea n reea (plci de reea).
Microprocesorul
La calculatoarele moderne blocul CPU a fost realizat sub forma unui singur circuit integrat
denumit microprocesor.
Istoric, primul microprocesor a fost realizat de firma INTEL sub numele de Intel 8008. A
11
urmat apoi microprocesorul Intel 8080 avnd un set de instruciuni extins. Curnd dup
aceea, firma ZILOG a realizat microprocesorul Z80 cu un set de instruciuni i mai mare,
circa dublu dect Intel 8080.
Toate aceste microprocesoare erau structurate pe 8 bii i puteau adresa o memorie de 64
KB, iar Z80 putea adresa succesiv mai multe blocuri de memorie de cte 64 KB denumite
pagini de memorie.
n anul 1981 apare microprocesorul 8088 pe 16 bii, eveniment care decalneaz evoluia
microprocesoarelor din familia 80x86, unde x=2, 3, 4, 5 (Pentium).
Au existat microprocesoarele simbolizate astfel:
80386SX fr coprocesor matematic ncorporat, i
80386DX cu coprocesor matematic ncorporat.
Coprocesorul matematic este un circuit separat sau ncorporat n microprocesor care
realizeaz n mod hard operaiile matematice, mult mai rapid dect n cazul realizrii lor n
mod soft (prin program).
Cnd microprocesorul nu coninea coprocesorul matematic, acesta se putea aduga pe
placa de baz a calculatorului ntr-un soclu special prevzut. n acest caz coprocesorul avea
simbolizarea 80x87, de exemplu 80287 adugabil la microprocesorul 80286, sau 80387
adugabil la microprocesorul 80386.
Cnd simbolizarea microprocesorului era postfixat cu o cifr, aceasta semnifica dublarea sau
triplarea frecvenei sale de lucru. De exemplu, 80486SX2 sau 80486DX2 lucrau la frecven
dubl fa de 80486SX sau 80486DX, iar 80486DX4 la frecven tripl fa de 80486DX.
Noua familie de microprocesoare poate accesa o memorie mult mai mare, de exemplu:
8086 pn la 1MB de RAM
80286 pn la 16MB de RAM
80386 i 80486 pn la 4GB de RAM.
Totui, calculatoarele construite cu microprocesoare de acest tip nu fac uz, deocamdat,
dect de o mic parte a posibilitilor lor de accesare de memorie RAM deoarece folosirea
integral a acestei capaciti ar conduce la arhitecturi cu complicaii att n privina gabaritului
ct i a timpului de utilizare a ntregii capaciti de memorie.
Structura (fr detaliere) a microprocesorului este cea din figura 1.6.2.
- UCC este Unitatea de Comand i Control. Ea are funciile:
= extrage din memoria intern a calculatorului o instruciune a programului;
= decodific instruciunea pentru a afla ce operaie trebuie executat i ce date vor fi folosite;
= extrage datele din memoria intern a calculatorului;
= activeaz circuitele corespunztoare din UAL pentru a executa operaia cu datele solicitate.
- UAL este Unitatea Aritmetico Logic. Ea are funciile evideniate n figura 1.6.2.
- Registrele proprii. Acestea sunt circuite de memorie coninute de microprocesor. n
aceste registre sunt pstrate temporar nformaiile care conin datele de prelucrat i
instruciunile de executat.
Exist urmtoarele tipuri de registre:
= registru de date: pstreaz datele de prelucrat i rezultatele prelucrrii;
= registru de instruciuni: pstreaz codul instruciunii n curs de execuie;
= registru contor de program: pstreaz adresa instruciunii care urmeaz s se execute;
= registru contor de date: pstreaz adresa la care se gsesc datele care urmeaz s fie prelucrate.
- UI este Unitatea de Interfa cu celelalte componente ale calculatorului. Ea asigur,
prin intermediul magistralei, legtura dintre microprocesor i celelalte componente ale
calculatorului: memoria intern i sistemul de intrare/ieire. Tot ea realizeaz i funcia de
transfer a datelor de la/ctre microprocesor.
12
Microprocesor
UAL
UCC
Adunare
Extragere de
instruciuni
Decodificarea
instruciunii
Scdere
nmulire
Extragere de date
mprire
Comparare
Memoria
intern
Registre
Fig.1.6.2.
Microprocesorul funcioneaz pe baza impulsurilor (tacturi) primite de la un oscilator
(sau ceas clock). Feacvena impulsurilor poate fi una din valorile standard: 6, 12, 16, 25, 33,
40, 55, 66 MHz (sau mai mari). Cu ct frecvena de tact este mai mare, cu att calculatorul
este mai rapid.
Memoria intern a calculatorului
Memoria intern a calculatorului are structura din figura 1.6.3.
Memoria de baz
640 KB
Memoria
expandat
Extensii de memorie
Fig.1.6.3.
Componentele ei sunt urmtoarele:
- Memoria de baz, de 640 KB, corespunde memoriei maxime de care dispuneau primele
calculatoare compatibile IBM-PC (ncepnd cu microprocesorul 8086) pentru care a fost
dezvoltat sistemul de operare DOS.
Aceasta este memoria de lucru care preia datele i instruciunile din programe pentru
execuie i n care se depun rezultatele;
- Memoria expandat, de 384 KB, care a fost adugat ulterior pentru a mri posibilitile
de lucru;
- Extensii de memorie, care reprezint memoria intern suplimentar celor 1084 KB (1
MB) aflat n configuraia de baz a calculatorului. Ea este folosit pentru stocarea datelor
programelor.
13
Memoria virtual a calculatorului

Aceast memorie nu exist din punct de vedere fizic n acelai mod ca memoria intern,
deci nu ca spaiu de memorie realizat prin circuite electronice.
Ea este un spaiu rezervat pe hard disc, vzut i exploatat de calculator asemntor cu
memoria RAM.
Periodic, ntre memoria intern i cea virtual, se face un transfer de date astfel:
- poriuni de program i de date care temporar nu vor mai fi folosite, sunt transferate pe discul
dur, elibernd memoria RAM pentru acele pri de informaie care trebuie accesate rapid;
- poriunile de progrm i de date care urmeaz s intre n uz sunt citite de pe discul dur i
sunt stocate n RAM pentru execuie i prelucrare;
- poriunile de program i de date devenite inutile sunt terse, dup caz, fie din RAM fie de
pe hard disc.
Memoria CMOS
La calculatoarele mai recente a fost adugat un nou tip de memorie care poate fi scris i
citit ca i memoria RAM, dar care nu se terge la oprirea calculatorului. Acest lucru este
posibil deoarece acest tip de circuite are un consum extrem de sczut i poate fi meninut activ
i dup oprirea calculatorului prin alimentarea de la un acumulator care se rencarc n timpul
funcionrii calculatorului. n aceast memorie se stocheaz:
- configuraia calculatorului;
- data calendaristic;
- ora;
- parola de acces;
- etc.
Totui, deoarece pn la urm orice acumulator se descarc, pentru a nu se pierde datele
stocate n acest tip de memorie trebuie respectate urmtoarele msuri:
- periodic, fie i numai pentru cteva minute, calculatorul trebuie pornit;
- acumulatorul nu trebuie demontat de pe placa de baz i nu trebuie scurtcircuitat.
Memoria cache
Acest tip de memorie este folosit ncepnd de la microprocesorul 80386. El are valorile
standard de 64, 128, 256 i 512 KB i servete ca stoc tampon separat pentru microprocesor,
mbuntindu-i performanele.
.1.7. Structura operaional a unui sistem de calcul

Succesul sistemelor de calcul moderne are la baz folosirea interactivitii grafice ca
instrument de lucru de baz.
Grafica interactiv poate fi definit ca fiind totalitatea metodelor i tehnicilor de
introducere, extragere i conversie a informaiei spre sau de la echipamentele specifice
tehnicii de calcul, astfel construite nct, pentru operatorul uman, informaia s aib caracter
grafic.
Sistemul grafic este un ansamblu format din echipamente i programe specializate n
tratarea i reprezentarea grafic a informaiei.
Prin aceste caracteristici ale sistemelor de calcul cu interaciune grafic operaiile pe care
le execut operatorul au un caracter natural, sunt rapid executabile, recunoaterea
informaiilor furnizate de calculator fiind rapid i comod.
Pentru realizarea acestui obiectiv, sistemul de calcul este prevzut cu o serie de
dispozitive periferice specializate.
14
Memorie
extern
Unitate
central
Relaie extern (conectare la reea)
Relaie tactil
Relaie vizual
Display
Tastatur
Controlere de
cursor grafic
Plotter
Mouse
Joy-stick
Track-ball
Printer
Interceptor
Light-pen
Digitizoare
Tablet grafic
Scanner
Operator
Video
camer
Fig.1.7.1.
15
Structura fizic a unui sistem de calcul este cea reprezentat n figura 1.7.1. Conform
acesteia schimbul de informaii dintre operator i unitatea central se desfoar pe dou
laturi: Relaia tactil i Relaia vizual. Fiecare dintre ele este deservit de o serie de
dispozitive periferice de intrare/ieire. Componentele evideniate sunt descrise mai jos.
Relaia tactil, este cea comandat de operator, prin care acesta introduce informaie n
calculator. Ea se realizeaz prin urmtoarele dispozitive de intrare:
- Tastatura este dispozitivul de intrare minimal, absolut necesar pentru introducerea
textelor comenzilor i a datelor numerice sau de tip ir de text;
- Controlerul de cursor grafic este o denumire generic pentru unul dintre urmtoarele
dispozitive de intrare:
= Mouse este un dispozitiv care controleaz micarea cursorului grafic pe ecran prin
controlul deplasrilor pe direciile x-y ale ecranului. Acest dispozitiv este complementar
tastaturii. Servete i la introducerea poziiilor n care se puncteaz pentru a declana
comenzi dependente de poziia de aplicare a punctrii (clic);
= Joy-stick este un dispozitiv care controleaz direcia i viteza de micare a cursorului
prin unghiul de nclinare al unei manete;
= Track-ball este de fapt un mouse rsturnat, operatorul acionnd direct asupra bilei.
- Interceptorul, concretizat prin creionul optic (light-pen) servete la interceptarea pe ecran
a unei zone de interes;
- Digitizorul, este folosit pentru a transforma o informaie grafic extern n informaie
digital stocabil n memoria calculatorului. Se folosesc n mod curent urmtoarele
dispozitive:
= Tableta grafic servete la transformarea micrii de urmrire manual a unui contur
existent pe hrtie sau de desenare a unui asemenea contur, ntr-o succesiune de puncte
reprezentate prin coordonate x,y exprimate numeric (evident n cod binar) constituind o
informaie de tip vectorial (succesiune de segmente orientate definite prin capetele lor);
= Scannerul i camera video citesc o imagine punct cu punct, primul de pe hrtie iar cea
de a doua n mod direct. Informaia generat este de tip raster (matrice constituit din linii
i coloane de puncte ale imaginii);
Relaia vizual, este cea prin care operatorul primete informaiile prelucrate de
calculator. Ea se realizeaz prin urmtoarele dispozitive de ieire:
- Display este dispozitivul de afiare minimal. Poate fi de diferite tipuri dintre care
menionm tubul catodic sau matircea de afiare cu cristale lichide;
- Plotter este un dispozitiv de desenare cu peni sau de tiere cu cuit (cutter).
Materializeaz desene de tip vectorial, adic compuse din succesiuni de vectori (segmente
orientate);
- Printer este un dispozitiv de imprimare sub form raster (matrice de puncte).
Uneori, prin abuz de limbaj, se folosete termenul de plotter pentru printere de dimensiuni
mari, dar aceast utilizare nu este corect i nu este recunoscut de dicionarele de termeni
informatici.
.1.8. Organizarea funcional a unui sistem de calcul

Conform figurii 1.8.1, funcia principal a unui sistem de calcul este aceea de memorare,
prelucrare i regsire a datelor. n raport cu staia de lucru ca sistem de intrare/ieire a
informaiilor, utilizatorul opereaz asupra datelor din sistem, n cadrul interaciunii la staia
de lucru, prin intermediul funciilor de introducere a datelor (folosind ca periferice de
intrare tastatura, mouse-ul, tableta grafic, etc) i a funciei de afiare a datelor prin
intermediul display-ului.
16
Ieire n format
main
Analiz
Afiare date
Regsire
asociativ
O
Utilizator
Baza de
date
Interaciune
la staia de
lucru
Memorare
asociativ
Introducere date
Post
procesare
Ieire n format
direct citibil
Staie de lucru
Memorare-prelucrare-regsire
Fig.1.8.1.
n cadrul sistemului, n raport cu baza de date care stocheaz datele de o anumit natur
asociate entitilor memorate n baza de date, se evideniaz:
- Funcia de memorare asociativ care introduce datele n baza de date dup ce
efectueaz prelucrrile necesare asocierii dintre datele care descriu entitile stocate n baz i
atributele care caracterizeaz aceste entiti.
Asocierea se face pe baza unei reguli de asociere stabilit n funcie de structura bazei de date,
i n concordan cu necesitile de definire a entitii de stocat n baz. De exemplu, o mingie
de tenis poate fi descris ca o sfer cu o anumit raz, dar aceast informaie nu este
suficient. Ea trebuie asociat cu poziia ei n raport cu un reper (de exemplu solul pe care
eventual se poate lua n considerare proiectarea unei umbre). Dac programul grafic are n
vedere i redarea aspectului fotografic al mingiei, informaia privitoare la geometria i poziia
acesteia trebuie nsoit i de informaia privind materialul din care ea este fcut. Alte
informaii, necesare aspectualizrii fotografice, pot defini o surs de lumin descris ca
punctual la distan finit (bec) sau la distan infinit (soare), cu o anumit intensitate
luminoas i avnd o anumit culoare. Aceste din urm informaii (intensitatea i culoarea)
sunt atributele (la rndul lor date) asociate datelor despre sursa de lumin.
Un alt exemplu este acela al asociaiei care este necesar a fi stabilit ntre denumirea unui
produs ca identificator i costul i cantitatea de produs existent n stoc, pentru ca gestiunea
corect a stocurilor de produse i a valorilor lor s poat fi efectuat
- Funcia de regsire asociativ este ntr-un fel inversul funciei de memorare
asociativ i este necesar pentru a direciona n mod selectiv datele ctre modulul de afiare,
dac sunt cerute acolo informaii despre anumite elemente din baza de date dorite, sau ctre
modulul de analiz care efectueaz calculele reclamate de anumite cerine ale aplicaiei.
Aceast funcie se desfoar pe baza regulilor de dependen din cadrul bazei de date.
- Funcia de analiz const din totalitatea procedeelor de prelucrarea a informaiei din
baza de date, dintre aceste procedee de prelucrare selectndu-se metoda adecvat tipului de
informaie de tratat. De exemplu, un set de date de forma dimensiune-poziie ar putea defini
latura unui ptrat i poziia n plan a centrului acestuia, dar ar putea defini i raza unui cerc i
17
poziia n spaiu a centrului lui. n funcie de atributul de tip asociat care indic dac este
vorba de ptrat sau de cerc, este selectat programul de desenare adecvat.
-Funcia de post-procesare realizeaz conversia datelor de la forma de reprezentare n baza
de date la o form adecvat unei alte utilizri dect cea curente. Ea se aplic cel mai adesea n
situaiile n care informaia stocat n baza de date este necesar altor programe aplicative dect
aceluia care le-a generat. Aa este cazul elaborrii informaiilor necesare pentru comanda
mainilor unelte cu comand program sau dispozitivelor de afiare grafic pe hrtie. Dup caz
ieirea datelor de post-procesare se poate face n format main sub forma unor fiiere cu un
anumit format de scriere, stocate pe suport magnetic (dischete sau band magnetic) sau pe suport
optic (CD-ROM), sau n format direct citibil, adic n form grafic sau text.
.1.9. Dispozitive periferice

Dispozitivele periferice sunt dispozitivele ataate calculatorului cu rolul de a realiza
operaiile de intrare/ieire n i din calculator a informaiilor.
1.9.1. Dispozitive de intrare
Tastatura
Tastatura este dispozitivul de intrare standard prin care utilizatorul trimite comenzi
calculatorului sub forma unui ir de caractere.
Fiecare caracter este generat la apsarea unei taste sau combinaie de taste.
Tastatura conine 4 blocuri de taste, ca n figura 1.9.1.
5
Fig.1.9.1.
1 tastatura alfanumeric. Ea conine:
- caracterele numerice: 0, 1, 2, , 9
- caracterele literale: a, , z i A, , Z
- semne de punctuaie i speciale: . , ! ? $ & % etc
- bara spaiu (space bar)
- taste de comand:
= tasta Enter care produce succesiunea de caractere CR (carriage return salt la
nceput de rnd) i LF (line feed nceperea unei linii noi)
= tasta Tab saltul cursorului cu un anumit numr de caractere pe orizontal ctre dreapta
= tasta Backspace pentru tergerea caracterului de la stnga cursorului
2 tastatura de editare. Aceasta conine:
- tastele direcionale simbolizate prin sgeile servind la deplasarea cursorului
n pagina de text cu cte o poziie n sensurile indicate
- tastele Page Up i Page Down pentru deplasarea cursorului cu o pagin de text ecran
n sus i n jos
18
- tastele Home i End pentru deplasarea cursorului la nceputul i la sfritul textului

- tasta Delete pentru tergerea caracterului curent la programele editoare de text cu
cursor de subliniere sau a caracterului de la dreapta la programele cu cursor de inserare
- tasta Insert pentru comutarea modului de scriere a caracterelor din modul inserare n
modul suprascriere i invers
3 tastatura numeric. Aceasta conine cifrele 0, 1, 2, , 9 i semnele operatorilor
aritmetici / * - +
4 - blocul tastelor funcionale care conine
- tasta Esc abandonarea unei proceduri sau ntreruperea executrii unui program
- tastele F1 F12 asociate prin program anumitor comenzi
- tasta Print Screen pentru intercepii de imagine de pe ecran (iar n sistemul DOS i
pentru copierea la imprimant a ecranului interceptat)
- tasta Pause/Break pentru suspendarea executrii unui program
5 Led-uri pentru semnalizarea diferitelor stri de funcionare.
Tastele menionate mai sus emit de regul un caracter fiind denumite "taste calde".
n afara lor exist i o serie de alte taste cunoscute sub denumirea de "taste reci" care nu
emit caractere dar care, dac sunt apsate n timp ce se apas o tast cald schimb caracterul
emis aceasta. Acesta este cazul tastelor Shift, Ctrl i Alt.
De exemplu:
Shift + A genereaz A pe cnd numai A genereaz a, dac Caps Lock nu este activ.
Tastele comutatoare sunt taste care comut regimul de funcionare al altor taste. Aici se
deosebesc:
- tasta Caps Lock care, cnd aste apsat comut de pe litere mici pe litere mari i invers
De exemplu, cu Caps Lock activat, Shift + A genereaz a
- tasta Num Lock care comut tastatura numeric n tastatur de editare
- tasta Insert pentru comutarea modului de scriere a caracterelor din modul inserare n
modul suprascriere i invers
Dispozitivul mouse
Mouse-ul este folosit pentru controlul cursorului grafic afiat pe ecran ca i pentru
selecatrea unor obiecte grafice.
Operaiile posibile cu ajutorul mouse-ului sunt:
- indicare prin poziionarea cursorului prin deplasare;
- clic, constnd din apsarea scurt a unui buton al mouse-ului;
- dublu clic, constnd din dubla apsare a butonului stnga la interval de timp scurt;
- antrenare (drag and drop) constnd din deplasarea mouse-ului cu butonul stnga apsat.
Scanner-ul
Scannerul este un dispozitiv de introducere n calculator prin digitizare a imaginilor afate
pe un suport bidimensional (pe hrtie). Digitizarea const aici din citirea imaginii punct cu
punct. Punctele citite sunt considerate aezate sub forma unei reele dreptunghiulare de careuri
elementare de suprafa. Fiecare punct este descris printr-un un set de coduri numerice binare
care descriu intensitaile culorilor elementare componente. Un scanner se caracterizeaz prin:
- Rezoluie, sau numr de puncte pe unitatea de lungime. De exemplu 300 dpi (dots per
inch = puncte pe ol):
- numr de culori discernute;
- vitez de scanare;
- suprafaa maxim scanabil.
19
1.9.2. Dispozitive de ieire

Display-ul
Generaliti, tipuri constructive
Display-ul sau dispozitivul de afiare (sau ecran, sau monitor) este dispozitivul de ieire
standard al calculatorului care, mpreun cu tastatura, compun ansamblul denumit consol
care, la unele calculatoare alctuiesc un singur bloc constructiv (denumirea de consol este
motenit de la vechile staii de afiare care erau construite astfel).
Display-ul este controlat de un bloc electronic denumit plac video, al crei rol este de a
transforma informaia binar primit de la microprocesor n semnalele electronice necesare
afirii imaginii pe ecran (screen).
1
2
3
4
Fig.1.9.2.
1
3
5
2
4
6
Faza II
Faza I
Fig.1.9.3.
Imaginea poate fi afiat n dou moduri:

- nentreesut (noninterlaced). Acest mod de afiare const din afiarea pe ecran a liniilor
de imagine componente n mod succesiv, adic n ordinea 1, 2, 3, , etc:
- ntreesut (interlaced). La acest mod de afiare se deosebesc dou faze:
= faza I (figura 1.9.2), n care sunt afiate succesiv toate liniile de indice impar: 1, 3, 5,
, etc;
= faza II (figura 1.9.3), n care sunt afiate succesiv toate liniile de indice par: 2, 4, 6,
, etc.
Acest mod de afiare are ca efect atenuarea efectului de plpire a imaginii pe ecran,
uurnd solicitarea vizual a utilizatorului i este recomandat la afiarea imaginilor dinamice.
Din punct de vedere constructiv se deosebesc urmtoarele tipuri de display-uri:
- display-uri pentru calculatoare de birou construite cu tub cinescopic;
- display-uri pentru calculatoare portabile construite ca ecrane plate cu cristale lichide sau
cu plasm;
- display-uri pentru afiare pe ecran de proiecie (sistem retroproiector sau proiector cu
raz laser dirijat);
Organizarea suprafeei de afiare a ecranului
Display-ul poate funciona n dou moduri principale:
Modul video text, caracteristic sistemului de operare DOS.
Acest mod de afiare consider ecranul mprit ntr-o reea de dreptunghiuri, fiecare dintre
ele fiind capabil s afieze cte un singur caracter tipribil, ca n figura 1.9.4.
Reeaua de dreptunghiuri este constituit dintr-o succesiune vertical de linii orizontale, pe
fiecare linie existnd acelai numr de dreptunghiuri aliniate pe vertical pe coloane.
Un dreptunghi de afiare a unui caracter este o matrice de puncte de imagine (pixeli).
Fiecare pixel este privit ca o arie elementar (careu) de imagine.
Trebuie fcut o precizare. Dup cum se observ n dreapta figurii 1.9.4, fiecare pixel de
imagine poate fi codificat pe un singur bit prin valorile 0 i 1 (stins respectiv aprins).
20
Codificarea ntregii matrici de pixeli este stocat undeva n memoria gestionat direct de
sistemul de operare DOS i nu este de competena programatorului s aib acces la aceast
zon. ntreaga matrice de pixeli a caracterului este privit ca un bloc de date care are asociat
ca identificator codul ASCII al caracterului.
linia 1
caracte
linia 25
coloana 1
pixel
pixel
coloana
Fig.1.9.4.
B
L
BG
C
FG
Fig.1.9.5.
Cnd se emite ordinul de afiare a unui caracter, n asociere cu codul ASCII al caracterului
se mai trimite i un byte (octet) n care este coninut codul de afiare al caracterului, care
determin cum va avea loc afiarea.
Aceast codificare are structura din figura 1.9.5.
Cei 8 bii ai octetului sunt folosii astfel:
Bitul 7 (BL Blinking = clipire) are semnificaiile: 0 caracterul nu clipete i 1
caracterul clipete;
Biii 6, 5 i 4 determin combinaia de culori fundamentale ale fondului BG (BackGround):
R (Red = rou), G (Green = verde) i B (Blue = albastru), fiecare putnd avea valorile 0
component lips sau 1 component prezent;
Bitul 3, notat cu L de la Light (luminos) este rezervat tonalitii culorii caracterului
(simbolizarea FG este pentru ForeGround partea de deasupra fondului): 0 culoare normal
i 1 culoare strlucitoare;
Biii 2, 1 i 0 codific componentele de culoare RGB ale caracterului.
Obs: notaiile BG i FG nu sunt standard. Ele au fost folosite aici pentru economie de
scriere.
n consecin, caracterul poate avea 16 culori iar fondul poate avea numai cele 8 culori
nestrlucitoare, conform tabelului 1.9.1.
Aadar, memorarea caracterului n modul text se face pe 2 octei, ca n figura 1.9.6.
Din aceste considerente, memoria necesar pentru memorarea unui ecran de text se poate
calcula cu relaia:
21
Tabelul 1.9.1
Cod binar
0 0 0 0
0 0 0 1
0 0 1 0
0 0 1 1
0 1 0 0
0 1 0 1
0 1 1 0
0 1 1 1
1 0 0 0
1 0 0 1
1 0 1 0
1 0 1 1
1 1 0 0
1 1 0 1
1 1 1 0
1 1 1 1
Valoare
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
Octet 1 Cod ASCII
Culoare
Negru BLACK
Albastru BLUE
Verde GREEN
Turcoaz - CYAN
Rou RED
Liliachiu MAGENTA
Galben YELLOW
Alb WHITE
Gri Gray
Albastru strlucitor LIGHTBLUE
Verde strlucitor LIGHTGREEN
Turcoaz strlucitor LIGHTCYAN
Rou strlucitor LIGHTRED
Liliachiu strlucitor LIGHTMAGENTA
Galben strlucitor LIGHTYELLOW
Alb strlucitor
Octet 2 Cod de culoare
Fig.1.9.6.
Mvt = cr2 octei

unde:
prin Mvt s-a notat memoria n modul video text;
prin c s-a notat numrul de coloane de caractere;
prin r s-a notat numrul de rnduri de caractere.
Pentru cazul r = 25 i c = 80 se obine: Mvt = 80252 octei = 4000 octei < 4 KB
Modul video grafic, folosit att sub sistemul de operare DOS ct i, n mod exclusiv, sub
sistemul Windows.
n modul grafic ecranul este considerat ca o matrice de pixeli tratai individual i nu n
blocuri ca n modul video text.
Performanele unui display capabil de afiare n modul video grafic sunt msurabile dup
urmtoarele caracteristici:
- Rezoluie, adic produsul dintre numrul de pixeli pe o linie de imagine i numruil de
linii de imagine (sau de pixeli pe coloan). Exemple de cteva asemenea rezoluii sunt:
640480 (rezoluia VGA standard), 800600, 1024768, etc;
- Definiie, adic distana minim dintre dou puncte pe ecran (de exemplu 0,28 mm);
- Numrul de culori folosit pentru afiarea imaginii.
Fiecare pixel are ataat un cod de culoare.
Fiecare culoare este codificat pe un anumit numr de bii.
Cea mai simpl codificare folosete un singur bit cu valorile 1 = aprins i 0 = stins, deci se
pot codifica 2 culori i anume alb i negru.
Formula general de calcul a numrului de culori rezultate din modul de codificare, Nc,
este:
Nc = 2b
22
unde b = 1, 2, 4, 8, 16, 32 este numrul de bii folosii la codificare

n funcie de modurile de codificare a culorilor, au existat monitoare cu:
b = 1, deci Nc = 2 culori;
etc.
Evolutiv, pot fi enumerate urmtoarele tipuri de plci grafice i monitoare:
- monitoare HGC (Hercules Graphics Card): 7203402 (liniicoloaneculori);
- monitoare CGA (Color Graphics Adapter): 3202004 sau 6402002;
- monitoare EGA (Enhanced Graphics Adapter): 64035016;
- monitoare VGA (Video Graphics Adapter): 80060016 sau 640480256;
- monitoare MCGA (Multi Color Graphics Array): 640480256;
- monitoare SVGA (Super Videu Graphics Array): 800600256 sau 102476816;
Practic, o dat cu monitoarele SVGA ncepe evoluia sistemelor de afiare actuale.
Formula de calcul pentru memoria video n modul grafic Mvg, este:
Mvg = nmc/8 octei
unde:
n = numrul de pixeli pe linie
m = numrul de pixeli pe coloan
c = numrul de bii de codificare a culorii
De exemplu, pentru un monitor SVGA cu 800600256, c = 8 (28 = 256) i memoria
video necesar va fi:
Mvg = 8006008/8 = 480000 octei < 469 KB
Rezultatul folosirii modului de afiare video grafic este un consum de memorie mare
precum i scderea vitezei de prelucrare a imaginilor.
Pentru a compensa acest efect, se folosesc "plcile cu accelerator grafic". Acestea conin
un "coprocesor grafic" care preia din sarcinile unitii centrale, avnd funcii precum:
- trasare de linii;
- umpleri de contururi;
- defilare de text;
- deplasri de blocuri de imagine, etc.
Imprimanta
Imprimanta este un dispozitiv de transpunere a informaiilor rezultate pe un suport
bidimensional (hrtie) prin parcurgere secvenial (fr revenire).
Componentele principale ale imprimantei sunt:
- un mecanism de imprimare;
- un mecanism de antrenare;
- un bloc electronic de comand;
- un panou cu butoane i indicatoare;
Ca tipuri de imprimante folosite, se pot enumera cronologic:
- Imprimante cu tambur cu caractere n prezent nu mai sunt folosite;
- Imprimante matriciale cu ace sunt aproape ieite din uz;
- Imprimante cu jet de cerneal;
- Imprimante cu laser (similare constructiv cu fotocopiatorul);
23
- Imprimante termice.
Caracteristicile principale ale imprimantelor sunt:
- Rezoluia, adic numrul de puncte afiate pe un ol (se msoar n dpi). De exemplu:
180, 300, 360, 600, 1200 dpi;
- Viteza de imprimare se msoar n cps (caractere pe secund) la imprimantele lente i n
ppm (pagini pe minut) la imprimantele rapide;
- Dimensiunea maxim a hrtiei. Se deosebesc imprimante pentru formatele A3 (420297
mm), A4 (210297 mm), A5 (148210 mm), B5 (182257 mm);
- Memoria proprie. Pentru a elibera calculatorul de o serie de sarcini de coordonare a
funcionrii imprimantei ca i pentru a scuti operatorul de a atepta terminarea lucrului
imprimantei comandat direct de calculator, imprimantele actuale posed un bloc de comand
i o memorie proprie, ele fiind de fapt calculatoare specializate n imprimare. Ca urmare,
informaia este preluat n pachete mari de catre imprimant i apoi imprimarea decurge
independent de calculator. Cu ct memoria proprie este mai mare cu att pachetele de
informaie transmise sunt mai mari i intervenia calculatorului mai rar.
Plotterul
Plotterul este un dispozitiv de desenare (sau de tiere cutter-plotter) vectorial. El
deseneaz trasee bidimensionale n orice direcie a hrtiei. n general plotterele sunt construite
pentru formate de hrtie mai mari dect cele ale imprimantelor, sau chiar foarte mari.
Precizia de desenare este mare, n general de circa 300-800 dpi.
Plotterul este compus dintr-o mas de lucru i un bra sau sistem mecanic de translaie pe
dou direcii a capului de trasare (la unele sisteme o micare de translaie se realizeaz prin
rotirea hrtiei peste un tambur iar cealalt micare de translaie este realizat obinuit, prin
glisarea capului de desenare pe o glisier liniar).
Capul de desenare poate fi prevzut cu un schimbtor de tocuri cu penie, sau cu un
dispozitiv pentru pulverizarea unui jet de cerneal.
1.9.3. Memoriile externe
Discul magnetic
n funcie de suportul magnetic pe care sunt realizate discurile magnetice pot fi:
Disc
Capete
Fig.1.9.7.
de
Fig.1.9.8.
- Discuri flexibile (floppy discuri), realizate pe folii de plastic cu suprafaa acoperit de un

strat cu proprieti magnetice care poate fi magnetizat dup dou direcii asociate cifrelor binare 0
i 1. Au existat discuri de diferite diametre, n prezent rmnnd n uz discurile de 3,25";
24
- Discuri dure (hard discuri). Acestea sunt realizate

sub form de pachete de discuri din aluminiu acoperite cu
un material paramagnetic (uor magnetizabil) pe baz de
oxid de fier.
n figura 1.9.8 este prezentat cazul unui singur disc pe
care gliseaz un ansamblu cu capete de citire/scriere, n
timp ce discul se rotete. Informaia poate fi stocat pe
ambele fee ale discului.
n figura 1.9.7 se observ modul de dispunere al
informaiilor pe disc. nregistrrile magnetice sunt dispuse
pe "piste" circulare concentrice mprite n "sectoare"
coninnd fiecare cte 512 octei.
Totalitatea pistelor de aceeai raz formeaz un "cilindru".
La discurile flexibile un cilindru are 2 piste (cte una
Fig.1.9.9.
pe fiecare fa a discului), iar la discurile dure (figura
1.9.9) un cilindru are un numr de piste egal cu dublul numrului discurilor din pachet.
Pentru a putea fi utilizat, un disc magnetic trebuie mai nti s fie formatat.
Formatarea este operaia de mprire a discului n piste i sectoare.
Atenie! Formatarea unui disc magnetic terge definitiv informaia existent pe el anterior.
Caracteristicile discurilor magnetice flexibile au fost simbolizate astfel:
- Simpl densitate (Single Density) - SD
- Dubl densitate (Double Densuty) - DD
- nalt densitate (High Density) - HD
- Densitate extins (Extended Density) - ED
- nregistrare pe o singur fa (Single Side) - SS
- nregistrare pe ambele fee (Double Side) - DS
Capacitile discurilor magnetice flexibile de 3,5"sunt (pn n prezent) urmtoarele:
- dubl densitate, dubl fa (DD, DS) 720 KB;
- nalt densitate, dubl fa (HD, DS) 1,44 MB;
- densitate extins, dubl fa (ED, DS) 2,88 MB;
Capacitile hard discurilor au evoluat de-a lungul timpului conform urmtoarelor valori:
10MB, 40MB, 80MB, 120MB, 200MB, 340MB, 560MB, , 10GB,
Caracteristicile de performan ale discurilor magnetice sunt:
- Timpul mediu de acces (sau de cutare seek time) este timpul n care are loc localizarea
unui sector de pe o pist pe disc. Valorile realizate de-a lungul timpului au fost: 25ms,
23ms, 18ms, 16ms, , 5ms;
- Viteza de transfer a informaiei este cantitatea de informaie transferat de la unitatea de
disc la memoria intern. Ea se msoar n KB/s. Se deosebesc valorile:
- pentru floppy disc 20KB;
- pentru hard discuri: 450, 600, 700, , 28000, 46000 KB/s
Compact discul
Compact discul este cunoscut sub prescurtarea CD. Se deosebesc:
- CD-ROM (Compact Disk Read Only Memory), CD-uri care pot fi numai citite;
- CD-RW (Compact Disk ReWritable), sau reinscriptibil.
Capacitatea unui CD este de circa 650MB, iar viteza este mai sczut dect a discurilor
magnetice. Avantajul principal este posibilitatea stocrii CD-urilor i ea este evident n
comparaie cu floppy discurile.
25
Caseta magnetic (streamer)

Aceast modalitate de stocare a aprut ntr-un moment n care evoluia hard discurilor
stagna iar CD-urile nu aveau nc o extindere suficient. Astzi se mai vorbete relativ puin
despre ele.
La vremea respectiv ele au oferit o capacitate de stocare mare (de circa cteva sute de
MB) comparativ cu capacitatea de stocare de la acea vreme a hard discurilor (de numai cteva
zeci de MB, pn la circa 100MB).
Datorit nevoii de derulare a benzii, accesul la informaie este secvenial ceea ce, chiar de
la acea vreme se prezenta ca un inconvenient, reducnd drastic viteza de exploatare.
.1.10. Organizarea datelor n memoria extern. Fiiere

1.10.1. Structurarea fiierelor
Pstrarea datelor n memoriile externe (disc flexibil, disc dur, compact disc, etc) se
realizeaz prin gruparea ei n fiiere.
Fiierul (File) este o colecie de informaii de o anumit natur i destinaie, care se
memoreaz mpreun pe un suport de informaie.
n privina naturii lor fiierele pot fi mprite n fiiere executabile constnd din programe
sau module de programe, i fiiere de date care conin datele de intrare i/sau de ieire n/dintrun proces de prelucrare de informaie. O clasificare mai detaliat va fi prezentat mai jos.
O dat cu creterea capacitii de stocare pe suporturi de memorie extern, a aprut nevoia
gruprii fiierelor n colecii de fiiere, pentru a uura operaiile de regsire a fiierelor.
Astfel a aprut noiunea de director, ca o colecie de fiiere grupate mpreun. n
privina naturii fiierelor dintr-un director nu exist nici o restricie, criteriul de grupare fiind
strict la latitudinea utilizatorului.
Pentru a permite o structurare convenabil a fiierelor s-a acceptat convenia ca un director
s poat conine la rndul su, nu numai fiiere, ci i alte directoare (se folosete frecvent
noiunea de subdirector). Prin aceast convenie se poate realiza o structur arborescent sau
ierarhic, aa cum este cea prezentat n figura 1.10.1.
Se observ ramificarea continu a structurii, pe nivele de ramificare. Primul nivel (nivel 0
sau rdcin) reprezint unitatea logic de memorie extern. Ramificarea are loc pn cnd la
un nod (director sau subdirector) nu se mai conecteaz nici un alt subdirector ci numai fiiere
(pot exista i directoare goale, care nu conin nici un fiier ci exist numai ca recipiente pentru
eventuala stocare ulterioar a unor fiiere).
Considernd calculatorul ca pe un gestionar de suporturi externe de memorie (prin
intermediul dispozitivelor de citire/scriere ataate), se poate prezenta structura din figura
1.10.2.
ncepnd cu sistemul de operare Windows 95, noiunea de director este lrgit. Apare
noiunea de folder care include n structurarea arborescent a informaiei, nu numai
directoarele ca stocuri compartimentate de fiiere, ci i alte structuri de gestiune a informaiei,
n special legate de modul de gestiune al comenzilor de execuie a anumitor programe,
prestabilite sau create de utilizator.
n figura 1.10.3 este prezentat un extras din fereastra aplicaiei Windows Explorer.
Se observ apariia unei entiti logice superioar calculatorului (My Computer) i anume
"masa de lucru" (Desktop) la care se ramific i alte compartimente logice (foldere).
Unul dintre acestea, conectat la My Computer, este Control Panel care, aa cum se observ
din cmpul de afiare din partea dreapt, nu conine fiiere ci comenzi de lansare n lucru a
unor programe destinate controlului modului de funcionare al calculatorului.
26
Suport de
memorie
director 1
director 2
director j
fiier 1
fiier 2
subdirector j1 subdirector j2
fiier j1
fiier j2
subdirector j21 subdirector j22
fiier j21
fiier j22
fiier m
fiier j21
fiier j2k
Fig.1.10.1.
Calculator
A:
B:
floppy discuri
C:
hard disc
D:
CD-ROM
Fig.1.10.2.
1.10.2. Operaii cu fiiere
Pentru manipularea fiierelor trebuie stabilit mai nti o convenie de definire a operaiilor
posibile cu fiierele. Se folosesc urmtoarele denumiri:
- Crearea unui fiier. Aceasta este o operaie efectuat de ctre un program creator de
fiiere, printr-o operaie de scriere a fiierului pe suportul de memorie.
Pentru a putea scrie fiierul, programul creator trebuie s cunoasc urmtoarele elemente:
= suportul de memorie (unitatea de disc) pe care se va face scrierea;
= directorul (subdirectorul) n care va fi inclus fiierul;
= numele fiierului.
Toate aceste elemente compun aa numita "cale" (path) ctre fiier. Sintaxa definirii unei
ci este urmtoarea:
dispozitiv:\director\subdirector\\subdirector\nume_fiier.tip
De exemplu:
D: \CosDocRom\UsrGuide\Pdf-doc\01intro.pdf
n figura 1.10.4 se observ corespondena dintre aceast notaie i modul de accesare al
fiierelor din directorul final corespunztor, cnd se folosete aplicaia Windows Explorer.
27
Fig.1.10.3.
- Consultarea (citire precedat de deschidere) unui fiier existent. Aceasta este o operaie
de extragere de informaie dintr-un fiier, fr modificarea lui.
n figura 1.10.5 se observ fereastra Open a unei aplicaii care este n curs de a deschide
fiierul de pe calea exemplificat mai sus.
- Actualizarea unui fiier. Orice fiier de date este compus din date structurate sub forma
unor nregistrri. nregistrrile pot fi privite ca stocuri de informaie elementare, componente
ale fiierului.
Se deosebesc trei cazuri de actualizare:
= adugarea unei (sau unor) nregistrri, cu consecina lungirii fiierului;
= tergerea unei (sau unor) nregistrri, cu consecina scurtrii fiierului;
= modificarea unei (sau unor) nregistrri. n acest caz consecina poate fi de lungire,
scurtare sau conservare a lungimii fiierului n funcie de modul cum sunt definite
nregistrrile. Dac acestea sunt de lungime fix, fiierul nu i modific lungimea. Dac
ns nregistrarea poate avea lungime variabil, fiierul se lungete sau se scurteaz
dup cum nregistrarea se modific prin lungire sau scurtare.
- Copierea unui fiier. Prin aceast operaie se obine o copie identic a fiierului.
Deoarece nici un sistem de operare nu tolereaz existena n acelai director a mai multor
fiiere cu acelai nume, copia poate avea:
= indiferent ce nume (acelai ca originalul sau diferit), dac fiierul este plasat ntr-un
alt director dect originalul;
= obligatoriu alt nume dect originalul, dac fiierul este plasat n acelai director cu
originalul.
n sistemul Windows 95 (sau superioare) este posibil copierea unui fiier n acelai
director fr specificarea unui nume diferit dar, n mod automat, sistemul de operare va
schimba numele din nume n Copy of nume, pentru a diferenia fiierul nou creat prin
copiere de cel original.
28
Fig.1.10.4.
Fig.1.10.5.
- tergerea unui fiier. Prin aceast operaie fiierul nu este propriu-zis ters de pe suport
deoarece operaia ar putea dura prea mult ci, ntr-un fiier special denumit "Tabel de alocare a
fiierelor" (FAT File Allocation Table) situat la nceputul suportului i invizibil pentru utilizator,
spaiul ocupat de fiier este marcat ca fiind liber. Aceasta permite ca urmtoarele operaii de
creare de fiiere noi sau de actualizare a fiierelor existente, s foloseasc acest spaiu. Din acest
motiv, anumite programe capabile s recupereze un fiier ters din greeal, pot aciona cu succes
numai dac ncercarea de recuperare se face nainte de a efectua prima operaie de scriere pe
suport (creare sau actualizare). Acest procedeu este valabil numai n sistemul de operare DOS i
numai dac ntre timp nu au fost folosite programe care necesit fiiere temporare (care se
reactualizeaz automat, fr intervenia explicit a operatorului). Cum sistemul Windows 95
folosete ntotdeauna un astfel de fiier (denumit swap file) de lungime variabil, pentru
recuperarea fiierelor terse din greeal, n acest sistem a fost prevzut un director special
denumit Recycle Bin (recuperare binar) n care, pentru un anumit timp, sunt pstrate fiierele
terse. Dac ele se terg i din acest director, recuperarea lor nu mai este posibil.
- Mutarea unui fiier. Prin aceast operaie un fiier poate fi mutat dintr-un director n
altul. i aceast operaie este simulat dac mutarea se face pe acelai suport. De fapt fiierul
rmne pe loc dar, n tabela de alocare de fiiere, el este marcat ca aparinnd altui director.
i aici acioneaz regula de a nu se admite mai multe fiiere cu acelai nume n acelai
director. De aceea, mutarea fiierului se poate face:
= pe acelai disc: fiierul va trebui ca anterior s fie redenumit dac n directorul
destinaie mai exist un fiier cu acelai nume. Altfel fiierul mutat l va substitui pe cel
preexistent. Mutarea este fictiv din punct de vedere fizic, operaia avnd loc numai n
FAT ca schimbare de atribut de apartenen;
= pe alt suport: este valabil precauia de mai sus privind denumirea. n plus, mutarea
este real, fiierul fiind scris la destinaie i ters (marcat ca spaiu liber) pe suportul
surs.
- Redenumirea unui fiier const din schimbarea numelui fiierului. Aceast operaie este
efectuat numai n tabela de alocare de fiiere.
1.10.3. Tipuri de fiiere
Se pot distinge urmtoarele tipuri principale de fiiere:
29
- Fiiere executabile care conin programe executabile (cu extensia EXE sau COM) sau
module executabile (de exemplu cele cu extensia DLL Dynamic Link Library);
- Fiiere de date, care conin date de diferite tipuri, eventual compuse din tipurile de mai
jos;
- Fiiere de text, care conin numai caractere ASCII tipribile, eventual i coduri de control
pentru formatarea textelor i aranjarea lor n pagin;
- Fiiere de imagine care conin descrierile necesare afirii sau imprimrii imaginilor.
Acestea pot fi:
= vectoriale, compuse din comenzi sau definiii necesare pentru trasarea de linii;
= raster (matriciale), compuse din descrierea succesiunii de pixeli de afiat.
.1.11. Noiuni privind structura software a calculatorului

Software-ul unui calculator este format din programele care pot fi executate de ctre
calculator n diverse scopuri.
Programul este o colecie organizat de comenzi de operaii pe care calculatorul trebuie s
le efectueze. Aceste comenzi sunt numite instruciuni.
Orice instruciune este tradus, n final, ntr-una sau mai multe instruciuni elementare
recunoscute de microprocesor, exprimate n cod binar i transmise microprocesorului spre
execuie.
1.11.1. Ierarhia programelor
Simplificnd lucrurile la extrem, se pot defini trei nivele
Sistem de operare
ierarhice n organizarea software a unui calculator (figura
1.11.1), i anume:
Program
- Programul monitor, este programul coninut n memoria
monitor
ROM a calculatorului. El este executat automat la punerea sub
(nucleu ROM)
tensiune a calculatorului i controleaz secvena de iniializare a
funcionrii calculatorului.
Astfel, se realizeaz:
Programe aplicative
= testarea conectrii i bunei funcionri a dispozitivelor
periferice:
tastatur, floppy disc, hard disc;
Fig.1.11.1.
= testarea memoriei RAM disponibile;
= ncrcarea sistemului de operare.
Prin intermediul acestui program se realizeaz exploatarea resurselor fizice de la nivelul
cel mai de jos al calculatorului.
- Sistemul de operare. Acesta const dintr-un set de programe care asigur exploatarea
optim a resurselor fizice i logice ale calculatorului.
Funciile realizate de sistemul de operare sunt:
= Sesizarea i tratarea evenimentelor aprute la perifericele de intrare (tastatur i
mouse);
= Deservirea perifericelor de ieire (ecran, discuri, imprimant);
Cronologic, sistemele de operare folosite (mai cunoscute) au fost:
- pe microcalculatoarele de 8 bii: SFDX, CP/M;
- pe minicalculatoare: RSX;
- pe microcalculatoare compatibile IBM-PC: DOS, UNIX, OS/2;
- pe microcalculatoare Mac Intosh: System;
- ncepnd de la versiunea Windows 95, pe microcalculatoarele compatibile IBM-PC
sistemul de interfaare grafic Windows a devenit sistem de operare nlocuind sistemul DOS.
Programe utilitare
30
- Programele utilitare sunt programe aplicative foarte generale cum ar fi:

= editoarele de texte;
= compilatoarele pentru diverse limbaje;
= gestionarele de informaie pe discuri, ca de ex: Norton Commander, Xtree Gold, PC
Shell, File Manager n versiunile de Windows mai vechi, Windows Explorer ncepnd
de la Windows 95;
= programele de testare i depanare a defectelor de pe discuri (de exemplu Scan Disk);
= optimizatoarele de discuri;
= etc.
- Programele aplicative sunt programe care rezolv diverse aplicaii specializate, realizate
fie de ctre firmele productoare de programe fie de ctre programatori individuali.
.1.12. Elemente de ingineria programrii

1.12.1. Generaliti
Termenul de ingineria programrii a fost introdus pentru prima oar n 1968/1969. Dei de
atunci, pentru clarificarea acestui concept, au fost elaborate multe studii, n principiu el
presupune utilizarea riguroas a unor metode i instrumente adecvate pentru dezvoltarea de
programe i aplicarea exact a unor principii de baz n activitatea de elaborare de programe
pentru calculatoare.
Necesitatea elaborrii acestei discipline a pornit de la productivitatea sczut a activitii
de programare i calitii sczute a rezultatelor acestei activiti, precum i de la costurile mari
ocazionate de ntreinerea i dezvoltarea ulterioar a programelor.
Se punea tot mai accentuat problema unor scheme generale de organizare a programelor
astfel nct ele s poat fi ulterior uor de citit, neles i corectat.
1.12.2. Modularizarea
Modularizarea este un concept pornit de la constatarea c este mai uor de tratat o
problem descompus n componente dect aceeai problem manipulat n ntregime.
De aceea programele medii i mari sunt ntotdeauna mprite n module care sunt
asamblate sau apelate dup anumite reguli.
Spargerea programelor n module este dictat i de limitrile tehnice ale calculatoarelor,
limitri care exist i vor exista mereu. Prima i cea mai critic resurs care dicteaz
modularizarea este memoria electronic i viteza de acces la ea.
Modularizarea i propune ca obiective:
- descompunerea unei probleme complexe n subprobleme (module), pornind de la criterii
ca: omogenitatea funciilor de realizat, folosirea unor date comune, nelegerea ct mai uoar,
etc:
- testarea corectitudinii unui modul independent de contextul de utilizare ntr-un program
mai mare;
- construirea unui program complex prin asamblare de module (subprograme) scrise de
mai ali programatori, fr a fi nevoie de cunoaterea structurii interne a programelor.
Pentru atingerea acestor obiective trebuie aplicate principii ca:
- abstractizarea, prin care un grup de operaii poate fi desemnat printr-un nume, fr a fi
necesar precizarea lor n detaliu;
- compoziia, pentru care construciile complexe sunt stabilite plecnd de la componente
mai simple.
Etapele principale ale modularizrii sunt:
- modularizarea funcional n care se identific i se specific funciile de prelucrare
31
automat a datelor;
- modularizarea structural n care se specific structura datelor;
- modularizarea procedural n care se specific ordinea de execuie a modulelor.
1.12.3. Teorema fundamental a ingineriei programrii
Fie P i Q dou probleme pentru care trebuiesc scrise dou programe distincte.
Fie M o msur pentru dimensiunea unei probleme i fie C costul scrierii unui program
pentru acea problem.
Dac M(P) > M(Q) este evident c C(P) > C(Q), adic scrierea unui program pentru o
problem mai mare este mai scump dect scrierea unui program pentru o problem mai mic.
Fie acum dou probleme separate P i Q pe care ne propunem s le tratm ca pe o
problem combinat P+Q pentru care ne propunem s scriem un singur program combinat.
Deoarece problemele sunt independente, programul trebuie s conin i efortul de corelare
ntre cele dou probleme pentru a se evita interferenele nedorite. Aadar:
M(P+Q) > M(P) + M(Q) i, n consecin, relaia deintre costuri va fi asemntoare:
C(P+Q) > C(P) + C(Q)
Fig.1.12.1.
A = curba erorilor comise la manipulare simultan
B = curba erorilor comise la manipulare separat
Acest rezultat poate fi privi i invers, adic este mai ieftin de creat dou programe mici
dect unul mare.
Acest lucru se explic prin faptul c, pe lng altele, efortul de corelare a problemelor
poate avea ca rezultat producerea de erori de programare, pentru a cror eliminare sunt
necesare cheltuieli suplimentare.
ntr-adevr, este demonstrat prin studii statistice c o persoan poate manipula n memoria
sa imediat un numr de circa 7 2 obiecte, entiti sau concepte. Peste acest numr de
elemente distincte utilizabile simultan, numrul de erori comise crete din ce n ce mai rapid
ca n diagrama din figura 1.12.1.
Aadar, este demonstrat c C(P+Q) > C(P) + C(Q)
De aici rezult imediat "Teorema fundamental a ingineriei programrii":
Fie P o problem care poate fi descompus n subproblemele tratabile separat P' i P". Atunci:
C(P) > C(P') + C(P")
adic, costul rezolvrii separate a componentelor unei probleme este mai sczut dect acela
al rezolvrii problemei n bloc.
32
n cazul programelor , s zicem cu 1000 de linii, va fi mai ieftin de proiectat un program cu

dou module de cte 500 de linii dect un singur modul cu 1000 de linii.
n cazul extrem putem scrie 1000 de module cu cte o singur linie.
Apare ns o nou problem. C(P') i C(P") conin i costurile realizrii interfeei dintre
modulele P' i P" i programul care le conine. Treptat preul interfarii crete tot mai mult i
se poate ajunge la situaia reflectat de figura 1.12.2.
Evident, costul realizrii fiecrui modul depinde de mrimea sa i va fi cu att mai mic cu
ct este mai mic dimensiunea modulului. n schimb, pe msur ce numrul de module n care
este descompus produsul este mai mare crete costul realizrii interfeelor dintre module.
Costul realizrii ntregului produs este suma celor dou costuri i va fi minim la o anumit
combinaie dimensiune medie de modul-numr de module, combinaie optim din punctul de
vedere al costului, dup depirea acestei valori obinndu-se din nou creterea costului total.
Fig. 1.12.2.
1.12.4. Date, tipuri i structuri de date
Datele sunt informaiile prelucrate de programe. Se deosebesc date elementare i date
structurate.
Tipurile de date elementare sunt urmtoarele:
a. Tipul numeric.
Acest tip include de obicei numerele ntregi, reale i complexe. n cadrul tipurilor numerice
se deosebesc subtipuri n funcie de lungimea de memorie folosit pentru reprezentare i care,
pentru numerele reale determin precizia de reprezentare.
b. Tipul logic (sau Boolean).
Acest tip cuprinde datele care pot avea valorile adevrat sau fals i ntre care sunt posibile
operaiile logice AND, OR i NOT.
c. Tipul ir de caractere.
Acest tip de date conine succesiuni finite de caractere (n cod ASCII), cea mai scurt
succesiune fiind irul vid (de lungime zero). Datele de aceste tip pot suporta operaii de
concatenare (alipire), ordonare, comparare, etc.
Unele limbaje recunosc tipul particular ir de caractere de lungime unitar sau tipul
caracter, din care se formeaz irurile de caractere.
d. Tipul pointer.
Acesta este un tip de dat special care conine adresa ctre o locaie de memorie n care
33
este stocat o dat de unul dintre tipurile de mai sus. Pentru a ajuta la localizarea exact a
datei, tipul pointer din limbajul C conine nu numai adresa datei ci i informaia privind tipul
ei, adic lungimea de stocare.
Pointerii sunt folosite n operaiile de referire a unei date, operaie care nlocuiete
transferul datei prin lista de argumente a unei funcii sau proceduri.
Structuri de date.
Datele individuale nu sunt suficiente pentru nevoile de programare. Adesea nevoile
practice impun manipularea de mulimi de date de un anumit tip sau de tip compus. Se
ntlnesc urmtoarele structuri de date:
a. Tabloul. Acesta este o colecie de date de acelai tip aranjate ntr-o structur
rectangular k-dimensional.
Astfel, deosebim:
- Tabloul unidimensional sau vectorul, constnd dintr-un ir simplu de date de tip numeric
de o anumit lungime (numr de elemente);
- Tabloul bidimensional sau matricea, constnd dintr-o serie de un anumit numr de iruri
de aceeai lungime. Echivalentul grafic este matricea cu n linii i m coloane;
- Tabloul tridimensional, sau masivul;
- etc.
b. irul. Un caz particular este irul de caractere descris mai sus. irul poate fi compus i
din numere (vectorul) dar i din alte iruri.
c. Lista. O list este o niruire de date de orice tip.
1.12.5. Structuri de programe. Programare structurat
Un program descrie un proces de calcul prin instruciuni care descriu operaiile pe care un
calculator le poate efectua ntr-o anumit ordine, succesiv sau, altfel spus, secvenial.
Astfel, dac:
S1, S2, , Si-1, Si, Si+1, ,Sn
este un program secvenial compus din instruciunile Si, i=1, ,n, atunci:
1. S1 este prima instruciune care se execut
2. dup execuia instruciunii Si se transfer controlul la instruciunea Si+1
3. Sn este ultima instruciune de executat
n practic, notaia Si poate fi folosit att pentru a desemna instruciuni separate ct i
secvene ntregi de instruciuni.
S1
S2
Selector
Fig.1.12.3.
Nu
Sn
Secvene
Condiie
ndeplinit
S2
Da
S1
Fig.1.12.4.
34
Un program structurat se compune din

urmtoarele
elemente de baz:
Adevrat
Fals
Secvena
Condiie
- Structura alternativ
- Structura repetitiv
S
O secven este o succesiune de instruciuni care
se execut succesiv, una dup alta, n ordinea scrierii
lor (a se vedea exemplul de mai sus).
Structura alternativ este de mai multe tipuri:
Fig.1.12.5.
Structura multialternativ, figura 1.12.3. La
aceast structur direcionarea execuiei pe o ramur sau
alta dintre mai multe ramuri (alternative) se face n funcie de valoarea unei variabile de test numeric
(selector de caz). Echivalentul n pseudocod al schemei grafice din figura 1.12.3 este urmtorul:
dac i
este egal cu i1 execut S1;
este egal cu i2 execut S2;
este egal cu in execut Sn;

Un exemplu de utilizare n limbaj C++ este urmtorul:
switch(i)
{case 1:
case 2:
case 3: y=1; break;
case 4: y=2; break;
default: y=0;
}
rezultatul produs fiind y=1 pentru i=1, 2 sau 3, y=2 pentru i=4, i y=0 pentru oricare alt
valoare a lui i.
Structura bialternativ (sau blocul de decizie), figura 10 direcioneaz execuia pe una dintre
dou ci n funcie de rezultatul afirmativ sau negativ (adevrat sau fals) al unui test logic.
Echivalentul n pseudocod al schemei logice din figura 1.12.4 este urmtorul:
dac condiie este adevrat
atunci execut secvena S1;
altfel execut secvena S2;
Un exemplu n limbaj C++ de bloc de decizie este:
if (a<b)
minab=a;
else
minab=b;
ccea ce are ca rezultat stocarea n variabila minab a celei mai mici dintre valorile
variabilelor a sau b.
O variant a structurii din figura 1.12.4 este structura bialternativ cu o ramur vid,
figura 1.12.5. Pseudocodul corespunztor este:
dac condiie este adevrat
atunci execut S
Varianta n C++ a procedurii de mai sus , cu acelai efect, va fi:
minab=b
if (a<b) minab=a;
35
S
Da
S
C
Nu
Fig.1.12.6.
Da
C
Nu
Fig.1.12.7.
Structura repetitiv, este o structur care repet o secven de instruciuni de un numr de

ori determinat de valoarea unui test logic efectuat pe parcursul repetiiei.
Exist dou variante de structur repetitiv.
Structura repetitiv condiionat anterior, figura 1.12.6. La aceast structur, testarea
condiiei de repetare se face naintea execuiei secvenei de repetat.
Pseudocodul folosit pentru aceast structur este:
ct timp condiia C este adevrat
execut S;
Pentru a nu se ajunge la o situaie de repetare la infinit, n cuprinsul secvenei S variabila
asupra creia se execut testul trebuie s i schimbe la un moment dat valoarea pentru ca
testul s dea rezultat negativ i repetiia s se opreasc.
De exemplu, n limbaj C++ valoarea lui n! se poate calcula astfel
n=5;
i=1;
factn=1;
while i<=n
{factn=factn*i;
i=i+1;
}
La sfritul acestei poriuni de program se obine valoarea factn=120, adic valoarea lui 5!.
Structura repetitiv condiionat posterior, figura 1.12.7. La aceast structur testul
condiiei de continuare a repetiiei se face dup executarea secvenei S.
n pseudocod aceast structur apare astfel:
execut S
ct timp condiia C este adevrat;
Un exemplu de astfel de structur, n limbajul C++, este urmtorul:
n=5;
i=1;
factn=1;
do
{factn=factn*i;
i++;
}while (i<=n);
avnd acelai rezultat ca mai sus, i anume calculul lui 5!.

Diferena de fond dintre structura repetitiv condiionat anterior i cea condiionat
posterior este c, la cea de a doua, execuia secvenei S are loc cel puin o dat chiar dac
condiia de repetare nu este ndeplinit.
36
Uneori se accept i testul negativ al condiiei C, adic repetarea s se produc pn cnd o

condiie de oprire s fie ndeplinit. n acest caz, n figura 1.12.7 condiiile Da i Nu sunt
inversate, iar pseudocodul apare astfel:
execut S
pn cnd C este adevrat;
n limbajul Visual Basic o astfel de structur repetitiv, de asemenea pentru calculul lui n!
va apare astfel:
n=5
i=1
factn=1
Do
factn=factn*i
i=i+1
Loop Until i>n
A fost demonstrat faptul c orice program poate fi scris folosind numai trei tipuri de
structuri, denumite structuri fundamentale, i anume:
- structura secvenial;
- structura alternativ cu dou ramuri;
- structura repetitiv condiionat anterior.
Un program scris astfel, se numete program D-structurat (iniiala D provenind de la
numele lui Dijkstra, cel care a introdus denumirea de programare structurat).
Totui, limbajele actuale prevd i alte tipuri de structuri, unele fiind menionate mai sus,
cu scopul de a uura munca programatorului.
Exist astzi un consens general de a evita, dac se poate total, folosirea instruciunii de
salt necondiionat GoTo, care are ca efect distrugerea structurrii. Totui, se accept folosirea
ei pentru cazuri de abandon forat al execuiei, ca ieire de siguran dintr-un program sau
procedur, i numai precedat de un test de condiie adecvat i nsoit de msuri adecvate de
stabilire a valorilor variabilelor care ar mai fi necesare ulterior.
n concluzie, structurarea programelor urmrete realizarea unei cerine de rigurozitate i
anume principiul ncapsulrii (separrii) aciunilor care se poate enuna ca eliminarea
posibilitii ca, prin instruciunile folosite ntr-un modul de program sau zon de modul, s se
declaneze aciuni dificil de controlat ntr-un alt modul sau zon de modul conceput ca
independent. Din acest punct de vedere instruciunea GoTo este deosebit de nefast.
Un alt principiu necesar a fi respectat este principiul ncapsulrii datelor care stipuleaz
limitarea sau blocarea vizibilitii variabilelor ntre diferitele module de program. Din acest
principiu rezult o clasificare a variabilelor n variabile locale care sunt vizibile numai n
interiorul unui modul de program (procedur sau funcie) i variabile globale care sunt
vizibile n tot cuprinsul programului, conform schemei din figura 1.12.8.
n acest scop, limbajele actuale folosesc
Program
instruciuni de declarare care, n funcie de locul
Variabile globale
unde sunt inserate (naintea definirii modulelor
G1Gk
sau n interiorul modulelor) determin
Modul 1
Modul n
vizibilitatea global sau local. n acest mod,
Variabile locale
Variabile locale
chiar dac n modulul n, de exemplu, se
L1,Ln1
L1,Lnn
folosete aceeai denumire pentru variabila L1
ca i n modulul 1, modificarea valorii acelor
variabile ntr-unul din module nu se reflect n
Fig.1.12.8.
cellalt modul.
Cu alte cuvinte, chiar dac cele dou variabile au aceeai denumire, n memoria
37
calculatorului ele sunt stocate la adrese diferite, fiind folosite n funcie de apartenana la
modulul n care sunt definite. Dimpotriv, o variabil global fiind stocat la o adres de
memorie unic va fi vzut la fel de ctre toate modulele.
Scopul principiului ncapsulrii datelor este pe de o parte de a nu fora programatorul s
fac un efort prea mare pentru a crea i manipula denumiri distincte de variabile, iar pe de alt
parte pentru a evita ca o modificare a unei valori a unei variabile dintr-un anumit modul s se
reflecte n mod nedorit ntr-un alt modul independent.
Declaraiile de vizibilitate (local sau global) permit programatorului s controleze cu
exactitate caracterul comun sau izolat al variabilelor folosite.
1.12.6. Metode de programare
Metoda de programare Top-Down (sau de rafinare n pai succesivi)
Aceast metod const n construirea programelor de sus n jos, adic pornind de la blocuri
mari ctre blocuri tot mai mici, pn la nivel de instruciuni simple.
La nceput programul este vzut ca un bloc care rezolv o problem (figura 15 a). Se
analizeaz problema i se descompune n blocuri succesive constituite din mulimi de
secvene (figura 112.9.b). Fiecare bloc sau secven este descompus n structuri coninnd
secvene din ce n ce mai mici care la rndul lor sunt exprimate prin structuri, i aa mai
departe, pn la nivelul simplelor instruciuni. Aceast metod permite programatorului s se
concentreze asupra aspectelor de fond ale problemei de programat, amnnd pentru mai trziu
rezolvarea problemelor de detaliu, legate de implementarea programului cu un limbaj
oarecare. De asemenea, pe msur ce are loc rafinarea problemei, se pot rezolva gradual
problemele de structurare a programului i de ncapsulare a datelor.
Aceasta este cea mai recomandat metod de programare, mai ales pentru programele care
se afl la prima elaborare cnd nu toate problemele sunt lmurite.
Program
Bloc 1
Bloc 2
Bloc n
Fig.1.12.9.
Metoda de programare Bottom-Up.
Aceast metod este contrariul celei de mai nainte. Ea presupune construcia programelor de
la baz la vrf, ncepnd cu elaborarea instruciune cu instruciune a fiecrui modul i apoi
interfaarea modulelor realizate, cu eventualele modificri necesare pentru succesul interfarii.
Metoda a fost folosit intens n epocile timpurii ale activitii de programare i i-a dovedit
din plin ineficiena prin complicaiile pe care le crea i prin marea risip de timp cauzat de
permanentele reconsiderri pe care le impunea practica i care conduceau la reluarea repetat
a procesului de la baz.
n prezent ea mai este folosit numai n msur limitat, pentru asamblarea unor module
existente i verificate, n programe cu problematic foarte clar.
.1.13. Programe i limbaje de programare

Prin program se nelege o colecie organizat de comenzi de operaii pe care calculatorul
trebuie s le efectueze pentru ndeplinirea unei anumite sarcini. Aceste comenzi poart
denumirea de instruciuni.
38
Orice instruciune a unui limbaj de programare oarecare este convertit n final n una sau
mai multe instruciuni elementare recunoscute de microprocesor, exprimate n cod binar i
transmise microprocesorului spre execuie.
Exprimarea n cod binar a comenzilor adresate microprocesorului poart denumirea de
limbaj main, i acesta este propriu fiecrui tip (generaie) de microprocesoare.
Cu excepia acestui limbaj, care este situat la nivelul cel mai de jos (cel mai apropiat de
microprocesor) exist i alte moduri de exprimare a comenzilor de execuie denumite limbaje
de programare.
Aceste limbaje reprezint construcii sintactice convenionale, care fac uz de mnemonice
scrise literal, mai inteligibile pentru programator.
Primul limbaj care a folosit tehnica mnemonicelor n locul codurilor binare a fost limbajul
de asamblare care reprezint o coresponden aproape direct n form literal a limbajului
main codificat binar. n acest limbaj fiecrei mnemonice literale i corespunde un cod binar
din limbajul main.
Au urmat o serie de alte limbaje n care o instruciune se traduce printr-un set de
instruciuni n limbajul main. Aceast tehnic a urmrit pe de o parte creterea
productivitii muncii de programare i, pe de alt parte, uurarea efortului de concepere i
manevrare a programelor.
Aceste limbaje sunt denumite limbaje de nivel nalt, de asemenea prin comparaie cu
limbajul de baz, acela al microprocesorului.
Exemple de astfel de limbaje sunt, n ordine cronologic: FORTRAN (RORmula
TRANslator - 1956), COBOL (COmmon Bussines Oriented Language - 1960), ALGOL
(ALGOrithmic Language 1960) din care a derivat limbajul PASCAL, BASIC (Beginer's All
purpose Symbolic Instruction Code- 1964), C (1971) din care deriv mai trziu limbajul JAVA.
Aceste limbaje sunt limbaje "procedurale" sau "algoritmice" deoarece ele descriu
algoritmul sau succesiunea rezolvrii unei probleme. La aceste limbaje ordinea de scriere a
instruciunilor determin strict ordinea n care ele vor fi executate.
Nevoia de flexibilitate a programrii n vederea rezolvrii problemelor lumii reale a condus
la cutarea de alternative la limbajele procedurale.
Astfel au aprut, ntr-o prim etap, limbajele neprocedurale n care ordinea scrierii
instruciunilor nu este n mod obligatoriu i ordinea lor de execuie. n aceste limbaje programatorul
precizeaz problema care trebuie rezolvat i mai puin modul sau algoritmul de rezolvare a ei. Un
exemplu de astfel de limbaj este limbajul LISP (LISt Processor) care are ca structur unic lista.
Lista poate fi att funcie (noiunea de instruciune sau subrutin nu exist n acest limbaj) ct i stoc
de date. Datorit acestei ambivalene a listei, limbajul posed capacitatea de a-i rescrie listele ca i
cum ar rescrie un stoc de date i prin aceasta el i poate rescrie funciile n chiar cursul execuiei.
Limbajul capt n acest fel posibiltatea de a se automodifica n execuie, posibilitate pe care
celelalte limbaje nu o au. Din acest motiv, acest limbaj este foarte mult folosit n problemele de
inteligen artificial care trebuie s aib puterea de autoadaptare la condiii de mediu variabile.
Totui, nici aceast tehnic de programare nu a dat n ntregime satisfacie, motiv pentru
care a aprut programarea orientat pe obiecte. Fr a face uz de limbaje speciale, aceast
tehnic folosete module de program care comunic ntre ele, conform schemelor prezentate
n capitolele anterioare.
1.13.1. Portabilitatea programelor
Portabilitatea este nsuirea unui program scris ntr-un anumit limbaj de a putea fi transpus
pe o alt main i de a putea fi rulat cu mai multe sau mai puine modificri. Se poate vorbi
despre:
39
- Portabilitatea programelor.
Fie cazul unui program pentru care exist un cod surs (succesiune de instruciuni scrise n
form text) asupra cruia nu se mai fac modificri. Acest program poate compilat pe un
anumit calculator obinndu-se codul executabil (succesiunea de coduri binare pentru
microprocesor) i poate apoi s fie rulat pe calculatoare din aceeai familie (construite cu
microprocesoare de acelai tip) fr a mai fi nevoie de nici o modificare a sursei sau
recompilare. Acesta este cazul calculatoarelor din familia PC-urilor pe platforma WINDOWS
sau DOS.
Dac ns se folosesc maini UNIX (calculatoare cu arhitecturi i procesoare diferite
construite pentru sistemul de operare UNIX) poate apare nevoia ca programul surs s fie cel
puin recompilat pentru maina respectiv dac nu chiar rescris, modificnd acele secvene
care apeleaz funcii efectuate n mod diferit n funcie de main.
- Portabilitatea limbajelor (sau portabilitatea programelor surs).
Deoarece microprocesoarele au n general diferene de la tip la tip i de la generaie la
generaie, cel mai neportabil limbaj este limbajul main. Dac se scrie un program ntr-un
astfel de limbaj (lucru foarte frecvent folosit la nivelul firmelor productoare de soft de baz)
el trebuie rescris i recompilat pentru fiecare tip de main n parte.
Pe msur ce se folosesc limbaje de nivel din ce n ce mai nalt portabilitatea acestora
crete, nemai fiind nevoie de rescrierea lor n funcie de main dac compilarea sursei se face
pe maina destinaie. Acest lucru se ntmpl datorit faptului c, compilatorul sau programul
de traducere n cod main, preia sarcina de a ine cont de maina pentru care face traducerea,
scutindu-l pe programator de acest efort.
Legat de problema portabilitii apare problema vitezei de execuie.
Deoarece programele n limbaj main se adreseaz direct microprocesorului, exprimarea
unei sarcini de efectuat printr-un set de instruciuni este cea mai scurt posibil i ca atare
viteza de execuie este cea mai mare posibil. La limbajele de nivel nalt acest mod de
exprimare este unul indirect, o instruciune dintr-un set apelnd nu direct o funcie a
microprocesurului ci un alt set de instruciuni. De aceea o portabilitate mare a unui limbaj se
realizeaz n dauna vitezei de execuie. Exist metode de a ocoli acest inconvenient, i ele
constau n includerea n limbaj a unor posibiliti de folosire direct a limbajului main n
cadrul limbajului de nivel nalt respectiv. Totui aceast rezolvare face programul respectiv
dependent de un anumit microprocesor (cel pentru care se folosesc respectivele instruciuni
main) ceea ce compromite de fapt portabilitatea mrit a limbajului de nivel nalt.
1.13.2. Fazele de elaborare a unui program executabil
Pentru elaborarea unui program trebuie parcurse urmtoarele faze:
A. Stabilirea problemei.
n aceast faz este definit problema de rezolvat, domeniile de definiie ale valorilor
datelor manipulate i metodele matematice i logice de tratare a problemei.
B. Stabilirea algoritmului de rezolvare a problemei
Algoritmul de rezolvare descrie succesiunea etapelor de rezolvare a problemei, nodurile
decizionale care pot interveni i deciziile care trebuie luate, modalitile de introducere a
datelor de intrare i de conservare a rezultatelor.
n fazele A i B nu este necesar cunoaterea unui limbaj de programare. Algoritmul poate
fi descris prin scheme logice sau prin pseudocod.
40
Primete b
De exemplu, operaia a=b/c se poate descrie:

a. Prin schem logic, figura 1.13.1;
b. Prin pseudocod:
Primete c
nceput
primete a;
primete b;
dac c 0
atunci { a = b/c; afieaz a;}
altfel afieaz "EROARE";
sfrit.
c0
Afieaz
EROARE
Calculeaz
a=b/c
Schema logic are avantajul c este mai uor de neles

"dintr-o privire" dar are dezavantajul de a necesita spaii
mari pe hrtie.
Pe de alt parte folosirea regulilor programrii
structurate a restrns drastic marea varietate de scheme
logice posibile nainte de introducerea susnumitelor reguli,
astfel nct ele nu mai sunt att de necesare ca n trecut.
STOP
Programatorii cu experien prefer folosirea
pseudocodului care este mai apropiat de modul n care va
Fig.1.13.1.
apare scris programul n final, cnd se va fi folosit un
limbaj de programare structurat.
Pentru exemplul de mai sus, transpunerea pseudocodului n limbaj C++ va apare astfel:
Afieaz
valoarea lui a
void main()
{float a, b, c;
cout << "b="; cin >> b;
cout << "\nc="; cin >> c;
if (c!=0)
{a=b/c; cout << "\na=" << a;}
else cout << "\nNu se poate imparti la 0";
}
C. Implementarea programului.
n aceast faz programatorul trebuie s opteze pentru limbajul care satisface cel mai bine
nevoile algoritmului. O dat opiunea fcut trebuie parcurse urmtoarele etape:
c1. Scrierea fiierului program surs, care conine instruciunile scrise n forma text.
c2. Generarea programului cod obiect executabil. n aceast etap la dispoziia
programatorului stau urmtoarele dou procedee de lucru:
Procedeul interpretor.
Prin procedeul interpretor se genereaz cod obiect executabil n cantitate limitat i anume,
numai pentru linia (sau instruciunea) de program curent. Simplificnd lucrurile, se citete
din fiierul surs cte o linie de program care este convertit n cod obiect executabil care se
ruleaz dac n urma conversiei nu au rezultat erori.
Schema de lucru n procedeul interpretor este cea din figura 1.13.2.
Conform figurii 1.13.2 fazele interpretrii unei linii:
- Analiza instruciunii din punct de vedere sintactic. n aceast faz se analizeaz
folosirea corect a sintaxei limbajului;
- Compilarea liniei. Aceast faz se concretizeaz prin convertirea instruciunii
respective n cod obiect executabil;
41
Execuia liniei, faz n care codul obiect executabil obinut este trimis ctre
microprocesor (via sistemul de operare) care l execut;
Salt la linia urmtoare, dac mai exist.
Fiier surs
Linia 1
Linia 2
eroare sintactic
Analiz
sintactic
Semnalare
eroare
erori de definire
Compilare
Linia i
STOP
erori de execuie
Execuie
Linia i+1
Salt la linia
urmtoare
Interpretare linie i
Linia n
Fig. 1.13.2.
Erorile care pot apare n decursul acestor faze sunt:
- Erori sintactice, cauzate de scrierea incorect a instruciunii sau a parametrilor ei (date
sau variabile);
- Erori de definire, cauzate de date sau variabile nedefinite sau folosire greit a tipurilor
variabilelor;
- Erori de execuie, cauzate de depirea capacitii de reprezentare a numerelor n
calculator n urma unor operaii aritmetice care au produs erori cumulate, folosirea de
operaii aritmetice nepermise (mprire la zero, radical sau logaritm din numr negativ,
etc).
n toate aceste cazuri eroarea este semnalat i programul este oprit.
n afar de aceste erori mai exist i erorile de logic. Pe acestea sistemul nu le semnaleaz
ele innd de concepia greit a programatorului. Consecinele acestor erori pot fi
imprevizibile, de la aparena bunei desfurri a execuiei dar cu rezultate eronate, i pn la
oprirea datorit unor erori de execuie sau, mai grav, blocarea sistemului de operare.
Avantajul programului interpretor este acela c erorile aprute ntr-o linie de program sunt depistate
imediat, ceea ce face depanarea programului mai uoar. n plus, programele scrise n limbaje
interpretoare pot fi rulate i pe pri (cu unele restricii), ceea ce, de asemenea, uureaz depanarea.
Un alt avantaj al unui program scris n limbaj de interpretare este acela de a permite
alocarea dinamic a memoriei, adic variabilitatea n cursul execuiei a zonei de memorie
alocat memorrii variabilelor. Acest lucru are un afect favorabil asupra economicitii
folosirii memoriei.
42
Dezavantajul major al procedeului rezult din analiza timpului de execuie consumat.

Timpul total de execuie al unei instruciuni se calculeaz cu relaia:
Timp de execuie total = Timp de analiz + Timp de compilare + Timp de execuie efectiv
Timpul de execuie efectiv este cu mult mai mic dect ceilali timpi. n plus, n cazul unor
blocuri de program ciclice, o instruciune care se repet este executat prin reparcurgerea
tuturor etapelor de mai sus cu toate c ea a mai fost analizat i compilat anterior.
Exemple de limbaje interpretoare sunt BASIC i LISP.
Procedeul compilator.
Acest procedeu separ complet faza de
Editare fiier surs
analiz sintactic i cea de compilare de faza de
execuie. Mai exact, programul surs este
Corectarea
analizat sintactic i compilat o singur dat iar
erorilor
Compilare program,
codul obiect executabil rezultat poate fi
testare,
executat ori de cte ori este nevoie.
depanare
Depanarea este ceva mai dificil, dar
execuia este mult mai rapid.
Fazele parcurse n cadrul acestui procedeu
Scriere fiier executabil
sunt cele ilustrate de figura 1.13.3.
Programul este scris cu ajutorul unui editor
de text "curat" adic unul care nu genereaz
caractere netipribile.
Executare program
Compilarea se face innd cont de aceleai
exigene ca i la interpretor dar se face global,
Fig. 1.13.3.
pentru toate instruciunile o dat.
Pot urma, dup caz, testarea i depanarea programului i, dac lucrurile au decurs bine, se
realizeaz generarea fiierului cod obiect executabil.
Atenie! Denumirea de cod obiect este una motenit prin tradiie nc de pe vremea cnd
tehnica programrii orientat pe obiecte nu apruse i, deci, nu are nici o legtur cu aceasta. Ea
este folosit pentru a diferenia codul binar rezultat dup compilare de cel textual sau surs.
O faz despre care, pentru a nu complica lucrurile, nu am vorbit pn acum, este faza de
editare a legturilor. Ea exist att n limbajele interpretoare ct i n cele complilatoare dar
este mai evident n acestea din urm unde trebuie realizat explicit sub controlul
programatorului, spre deosebire de limbajele interpretoare unde este realizat automat.
Programele mari sunt compuse din module de cod obiect realizate de programator sau
preluate din biblioteci de module existente.
n cadrul acestor module, adresele de memorie ale secvenelor de cod sunt fictive,
ncepnd ntotdeauna de la zero, deoarece nu se poate cunoate dinainte configuraia final a
programului n memorie. Acest tip de module sunt numite cod obiect relocabil (sau
repoziionabil). Faza de compilare este de fapt compus din dou faze:
- compilarea propriu-zis, care produce modulele de cod obiect relocabil;
- legarea modulelor sau faza de editare de legturi (linkeditare) n care sunt cutate n
biblioteci modulele referite modulele compilate, sunt calculate noile adrese de memorie
conform succesiunii modulelor, i sunt rescrise aceste adrese n toate modulele
concurente ale aceluiai program, rezultatul fiind codul obiect executabil.
n WINDOWS acest concept este generalizat, folosindu-se intens modulele de tip DLL
(dynamic link libraries biblioteci cu legare dinamic) editarea de legturi fcndu-se chiar n
timpul execuiei. Acest fapt poate produce o anume ncetinire a execuiei dar asigur
flexibilitatea i economicitatea folosirii memoriei ca i reducerea efortului programatorului.
43
Cap.2. Limbajul C
2.1. Caractere
Caracterele folosite la scrierea programelor n limbajul C alctuiesc mulimea de mai jos:
a. Litere mari:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
b. Litere mici:
abcdefghijklmnopqrstuvxyz
c. Caracterul de subliniere:
_
d. Caracterele numerice>
0123456789
Caracterele din categoriile a, b, c, d pot servi la scrierea constantelor, identificatorilor i a
cuvintelor cheie care vor fi descrise mai trziu. Literele mari i mici sunt interpretate distinct.
Astfel, Functie i functie sunt entiti C diferite.
c. Caractere cu destinaii diverse: ! % & | ( ) * + - , . / : ; < = > ? [ ] ^ { } ~ se folosesc
fie cu valoarea recunoscut de limbajul C n scrierea instruciunilor C, a operatorilor, etc, fie,
mpreun cu acelea din categoriile a, b, c, d, n componena irurilor de caractere.
f. Caractere netipribile (secvene ESC). Aceste secvene sunt combinaii speciale de
caractere care, incluse ntr-un ir de caractere delimitat de ghilemele ..., foreaz trimiterea
ctre dispozitivul de ieire de destinaie a unui caracter ASCII care nu are reprezentare grafic
sau care nu poate fi afiat pe ecran prin scrierea obinuit. Ele sunt urmtoarele:
\n pentru salt la linie nou (New Line);
\t pentru tabulare orizontal;
\v pentru tabulare vertical;
\b pentru backspace;
\r pentru revenire la nceput de linie (Carriage Return);
\f pentru avans la pagin nou (Form Feed);
\ pentru tiprirea semnului apostrof ;
\\ pentru tiprirea semnului backslash \ ;
\ddd pentru caracter ASCII n notaie octal, unde d simbolizeaz o cifr (digit);
\xdd pentru caracter ASCII n notaie hexazecimal;
De exemplu, \015 este caracterul ASCII cu codul zecimal 1X8+5=13, acelai cu \x00D,
adic CR (Carriage Return).
2.2. Atomi lexicali

Atomii lexicali sunt caractere simple sau grupate care, n cursul procesului de compilare,
capt o anumit semnificaie n funcie de sintaxa limbajului i de contextul lor de apariie.
2.2.1. Identificatori
Identificatorii sunt nume utilizabile pentru reprezentarea variabilelor, constantelor,
tipurilor, funciilor i etichetelor n cadrul programului. Aceste nume se creaz prin
specificarea lor n declaraii.
Identificatorul este o secven (grup) de caractere compus din litere, cifre i simbolul de
subliniere _.
Este obligatoriu ca identificatorul s nceap cu o liter sau cu caracterul _ dar, deoarece
prin convenie, identificatorii care ncep cu _ au, n general, semnificaii speciale (atribuite de
furnizorii de medii de programare a aplicaiilor n C), programatorii de C obinuii trebuie s
evite nceperea unui identificator cu caracterul _.
Reamintim c C face distincie ntre literele mari i cele mici. De exemplu punct3d i
punct3D sunt identificatori diferii.
2.2.2. Numere
Un numr este o secven de cifre i litere de forma p.pz ez, unde p este ntreag, pz este
Cap.2. Limbajul C
44
partea zecimal i ez este exponentul zecimal de forma Ep sau ep unde p este puterea lui 10,
cu semnul + sau -.
De exemplu: 1.23e+2 este echivalent cu 123.
Observaie: n limbajul C numrul nu are semn. Apariia semnului - n faa unui numr
este deja o aplicare a operatorului de negare aritmetic - aplicat numrului respectiv.
2.2.3. Constante
Constantele sunt de dou tipuri:
a. Constante caracter, de forma caracter. De exemplu A.
b. Constante ir, de forma ir_de_caractere. De exemplu Sir.
Observaie: n cuprinsul unei constante caracter ca i al unei constante ir, pot intra
secvene ESC. De exemplu: \t sau Rezultate:\n.
2.2.4. Delimitatori de comentariu
ncadrarea ntre perechile /* i */ a unui ir de caractere produce ignorarea acestuia de ctre
compilator. n C++ acelai efect se obine i pentru toate caracterele care urmeaz de la
perechea // pn la captul liniei.
2.2.5. Cuvinte cheie
Cuvintele cheie sunt identificatori predefinii care au neles special pentru compilatorul de
C. Aceste cuvinte nu pot fi redefinite iar utilizarea lor trebuie limitat la scopul predestinat.
Iat, mai jos, cteva exemple de cuvinte cheie mai des utilizate:
asm
auto
break
case
char
const
continue
default
do
double
else
extern
far
float
for
goto
huge
if
int
long
near
return
short
sizeof
static
struct
switch
typedef
union
unsigned
void
while
2.2.6. Operatori
Operatorii sunt combinaii de caractere speciale care specific modul de atribuire i de
transformare a valorilor (operanzilor). n funcie de numrul de operanzi asupra crora se
aplic, operatorii pot fi clasificai n operatori unari, binari, ternari i operatori de asignare
combinai.
2.2.6.1. Operatori unari
Un operator unar este aplicat asupra unui singur operand. Asociativitatea operatorilor,
adic ordinea de aplicare a operatorilor consecutivi, pentru aceast categorie, este de la
dreapta la stnga. Aceti operatori sunt:
a. Operatori de complementare:
- Negarea aritmetic (-). Acest operator, aplicabil asupra unui operand ntreg sau n
virgul mobil, produce valoarea negativ a operandului. De exemplu:
short a=122, b;
.....
b=-a;
.....
produce atribuirea valorii -122 lui b.
45
- Negare la nivel de bit (~). Acest operator, aplicabil numai valorilor ntregi, transform
biii 0 n 1 i invers. De exemplu:
unsigned short a=0x0023; /* a=00000000100011 */
.....
a=~a;
/* a=11111111011100 */
.....
produce rezultatul 0xFFDC atribuit lui a.

- Negarea logic (!). Acest operator, NOT logic, aplicat asupra unui opeand de tip ntreg,
virgul mobil sau pointer, produce valoarea zero dac operandul este adevrat (diferit de
zero) sau valoarea 1 dac operandul este fals (egal cu zero). Rezultatul este de tip ntreg. De
exemplu:
int a=2, b=3, maxab;
.....
if(!(a<b)) maxab=a; else maxab=b;
.....
n acest exemplu (a<b) este o expresie format cu operatorul relaional <. Ea are ca rezultat
logic 1 dac este adevrat i 0 dac este fals.
b. Operatori de indirectare i adres :
- Operatorul de indirectare (*). Acest operator este folosit la definirea de variabile
pointer prin prefixarea operandului. Pe aceast cale se realizeaz o accesare indirect, prin
intermediul pointerului. Rezultatul este valoarea ctre care puncteaz operandul iar tipul
rezultatului este tipul adresat de operand. De exemplu:
int * pv;
definete pv ca un pointer ctre o valoare de tip ntreg.

Importana acestui mod de adresare se va putea vedea de abia la definiia funciilor care
ntorc ca rezultat pointeri ctre structuri coninnd rezultate obinute n corpul funciilor.
- Operatorul de adresare (&). Acest operator este folosit pentru aflarea adresei
operandului. Aceast adres poate fi folosit pentru a fi atribuit unui pointer sau pentru a o
transmite unei funcii cu efect lateral asupra entitii creia i aparine adresa. De exemplu:
functie(a, &b);
este apelul unei funcii denumit functie care primete ca argumente valoarea a i adresa
lui b. n corpul funciei au loc procese care modific valoarea lui b (b poate fi i o structur).
La ieirea din funcie, orice evaluare a lui b va gsi noua sa valoare.
c. Operatorul de lungime sizeof:
Acest operator, aplicat asupra unui operand oarecare, determin dimensiunea de memorie
alocat operandului respectiv. Forma de aplicare a operatorului este: sizeof(operand), iar
rezultatul returnat este lungimea exprimat n octei necesar memorrii operandului.
Cu
ajutorul operatorului sizeof se poate asigura independena de calculator a lungimii datelor,
calculul acesteia cznd n sarcina compilatorului, ceea ce este deosebit de folositor n cadrul
operaiilor de alocare a memoriei.
2.2.6.2. Operatori binari
Operatorii binari sunt aplicabili asupra a doi operanzi. n acest caz, asociativitatea este de
la stnga la dreapta.
a. Operatori multiplicativi:
- nmulirea (*), specific nmulirea operanzilor. De exemplu:
float x=3.0, y;
int i=2;
.....
y=x*i;
Cap.2. Limbajul C
46
.....
va produce rezultatul n virgul mobil 6.0 atribuit lui y.

- nprirea (/), specific nprirea primului operand la al doilea. Dac ambii operanzi
sunt ntregi, rezultatul este rotunjit la valoarea ntreag cea mai apropiat de zero. De
exemplu:
float x;
int a=3, b=2;
.....
x=a/b;
.....
produce rezultatul ntreg 1 convertit n virgul mobil i atribuit lui x, deci x=1.0.
- Modulo (%), specific restul npririi primului operand la al doilea. De exemplu:
int a=8, b=3, r;
.....
r=a%b;
.....
produce rezultatul ntreg 2 atribuit lui r;

b. Operatori aditivi :
- Adunarea (+), specific adunarea primului operand cu al doilea, operanzii putnd fi de
tip ntreg sau n virgul mobil.
- Scderea (-), specific scderea celui de al doilea operand din primul, operanzii putnd
avea tip ntreg sau virgul mobil.
Att adunarea ct i scderea se pot aplica asupra unui prim operand de tip pointer i unui
al doilea operand de tip ntreg. Tehnica aplicat de compilator este asemntoare n ambele
cazuri i const din nmulirea valorii ntregi cu lungimea tipului ctre care puncteaz
pointerul, urmat de adunarea sau, dup caz, scderea rezultatului obinut din adresa
operandului de tip pointer. Rezultatul este de tip pointer i trebuie atribuit unei variabile
pointer de acelai tip.
De exemplu:
#include <conio.h>
#include <stdio.h>
void main()
{int i=3, j=2;
float a[5]={0,1,2,3,4}, *pa1, *pb1;
pa1=&a[4]-i;
pb1=&a[3]-j;
printf(*pa1=%f, *pb1=%f\n, *pa1, *pb1);
getch();
}
n ambele cazuri pa1 i pb1 reprezint adresa celui de al doilea element al tabloului a i ca
urmare programul va afia:
*pa1=1.000000, *pb1=1.000000
c. Operatori relaionali:
Aceti operatori testeaz valabilitatea relaiei dintre doi operanzi. Rezultatul produs este 1
dac relaia este adevrat, sau 0 dac relaia este fals. Tipurile operanzilor pot fi oricare
dintre tipurile ntreg, virgul mobil sau pointer. Rezultatul produs este de tip ntreg (int).
Comparaiile ntre operanzi de tip pointer ai aceluiai masiv (tablou) de date au sens
deoarece, n acest caz, se compar poziia relativ a adreselor de memorie care cresc n
ordinea de cretere a indicilor n tablou. Comparaia dintre o dat oarecare i una de tip
pointer, n general, poate s nu aib sens deoarece adresele de stocare ale datelor din masive
47
diferite sunt stabilite de ctre compilator dup o lege necontrolabil de ctre programator.
Exist urmtorii operatori relaionali:
< a a>b a strict mai mare dect b
<= a<=b a mai mic sau egal cu b
>= a>=b a mai mare sau egal cu b
== a==b a egal cu b
!= a!=b a diferit de b
d. Operatori de deplasare :
Aceti operatori sunt de dou tipuri:
- operatorul de deplasare la stnga <<, i
- operatorul de deplasare la dreapta >>.
Operaiile efectuabile cu aceti operatori au formele: x << n i x>>n. Att x ct i n sunt de
tip ntreg, iar n trebuie s fie pozitiv i mai mic n valoare sau egal cu numrul de bii pe care
este reprezentat x, altfel rezultatul este indefinit. Valoarea n reprezint numrul de deplasri
ale biilor lui x. Dup deplasarea biilor spre stnga sau spre dreapta, se face completarea cu
zero la dreapta, respectiv la stnga.
De exemplu:
#include <conio.h>
#include <stdio.h>
void main()
{unsigned x=65, y;
y=x<<1;
printf(x=%u, y=%u\n,x,y);
}
getch();
n acest program valoarea ntreag fr semn x=65, adic 01000001, este deplasat la
stnga cu o poziie obinndu-se ca rezultat valoarea 10000010, adic 130, atribuit lui y i, ca
urmare, programul va afia:
x=65, y=30
e. Operatori la nivel de bit:

- I la nivel de bit (&), produce ca rezultat 1 dac ambii bii sunt 1, i 0 n caz contrar;
- SAU INCLUSIV la nivel de bit (|), produce rezultatul 0 numai dac ambii bii sunt 0, i
1 n caz contrar;
- SAU EXCLUSIV la nivel de bit (^), produce rezultatul 1 dac numai unul dintre bii
este 1, i 0 n caz contrar;
Pentru toi aceti operatori, operanzii trebuie s fie de tip ntreg, chiar dac tipurile de
ntregi sunt diferite.
De exemplu:
#include <conio.h>
#include <stdio.h>
void main()
{unsigned x=1, y=2, z=3, x1, y1, z1;
x1=x&y; y1=x|y; z1=x^y;
printf(x&y=%u x|y=%u x^z=%u\n, x1, y1,z1);
}
getch();
Reprezentrile binare sunt: pentru x 00000001, pentru y 00000010 i pentru z 00000011.

Rezultatele sunt:
pentru x1=00000001 & 00000010 se obine 00000000, adic valoarea zecimal 0;
Cap.2. Limbajul C
48
pentru y1=00000001 | 00000010 se obine 00000011, adic valoarea zecimal 3;

pentru z1=00000001 ^ 00000011 se obine 00000010, adic valoarea zecimal 2,
i, ca urmare, programul va afia:
x&y=0 x|y=3 x^y=2
f. Operatori logici :
n cazul utilizrii operatorilor logici tipurile operanzilor pot fi ntregi, virgul mobil sau
pointer, i pot fi diferii ntre ei.
Evaluarea operanzilor are loc de la stnga la dreapta. Dac evaluarea primului operand este
suficient pentru a determina rezultatul, evaluarea celui de al doilea operand nu mai are loc.
Evaluarea operanzilor se face numai n sensul echivalrii cu zero. Rezultatul operaiei logice
este 0 sau 1.
- I logic (&&), produce ca rezultat valoarea 1 numai dac ambii operanzi sunt diferii de
0.
- SAU INCLUSIV logic (||), produce ca rezultat valoarea 1 dac cel puin unul dintre
operanzi este diferit de 0.
De exemplu:
#include <conio.h>
#include <stdio.h>
void main()
{float x1=1.5, x2=3, x;
printf(x=); scanf(%f, &f);
if(x>x1 && x<x2)
printf(x%f este interior domeniului x1=%f - x2=%f\n,x,x1,x2);
else
printf(x%f este exterior domeniului x1=%f - x2=%f\n,x,x1,x2);
getch();
}
Ca urmare a rulrii acestui program, se va afia cererea: x=

ntroducnd valoarea 1.6 programul va afia:
x=1.600000 este interior domeniului x1=1.500000 - x2=3.000000
g. Operatorul de evaluare secvenial (,) :

Acest operator se folosete atunci cnd sintaxa limbajului impune o singur expresie, dar nevoile
de programare cer evaluarea mai multor expresii. n acest caz, expresiile separate prin virgule sunt
evaluate de la stnga la dreapta, rezultatul final fiind cel provenit din evaluarea ultimei expresii.
Ca exemplu, s presupunem c o funcie admite numai doi parametri, avnd forma f(x,y),
dar x trebuie s fie obinut din nite operaii intermediare. Se poate scrie, de exemplu:
f((a++, x-=a), y)
ceea ce ntr-o scriere obinuit ar fi aprut ca trei instruciuni:

a=a+; x=x-a; f(x,y);
Observaie: A nu se confunda rolul virgulei ca separator al parametrilor funciei cu virgula

ca operator de secveniere a evalurii expresiilor din primul parametru (cel nchis ntre
paranteze) al funciei, rolurile lor fiind complet diferite n cele dou contexte. n cazul
expresiei secveniale (a++, x=-a) este evaluat mai nti incrementarea lui a, adic a++,
i abia apoi operaia x=x-a al crei rezultat este transmis funciei f ca prim parametru.
2.2.6.3. Operatorul ternar condiional
Numit, pe scurt, operator condiional, acesta are forma:
operand1 ? operand2 : operand3
49
Algoritmul de evaluare const, mai nti, din evaluarea lui operand1. Dac acesta este
adevrat (diferit de zero), rezultatul returnat este cel provenit din evaluarea lui operand2, iar
altfel este returnat rezultatul provenit din evaluarea lui operand3. De exemplu:
maxab = a>b ? a : b;
Operandul operand1 este, aici, expresia a>b. Dac aceasta este adevrat, valoarea lui a ca
operand2 va fi returnat ca rezultat i atribuit lui maxab, altfel lui maxab i se va atribui
valoarea lui b ca operand3.
2.2.6.4. Operatorul de atribuire simpl i compus
Operaia de atribuire simpl folosete operatorul = i are forma:
operand1=operand2
i const n atribuirea valorii lui operand2 lui operand1.

Pentru a reduce lungimea programelor surs, a fost introdus operaia de atribuire
compus, avnd forma general:
operand1 operator= operand2; ceea ce este echivalent cu:
operand1 = operand1 operator operand2;
Astfel, se pot forma combinaiile:
Operaie
a*=;
a/=b;
a%=b;
a+=b;
a-=b;
a<<=n;
Echivalent
a=a*b
a=a/b;
a=a%b;
a=a+b;
a=a-b;
a=a<<n;
Denumire i efect
multiplicare cu atribuire - multiplicare lui a cu b i atribuire lui a
nprire cu atribuire - nprirea lui a la b i atribuire lui a
rest cu atribuire - a modulo b cu atribuire lui a
adunare cu atribuire - a adunat cu b i atribuire lui a
scdere cu atribuire - b sczut din a i atribuire lui a
deplasare la stnga cu atribuire - deplasarea la stnga a lui a cu n bii i
atribuire lui a
a>>=n; a=a>>n; deplasare la dreapta cu atribuire - deplasarea la dreapta a lui a cu n bii
i atribuire lui a
a&=b;
a=a&b;
I la nivel de bii cu atribuire - a I b cu atribuire lui a
a|=b;
a=a|b;
SAU INCLUSIV la nivel de bii cu atribuire - a SAU INCLUSIV b cu
atribuire lui a
a^=b;
a=a^b;
SAU EXCLUSIV la nivel de bii cu atribuire - a SAU EXCLUSIV b
cu atribuire lui a
Tot cu scopul reducerii scrierii programelor surs au fost introdui i operatorii unari de
incrementare ++ i de decrementare --. Ei pot s apar n formele:
a. forma prefixat: operator operand, adic ++operand sau -operand, iar
rezultatul operaiei este operand + 1 sau operand - 1, identic cu starea operandului dup
operaie.
b. forma postfixat: operand operator, adic operand++ sau operand--, iar rezultatul
operaiei este n ambele cazuri operand, identic cu starea operandului nainte de operaie,
starea operandului dup operaie fiind, ca i mai nainte, operand +1 sau operand - 1.
De exemplu:
int x=2, y;
.....
y=++x;
.....
va avea ca rezultat y=x=3, deoarece x este mai nti incrementat i abia apoi rezultatul este
atribuit lui y, pe cnd:
y=x++
Cap.2. Limbajul C
50
va avea ca rezultat y=2 i x=3, deoarece rezultatul lui x++ este starea dinainte de
incrementare, adic valoarea 2 care este atribuit lui y, starea lui x dup incrementarea
postfixat fiind valoarea 3.
2.2.7. Precedena operatorilor
Precedena reprezint prioritatea la evaluare a unui operator. Aceasta este important
numai n prezena altui operator de preceden diferit. Expresiile formate cu operatori de
preceden mai nalt sunt evaluate primele.
n tabelul 2.1.1 operatorii sunt listai astfel: operatorii situai pe aceeai linie au aceeai
preeceden, iar pe vertical operatorii de la nceputul tabelului au precedena cea mai nalt,
cei de la sfrit avnd precedena cea mai sczut.
Dac la un nivel al unei expresii apar mai muli operatori cu preceden egal,
evaluarea se realizeaz, n funcie de asociativitatea operatorului (direcie de evaluare), de la
stnga la dreapta (S D) sau invers (D S), dup caz.
Tabelul 2.2.1.
Tip de operaie
Operator
Asociativitate
( ) [ ] -> .
expresie
(S D)
~
!
*
&(adresa)
++
unar
(D S)
multiplicativ
aditiv
deplasare
relaional (inegalitate)
relaional (egalitate)
I la nivel de bii
SAU EXCLUSIV la nivel de bii
SAU INCLUSIV la nivel de bii
I logic
SAU logic
condiie ternar
atribuire simpl i combinat
evaluare secvenial
* / %
+ << >>
< > <= >=
== !=
&
^
|
&&
||
? :
*= /= %= +=
,
-=
(S D)
(S D)
(S D)
(S D)
(S D)
(S D)
(S D)
(S D)
(S D)
(S D)
(D S)
(D S)
(S D)
Datorit nivelelor de preceden ale operatorilor, compilatorul tinde s evalueze operaiile

prin considerarea gruprilor ntre operatori i operanzi n raport cu aceste nivele. Pentru
nceptori, este indicat ca ei s se foloseasc de paranteze pentru a delimita gruprile dorite,
cu scopul de a evita erorile datorate scprilor din vedere ale nivelelor de preceden.
2.3. Tipuri de date standard

2.3.1. Tipuri de baz
Tipurile de baz admise de limbajul C sunt urmtoarele:
- Date de tip text, caractere simple sau iruri de caractere, tip desemnat prin cuvntul cheie char;
- Date de tip numeric ntreg, pentru care se folosesc cuvintele cheie int, short i long;
- Date de tip real (n virgul mobil), desemnate prin cuvintele cheie float, double i long
double;
- Date de tip enumerativ, desemnate prin cuvntul cheie enum;
- Pointeri, sau date care conin ca informaii adresa ctre locaiile de memorie care conin
51
data propriu-zis. Deoarece datele referite au propriul lor tip, pointerii sunt desemnai printr-o
prefixare cu caracterul * a notaiei entitii pointer, prefixul * i notaia pointerului urmnd
unui cuvnt cheie care desemneaz tipul, ca mai jos:
tip * nume_pointer
i se citete nume_pointer punctnd ctre tip;

- Tipul void care, dup caz, dac se refer la funcii are semnificaia de numic, iar dac se
refer la pointeri are semnificaia de orice.
2.3.2. Modificatori de tipuri
Modificatorul de tip este un element ataat tipurilor aritmetice ntregi, referindu-se la
reprezentarea cu sau fr semn.
Astfel, tipul signed (care, de altfel, este implicit) se refer la reprezentri cu semn, iar tipul
unsigned se refer la reprezentri fr semn (numere pozitive).
Pot fi folosite abreviaiile din tabelul 2.3.1.
Tabelul 2.3.1.
Tip
Abreviaie
signed char
char
signed int
signed, int
signed short int
signed short, short
signed long int
signed long, long
unsigned char
fr abreviaie
unsigned int
unsigned
unsigned short int
unsigned short
unsigned long int
unsigned long
2.3.3. Stocare n memorie i domenii de valori
n tabelul 2.3.2 sunt redate numerele de octei necesare stocrii n memorie i domeniile de
valori reprezentabile pentru tipurile de baz.
Tabelul 2.3.2
Tip
Stocare
Domeniu de valori
char
1
-128...127
int
2
-32768...32767
short
2
-32768...32767
long
4
-2147483648... 2147483647
unsigned char
1
0...255
unsigfned int
2
0...65535
unsigned short
2
0...65535
unsigned long
4
0...4294967295
float
4
3.4E-38...3.4E+38
double
8
1.7E-308...1.7E+308
long double
10
3.4E-4932...1.1E+4932
2.3.4. Tipul enumeraie
Tipul enumeraie este un tip ntreg special, care permite unei variabile enumerative s ia
valori ntr-0 mulime finit de numere ntregi numite constante enumerative. Pot exista
urmtoarele variante de definire:
enum nume_tip_enumerare {mulime_enumerativ}
Cap.2. Limbajul C
52
unde:
{mulime_enumerativ} este o list de forma:
{definire_constanta_enumerativ_0,..., definire_constant_enumerativ_0}
iar: definire_constant_enumerativ_i are forma:
constant_enumerativ_i [=valoare_atribuit_explicit]
Astfel, se poate defini:
enum meniu {aperitiv, supa, pilaf, placinta};
caz n care valorile atribuite de ctre compilator sunt: aperitiv=0, supa=1, pilaf=2,
placinta=3.
Dac se dorete s se exclud aperitiv din meniu, dar s se pstreze aceleai numere,
trebuie s se defineasc:
enum meniu {supa=1, pilaf, placinta};
Observaie: valorile constantelor enumerative nu mai pot fi schimbate.

O dat tipul definit, se pot defini variabilele enumerative n maniera:
enum nume_tip_enumerare variabil_enumerativ
ca de exemplu:
enum meniu fel_de_mancare
Aceast definiie stabilete numai faptul c fel_de_mancare este de tipul meniu, adic
poate lua ca valori numai valorile definite n mulimea enumerativ.
Ulterior se poate scrie:
fel_de_mancare=pilaf;
ceea ce va produce atribuirea valorii ntregi 2 variabilei fel_de_mancare.

2.3.5. Tipul structur
Structura definete un stoc de date care pot fi de diferite tipuri. Sintaxa definiiei
structurii folosete cuvntul cheie struct i poate avea una dintre formele:
struct nume_tip_structura {lista_membri_structura} [structura_1,...,structura_k];
struct nume_tip_structura structura_1 [,...,structura_k];
struct {lista_membri_structura} structura_1 [,...,structura_k];
n lista membrilor structurii nu pot intra constante cu atribuire iniial, dar membrii
structurii pot fi de orice tip, inclusiv structuri. Astfel, se poate defini, de exemplu:
struct punct2D {float x,y;} punctA;
struct triunghi {punct2D a,b,c} ABC;
struct cerc {punct2D centru; float raza} cerc_1;
Referirea unui membru al structurii se face prin notaia structura.membru, ca de

exemplu:
punctA.x=2.5;
punctA.y=3.0;
cerc_1.centru=punctA;
cerc_1.raza=5;
Dei membrii structurilor nu pot fi iniializai, structurile pot fi iniializate dup ce au fost
definite ca tip.
Astfel, se poate scrie, de exemplu:
struct punct2D r{0,0}, s{2,0}, t{0,2};
struct triunghi {r,s,t};
Dac referirea structurii se face indirect, ca pointer, notaia (*structura).membru se

poate scrie prescurtat pstructura->membru, unde pstructura este un pointer de tip structur
ctre un tip.
De exemplu:
53
#include <conio.h>
#include <stdio.h>
struct punct2D {float x,y;};
void oglinda_oy(punct2D *pct) {pct->x=-pct->x;}
void main()
{struct punct2D A={5,3};
printf(Punctul original A are x=%f si y=%f\n, A.x, A.y);
oglinda_oy(&A);
printf(Punctul oglindit A are x=%f si y=%f\n, A.x, A.y);
getch();
}
Ca urmare a rulrii programul afieaz:

Punctul original A are x=5.000000 si y=3.000000
Punctul oglindit A are x=5.000000 si y=3.000000
Modul de folosire a adresrii indirecte se observ din definiia funciei oglinda_oy.

2.3.6. Tipul uniune
Cuvntul cheie care desemneaz acest tip este union.
Din punct de vedere formal tipul uniune apare scris la fel ca tipul structur. Deosebirea este
c, n timp ce tipul structur aloc spaiul de memorie pentru fiecare membru al structurii,
tipul uniune aloc un singur spaiu de memorie avnd lungimea egal cu lungimea celui mai
lung tip de membru al uniunii. Astfel, tipul:
union orice_tip (char c; int i; float f; double d;) tip_data
va permite salvarea n variabila tip_data a unei informaii de oricare tip dintre cele
patru tipuri membre ale uniunii orice_tip.
Referirea unui membru al uniunii se face, ca i n cazul structurilor prin operatorul punct
(.) sub forma uniune. membru
Orice dat este stocat n variabila uniune ncepnd de la prima locaie de memorie
rezervat uniunii i este returnat conform tipului referit. Astfel, n exemplul urmtor:
#include <conio.h>
#include <stdio.h>
union tip_dublu {int i; float f;} ddata;
void main()
{ddata.f=1234.56e+5;
printf(ddata.f=%f\n, ddata.f);
printf(ddata.i=%f\n, ddata.i);
getch()
}
rezultatul rulrii va fi afiarea:

ddata.f=123456000.000000
ddata.i=31040
ceea ce este corect pentru tipul float dar este greit pentru tipul int. Aceasta se datoreaz
faptului c citirea din memorie are loc numai pentru a parte a octeilor stocai n uniune,
conform tipului ntreg.
Aceasta este o posibil surs de erori i nu poate fi evitat dect prin grija strict a
programatorului de a ine cont de ultimul tip stocat n uniune.
2.3.7. Date nemodificabile. Declaraia const
Pentru a preveni modificarea din greeala programatorului a valorilor anumitor date care
trebuie s fie nemodificabile, se folosete declaraia const, n forma:
Cap.2. Limbajul C
54
const tip_de_dat iniializare_dat

De exemplu:
const float pi=3.141593;
are ca efect imposibilitatea de a mai schimba valoarea variabilei pi. n acest caz atribuirea:
pi=2.5;
va produce la compilare un mesaj de eroare care, n funcie de compilatorul folosit, ar putea fi

de forma:
Error...: Cannot modify a const object
Observaie: acelai efect l are i directiva preprocesor #define, dar mesajul de eroare este
diferit.
2.3.8. Declaraia typedef
Aceast declaraie are forma:
typedef tip declaraie
i are rolul de a crea denumiri sinonime pentru tipuri.
De exemplu:
typedef int intreg;
/* creaza un sinonim pentru tipul int */
typedef struct punct3D {float x,y,z} p3D;
/* face ca punct3D si p3D
sa fie utilizate cu acelasi rol */
2.4. Conversii de tipuri de date

2.4.1. Conversia automat de tip
Acest mod de conversie este realizat automat de ctre compilator la generarea codului
executabil, ori de cte ori ntr-o operaie apar tipuri de date diferite. De exemplu, pentru a
face operaia:
rezultat_tip=valoare_int_1*valoare_float_2;
compilatorul constat c n partea dreapt tipul cel mai lung este float i face o copie a lui
valoare_int_1 ntr-o zon temporar de memorie de lungime sizeof(float), convertind acolo
valoarea de tip int la valoare de tip float.
Apoi execut operaia i, la pasul urmtor, determin lungimea rezultatului operaiei, adic
sizeof(float) i lungimea variabilei rezultat_tip, convertind valoarea rezultatului operaiei la
tipul variabilei rezultat_tip.
Dac lungimea lui rezultat_tip este cel puin egal cu lungimea rezultatului operaiei,
conversia se face fr erori.
Exist o ierarhie a conversiei de la cea mai nalt la cea mai sczut, n ordinea:
double float long int short
Dac conversia se face de la un nivel inferior la unul superior ea rezult corect. Dac
conversia se face de la un nivel superior la unul inferior, ea poate rezulta eronat dac
mrimea numrului rezultat depete capacitatea de reprezentare a tipului destinaie.
n exemplul anterior, dac rezultat_tip este de tip int iar rezultatul operaiei este mai mic
dect 32767, numrul va fi convertit corect, altfel va fi convertit eronat.
2.4.2. Conversia explicit de tip. Operatorul cast
Fie urmtoarea secven de instruciuni:
val_float_1=3.0;
val_int_2=4;
val_int_3=5;
rezultat_float=val_float_1+val_int_2/val_int_3;
Operaia val_int_2/val_int_3, avnd doi operanzi de acelai tip (ntreg), va avea rezultatul de
tip int i acesta, prin rotunjire, va fi egal cu zero. Ca urmare rezultat_float va cpta valoarea 3.0.
55
Dac cel puin unul dintre operanzii val_int_2 i val_int_3 ar fi fost de tip float, nprirea
lor ar fi fost convertibil la tipul float (cel mai lung dintre tipurile float i int) i ar fi rezultat
0.8, iar rezultatul final ar fi fost cel corect, adic 3.8.
Deci, cnd din diferite motive legate de scrierea programului, nu este posibil schimbarea
tipului iniial al datelor, se poate face uz de conversia explicit de tip folosind operatorul
cast. Acesta are forma:
(tip)
i prefixeaz variabila a crei conversie trebuie realizat.
n consecin, pentru operaia descris mai sus, se poate scrie una dintre variantele:
rezultat_float=val_float_1+(float)val_int_2/val_int_3;
rezultat_float=val_float_1+val_int_2/(float)val_int_3;
rezultat_float=val_float_1+(float)val_int_2/(float)val_int_3;
ceea ce asigur, cel puin pentru unul dintre operanzii val_int_2 i val_int_3 (sau, respectiv,
pentru ambii) conversia n timpul operaiei la tipul specificat de operatorul cast i, n
consecin, producerea unui rezultat corect.
2.5. Instruciuni
Execuia unui program scris n limbajul C este controlat prin instruciuni.
Instruciunile pot fi: instruciuni simple, care vor fi trecute n revist n acest capitol, sau
instruciuni compuse, formate din alte instruciuni.
Instruciunile simple se termin cu caracterul ; iar instruciunile compuse sunt
cuprinse ntre acolade {} i se mai numesc i blocuri.
Pot fi folosite i instruciuni vide care apar sub forma caracterului ;.
Orice instruciune poate fi precedat de o etichet format dintr-un nume urmat de
caracterul :, sub forma:
nume_eticheta:
Eticheta nu este util dect n cazul folosirii instruciunii goto sau switch.
2.5.1. Instruciunea expresie
O expresie apare sub forma general:
expresie;
Ca exemple de expresii se pot cita:
- expresii de atribuire. De exemplu:
x=a+b;
unde variabilei x i se atribuie suma variabilelor a i b.

- expresii cu efect lateral. De exemplu:
i++
unde i capt valoarea i+1, sau

f(x)
unde este apelat funcia f cu parametrul x. Aici se pot distinge cazurile:

a. O variabil global i modific valoarea n corpul funciei f i, n consecin, dup
apelul funciei f, programul va vedea aceast valoare modificat. Acelai lucru se ntmpl
i dac x nu este variabil global dar este o adres de variabil, ca n cazul apelului funciei
f(&x);. Acesta este cazul funciilor cu efect lateral;
b. funcia f execut o anumit aciune (de exemplu, tiprete pe ecran sau la imprimant
valoarea lui x) fr s aib un alt efect;
c. funcia f returneaz un rezultat. Cum ns nu exist nici o atribuire de forma y= f(x);
rezultatul se pierde i, n acest caz, nu exist nici un efect.
56
Cap.2. Limbajul C
2.5.2. Instruciunea de decizie

Forma general a instruciunii de decizie este:
if (condiie) instruciune_1 [else instruciune_2]
Instruciunile condiionate instruciune_1 i instruciune_2 pot fi instruciuni simple sau
compuse (blocuri), caz n care ele trebuie s fie ncadrate de acolade. Alternativa else poate lipsi.
Aciunea instruciunii if este de a evalua mai nti instruciunea condiie i, dac aceasta
este adevrat (diferit de zero), de a executa instruciune_1 sau, n caz contrar, de a executa
instruciune_2. De exemplu:
if(a<=0) absa=-a; else absa=a;
Instruciunile if-else pot fi ncuibate una n alta. n acest caz alternativa else se refer la
ultima condiionare if care nu are alternativ else. De exemplu:
if(a<b)
/* primul if
*/
if(c<a) minabc=c;
/* al doilea if
else minabc=a;
/* primul else
else
/* al doilea else
if(c<b) minabc=c; /* al treilea if
*/
else minabc=b; /* al treilea else */
*/
*/
*/
Se observ din acest exemplu c al doilea else se refer la primuil if, iar al treilea else se
refer la al treilea if.
Pentru ncuibri mai complicate este indicat s se foloseasc acoladele pentru delimitarea
blocurilor dorite fr echivoc, pentru a evita erorile de scriere a schemelor decizionale.
2.5.3. Instruciunea de selecie
Instruciunea de selecie are forma genaral:
switch (expresie_selectoare)
{case i1: secventa_i1 [break;]
.....
case in: secventa_in [break;]
[default: secventa_d]
}
unde: expresie_selectoare trebuie s produc un rezultat de tip ntreg;
etichetele i1,...,in trebuie s fie constante sau expresii cu valoare constant de tip
ntreg i trebuie s aib valori distincte;
secvenele pot fi secvene de instruciuni sau pot fi vide;
eticheta default: i secventa_d asociat ei sunt opionale.
Aciunea de execuie selectiv se desfoar astfel:
1. Se evalueaz expresie_selectoare;
2. Se caut aceea dintre expresiile i1,...,in care are valoarea egal cu rezultatul evalurii lui
expresie_selectoare. Dac o astfel de expresie este ntlnit, se vor executa toate secvenele de
instruciuni din corpul instruciunii switch pn la eticheta default sau pn la primul break ntlnit.
Dac nici una dintre expresiile i1,...,in nu are valoare egal cu rezultatul dat de
expresie_selectoare, este executat secvena de instruciuni asociat etichetei default, dac
aceasta exist.
ntlnirea unei instruciuni break transfer controlul execuiei la prima instruciune care
urmeaz instruciunii switch.
De exemplu:
switch(i)
{case 1:
case 2:
57
case 3: y=1; break;

case 4: y=2; break;
default: y=0;
}
rezultatul produs fiind y=1 pentru i=1, 2 sau 3, y=2 pentru i=4, i y=0 pentru oricare alt
valoare a lui i. Sau:
switch (i)
{case 1: y++;
case 2: y++;
case 3: y++;
}
n acest caz rezultatele sunt: pentru i=1 se obine y=y+3, pentru i=2 se obine y=y+2, iar
pentru i=3 se obine y=y+1. Pentru oricare alt valoare a lui i, y rmne neschimbat.
2.5.4. Instruciunea de ciclare for
Forma general a instruciunii for este:
for([iniializare];[condiie];[actualizare]) instruciune;
i are ca efect urmtoarele aciuni:
a. se execut instruciunea iniializare;
b. se testeaz expresia condiie. Dac aceasta este adevrat, se execut instruciune;
c. se execut instruciunea actualizare.
n continuare se reiau numai paii b i c att timp ct condiie este adevrat.
De exemplu:
#include <conio.h>
#include <stdio.h>
void main()
{int i,a;
for(a=1,i=1; i<=5; i++) a*=i;
printf(a=%i\n,a);
getch();
}
va afia rezultatul a=120

Dac bucla for trebuie aplicat, nu asupra unei instruciuni ci asupra unui bloc de
instruciuni, forma general va fi:
for([iniializare];[condiie];[actualizare]) {bloc}
n orice punct din interiorul blocului execuia poate fi ntrerupt printr-un break. Astfel,
pentru exemplul de mai sus, se poate scrie varianta:
#include <conio.h>
#include <stdio.h>
void main()
{int i,a=1;
for(i=1;; i++) {a*=i; if(i>=5) break;}
printf(a=%i\n,a);
getch();
}
care va afia acelai rezultat.

2.5.5. Instruciunea de ciclare cu test iniial, while
Aceast instruciune are forma general:
while(condiie) instruciune;
Cap.2. Limbajul C
58
respectiv, dac se aplic asupra unui bloc de instruciuni:

while(condiie) {bloc}
i are ca efect executarea instruciunii sau a blocului, att timp ct expresia de test condiie
este adevrat.
De exemplu, secvena:
sum=0; i=1;
while(i<=3) sum+=a;
va produce rezultatul sum=3a.

Ca i la instruciunea for, i la instruciunea while se poate fora ieirea din bloc printr-un
break.
2.5.6. Instruciunea de ciclare cu test final, do-while
Aceast instruciune are forma general:
do instruciune; while(condiie);
respectiv, dac se aplic asupra unui bloc de instruciuni:
do {bloc} while(condiie);
i are acelai efect ca i instruciunea while cu test iniial, dar testul condiiei are loc abia la
sfritul ciclului.
Aadar, pe cnd ciclul while poate s nu execute de loc instruciune sau bloc dac
condiie este fals de la nceput, ciclul do-while efctueaz execuia cel puin o dat.
2.5.7. Instruciunea continue
Aceast instruciune are sintaxa:
continue;
i se folosete n blocurile instruciunilor for, while i do-while, pentru a produce saltul
forat la ciclul urmtor, prin ignorarea instruciunilor care apar dup poziia n care este
amplasat.
De exemplu:
#include <conio.h>
#include <stdio.h>
void main()
{float x=-2,y=1,z;
while(++x<2)
{if(x==0) continue;
z=y/x;
printf(z=%f\n,z);
}
getch();
}
are ca efect evitarea executrii mpririi lui y prin x=0. Ca rezultat al rulrii programul va
afia:
z=-1.000000
z=1.000000
ceea ce arat c, din ciclul while, au fost executate numai operaiile corespunztoare valorilor
x=-1 i x=1.
2.5.8. Instruciunea de salt, goto
Aceast instruciune are sintaxa:
goto etichet;
i are ca efect transferul execuiei la instruciunea precedat de etichet.
59
Instruciunea goto i eticheta referit pot fi amplasate numai n interiorul aceleiai

funcii.
Meninerea acestei instruciuni are valoare istoric. Utilizarea ei este contrar regulilor
de programare structurat i este contraindicat.
Totui, ea poate fi folosit ca ieire de urgen, definitiv, la detectarea unor cazuri de
imposibilitate de continuare a algoritmului.
2.6. Tablouri
Tablourile sunt masive de date de acelai tip, memorate ca variabile indexate.
Ca orice variabile, i variabilele tablou sunt referite prin nume, iar o variabil anume din
tablou este identificat prin indicele ei, baza de indexare pornind de la indicele zero considerat
ca identificnd primul element al tabloului.
Astfel, declaraia:
tip nume[numr_total]
definete o variabil tablou denumit nume, avnd numr_total de elemente de acelai tip
i care ocup un numr de locaii de memorie egal cu numr_total*sizeof(tip).
Referirea unui element al tabloului se face sub forma:
nume[indice]
De exemplu:
int a[5];
definete un vector (tablou cu o dimensiune) coninnd 5 elemente de tip int, iar prin
a[2]este referit al treilea element al vectorului.
Abstracie fcnd de faptul c toate elementele tabloului sunt de acelai tip, tipul n sine
poate fi oricare (afar de tipul void), inclusiv structuri.
Tablourile pot fi multidimensionale, n acest caz sintaxa de definire fiind:
tip nume[numr_1][numr_2]...
De exemplu:
float b[3][4];
este un tablou de elemente de tip float, cu dou dimensiuni avnd 3 rnduri i 4 coloane.
Iniializarea unui tablou se poate face n dou moduri:
a. implicit, prin scrierea valorii zero de ctre compilator n toate elementele tabloului.
Astfel, definiia:
float c[3];
produce umplerea cu valoarea 0 a tuturor elementelor tabloului c;

b. explicit, prin definirea ntre acolade a valorilor tabloului, sub forma:
tip nume[n]={valoare_1, valoare_2,...,valoare_n};
De exemplu:
float c[3]={1.0, 1.5, 2.0};
atribuie fiecrui element al tabloului c valorile dintre acolade, n ordine, de la stnga la

dreapta, astfel:
c[0]=1.0, c[1]=1.5, c[2]=2.0
Puin altfel stau lucrurile n cazul tablourilor de tip ir de caractere. Astfel, se poate defini:
char mesaj[20]=Apasa orice tasta\n;
situaie n care compilatorul completeaz elementele tabloului cu caracterele menionate

ntre ghilimele, cu condiia ca irul s nu depeasc numrul de elemente prescris, n cazul de
fa 20.
Metoda este destul de greoaie deoarece oblig programatorul la numrarea caracterelor irului.
Mult mai simplu este s se fac uz de iniializarea cu lungime neprecizat, sub forma:
char mesaj[]=Apasa orice tasta\n;
60
Cap.2. Limbajul C
i, n acest caz, compilatorul face el oficiul de numrare a caracterelor i aloc tabloului

mesaj spaiul necesar.
Atribuirea unei valori pentru un element individual al unui tablou se poate face:
b[2]=3.0;
- pentru elemente numerice, de exemplu:
- pentru elemente ale unui ir de caractere, de exemplu: mesaj[12]=p;
Se poate reine de aici c numai irurile de caractere se definesc prin ncadrare ntre
ghilimele: ...,caracterele individuale fiind definite prin ncadrare ntre apostrofuri: X.
Din acest motiv, tablourile de caractere pot fi definite i n forma din exemplul urmtor:
char nume[5]={G,i,g,i,\0};
mod de definire care este identic cu cel numeric i care, de fapt, este chiar o definire
numeric deoarece fiecare caracter este reprezentat (substituit) prin codul su numeric ntreg
n conformitate cu standardul ASCII.
n sfrit, pentru definirea tablourilor multidimensionale se folosete ncadrarea ntre
acolade incuibate.
De exemplu:
int a[2][3]={{1,2,3},{6,2,5}};
tehnica fiind valabil i pentru tablourile ir de caractere.
2.7. Adrese i pointeri

2.7.1. Definiia pointerilor
n memoria calculatorului, orice entitate are coninutul
stocat la o anumit adres de memorie. Situaia se prezint
ca n figura alturat.
Fig.2.7.1.
n limbajul C, pentru a obine adresa_entitate se
prefixeaz continut_entitate cu operatorul &.
O variabil prin care se manipuleaz o adres a unei entiti se numete variabil pointer.
Denumirea provine de la a puncta ctre i, aa cum o arat i figura de mai sus, este vorba de
o adres care puncteaz ctre o entitate sau, altfel spus, o entitate care este punctat de ctre o
adres. Deoarece entitatea trebuie s aib un tip, acesta trebuie declarat conform sintaxei:
tip * adresa_entitate;
n lumina celor enunate mai sus, a scrie:
int continut_entitate;
int *adresa_entitate;
continut_entitate=175;
adresa_entitate=&continut_entitate;
*adresa_entitate=175;
nseamn a declara continut_entitate de tip ntreg i adresa_entitate ca o adres care

puncteaz ctre o variabil de tip ntreg. Urmeaz apoi atribuirea direct a valorii 175
variabilei continut_entitate. Ultimele dou instruciuni realizeaz indirect ceea ce realiza
instruciunea de atribuire direct i anume: se atribuie variabilei de tip pointer ctre entitatea
de tip ntreg, adresa la la care se gsete continut_entitate i apoi se atribuie valoarea 175
entitii de tip ntreg ctre care puncteaz adresa_entitate.
Avantajul folosirii pointerilor const n aceea c, prin acest procedeu, compilatorul
cunoate i tipul ctre care puncteaz adresa, adic numrul de octei n care este stocat
entitatea, ceea ce degreveaz programatorul de o foarte complet gestiune a spaiului de
memorie i face programele surs independente de tipul de calculator sau de tipul de
implementare a limbajului C, adic asigur portabilitatea programelor surs.
Din exemplul anterior trebuie reinut c adresa_entitate trebuie obligatoriu s puncteze
ctre tipul prin care este declarat continut_entitate. Din acest motiv, secvena de mai jos:
61
float valoare_reala=15.73;
int * pointer_catre_intreg;
pointer_catre_intreg=&valoare_reala;
este ilegal deoarece se ncearc atribuirea unei adrese de tip float unui pointer ctre o valoare
ntreag.
2.7.2. Utilizarea variabilelor pointer
Printr-o variabil pointer se pot prelua i transmite date. De exemplu:
adresa_entitate=&valoare_1;
va conine adresa variabilei valoare_1, apoi prin:

temporar= *adresa_entitate;
variabilei temporar i se transmite valoarea variabilei valoare_1. n continuare, prin:

*adresa_entitate=valoare_2;
variabila valoare_1, a crei adres este coninut de adresa_entitate, capt valoarea

variabilei valoare_2.
n fine, prin:
valoare_2= temporar;
variabila valoare_2 capt coninutul variabilei temporar, adic coninutul iniial al

variabilei valoare_1.
n acest mod, valoare_1 i valoare_2 au schimbat reciproc valorile lor iniiale.
2.7.3. Iniializarea variabilelor pointer
La o declaraie de tipul:
tip * adresa_entitate;
variabila pointer adresa_entitate nu conine o adres ctre o entitate anume, ci doar este
fcut o ntiinare a compilatorului asupra tipului de entitate ctre care se poate puncta.
O iniializare cu o adres a unei entiti anume se poate face prin secvena:
tip entitate;
tip * adresa_entitate=&entitate;
De exemplu:
#include <conio.h>
#include <stdio.h>
void main()
{char j=W,k;
char *pj=&j;
k=*pj;
printf(k=%c\n,k);
getch();
}
Prin acest program a fost fcut o atribuire indirect a valorii de tip caracter de la variabila
j la variabila k prin mecanismul de iniializare a pointerului pj cu adresa lui j i apoi de
atribuire a acesteia lui k.
2.7.4. Relaia dintre pointeri i tablouri
Numele unui tablou este o constant a crei valoare reprezint adresa primului element al
tabloului. Din acest motiv, notaiile tablou i &tablou[0] sunt echivalente. Atunci, conform
celor spuse la definirea pointerilor, accesul la primul element al tabloului se poate face fie
prin *tablou fie prin tablou[0].
De la aceast regul fac excepie pointerii ctre tipul void i pointerii ctre funcii.
Cap.2. Limbajul C
62
Ca exemplu, fie secvena:

int a[10], *ap;
Instruciunea urmtoare atribuie adresa primului element al tabloului a variabilei pointer ap:
ap=a;
ceea ce este echivalent cu instruciunea:

ap=&a[0];
n schimb, atribuirile inverse:

a=ap;
i
&a[0]=ap;
sunt ilegale deoarece o adres este o constant nemodificabil, creia nu i se poate atribui o
alt valoare.
2.7.5. Pointeri ctre pointeri
Limbajul C poate defini variabile pointer care puncteaz ctre alte variabile pointer. n
acest caz prefixarea se face cu dou asteriscuri: **. Generaliznd, numrul de asteriscuri
determin nivelul de indirectare al variabilei pointer.
De exemplu, declaraiile i atribuirile:
int data_intreaga=3;
int *pint_1, **pint_2;
pint_1=&data_intreaga;
pint_2=&pint_1;
reflect situaia din figura 2.7.2:
Fig.2.7.2.
Desigur, adresele 1293 i 3174 din figur sunt fictive, ele depinznd de aciunea compilatorului,
i sunt date pentru a urmri corespondena dintre adresa i coninutul variabilei pointer.
2.7.6. Aritmetica pointerilor
Limbajul C permite efectuarea numai a dou operaii asupra adreselor reflectate de
pointeri, i anume adunarea i scderea, conform regulilor urmtoare:
a. adunarea unui pointer cu un ntreg i echivaleaz cu a aduna valoarea adresei stocate
de pointer cu valoarea i*sizeof(tip_pointer), unde tip_pointer este tipul ctre care puncteaz
pointerul. De exemplu, secvena:
float tabel[3]={1.1,2.2,3.3};
float *p_tabel=tabel
/* adresa primului element din tabel */
float valoare;
valoare=*(p_tabel+1);
va avea ca urmare preluarea de ctre variabila valoare a celui de al doilea element al

tabloului, adic 2.2;
b. scderea unui ntreg i dintr-un pointer se interpreteaz la fel cu adunarea deoarece, n
acest caz, pointer-i este echivalent cu pointer+(-i). De exemplu, scriind:
p_tabel=&tabel[2]; /* adresa ultimului element din tabel */
valoare=*(p_tabel-2);
se va atribui variabilei valoare coninutul primului element din tabel. Adic valoarea 1.1.
63
Operaiile de incrementare ++ i decrementare pot fi, de asemenea, aplicate pointerilor.

Cele expuse pentru tablouri sunt valabile i pentru iruri deoarece acestea sunt de fapt
tablouri de caractere. De exemplu, secvena:
char sir[]=Cititor, caracter;
char *adresa_caracter=&sir[0]
/* sau, echivalent, =sir */
for(i=1;i<6;i++) adresa_caracter++;
caracter=*adresa_caracter;
va transfera n variabila caracter valoarea celui de al 6-lea element al irului "Cititor", deci
caracterul o.
2.8. Funcii
Spre deosebire de alte limbaje, limbajul C recunoate ca module componente ale unui
program numai funciile i ele nu pot fi definite n interiorul altei funcii.
2.8.1. Prototipul unei funcii
Prototipul unei funcii este o simpl declaraie, plasat n zona de nceput a programului,
declaraie care are rolul de a ntiina compilatorul asupra numrului i tipurilor de argumente
primite de funcie, precum i asupra tipului de rezultat returnat de ctre funcie.
Forma general a prototipului unei funcii este urmtoarea:
[clasa_de_memorare] tip_rezultat nume_functie([lista_tipuri_argumente]);
unde:
clasa_de_memorare poate fi de tipul static sau extern. Atributul static face ca funcia
respectiv s nu fie vizibil pentru programe definite n alte fiiere. Atributul extern este
opional i implicit i face funcia respectiv vizibil i dintr-un alt fiier surs;
tip_rezultat specific tipul rezultatului returnat de funcie. Din acest punct de vedere
trebuie s existe concordana cu tipul de rezultat referit de instruciunea return. Dac funcia
nu returneaz nici un rezultat, atunci tip_rezultat este tipul void;
nume_functie este numele funciei. El trebuie s fie unic i s nu coincid cu vreunul
dintre numele de funcii standard ale limbajului C;
lista_tipuri_argumente are forma:
tip_arg_1,...,tip_arg_n
unde tip_arg_j este tipul argumentului j, j=1,2,...,n.
Dac funcia nu primete nici un argument, atunci lista_tipuri_argumente va conine
numai meniunea void.
2.8.2. Definirea unei funcii
Definirea unei funcii are forma:
antet
{corp_functie}
unde antet are aproape aceeai form cu prototipul funciei, i anume:
tip_rezultat nume_functie([lista_tipuri_argumente]);
cu deosebirea c lista_tipuri_argumente are acum forma:
tip_arg_1 nume_arg_1,..., tip_arg_n nume_arg_n
unde nume_arg_j este numele intern (din funcie) al argumentului j, j=1,2,...,n;
{corp_functie} este un bloc de program coninnd declaraii de variabile, constante i
instruciuni.
2.8.3. Apelul unei funcii
O funcie se apeleaz sub forma:
64
Cap.2. Limbajul C
nume_functie(nume_arg_1,...,nume_arg_n);
unde: nume_arg_j, j=1,2,...,n, trebuie s desemneze un argument de tipul acceptat de
funcie. Dac funcia nu primete nici un argument, atunci lista de argumente este vid, de
forma ().
2.8.4. Instruciunea return
ntr-o funcie pot exista mai multe instruciuni return sau nici una. Atingerea unei
instruciuni return n cursul execuiei produce ntoarcerea n programul principal. Forma
instruciunii return este:
return rezultat;
unde: rezultat trebuie s fie de tipul tip_rezultat definit de prototipul funciei.
Dac funcia nu produce nici un rezultat, instruciunea return are forma:
return;
Dac acest lucru se produce la sfritul corpului funciei, instruciunea return poate lipsi.
2.8.5. Funcia main
Funcia main reprezint, de fapt, programul principal n limbajul C. Ea nu are nevoie de
prototip ci numai de definiie, care apare n forma:
[void] main([parametri])
{corp_functie}
n versiunile timpurii de C, definiia funciei main era precedat de tipul void, dar la
versiunile recente menionarea lui nu mai este dect opional, fiind meninut pentru
compatibilitatea cu programele surs scrise pentru versiunile anterioare.
De obicei funcia main nu are parametri. Acesta este cazul programelor lansate numai prin
nume, fr parametri n linia de comand. n aceste caz, lista de parametri este vid:
main() {corp_functie}
n sistemul de operare DOS un program poate fi lansat cu parametri n linia de comand, n
forma general:
nume_program param_1, param_2,...,param_n
Parametrii param_1, param_2,...,param_n trebuie preluai de program i prelucrai n
corpul su. n acest caz, funcia main trebuie s apar cu o list format din doi parametri:
main(int numar_par_com, char ** tabl_par){corp_functie}
unde:
numar_par_com este numrul de parametri din linia de comand;
**tabl_par este un pointer ctre un tablou de iruri de caractere care conine
cuvintele liniei de comand, astfel:
tabl_par[0] este numele programului, adic nume_program;
tabl_par[1] este primul pametru al liniei de comand, adic param_1;
.....
tabl_par[n] este ultimul pametru al liniei de comand, adic param_n;
2.8.6. Exemplu de folosire a funciilor ntr-un program C
Cu toate c nu a fost fcut nc o prezentare a structurii unui program C (pentru c mai
este necesar parcurgerea nc a unor noiuni), pentru nelegerea modului de folosire a
funciilor, n continuare este prezentat un exemplu de program C simplu:
#include <conio.h>
#include <stdio.h>
float a=1.0, b=2.5, c;
/*declarare si initializare variabile
globale */
float aduna(float, float); /* declarare prototipuri functii */
65
main()
/* definire functie main */
{c=aduna(a,b);
/* apelul functiei si atribuirea
rezultatului */
printf("c=a+b=%f+%f=%f\n",a,b,c);
/*afisare */
getch();
/* asteptarea apasarii unei taste */
}
float aduna(float u, float v) /* definirea functiei aduna*/
{float w;
/* declarare variabila locala */
w=u+v;
/* operatia de adunare si atribuire */
return w;
/* returnarea rezultatului */
}
Cnd compilatorul ajunge la funcia main, el ntlnete apelul funciei aduna. Pentru a
rezolva corect legturile pe care le are de fcut el trebuie s cunoasc, dac nu chiar funcia
aduna, mcar prototipul ei. De aceea acest prototip trebuie s precead apelul, aadar trebuie
s se gseasc n partea de nceput a programului.
Dac, ns, este mutat definiia funciei aduna naintea definiiei funciei main n care se
gsete apelul funciei aduna, prototipul funciei aduna nu mai este necesar, deoarece datele
necesare efecturii legturilor necesare sunt luate chiar din definiia funciei aduna.
Ca urmare a rulrii programului de mai sus, se va obine afiarea:
c=a+b=1.000000+2.500000=3.500000
adic funcia aduna returneaz suma numerelor argumente, acest rezultat fiind atribuit
variabilei c.
2.8.7. Transferul argumentelor funciilor
Reamintind cele prezentate anterior, definirea unei funcii se prezint sub forma:
tip_rezultat nume_functie(tip_1 arg_formal_1,..., tip_n arg_formal_n)
{...
...
}
unde:
tip_j, j=1,2,...,n este tipul argumentului;
arg_formal_j, j=1,2,...,n este argumentul formal (denumirea din interiorul
funciei);
iar apelul funciei are forma:
nume_functie(arg_efectiv_1,...,arg_efectiv_n);
unde: arg_efectiv_j, j=1,2,...,n este argumentul efectiv (denumirea din blocul de unde se
apeleaz funcia).
ntre arg_formal_j i arg_efectiv_j trebuie s existe concordan de tip,
arg_efectiv_j putnd s fie o constant, o variabil, o expresie sau o funcie cu rezultatul de
tipul tip_j.
Mecanismul de aciune al apelului este urmtorul:
- se atribuie lui arg_formal_j valoarea lui arg_efectiv_j;
- se execut operaiile din corpul funciei;
- se returneaz rezultatul (dac exist o returnare de rezultat).
Ca urmare, dac argumentele nu sunt de tipul adres, indiferent ce s-ar ntmpla n corpul
funciei, valorile argumentelor arg_efectiv_j nu sunt afectate.
n exemplul urmtor:
#include <conio.h>
#include <stdio.h>
typedef struct {float x,y;} punct2D;
66
Cap.2. Limbajul C
punct2D punct_mediu(punct2D p1, punct2D p2)

{punct2D pm, ptemp;
pm.x=0.5*(p1.x+p2.x);
pm.y=0.5*(p1.y+p2.y);
ptemp=p1; p1=p2; p2=ptemp;
return pm;
}
main()
{punct2D a={0,0}, b={6,6}, c;
c=punct_mediu(a,b);
printf("a(%f,%f)\n",a.x,a.y);
printf("b(%f,%f)\n",b.x,b.y);
printf("c(%f,%f)\n",c.x,c.y);
getch();
}
se obine ca efect atribuirea listei de coordonate medii ale coordonatelor punctelor a i b

punctului c dup care se afieaz:
a(0.000000,0.000000)
b(6.000000,6.000000)
c(3.000000,3.000000)
Dei n corpul funciei punctele p1 i p2 i-au schimbat ntre ele coordonatele, ele fiind
numai copii ale punctelor a i b, aceast inversare nu are efect n exteriorul funciei
punct_mediu. Dac, ns, se modific programul ca mai jos:
#include <conio.h>
#include <stdio.h>
punct2D punct_mediu(punct2D *p1, punct2D *p2)
{punct2D pm, ptemp;
pm.x=0.5*(p1->x+p2->x);
pm.y=0.5*(p1->y+p2->y);
ptemp=*p1; *p1=*p2; *p2=ptemp;
return pm;
}
main()
{punct2D a={0,0}, b={6,6}, c;
c=punct_mediu(&a,&b);
getch();
}
se va obine ca rezultat afiarea

a(6.000000,6.000000)
b(0.000000,0.000000)
c(3.000000,3.000000)
ceea ce denot acelai efect direct al returnrii rezultatului atribuit punctului c, dar, deoarece
ca parametri ai funciei punct_mediu se transmit adresele punctelor a i b, prelucrrile din
interiorul funciei vor avea loc asupra originalelor i, ca urmare, la ieirea din funcie punctele
originale a i b vor avea coordonatele schimbate reciproc.
Acesta este un exemplu de efect lateral al unei funcii i, dac nu este intenionat, poate fi
o surs de erori.
67
Exemplele de mai sus au avut ca mod de lucru:

a. transferul parametrilor d eintrare prin argumente efective;
b. transferul rezultatului (ieirea) prin rezultatul returnat de funcie;
Este posibil asigurarea exclusiv prin argumentele funciei, att a transmiterii parametrilor
de intrare ct i a obinerii rezultatului. n acest caz, adaptnd cele dou programe de mai sus
i eliminnd efectul lateral nedorit, poate fi scris programul:
#include <conio.h>
#include <stdio.h>
void punct_mediu(punct2D p1, punct2D p2, punct2D *pm)
{pm->x=0.5*(p1.x+p2.x);
pm->y=0.5*(p1.y+p2.y);
}
main()
{punct2D a={0,0}, b={6,6}, c;
punct_mediu(a,b,&c);
getch();
}
Acum, n funcia main, funcia punct_mediu primete ca argumente efective valorile

punctelor a i b i apoi adresa punctului c. La terminarea execuiei, la adresa punctului c se va
gsi stocat rezultatul obinut n corpul funciei punct_mediu.
Se observ deja unele mecanisme de transfer foarte avantajoase: deoarece o funcie poate
returna un singur rezultat, cnd este necesar ca ea s aib ca rezultat un efect asupra unui set
de date, se pot folosi urmtoarele modaliti de lucru:
- returnarea unei structuri care conine un set de date;
- folosirea de variabile globale pentru variabilele din set care vor reflecta starea dup
ieirea din funcie;
- folosirea de adrese ca argumente ale funciei, la ieirea din funcie variabilele adresate
avnd starea cptat n corpul funciei.
Modalitatea recomandabil este prima. Ultimele dou modaliti ncalc principiul
ncapsulrii datelor i, dei pot fi foarte utile, trebuie folosite cu foarte mult atenie.
Transmiterea argumentelor de tip tablou ale unei funcii are la baz mecanismul de
transmitere a adreselor descris mai sus. Numele unui tablou are semnificaia unui pointer la
primul element al tabloului deci, transmiterea prin indicarea numelui tabloului nu se face prin
copierea tabloului ci prin referin la adresa lui.
Ca urmare, n programul:
#include <stdio.h>
float suma(float tablou[], int nmax)
{float s=0; int i;
for(i=0;i<nmax;i++) s+=tablou[i];
return s;
}
main()
{float tabl[]={1,2,3};
printf("suma=%f\n",suma(tabl,3));
getch();
}
Cap.2. Limbajul C
68
funcia suma va returna suma elementelor tabloului, fr s altereze valoarea acestora

deoarece nu se opereaz asupra lor. Efectul rulrii acestui program este afiarea:
suma=6.000000
n schimb, n programul:
#include <conio.h>
#include <stdio.h>
void rotire_stanga(float tablou[], int nmax)
{float temp=tablou[0]; int i;
for(i=0;i<nmax-1;i++) tablou[i]=tablou[i-1];
tablou[nmax-1]=temp;
}
main()
{float tabl[]={1,2,3}; int i;
rotire_stanga(tabl,3);
for(i=0;i<3;i++) printf("tabl[%i]=%f\n",i,tabl[i]);
getch();
}
funcia rotire_stanga nu returneaz nici o valoare dar are ca efect, dup ieirea din ea, rotirea
elementelor tabloului cu o poziie ctre stnga. Efectul rulrii programului va fi afiarea:
tabl[0]=2.000000
tabl[1]=3.000000
tabl[2]=1.000000
Tablourile pot fi tratate la transmitere i ca pointeri, ca n exemplul urmtor, n care numai

definirea funciei este modificat, restul programului rmnnd neschimbat:
void rotire_stanga(float *tablou, int nmax)
{float temp=*tablou; int i;
for(i=0;i<nmax-1;i++) *(tablou+i)=*(tablou+i+1);
*(tablou+nmax-1)=temp;
}
n cazul tablourilor multidimensionale, lucrurile sunt puin diferite.

Fie cazul unui tablou cu dou dimensiuni, pentru care se cere incrementarea tuturor
elementelor. Se poate proceda n mai multe moduri, conform exemplelor urmtoare:
a.
#include <conio.h>
#include <stdio.h>
#define dim1 2
#define dim2 2
void increment(float tablou[dim1][dim2])
{int i,j;
for(i=0;i<dim1;i++) for(j=0;j<dim2;j++) tablou[i][j]++;
}
main()
{int i,j;
float tabl[dim1][dim2]={{11,12},{21,22}};
increment(tabl);
for(i=0;i<dim1;i++)
for(j=0;j<dim2;j++)
printf("tabl[%i][%i]=%f\n",i,j,tabl[i][j]);
getch();
}
69
b. la fel ca n cazul a, cu unica diferen c definirea funciei este de forma:

void increment(float tablou[][dim2])
.....
c. se modific funciile increment i main, astfel:

void increment(float **ptablou, int k1, int k2)
{int i,j;
for(i=0;i<k1;i++)
for(j=0;j<k2;j++) (*((*ptablou)+i*k2+j))++;
}
main()
{int i,j;
float tabl[dim1][dim2]={{11,12},{21,22}};
float *ptab;
ptab=*tabl;
increment(&ptab,dim1,dim2);
for(i=0;i<dim1;i++)
for(j=0;j<dim2;j++)
printf("tabl[%i][%i]=%f\n",i,j,tabl[i][j]);
getch();
}
n cazurile a i b s-a efectuat apelul cu numele tabloului iar funcia trebuia s vad mcar
ultima dimensiune a tabloului i faptul c are dou dimensiuni. n cazul c s-a fcut uz de
mecanismele de transfer a pointerilor i de derefereniere a acestora.
2.9. Directive preprocesor

Directivele preprocesor sunt directive care au efect numai pe perioada aciunii
compilatorului i se adreseaz acestuia n vederea pregtirii procesului de compilare.
2.9.1. Directiva include
Directiva include se prezint n dou forme:
#include <fisier_antet>
i
#include fisier_antet
i are ca efect includerea coninutului unui fisier_antet n fiierul curent.
Un fiier antet este un fiier care conine declaraii i definiii necesare compilatorului
pentru a realiza corect legturile necesare cu bibliotecile limbajului.
De exemplu, a putut fi observat foarte des n exemplele anterioare, directiva:
#include <stdio.h>
Prima variant a directivei include (cea cu paranteze unghiulare) ordon compilatorului s

caute fiierul antet n directoarele indicate prin setarea opiunii de includere din cadrul
proiectului de program.
A doua variant (cea ntre ghilimele) descrie explicit calea de cutare. Dac nu se face nici
o alt specificare, fisier_antet este cutat n directorul curent. Dac este necesar, se indic
drumul de cutare aa cum se obinuiete, n forma disc:\directoare\fisier_antet.
Destul de frecvent, programatorii folosesc directiva include pentru a include n fiierul
surs curent un alt fiier surs coninnd blocuri de program C.
Directiva include poate fi plasat oriunde n program, dar trebuie inut cont c fiierul
cerut pentru a fi inclus este inserat n poziia n care apare directiva include.
Cap.2. Limbajul C
70
2.9.2. Directiva define

Directiva define are forma:
#define identificator text
i are rolul de a substitui orice apariie n textul surs a lui identificator prin text.
De exemplu:
#define ZECE 10
va nlocui peste tot textul ZECE prin textul 10, care la compilare va fi interpretat numeric.
Dac, dup aceasta, se scrie:
#define INCRZECE ZECE+1
se va nlocui INCRZECE cu ZECE+1, astfel nct instruciunea:

val=INCRZECE*2;
devine la compilare:
val=(10+1)*2;
Tot astfel:
#define MESAJ EROARE\n
poate servi la utilizarea cuvntului MESAJ ca argument al unei funcii de ieire pentru
scrierea pe ecran a mesajului EROARE urmat de un salt la o linie nou.
Directiva define are i o form parametrizat, denumit macrodefiniie:
#define identificator (lista_de_parametri)
care poate servi la crearea de definiii scurte pentru funcii simple. Un exemplu clasic este
urmtorul:
#define max(a,b) ((a)>(b) ? (a) : (b))
Aceast definiie are ca efect, de exemplu, transformarea la compilare a instruciunii:

if(max(u,v+1)>x) u=x;
n instruciunea:
if(((u)>(v+1) ? (u):(v+1))>x) u=x;
2.9.3. Directiva undef

Directiva undef are forma:
#undef identificator
i ordon compilatorului ca de la linia n care a aprut aceast directiv, s nceteze efectul
unei directive anterioare define referitoare la acel identificator.
Folosind perechi define - undef se pot crea diferite interpretri ale unui identificator n
diferite blocuri de program delimitate de asemenea perechi.
2.9.4. Directive de compilare condiionat
Sintaxa general a unui bloc de compilare condiionat este:
#if conditie
[text]
[#elif conditie
text]
[#elif conditie
text]
.....
[#elif conditie
text]
[else
text]
#endif
71
unde conditie este o expresie constant ntreag, evaluabil n momentul compilrii.

Directivele if i endif sunt obligatorii pentru a marca nceputul i sfritul blocului.
ntre if i endif (n lipsa lui else) pot exista ntre zero i mai multe directive elif, dar
directiva else este admis o singur dat naintea directivei endif.
n funcie de adevrul condiiilor, preprocesorul selecteaz pentru compilare una dintre
alternative, iar dac nici o condiie nu este adevrat, selecteaz alternativa else. Ca urmare,
textul corespunztor va fi procesat fie n sensul preprocesor (substituire de asociaii
identificator - text prin directiva define) fie prin compilare, dac text este constituit din
instruciuni i apeluri de funcii.
De exemplu, programul:
#include <conio.h>
#include <stdio.h>
#define CAZ 3
#if CAZ==1
#define LATURA 10
#elif CAZ==2
#define LATURA 15
#else
#define LATURA 20
#endif
main()
{int l=LATURA;
printf("Latura=%i\n",l); getch();
}
va avea ca efect afiarea:

Latura=20
Blocurile if - endif pot fi ncuibate (evident cu condiia ca fiecrui if s-i corespund un

endif).
Condiiile nu pot conine expresii sizeof, conversii de tipuri sau constante enumerative.
Se poate folosi expresia constant special:
defined (identificator)
care are valoare adevrat (diferit de zero) dac identificator a fost definit anterior.
De exemplu, nlocuind n exemplul anterior blocul de compilare condiionat prin:
#define CAZ 1
#if defined (CAZ)
#define LATURA 10
#else
#define LATURA 20
#endif
se va obine afiarea
Latura=10
Pentru simplificarea scrierii programelor pot fi folosite directivele:

ifdef
echivalent cu
if defined
i
ifndef
echivalent cu opusul lui ifdef
meninndu-se obligativitatea ncheierii blocului prin endif.
72
Cap.3. Elemente de limbaj C++

Limbajul C++ este un superset al limbajului C standard. Fr a face o prezentare
cuprinztoare a diferenelor dintre C i C++ (aceasta poate fi gsit n orice manual care se
ocup exclusiv de prezentarea limbajului C), vor fi prezentate succint acele caracteristici ale
limbajului C++ considerate a fi strict necesare pentru construirea aplicaiilor inginereti.
Pentru nceput trebuie reinut c orice program scris n C++ trebuie s aib terminaia de
nume .CPP.
3.1. Operaii de intrare/ieire cu consola

Fr a intra n amnunte, pentru a putea nelege cele ce vor urma, vor fi prezentate cele
dou dispozitive de intrare/ieire standard predefinite n C++ i anume cin i cout.
cin (Console Input) este dispozitivul de intrare de la consol (tastatur), care corespunde
dispozitivului stdin din limbajul C;
cout (Console OUTput) este dispozitivul de ieire la consol (monitor), care corespunde
dispozitivului stdout din limbajul C;
>> este operatorul asociat cu cin, nsemnnd " recepteaz de la ";
<< este operatorul asociat cu cout, nsemnnd "transmite la";
Formele de utilizare sunt:
cin >> var1 >> var2 >> ... >> varN; pentru a primi de la tastatur o serie de valori atribuite
variabilelor var1 ... varN;
cout << var1 << var2 << ... << varN; pentru a scrie pe ecran valorile variabilelor var1 ...
varN.
Se observ lipsa specificatorilor de format, acesta fiind ales automat n funcie de tipul
variabilelor, la forma potrivit. Totui, exist i n acest caz modaliti de specificare a unor
formate preferate de afiare. Ele pot fi aflate prin consultarea help-ului mediului de
programare.
3.2. Suprancrcarea funciilor

Compilatorul de C++ este capabil s disting o funcie dup "semntura" sa, adic dup
lista de parametri (numrul de parametru i tipul lor). Aceasta permite definirea mai multor
funcii care pot avea acelai nume dar, obligatoriu, trebuie s aib liste de parametri diferite.
Compilatorul va ti s aleag singur, dintre mai multe funcii cu acelai nume, pe aceea care
corespunde semnturii indicate de lista de parametri definit la apelul funciei. Aceast
caracteristic a limbajului C++ confer mai mult naturalee scrierii programelor. n acelai
timp este necesar o mai mare atenie, deoarece C++ permite ignorarea tipului rezultatului
returnat de funcie. Prin urmare, nu trebuie construite funcii care difer numai prin tipul
rezultatului returnat deoarece, n acest caz, compilatorul nu mai poate face distincie ntre ele.
#include <iostream.h>
#include <conio.h>
struct vect2D{float x,y;};
struct vect3D{float x,y,z;};
vect2D suma_vect(vect2D a, vect2D b)
{vect2D c; c.x=a.x+b.x; c.y=a.y+b.y; return c;}
vect3D suma_vect(vect3D a, vect3D b)
{vect3D c; c.x=a.x+b.x; c.y=a.y+b.y; c.z=a.z+b.z; return c;}
main()
{vect2D a,b,c; vect3D u,v,w;
73
a.x=-2; a.y=0; b.x=0; b.y=3;

c=suma_vect(a,b);
u.x=3; u.y=4; u.z=0; v.x=0; v.y=0; v.z=5;
w=suma_vect(u,v);
cout << "c=(" << c.x << ")i+(" << c.y << ")j+(0)k\n";
cout << "w=(" << w.x << ")i+(" << w.y << ")j+(" << w.z << ")k\n";
getch();
uureaz mult scrierea programului principal, deoarece programatorul nu trebuie s mai

trateze distinct apelul funciilor destinate adunrii vectorilor plani de cle pentru adunarea
vectorilor spaiali. Singura dificultate rmas este aceea a folosirii instruciunii de scriere, care
se scrie difereniat pentru cele dou tipuri de vectori.
3.3. Utilizarea argumentelor prestabilite

La definirea unor funcii se pot indica valori prestabilite pentru unele argumente. Dac la
apelul funciei argumentul este omis, va fi folosit automat valoarea prestabilit. Totui,
exist urmtoarele restricii:
- dac se atribuie unui argument o valoare prestabilit, se vor atribui valori prestabilite
tuturor argumantelor care i urmeaz n lista de parametri;
- dac un argument este omis, se vor omite toate argumentele care i urmeaz;
- nu pot fi omise argumentele care nu au valori prestabilite.
De exemplu, se poate restructura aplicaia anterioar, astfel:
#include <conio.h>
struct vect{float x,y,z;};
vect constr_vect(float x, float y, float z=0)
{vect a; a.x=x; a.y=y; a.z=z; return a;}
vect suma_vect(vect a, vect b)
{vect c; c.x=a.x+b.x; c.y=a.y+b.y; c.z=a.z+b.z; return c;}
main()
{vect c,w;
c=suma_vect(constr_vect(-2,0), constr_vect(0,3));
cout << "c=(" << c.x << ")i+(" << c.y << ")j+(" << c.z << ")k\n";
w=suma_vect(constr_vect(3,4), constr_vect(0,0,5));
cout << "w=(" << w.x << ")i+(" << w.y << ")j+(" << w.z << ")k\n";
getch();
}
Fa de aplicaia anterioar noul program este chiar mai scurt i nu produce nici o
complicaie de scriere.
3.4. Alocarea dinamic a memoriei

Toate funciile de alocare dinamic a memoriei folosite n C sunt recunoscute i n C++. n
plus, limbajul C++ introduce operatorii new i delete.
Alocarea dinamic prin operatorul new poate avea una dintre formele sintactice:
tip_var_pointer=new tip_variabil;
unde:
tip_var_pointer este o variabil pointer ctre un tip;
tip_variabil este tipul variabilei dinamice
tip_var_pointer=new tip_variabil(valoare);
unde:
valoare este valoarea iniial care se atribuie variabilei dinamice.
74
tip_var_pointer=new tip_variabil[dimensiune];
unde:
dimensiune este dimensiunea variabilei dinamice de tip tablou. Tabloul poate
fi multidimensional, n acest caz fiind necesar specificarea tuturor dimensiunilor. Tablourile
nu pot fi iniializate valoric.
n toate cazurile, dac alocarea dinamic a reuit, este returnat un pointer de tipul
tip_variabil. Dac alocarea a euat, este returnat un pointer de valoare NULL. Este
recomandabil testarea valorii returnate, nainte de a efectua exploatarea spaiului de
memorie alocat dinamic.
Eliberarea memoriei alocate dinamic se face folosind operatorul delete, cu sintaxa:
delete tip_var_pointer
unde:
tip_var_pointer este valoarea pointer returnat la alocarea anterioar cu new.
De exemplu:
#include <ctype.h>
main()
{int endprog=0, ls, i; char cont, *sir;
while(endprog==0)
{cout << "Lungime sir="; cin >> ls;
sir=new char[ls+1];
for(i=0;i<ls;i++) sir[i]='*';
sir[ls]='\0';
cout << sir << "\nContinuare(D/N)?"; cin >> cont;
if(toupper(cont)!='D') endprog=1;
delete sir;
}
}
Programul cere lungimea unui ir de caractere, aloc spaiul necesar plus o locaie pentru
caracterul terminator de ir \0, completeaz zona de memorie alocat cu caractere * i o
ncheie cu caracterul terminator de ir. Dup aceea cere confirmarea continurii. La fiecare
sfrit de ciclu elibereaz memoria alocat.
3.5. Conceptul de clas

Clasa reprezint un concept nou introdus de limbajul C++ ca o contribuie major la
dezvoltarea tehnicilor de programare. Ea reprezint o extindere a conceptului de structur ca
grupare de date, la o treapt superioar care, pe lng date, conine i metodele de tratare
asociate datelor prin funcii care, impreun cu datele, sunt membri ai clasei. Pe baza
conceptului de clas este dezvoltat tehnica de programare orientat pe obiecte.
3.5.1. Structura n C++
Spre deosebire de limbajul C, n C++ structura este mai puternic, putnd s conin ca membri,
pe lng date, i funcii i, din acest motiv, este privit ca o prefigurare a conceptului de clas.
Fie urmtorul exemplu de program:
#include <conio.h>
struct calc_vect
{vect a,b,rezv; float rezs;
void set_vect(vect,vect);
void suma_vect(void);
} svect;
75
void calc_vect::set_vect(vect v1,vect v2){a=v1; b=v2;}

void calc_vect::suma_vect(void)
{rezv.x=a.x+b.x; rezv.y=a.y+b.y; rezv.z=a.z+b.z;}
main()
{vect v1={-2,0,0}, v2={0,3,0};
svect.set_vect(v1,v2);
svect.suma_vect();
cout << "c=(" << svect.rezv.x << ")i+("
<< svect.rezv.y << ")j+(" << svect.rezv.z << ")k\n";
getch();
}
Se observ c funciile coninute ca membri ai structurii svect acioneaz asupra membrilor

date ale structurii. Din acest motiv, deoarece datele pot fi extrase prin referin la membrii
structurii, nu a fost necesar ca funciile membre s returneze valori.
Asocierea dintre funcia membru i structur se face prin operatorul :: folosit la definirea
funciei cu sintaxa de definire:
tip_rezultat nume_structur :: funcie_membru(parametri) {corp_funcie_membru}
La apel funcia este referit ca i datele membru ale structurii, prin operatorul punct (.).
Funciile membru pot returna i valori, ca n exemplul restructurat urmtor:
#include <conio.h>
struct calc_vect
{vect a,b; float rezs;
float prod_scal(void);
} svect;
float calc_vect::prod_scal(void)
{rezs=a.x*b.x+a.y*b.y+a.z*b.z; return rezs;}
main()
{vect v1={2,1,0}, v2={3,4,0}; float pscal;
svect.set_vect(v1,v2); pscal=svect.prod_scal();
cout << "Produsul scalar=" << pscal << ", sau\n";
cout << "Produsul scalar=" << svect.rezs << "\n";
getch();
}
Analiznd modul de comportare al funciilor membre ale structurii se observ c:

- funcia set_vect transfer valorile de tip vect, transmise ei ca parametri de apel, datelor
membri de tip vect a i b ale structurii svect;
- celelalte funcii membre, suma_vect n primul exemplu i prod_scal n al doilea,
lucreaz cu valorile datelor membre i, eventual le modific (funcia suma_vect stabilete
valoarea datei membru rezv, iar prod_scal stabilete valoarea datei membru rezs);
- Datele membre ale structurii pot fi accesate pe calea obinuit cu operatorul punct. n cazul
primului exemplu, rezultatul sumei vectoriale, adic efectul obinut prin apelul funciei suma_vect,
a fost extras prin acces la datele membre x, y i z ale structurii rezv, membr la rndul ei n structura
svect. n al doilea exemplu, data rezs membr a structurii svect a fost stabilit prin efectul apelului
funciei membre prod_scal. La rndul ei funcia prod_scal returneaz valoare, astfel nct se putea
renuna la includerea n structura svect a datei membru rezs.
Cu aceste nbuntiri oferite de structur n C++, ea devine o form elementar de clas.
76
3.5.2. Clasa n C++

Membrii unei structuri sunt n mod implicit publici. Aceasta nseamn c pot fi referii din
program prin intermediul operatorului punct.
nlocuind cuvntul cheie struct cu cuvntul cheie class se obine clasa, ai crei membri
sunt n mod implicit privai, vizibilitatea lor fiind limitat la interiorul clasei.
Ultimul exemplu se poate converti la utilizarea claselor prin definiia:
class calc_vect
{vect a,b;
public:
float rezs;
} cvect;
restul programului rmnnd neschimbat cu excepia nlocuirii numelui svect cu numele cvect.
Dac, ns, se va ncerca accesarea membrilor a i b din program, rezultatul la compilare
va fi un mesaj de eroare avertiznd c aceti membri sunt inaccesibili. Aceeai reacie se va
obine dac, omind cuvntul cheie public n definiia clasei, se va ncerca referirea din
program a vreuneia dintre funciile membre ale clasei. n acest caz funciile devin inaccesibile
din exterior, dar sunt accesibile din interiorul altor funcii membre ale clasei.
Pentru a nltura confuziile din partea unui programator care citete programul, este indicat
s se foloseasc declaraiile explicite complete. Astfel, definiia:
class calc_vect
{private: vect a,b;
public:
float rezs;
} cvect;
este perfect echivalent cu cea anterioar i este mai explicit.

Ca i n cazul funciilor obinuite, i funciile membre pot fi suprancrcate, compilatorul
fiind capabil s discearn ntre mai multe funcii omonime, prin analiza semnturilor lor.
3.5.3. Funcii speciale ale clasei. Constructori i destructori
Constructorii sunt funcii care se execut automat la crearea unui obiect de tipul clasei.
Un constructor are acelai nume ca i clasa. Ca orice funcie, i constructorul poate fi
suprancrcat i, din acest motiv, se deosebesc trei tipuri de constructori:
- constructorul prestabilit;
- constructorul de copiere;
- constructorul oarecare.
Dintre aceti constructori, la crearea unui obiect (instan) al clasei respective, va fi
executat automat acel constructor care corespunde semnturii de la apelul crerii instanei.
Vor fi analizate pe rnd cele trei cazuri.
- Constructorul prestabilit. n general, rolul acestuia este de a iniializa datele membre
ale clasei. El poate s aib fie nici un argument, fie argumente prestabilite. Pentru a nelege
modul cum se lucreaz cu acest constructor, trebuie analizat exemplul urmtor:
#include <conio.h>
vect v0={0,0,0};
class calc_vect
{private: vect a,b;
int jinst;
static int nrinst;
public:
calc_vect(vect=v0,vect=v0);
77
/* membru static */
/* constructor de initializare cu
parametri prestabiliti */
calc_vect(calc_vect& cv);
/* constructor de copiere
a unei instante */
~calc_vect();
/* destructor - numai pentru evidentiere */
calc_vect& copie_vect(calc_vect& cv)
{a=cv.a; b=cv.b; return *this;};
/* copiere cu autoreferire */
vect suma_vect(void);
void print_vect(vect);
static int nrInstante(void){return nrinst;} /* functia statica */
};
calc_vect::calc_vect(vect v1, vect v2)
{a=v1; b=v2; jinst=++nrinst;
cout << "A fost creata instanta nr=" << jinst << "\n";
}
calc_vect::calc_vect(calc_vect& cv)
{a=cv.a; b=cv.b; jinst=++nrinst;
cout << "A fost creata instanta nr=" << jinst << " prin copiere\n";
}
calc_vect::~calc_vect()
{cout << "Distrugerea instantei " << jinst << ". Apasa o tasta\n";
getch();
}
vect calc_vect::suma_vect(void)
{vect c; c.x=a.x+b.x; c.y=a.y+b.y; c.z=a.z+b.z; return c;}
void calc_vect::print_vect(vect c)
{cout << "c=(" << c.x << ")i+(" << c.y << ")j+(" << c.z << ")k\n";}
int calc_vect::nrinst=0;
main()
{vect u={-2,0,0}, v={0,3,0}, w;
cout << "Inceput de calcul\n";
calc_vect cvect1;
/*parametrii constructorului sunt omisi */
w=cvect1.suma_vect(); cvect1.print_vect(w);
cout << "Instanta cvect1 este initializata cu vectori nuli\n";
calc_vect cvect2(u,v);
/* se dau parametrii u si v
constructorului */
cvect2.print_vect(cvect2.suma_vect());
cout << "Instanta cvect2 este initializata cu vectori u si v\n";
cvect1.set_vect(u,u);
w=cvect1.suma_vect();
cvect1.print_vect(w);
cout << "Instanta cvect1 este modificata cu vectorii u si u\n";
calc_vect cvect3(cvect1);
/* se creaza copia instantei cvect1
in cvect3 */
78
cout << "Instanta cvect1 este copiata in instanta cvect3\n";

cvect3.copie_vect(cvect2);
/* se copiaza instanta cvect2 in
cvect3 */
cout << "Instanta cvect2 este copiata in instanta cvect3\n";
cout << "In acest moment sunt create "
<< calc_vect::nrInstante() << " instante\n";
getch();
}
Trebuie observat i notat regula: constructorul nu returneaz nici o valoare (nici mcar
void) i de aceea definiia funciei constructor nu este precedat de nici un nume de tip.
n exemplul dat, la crearea obiectului cvect1, el este iniializat automat cu valorile vectori a
i b ale clasei egale cu vectorul nul. La crearea obiectului cvect2, deoarece sunt menionai
parametrii u i v de valori definite n funcia main, vectorii a i b primesc aceste valori.
Aceasta se poate vedea din efectul funciilor de scriere pe ecran, print_vect ale obiectelor
create. Ulterior, prin funcia set_vect, sunt schimbate valorile vectorilor a i b ai obiectului
cvect1 la valorile vectorilor u i respectiv v. Pe ecran va apare afiarea:
Inceput de calcul
A fost creata instanta nr=1
c=(0)i+(0)j+(0)k
Instanta cvect1 este initializata cu vectori nuli
A fost creata instanta nr=2
c=(-2)i+(3)j+(0)k
Instanta cvect2 este initializata cu vectorii u si v
c=(-4)i+(0)j+(0)k
Instanta cvect1 este modificata cu vectorii u si u
A fost creata instanta nr=3 prin copiere
c=(-4)i+(0)j+(0)k
Instanta cvect1 este copiata in instanta cvect3
c=(-2)i+(3)j+(0)k
Instanta cvect2 este copiata in instanta cvect3
In acest moment sunt create 3 instante
Distrugerea instantei 3. Apasa o tasta
Evident c afirile fcute de constructori i destructori au fost prevzute numai pentru a

urmri fenomenul pas cu pas. n mod obinuit aceasta nu se face.
- constructorul de copiere a unei instane. Acest constructor servete la copierea unei
instane existente ntr-o alta care se creaz. Dup cum se observ din exemplul dat, instana
cvect3 a fost creat copiind valorile a i b ale instanei cvect1. Folosirea constructorilor de
copiere este recomandabil n special dac se dorete copierea datelor alocate dinamic.
Compilatorul creaz el nsui un constructor de copiere dac nici un astfel de constructor nu a
fost declarat explicit de ctre programator, dar acest constructor creat de compilator face doar
o copiere superficial, numai a datelor membre iar nu i a celor dinamice.
- ali constructori pot fi declarai de ctre programator n diverse scopuri.
Destructorul, ca i constructorul, are acelai nume cu clasa dar este precedat de caracterul ~
i este unic. Ca i constructorul, destructorul nu este precedat de nume de tip i nu are niciodat
parametri. Rolul lui este numai acela de a dezafecta clasa atunci cnd ea nu mai este util. Dac
programatorul nu definete explicit un destructor, compilatorul va crea el nsui unul.
79
Fie exemplul urmtor:

#include <conio.h>
char ast='*';
class sir_car
{private: char *sircar; int lung; char car;
public:
sir_car(int, char); /* constructor cu parametri prestabiliti
sir_car(sir_car& s); /* constructor de copiere */
~sir_car();
/* destructor pentru eliberarea memoriei
void scrie_sir(void);
};
sir_car::sir_car(int i=1, char c=ast)
{lung=i; car=c;
sircar=new char(lung+1);
for(i=0;i<lung;i++)sircar[i]=car;
sircar[lung]='\0';
}
sir_car::sir_car(sir_car& s)
/* copierea datelor instantei
{car=s.car; lung=s.lung; sircar=s.sircar;}
sir_car::~sir_car()
{delete sircar; /* se elibereaza memoria alocata in instanta
cout << "Distrugere. Apasa o tasta!\n"; getch();
}
void sir_car::scrie_sir(void){cout << sircar << "\n";}
main()
{sir_car sir1;
/* creaza o instanta
prestabiliti */
sir1.scrie_sir();
sir_car sir2(10);
cu
ambii
*/
*/
*/
*/
parametri
/* creaza o instanta cu 10 caractere

prestabilite */
sir2.scrie_sir();
sir_car sir3(15,'$'); /* creaza instanta sir3 cu 15 caractere $ */
sir3.scrie_sir();
sir_car sir4(sir2); /* copiaza instanta sir2 in noua instanta sir4 */
sir4.scrie_sir();
getch();
}
Programul va afia:
*
**********
$$$$$$$$$$$$$$$
**********
Distrugere. Apasa
Distrugere. Apasa
Distrugere. Apasa
Distrugere. Apasa
o
o
o
o
tasta!
tasta!
tasta!
tasta!
n acest caz destructorul definit explicit prin program, elibereaz prin instruciunea delete
memoria alocat n cadrul instanelor cu instruciunea new. Altfel, prin aciunea unui
destructor creat de compilator, ar fi fost distruse numai instanele nsei, nu ns i memoria
alocat n cadrul lor. Aceasta ar fi rmas n evidena sistemului de operare ca fiind ocupat,
80
dei nefolosit. Dac programul ar fi fost folosit n mod repetat, s-ar fi putut ajunge la un
moment dat la situaia ca ntreaga memorie s fie ocupat i nefolosibil, lucru care nu se
poate remedia dect prin restartarea calculatorului.
3.5.4. Autoreferina unui obiect al clasei. Cuvntul cheie this
Analiznd exemplul anterior se observ c se poate crea o instan copie a alteia prin
intermediul constructorului de copiere, la apelul de creare a instanei. Ce este ns de fcut
dac se dorete copierea unei instane ntr-o alta care a fost deja creat?
n exemplul dat la constructori, a fost definit funcia membru copie_vect care primete ca
parametru o instan existent i returneaz prin intermediul cuvntului cheie this o referin
la instana apelat. Ea modific datele membre ale instanei curente (cea apelat) copiindu-le
pe acelea ale instanei date ca parametru.
Prin aceast metod se spune c obiectul (instana) se autorefer.
Exist o restricie, i anume aceea ca expresia *this s fie folosit numai n funciile
membre ale clasei.
3.5.5. Membrii statici ai clasei
Un membru static este un membru care aparine ntregii clase, deci este comun tuturor
obiectelor (instanelor) clasei respective. Membrii statici, date sau funcii, sunt precedai de
cuvntul cheie static.
n exemplul dat la clasa calc_vect se observ existena variabilei statice nrinst care este
iniializat n afara clasei, deoarece un membru static exist separat de instanele clasei i
poate fi accesat nainte de crearea instanelor. Variabila servete la contorizarea numrului de
instane existente i, datorit introducerii membrului jinst nestatic (deci propriu fiecrei
instane) se poate face numerotarea instanelor.
Funciile membre statice, cum este nrInstante, datorit independenei de existena clasei,
nu poate accesa dect membri statici, n cazul de fa numai pe nrinst. De asemenea, din
acelai motiv, funciile membre statice nu pot returna expresia *this.
3.5.6. Funcii prietene
O funcie prieten a unei clase este o funcie extern clasei respective (ea poate fi membr
a unei alte clase) i creia i este permis accesul la membrii clasei cu care este prieten.
Declararea calitii de funcie prieten a clasei se face n cadrul clasei prin prefixarea
declaraiei funciei cu cuvntul cheie friend. Iat urmtorul exemplu, reluare a exemplului
anterior pentru calcul vectorial:
#include <conio.h>
vect v0={0,0,0};
class calc_vect
{private: vect v;
public:
calc_vect(vect a=v0){v=a;}
calc_vect(calc_vect& cv){v=cv.v;}
friend calc_vect se_substituie_cu(calc_vect& cv);
void suma_vect(calc_vect& a, calc_vect& b);
void print_vect();
};
void calc_vect::suma_vect(calc_vect& a, calc_vect& b)
81
{v.x=a.v.x+b.v.x; v.y=a.v.y+b.v.y; v.z=a.v.z+b.v.z;}

void calc_vect::print_vect(void)
{cout << "(" << v.x << ")i+(" << v.y << ")j+(" << v.z << ")k\n";}
calc_vect se_substituie_cu(calc_vect& cv)
{calc_vect rez; rez.v=cv.v; return rez;}
main()
{vect a={-1,2,3}, b={2,1,3};
cout << "*****************\n";
calc_vect c1; cout << "c1="; c1.print_vect();
calc_vect c2(a); cout << "c2="; c2.print_vect();
calc_vect c3(b); cout << "c3="; c3.print_vect();
c1.suma_vect(c2,c3); cout << "c1=c2+c3="; c1.print_vect();
c1=se_substituie_cu(c2);
cout << "c1 se substituie cu c2="; c1.print_vect();
getch();
}
n exemplul dat, a fost definit funcia prieten se_substituie_cu care permite substituirea
vectorului dintr-o instan a clasei calc_vect cu un altul.
Singura diferen dintre o funcie membru i una prieten este aceea c, funcia prieten
fiind extern, nu poate returna expresia *this ca referin la o instan,
3.5.7. Supradefinirea operatorilor
n limbajul C++ operatorii pot fi supradefinii n cadrul claselor, fiind tratai ca funcii
membre sau prietene. Supradefinirea operatorilor este valabil numai n contextul clasei n
care este fcut.
Dintre operatorii care se pot supradefini, se pot meniona urmtorii:
+ - * / % = += -= /= %=
== != < > <= >=
| & || &&
[] ()
'
Sintaxa supradefinirii unui operator este:

tip operator oper(lista_de_parametri);
unde
oper este simbolul operatorului de supradefinit.
De exemplu:
#include <conio.h>
vect v0={0,0,0};
class calc_vect
{private: vect v;
public:
calc_vect(vect a=v0){v=a;}
calc_vect(calc_vect& cv){v=cv.v;}
calc_vect& operator=(calc_vect& cv) /* operator membru */
{v.x=cv.v.x; v.y=cv.v.y; v.z=cv.v.z; return *this;}
calc_vect& operator+=(calc_vect& cv) /* operator membru */
{v.x+=cv.v.x; v.y+=cv.v.y; v.z+=cv.v.z; return *this;}
friend calc_vect operator+(calc_vect& cv1,calc_vect& cv2);
void print_vect();
};
82
calc_vect operator+(calc_vect& cv1, calc_vect& cv2) /* operator

prieten */
{calc_vect rez;
rez.v.x=cv1.v.x+cv2.v.x;
rez.v.y=cv1.v.y+cv2.v.y;
rez.v.z=cv1.v.z+cv2.v.z;
return rez;
}
void calc_vect::print_vect(void)
{cout << "(" << v.x << ")i+(" << v.y << ")j+(" << v.z << ")k\n";}
main()
{vect a={-1,2,3}, b={2,1,3};
cout << "*****************\n";
calc_vect c1; cout << "c1="; c1.print_vect();
calc_vect c2(a); cout << "c2="; c2.print_vect();
calc_vect c3(b); cout << "c3="; c3.print_vect();
c1=c2; cout << "c1=c2="; c1.print_vect();
c1=c2+c3; cout << "c1=c2+c3="; c1.print_vect();
c2+=c2; cout << "c2+=c2="; c2.print_vect();
getch();
}
Au fost supradefinii operatorii = i += ca operatori membri ai clasei calc_vect, iar

operatorul + a fost supradefinit ca operator prieten al clasei.
Se observ repede c, prin supradefinirea operatorilor, scrierea operaiilor vectoriale din
program se simplific mult fa de metodele din aplicaiile anterioare.
83
Cap.4. Programarea n limbajul C sub sistemul DOS

.4.1. Structura unui program C
Un program scris n limbajul C are, n general, structura reflectat de urmtorul exemplu:
#include <conio.h>
#include <stdio.h>
#define UNU 1
/* directive preprocesor */
typedef int intreg;
/* definiii de tipuri */
void mesaj(intreg numar)

/* definiri de functii */
{printf("Acesta este programul nr.=%i\n",numar);}
main()
/* functia main = programul principal */
{intreg primul=UNU;
mesaj(primul);
getch();
}
Primele dou linii din program cer compilatorului s caute n fiierele antet conio.h i
stdio.h prototipurile i definiiile funciilor nedefinite dar apelate n program.
A treia linie definete constanta UNU care va fi substituit peste tot n program prin textul
1 interpretat numeric de ctre compilator.
A patra linie definete tipul intreg (ca denumire substitut pentru tipul int).
Dac n program se folosesc variabile globale (vizibile din interiorul oricrei funcii
definit n fiierul surs) ar trebui s urmeze definiii privind tipul i identificatorii acestor
variabile, ceea ce nu a fost cazul n acest program.
Urneaz apoi definiiile de funcii apelate n program, aici funcia mesaj, i apoi definiia
funciei main care constituie programul principal. Trebuie reamintit faptul c orice funcie apelat
dintr-o alta trebuie s fie precedat, dac nu de definiia ei, mcar de definiia prototipului ei.
Variabila de tip ntreg primul este local, fiind vizibil numai din funcia main, unde este
declarat i iniializat. Tot astfel, variabila de tip ntreg numar, definit n lista de parametri
ai funciei mesaj, este vizibil numai n interiorul acestei funcii.
Efectul execuiei acestui program este afiarea:
Acesta este programul nr.=1
urmat de saltul cursorului la nceputul liniei urmtoare i ateptarea apsrii unei taste.
.4.2. Fiiere antet

Fiierele antet sunt fiiere care conin macrodefiniii i prototipuri de funcii pentru
funciile de bibliotec standard ale limbajului C. De asemenea, fiiere antet pot fi create de
utilizator pentru a conine macrodefiniii, prototipuri i funcii proprii.
Un nume de fiier antet are forma:
nume.h
ncluderea coninutului unui fiier antet ntr-un fiier program surs se face cu ajutorul
directivei preprocesor include expus mai nainte.
.4.3. Funcii de bibliotec standard

n continuare, se face o trecere n revist a unora dintre funciile de bibliotec C standard.
Ele sunt valabile ncepnd de la mediul Borland C++ 4.0.
Sunt menionate numai funciile portabile pe sistemul DOS i Windows pe 32 de bii.
84
O funcie este prezentat prin prototipul su pentru a preciza tipul parametrilor de intrare i
tipul rezultatului returnat.
Este menionat fiierul antet care trebuie inclus pentru ca funcia s poat fi folosit i,
unde este necesar este fcut o scurt prezentare.
Mai multe detalii pot fi obinute consultnd Help-ul mediului pe care se lucreaz.
4.3.1. Funcii de conversie a datelor
double atof(const char *ir);
math.h
Convertete un ir de caractere numerice scris n formatul:
[spaii] [semn] [parte ntreag] [.[parte zecimal]] [e/E[semn]exponent]
ntr-un numr de tip virgul mobil pe care l returneaz ca rezultat.
int atoi(const char *ir);
math.h
long atol(const char *ir);
math.h
Funciile convertesc un ir de caractere numerice scris n formatul
[spaii] [semn] [cifre]
ntr-un numr de tip ntreg pe care l returneaz ca rezultat.
char *itoa(int valoare, char *ir, int baz)
stdlib.h
char *ltoa(long valoare, char *ir, int baz)
stdlib.h
Funciile convertesc un numr de tip ntreg ntr-n ir de caractere pe care l returneaz ca
rezultat sub forma unui pointer ctre ir. Baza de numeraie este indicat de valoarea baz.
Rezultatul conversiei este utilizabil i prin pointerii *ir.
4.3.2. Funcii matematice
int abs(int valoare)
math.h
long labs(long valoare)
math.h
Funciile returneaz o valoare ntreag absolut a argumentului de tip ntreg valoare.
double acos(double valoare)
math.h
long double acosl(long double valoare)
math.h
Funciile returneaz o valoare de tip real ntre 0 i reprezentnd arcul cosinusului de
argument real dat (valoare) care trebuie s fie cuprins ntre -1 i +1 pentru a nu se obine o
eroare.
double asin(double valoare)
math.h
long double asinl(long double valoare)
math.h
Funciile returneaz o valoare de tip real ntre 0 i reprezentnd arcul sinusului de
argument real dat (valoare) care trebuie s fie cuprins ntre -1 i +1 pentru a nu se obine o
eroare.
double atan(double valoare)
math.h
long double atanl(long double valoare)
math.h
Funciile returneaz o valoare de tip real ntre -/2 i -2 reprezentnd arcul tangentei de
argument real dat (valoare).
double atan2(double a, double b)
math.h
long double atan2l(long double a, long double b)
math.h
Funciile returneaz o valoare de tip real ntre -/2 i -2 reprezentnd arcul tangentei de
argumente reale a/b date.
85
double ceil(double x)
math.h
long double ceil(long double x)
math.h
Funciile returneaz rezultatul de tip real al rotunjirii argumentului real x n sensul creterii
pozitive (de exemplu, -1.0250 este rotunjit la -1.0000).
double cos(double unghi)
math.h
long double cosl(long double unghi)
math.h
Funciile returneaz valorea de tip real situat n intervalul -1...1 a cosinusului unghiului
dat ca valoare de tip real n radiani.
double cosh(double x)
math.h
long double coshl(long double x)
math.h
Funciile returneaz o valoare real reprezentnd cosinusul hiperbolic de argument x real.
div_t div(int numarator, int numitor)
stdlib.h
ldivt_t ldiv(long int numarator, long int numitor)
stdlib.h
Funciile primesc ca argumente valorile de tip ntreg numarator i numitor i returneaz ca
rezultat o structur de tipul div_t sau ldiv_t definite ca:
typedef struct{int quot; int rem} div_t;
typedef struct{long int quot; long int rem} ldiv_t;
unde quot i rem sunt ctul i restul npririi celor dou numere ntregi.
double exp(double x)
math.h
long double expl(long double x)
math.h
Funciile returneaz rezultatul de tip real al funciei exponeniale ex de argument real x.
double fabs(double x);
math.h
long double fabsl(long double x);
math.h
Funciile returneaz valoarea absolut de tip double sau long double a argumentului x.
double floor(double x);
math.h
long double floorl(long double x);
math.h
Funciile returneaz o valoare de tip double sau long double a numrului x rotunjit la valoarea
ntreag ctre sensul negativ al axei numerelor. De exemplu, -3,02 devine -4, iar 5.33 devine 5.
double fmod(double numrtor, double numitor);
math.h
long double fmodl(long double numrtor, long double numitor); math.h
Funciile returneaz valoarea de tip double sau long double a mrimii numrtor modulo
numitor, adic restul npririi numrtorului la numitor, conform relaiei
numrtor=ct*numitor+rest, unde ct este ntreg, iar 0<rest<numitor. Cnd numitorul este
egal cu zero, funciile returneaz zero. Semnul restului este acelai cu semnul numrtorului.
double hypot(double cat1, double cat2);
math.h
long double hypot(long double cat1, long double cat2);
math.h
Funciile returneaz ca rezultat, de tipul double sau long double, lungimea ipotenuzei unui
triunghi dreptunghic de catete cat1 i cat2.
double ldexp(double x, int exp)
long double ldexpl(long double x, int exp)
math.h
math.h
86
Funciile returneaz ca rezultat, de tipul double sau long double, valoarea x*2exp.
double log(double x)
math.h
long double logl(long double x)
math.h
Funciile returneaz ca rezultat, de tip double sau long double, logaritmul natural din
argumentul x, cu condiia ca acesta s fie mai mare dect zero.
double log10(double x)
math.h
long double log10l(long double x)
math.h
Funciile returneaz ca rezultat, de tip double sau long double, logaritmul zecimal din
argumentul x, cu condiia ca acesta s fie mai mare dect zero.
double poly(double x, int grad, double coef[ ]);
math.h
long double polyl(long double x, int grad, long double coef[ ]);
math.h
Funciile returneaz ca rezultat, de tip double sau long double, valoarea unui polinom de
gradul grad, care are coeficienii coef[0], coef[1],...,coef[grad], polinomul avnd forma:
coef[grad]*xgrad+coef[grad-1]*xgrad-1+...+coef[0]*x0
double pow(double baza, double exp);
math.h
long double powl(long double baza, long double exp);
math.h
Funciile returneaz ca rezultat, de tip double sau long double, valoarea bazaexp.
double pow10(double exp);
math.h
long double pow10l(long double exp);
math.h
Funciile returneaz ca rezultat, de tip double sau long double, valoarea 10exp.
double sinh(double x);
math.h
long double sinhl(long double x);
math.h
Funciile returneaz ca rezultat, de tip double sau long double, valoarea (ex-e-x)/2.
double sqrt(double x);
math.h
long double sqrtl(long double x);
math.h
Funciile returneaz ca rezultat, de tip double sau long double, rdcina ptrat a
argumentului x, cu condiia ca x s fie pozitiv.
double tan(double arc);
math.h
long double tanl(long double arc);
math.h
Funciile returneaz ca rezultat, de tip double sau long double, tangenta arcului arc
exprimat n radiani.
double tanh(double x);
math.h
long double tanhl(long double x);
math.h
Funciile returneaz ca rezultat, de tip double sau long double, tangenta hiperbolic a argumentului x.
4.3.3. Funcii de intrare/ieire ale consolei
Din mulimea de funcii de intrare/ieire ale consolei (tastatur i ecran), au fost selectate
cteva mai frecvent folosite, referite de fiierul antet conio.h.
4.3.3.1. Funcii de intrare de la tastatur
char *cgets(char *sir);
conio.h
Funcia citete un ir de caractere de la consol. nainte de a apela funcia, sir[0] trebuie
87
fcut s conin numrul maxim de caractere citibile, inclusiv caracterul terminator de ir \0.
Dup apelarea funciei, introducerea irului de la tastatur i apsarea tastei ENTER, sir[1]
conine numrul de caractere citite, iar de la sir[2] ncepe irul de caractere introdus de la
tastatur. Lungimea total a tabloului sir este sir[0]+2. Rezultatul returnat de funcie este un
pointer ctre sir[2].
int getch(void);
conio.h
Funcia preia un caracter de la tastatur i l returneaz ca rezultat de tip ntreg.
int getche(void);
conio.h
Funcia preia un caracter de la tastatur i l returneaz ca rezultat de tip ntreg. n acelai
timp, ca ecou, afieaz caracterul preluat.
4.3.3.2. Funcii de acces la ecranul text
void clrscr(void);
conio.h
Funcia terge ecranul i plaseaz cursorul n poziia iniial (1,1) a ecranului aflat n
modul de afiare text.
void delline(void);
conio.h
Funcia terge toat linia pe care se afl cursorul i mut toate liniile inferioare n sus cu o poziie.
void gotoxy(int x, int y)
conio.h
Funcia poziioneaz cursorul text pe linia y n coloana x. Parametrii x i z sunt ntregi
reprezentnd coordonate n fereastra text curent i sunt diferite de zero.
void insline(void);
conio.h
Funcia insereaz o linie vid n linia pe care se afl cursorul. Toate liniile preexistente,
ncepnd de la linia cursorului sunt npinse n jos cu o poziie. Dac ultima linie de jos se afla
chiar la baza ecranului, ea este eliminat.
int gettext(int colstg, int randsus, int coldr, int randjos, void *stocdest); conio.h
int puttext(int colstg, int randsus, int coldr, int randjos, void *stocsurs); conio.h
Funciile gettext i puttext preiau/aduc de pe/pe ecran toate caracterele aflate n
dreptunghiul de coordonate colstg-coloan stnga, randsus-rnd de sus, coldr-coloan dreapta,
randjos-rndul de jos. Caracterele sunt duse la/aduse din o zon tampon de memorie
stocdest/stocsurs a crui lungime se calculeaz cu formula:
lungime=2*(coldr-colstg+1)*(randjos-randsus+1)
Valorile returnate sunt diferite de zero dac operaiile au decurs cu succes i zero n caz
contrar.
void textbackground(int culfond);
conio.h
void textcolor(int cultext);
conio.h
Funciile selecteaz culoarea pentru fondul textului i culoarea textului propriu-zis cu care
se vor face afirile ulterioare. Culorile se selecteaz din tabela urmtoare:
Constanta
simbolic
BLACK
BLUE
Valoare
textbackground
textcolor
0
1
Da
Da
Da
Da
88
Constanta
simbolic
GREEN
CYAN
RED
MAGENTA
BROWN
LIGHTGRAY
DARKGRAY
LIGHTBLUE
LIGHTGREEN
LIGHTCYAN
LIGHTRED
LIGHTMAGENTA
YELLOW
WHITE
BLINK
Valoare
textbackground
textcolor
2
3
4
5
6
7
8
9
10
11
12
13
14
15
128
Da
Da
Da
Da
Da
Da
Nu
Nu
Nu
Nu
Nu
Nu
Nu
Nu
Nu
Da
Da
Da
Da
Da
Da
Da
Da
Da
Da
Da
Da
Da
Da
Da
Valoarea BLINK face textul s clipeasc dac este adunat la valoarea culorii pentru text.
De exemplu textcolor(BLINK+BLUE) face ca afirile ulterioare de text s fie fcute cu
albastru i s clipeasc.
int wherex(void)
conio.h
int wherey(void)
conio.h
Funciile returneaz o valoare ntreag reprezentnd poziia unde se afl cursorul text pe
direcia x (numrul coloanei) sau pe direcia y (numrul rndului), n momentul apelului
funciei.
void window(int colstg, int randsus, int coldr, int randjos)
conio.h
Funcia definete fereastra text curent, n coordonate ecran, unde colstg este indicele
coloanei din stnga, coldr este indicele coloanei din dreapta, iar randsus i randjos sunt indicii
rndurilor de sus i de jos care definesc noua fereastr text. Dac coordonatele sunt greite,
funcia nu are efect. Mrimea implicit este ecranul ntreg cu coordonatele 1,1,C,R, unde C i
R sunt numrul de coloane i de rnduri ale modului text curent. Dup declararea noii ferestre,
toate funciile care lucreaz cu coordonate de fereastr text se raporteaz la colul din stnga
sus al noii ferestre, considerat a fi de coordonate (1,1).
4.3.4. Funcii de intrare/ieire standard
n acest subcapitol sunt descrise sumar cteva dintre cele mai folosite funcii din fiierul
stdio.h care deservesc intrrile/ieirile standard predefinite stdin - dispozitivul de intrare
standard i stdout - dispozitivul de ieire standard, precum i lucrul cu fiiere.
4.3.4.1. Intrri/ieiri standard
int getchar(void)
stdio.h
Funcia ateapt introducerea unui ir de caractere de la tastatur, pn la apsarea tastei
ENTER.
Rezultatul returnat de funcie este numai primul caracter din irul introdus.
89
char *gets(char *sir);

stdio.h
Parametrul funciei este numele unui ir. El nu trebuie prefixat cu * deoarece se tie c
numele de ir este de fapt un pointer ctre un tablou de caractere. Funcia recepteaz un ir de
caractere de la tastatur i terminat prin caracterul new-line (obinut prin apsarea tastei
ENTER) pe care l substituie cu caracterul terminator de ir \0. Valoarea returnat de funcie
este un pointer ctre tipul char reprezentnd irul receptat.
Exemplu de folosire:
#include <stdio.h>
#include <conio.h>
main()
{char sir[80];
printf("Scrieti un sir:"); gets(sir);
printf("Ati scris sirul:%s\n",sir); getch();
}
int puts(char *sir);

stdio.h
Ca i la funcia gets, parametrul funciei este numele unui ir de caractere predefinit, fr
prefixare cu *, din acelai motiv. Funcia afieaz pe ecran irul de caractere completat cu
caracterul new-line. Rezultatul returnat este un ntreg nenegativ dac ieirea a avut loc cu
succes, altfel este returnat valoarea EOF (end of file).
Exemplu:
main()
{char sir[]="Acesta este un sir de caractere";
puts(sir); getch();
}
int putchar(int car);

stdio.h
Funcia trimite la stdout caracterul car. Valoarea returnat este caracterul car sau EOF n
caz de eroare.
int printf(char * format[, argument,...]);
stdio.h
Funcia formateaz i trimite la stdout (ecran) o serie de caractere i valori.
Parametrul format conine caractere normale, secvene ESC i, dac este urmat de
argumente, conine specificatori de format care se aplic acestora. n consecin, numrul de
specificatori de format trebuie s fie egal cu numrul de argumente, n caz contrar rezultatul
poate s fie impredictibil sau dezastruos. Dac sunt mai multe argumente dect specificatori
de format, argumentele n plus sunt ignorate.
Valoarea returnat de funcie este un numr ntreg reprezentnd numrul de caractere
trimise la stdout, iar n caz de eroare, valoarea EOF.
irul format trebuie s existe ca argument obligatoriu n orice funcie printf. El conine
dou tipuri de caractere:
- cmpuri de caractere recunoscute de stdout i care sunt trimise la ieire ca atare;
- specificatori de format care guverneaz modul de conversie al argumentelor n iruri de
caractere. Aceste iruri de caractere obinute prin conversie substituie specificatorii de format,
rezultatul fiind un ir concatenat trimis la ieire.
Specificatorii de format au forma general:
%[indicatori][lime][.precizie][h | l | L]tip
Orice specificator de format ncepe cu caracterul %.
Semnificaiile cmpurilor de dup % sunt:
- indicatori:
90
aliniere la stnga, alinierea la dreapta fiind implicit;

+ ataeaz semnul + valorilor pozitive i - celor negative;
spaiu ataeaz numai semnul - valorilor negative, cele pozitive avnd ataat caracterul
spaiu;
# are urmtoarele efecte n combinaie cu:
c s d i u - nici un efect;
o x X - prefixeaz orice valoare nonzero cu 0, 0x sau 0X;
e E f - punctul zecimal apare i n lipsa prii fracionare;
g G - acelai efect cu e i E i n plus inhib eliminarea zerourilor nesemnificative;
- lime specific numrul de caractere de afiat. Dac numrul de caractere de rezultat
este mai mic, are loc umplurea cu zero sau cu spaii. Prefixarea cu 0 a numrului de caractere
produce complatarea la stnga cu zerouri. De exemplu:
.....
int i=231;
.....
printf("i=%i+06i\n",i);
.....
produce afiarea: i= +0231

Dac n locul numrului de caractere se scrie caracterul * atunci lime trebuie s apar ca
argument precednd argumentul la care se refer. De exemplu, acelai efect al exemplului
anterior se poate obine cu:
printf("i=%i+*i\n",6,i);
- precizie. Indicarea preciziei ncepe ntotdeauna cu caracterul punct, dup care

urmeaz numrul de caractere de afiat, n conformitate cu tipul, astfel:
dioux
- precizie determin numrul maxim de caractere de afiat. Dac
precizie este mai mare dect numrul de cifre de afiat, se vor se vor aduga zerouri la
stnga. Dac precizie se omite, este zero sau este sub forma "." neurmat de un numr,
atunci precizie este egal cu 1;
eE
- precizie determin numrul maxim de zecimale. Ultima zecimal se
rotunjete. Dac precizie este zero sau punct neurmat de numr, punctul
zecimal nu este afiat;
f
- precizie determin numrul de zecimale. Dac precizie lipsete ea este
considerat implicit zero. Dac este 0, punctul zecimal nu apare;
gG
- precizie determin numrul maxim de cifre semnificative de afiat. Dac
precizie lipsete, sunt afiate cifrele semnificative;
c
- precizie nu are efect;
s
- precizie determin numrul maxim de caractere de afiat. Dac precizie
lipsete, irul se afieaz pn la ntlnirea terminatorului de ir.
- [h | l | L] sunt modificatori care determin lungimea argumentului, astfel:
h
- prefixeaz tipurile d i o u x X i specific un argument de tip short;
l
- prefixeaz tipurile d i o u x X i specific un argument de tip long;
L
- prefixeaz tipurile e E f g G i specific un argument de tip long
double;
- tip. Descrierea tipului este obligatorie i se face cu ajutorul caracterelor:
d
- ntreg zecimal cu semn;
i
- ntreg zecimal cu semn;
o
- ntreg octal cu semn;
u
- ntreg zecimal fr semn;
x
- ntreg hexazecimal fr semn, caracterele litarale folosite fiind a, b, c, d, e, f;
X
f
e
E
g
G
c
s
91
- ntreg hexazecimal fr semn, caracterele literale folosite fiind A, B,

C, D, E, F;
- valoare cu semn de forma [-]dddd.dddd, unde dddd sunt caractere
zecimale;
- valoare cu semn de forma [-]d.dddde[semn]ddd;
- valoare cu semn de forma [-]d.ddddE[semn]ddd;
- valoare zecimal de forma e sau f cu selectare automat a variantei
cea mai compact conform valorii i preciziei date. Zerourile finale sunt
eliminate iar punctul zecimal apare numai dac exist parte zecimal;
- la fel ca g dar folosind E n loc de e;
- un singur caracter;
- ir (de fapt pointer ctre ir). Afieaz toate caracterele pn la
terminatorul de ir \0.
4.3.4.2. Intrri/ieiri n flux (de la/spre fiiere)

FILE *fopen(char *cale, char *tip);
stdio.h
Funcia produce deschiderea unui fiier. Argumentele funciei sunt:
cale - reprezint calea ctre fiier inclusiv numele fiierului, sub forma unui ir de caractere;
tip - este un ir delimitat de ghilimele, coninnd una dintre valorile:
f
- deschidere pentru citire;
w
- crearea unui fiier nou pentru scriere sau suprascrierea peste fiierul existent;
a
- adugarea la sfritul unui fiier existent sau crearea unui fiier nou pentru
scriere;
r+
- deschiderea unui fiier existent pentru actualizare (citire i scriere);
w+
- crearea unui fiier nou pentru actualizare (citire i scriere) sau suprascrierea
unui fiier existent;
a+
- deschiderea pentru adugare ntr-un fiier existent sau crearea unui fiier nou
pentru scriere.
Caracterele t i b adugate caracterelor r w sau a specific modul de transmitere text sau
binar. n modul text (t) caracterul CR-LF este transformat n LF la intrare iar caracterul LF
este transformat n CR-LF la ieire. Caracterul CTRL+Z este interpretat la intrare ca sfrit de
fiier. n modul binar (b) transformrile de mai sus nu au loc.
Valoarea returnat de funcie este un pointer ctre un fiier deschis. Acesta este folosit ca
argument n funciile de citire/scriere ca fread i fwrite, sau pentru nchidere de fiier, ca fclose.
int fclose(FILE *fisier);
stdio.h
Funcia nchide fiierul desemnat prin pointerul ctre fiier *fiier, deschis anterior cu
funcia fopen. Valoarea returnat este 0 n caz de succes i EOF altfel.
int fcloseall(void);
stdio.h
Funcia are ca efect nchiderea tuturor fiierelor deschise. Valoarea returnat este numrul
de fiiere nchise, sau EOF n caz de eroare.
int fgetc(FILE *fisier);
stdio.h
Argumentul funciei este un pointer ctre fiier, returnat de funcia fopen care deschide
fiierul pentru citire. Funcia citete din fiier caracterul corespunztor indicatorului de poziie
curent n fiier i apoi incrementeaz indicatorul de poziie cu o unitate. Valoarea returnat
de funcie ca ntreg fr semn este este caracterul citit. n caz de eroare sau la atingerea
sfritului de fiier, funcia returneaz EOF.
92
Ca exemplu pentru funciile descrise mai nainte, iat programul urmtor:

#include <stdio.h>
#include <string.h>
#include <conio.h>
main()
{FILE *fwr,*frd;
char tampon[]="0123456789ABCDEF";
int i=0; char car;
fwr=fopen("HEXAZEC.FIS","w");
fwrite(&tampon, strlen(tampon),1,fwr);
fclose(fwr);
frd=fopen("HEXAZEC.FIS","r");
while((car=fgetc(frd))!=EOF){fputc(car,stdout); i++;}
printf("\nAu fost citite %i caractere din fisier.\n",i);
fclose(frd); getch();
}
Acest program deschide, pentru scriere, un fiier nou cu numele HEXAZEC.FIS n

directorul de lucru curent i scrie n el irul de caractere "0123456789ABCDEF", dup care
nchide fiierul. n continuare, fiierul este deschis din nou, de data aceasta pentru citire. Ct
timp caracterul citit din fiier nu este caracterul EOF (sfrit de fiier), caracterul citit cu
funcia fgetc este transmis la ieirea standard, adic la ecran, i contorizeaz numrul i de
caratere citite. Dup ntlnirea sfritului de fiier, este afiat mesajul cu privire la numrul de
caractere citite i apoi este nchis fiierul.
int fputc(int car, FILE *fisier);
stdio.h
Funcia are ca prim parametru caracterul car care trebuie scris n fiierul determinat de cel
de al doilea parametru. Acesta poate fi un pointer ctre un fiier deschis pentru scriere sau
numele stdout pentru ieirea pe ecran. O variant asemntoare este funcia putc. Valoarea
returnat de funcie este caracterul car, iar n caz de eroare, EOF.
int fgets(char *sir, int ncar, FILE *fisier);
stdio.h
Primul parametru al funciei este un pointer ctre un tampon pentru irul de caractere
(numele irului). Al doilea parametru este lungimea tamponului (ncar) adic numrul de
caractere de citit plus o locaie pentru terminatorul de ir (caracterul \0). Al treilea parametru
este un pointer ctre fiierul deschis cu funcia fopen. Funcia citete din fiier ncar-1
caractere sau cte caractere ntlnete pn la primul caracter new-line (\n), dac acesta este
gsit nainte de citirea numrului de caractere prescris, i apoi adaug terminatorul de ir.
Valoarea returnat este pointerul ctre ir sau NULL n caz de eroare sau sfrit de fiier.
int fputs(char *sir, FILE *fisier);
stdio.h
Primul parametru al funciei este numele irului de scris, iar al doilea este pointerul ctre
fiierul n care se face scrierea, pointer returnat de funcia fopen, sau numele stdout pentru
scrierea pe ecran. irul este scris la ieirea indicat cu adugarea terminatorului de ir \0, fr
a fi adugat caracterul new-line. Valoarea returnat este este un numr nenegativ sau EOF n
caz de eroare.
int fread(void *ptr, size_t lung, size_t nart, FILE *fisier);
stdio.h
Primul argument al funciei este un pointer ctre un bloc de memorie n care se face
memorarea octeilor citii. Al doilea argument este lungimea n octei a fiecruia dintre cele
nart articole citite. Al treilea argument este numrul de articole de citit. Al patrulea argument
93
este pointerul ctre fiierul deschis pentru citire cu funcia fopen. Blocul de memorie de
stocare trebuie s aib lungimea de minimum lung*nart octei. Valoarea returnat de funcie
este numrul efectiv de articole citite. n caz de eroare sau de ntlnire a sfritului de fiier,
este returnat zero.
int fwrite(void *ptr, size_t lung, size_t nart, FILE *fisier);
stdio.h
Semnificaia parametrilor formali i a valorii returnate este aceeai ca la funcia fread cu
deosebirea c, de aceast dat, este vorba de o operaie de scriere.
int feof(FILE *fisier);
stdio.h
Funcia are ca parametru pointerul ctre fiierul deschis pentru citire cu funcia fopen.
Funcia testeaz dac operaia anterioar de citire din fiier a atins sfritul acestuia i, n acest
caz, returneaz o valoare non zero, sau zero n caz contrar. Returnarea valorii non zero are loc
pn cnd fiierul este redeschis (cu rewind) sau nchis.
int fseek(FILE *fisier, long depl, int reper);
stdio.h
Primul parametru este un pointer ctre fiierul deschis cu funcia fopen. Parametrul depl reprezint
un deplasament n raport cu parametrul reper care poate avea valorile din tabelul urmtor:
Constanta simbolic
SEEK_SET
SEEK_CUR
SEEK_END
Valoarea numeric
0
1
2
Locaia n fiier
nceputul fiierului
Poziia curent n fiier
Sfritul fiierului
Funcia returneaz zero dac repoziionarea afost posibil, i nonzero n caz de eec. n caz
de eec, variabila global errno poate avea una dintre valorile: EBADF - pointer de fiier
greit, EINVAL - argument incorect.
#include <stdio.h>
#include <conio.h>
main()
{FILE *frd; int i=11; char car;
frd=fopen("HEXAZEC.FIS","r");
fseek(frd,i,SEEK_SET); car=fgetc(frd);
printf("Al %i-lea caracter din fisier este: %c\n",i,car);
}
deschide fiierul creat cu exemplul de la funcia fgetc, i afieaz:

Al 11-lea caracter din fisier este: B
int fprintf(FILE *fisier, char * format[, argument,...]);

stdio.h
Funcia lucreaz asemntor cu funcia printf, cu deosebirea c scrierea se face nu pe ecran
ci la ieirea indicat de primul argument, care pote fi un pointer ctre fiierul deschis cu
funcia fopen, sau numele standard predefinit (de exemplu stdout).
int fscanf(FILE *fisier, char * format[, adresa,...]);
stdio.h
Funcia citete cmpurile de date ncepnd de la poziia curent a indicatorului de poziie n
fiier i le stocheaz la adresele indicate. Citirea se face conform formatului:
%[lime][h | l | L]tip
94
unde: lime este numrul de caractere de citit, iar h, l i L sunt modificatori de tip cu
semnificaiile:
h - short int;
l - long int dac tip specific conversia la ntreg;
l - double dac tip specific conversia la virgul mobil;
L - long double, valabil numai pentru conversia la virgul mobil;
tip este specificatorul de tip la care se face conversia caracterelor citite.
Observaie: funcia ncheie citirea nainte de a citi numrul de caractere egal cu lime,
dac ntlnete un spaiu sau un caracter neconvertibil.
Valoarea returnat de funcie este numrul de cmpuri citite, convertite i stocate, eventual
0, i EOF la atingerea sfritului de fiier.
#include <stdio.h>
#include <conio.h>
#include <math.h>
main()
{FILE *fwr,*frd; float valcit;
char numfis[]="VALPI.DAT"; char sirscr[]="pi=", sircit[10];
fwr=fopen(numfis,"w");
fprintf(fwr,"%s %7.4f",sirscr,M_PI); fclose(fwr);
frd=fopen(numfis,"r"); fscanf(frd,"%s%f",&sircit,&valcit);
printf("S-au citit: %s si %f\n",sircit,valcit);
}
creaz fiierul VALPI.DAT n care scrie irul pi= 3.1416 i l nchide. Fiierul este deschis
din nou, de data aceasta pentru citire, este citit irul de caractere i valoarea i, nainte de a
nchide fiierul din nou, este fcut afiarea:
S-au citit: pi= si 3.141600
void rewind(FILE *fisier);

stdio.h
Funcia repoziioneaz indicatorul de poziie curent n fiier la nceputul fiierului.
int remove(char *numefis);
stdio.h
Singurul parametru al acestei funcii este numele fiierului (numefis), eventual incluznd
calea de acces ctre el.
Funcia terge fiierul indicat. Dac fiierul era anterior deschis,
pentru a se ncerca tergerea lui el trebuie mai nti nchis. Valoarea returnat este 0 dac
tergerea a putut fi efectuat cu succes, sau -1 n caz de eroare, cnd variabila global errno va
fi setat pe una dintre valorile: EACCES - acces interzis (ncercare de tergere a unui fiier cu
atributul read only), ENOENT - nume de fiier sau cale greite.
int rename(char *numevechi, char *numenou);
stdio.h
Funcia redenumete fiierul numevechi n numenou, ca n secvena de program:
.....
char nv[]="VALPI.DAT", nn[]="PIVAL.DAT";
.....
rename(nv,nn);
.....
Valoarea returnat este 0 n caz desucces sau -1 n caz de eec, cnd variabila global errno
va fi setat pe una dintre valorile: EACCES i ENOENT descrise la funcia remove, sau
ENOTSAM - inexistena dispozitivului indicat.
95
4.3.5. Funcii de lucru cu iruri de caractere

Funciile descrise n acest paragraf sunt referite prin intermediul fiierului antet string.h.
void *memcpy(void *dest, void *sursa, size_t n);
string.h
Funcia copiaz un bloc de n octei din sursa n dest. Dac sursa i dest se suprapun,
comportamentul memoriei este nedefinit. Valoarea returnat este un pointer ctre dest.
void *memmove(void *dest, void *sursa, size_t n);
string.h
Funcia lucreaz la fel ca i memcpy, dar se comport bine i dac sursa i dest se suprapun.
void *memset(void *sir, int car, size_t n);
string.h
Funcia seteaz primii n octei din blocul de memorie sir cu caracterul car. Valoarea
returnat este un pointer ctre irul sir.
void setmem(void *dest, unsigned lungime, char valoare);
string.h
Funcia atribuie valoarea de tip caracter valoare unui domeniu de memorie de lungime
dat, punctat de pointerul dest. Nu este returnat nici o valoare.
char *strcpy(char *dest, char *sursa);
string.h
Funcia copiaz un ir din sursa n dest, oprindu-se dup ce caracterul terminator de ir \0
al irului sursa a fost copiat. Valoarea returnat este un pointer ctre dest.
char strcat(char *dest, char *sursa);
string.h
Funcia adaug o copie a irului sursa la sfritul irului dest. Ambele iruri trebuie s se
termine prin caracterul terminator de ir \0. Lungimea irului rezultat este
strlen(sursa)+strlen(dest). Valoarea returnat este un pointer ctre irul concatenat dest.
size_t strlen(char *sir);
string.h
Funcia calculeaz lungimea irului sir. Valoarea returnat const din numrul caracterelor
irului sir, mai puin caracterul terminator de ir \0.
char *strrev(char *sir);
string.h
Funcia inverseaz ordinea caracterelor irului sir, mai puin caracterul terminator de ir \0.
Valoarea returnat este un pointer ctre irul inversat.
char *strset(char *sir, int car);
string.h
Funcia completeaz n ntregime irul sir cu caracterul car. Valoarea returnat este un
pointer ctre sir.
char *strlwr(char *sir);
string.h
Funcia convertete toate caracterele unui ir n litere mici. Valoarea returnat este un
pointer ctre sir.
char *strupr(char *sir);
string.h
Funcia convertete toate caracterele unui ir n litere mari. Valoarea returnat este un
pointer ctre sir.
4.3.6. Funcii de clasificare i conversie a caracterelor
Funciile descrise n acest paragraf sunt referite prin intermediul fiierului antet ctype.h.
int isalnum(int c);
ctype.h
Funcia returneaz o valoare diferit de zero cnd caracterul c este alfanumeric, i zero n
caz contrar.
96
int isalpha(int c);

ctype.h
Funcia returneaz o valoare diferit de zero cnd caracterul c este alfabetic, i zero n caz contrar.
int isascii(int c);
ctype.h
Funcia testeaz dac caracterul c este un caracter ASCII i returneaz o valoare diferit de
zero, sau zero n caz contrar. Valoarea diferit de zero este returnat dac octetul mai puin
semnificativ al caracterului c este cuprins ntre 0 i 127.
int iscntrl(int c);
ctype.h
Funcia returneaz o valoare diferit de zero cnd caracterul c este de control, i zero n caz contrar.
int isdigit(int c);
ctype.h
Funcia returneaz o valoare diferit de zero cnd caracterul c este zecimal, i zero n caz contrar.
int isgraph(int c);
ctype.h
Funcia returneaz o valoare diferit de zero cnd caracterul c este caracter tipribil
(exceptnd caracterul spaiu), i zero n caz contrar.
int islower(int c);
ctype.h
Funcia returneaz o valoare diferit de zero cnd caracterul c este o liter mic, i zero n
caz contrar.
int isprint(int c);
ctype.h
Funcia returneaz o valoare diferit de zero cnd caracterul c este tipribil (inclusiv
caracterul spaiu), i zero n caz contrar.
int ispunct(int c);
ctype.h
Funcia returneaz o valoare diferit de zero cnd caracterul c este de punctuaie, i zero n
caz contrar.
int isspace(int c);
ctype.h
Funcia returneaz o valoare diferit de zero cnd caracterul c este caracter tipribil de
spaiere (spaiu, TAB, carriage return, new-line, tab vertical, avans la pagin nou, etc), i
zero n caz contrar.
int isupper(int c);
ctype.h
Funcia returneaz o valoare diferit de zero cnd caracterul c este o liter majuscul, i
zero n caz contrar.
int tolower(int c);
ctype.h
Funcia transform caracterul c n liter mic. Valoarea returnat este valoarea caracterului
c convertit n liter mic, dac acesta a fost iniial o majuscul, altfel o las neschimbat.
int toupper(int c);
ctype.h
Funcia transform caracterul c n liter majuscul. Valoarea returnat este valoarea
caracterului c convertit n majuscul, dac acesta a fost iniial o liter mic, altfel o las
neschimbat.
4.3.7. Funcii de acces la directoare i dispozitive
Funciile descrise n acest paragraf sunt referite prin intermediul fiierului antet dir.h.
97
int chdir(char *cale);

dir.h
Funcia face ca directorul specificat prin irul cale s devin directorul curent de lucru.
irul cale trebuie s specifice un director existent. Dac operaia a avut loc cu succes, este
returnat valoarea 0. Altfel, este returnat valoarea -1 iar variabila global errno este stabilit
la valoarea ENOENT (calea sau numele fiierului nu pot fi gsite).
int getcurdir(int dispozitiv, char *director);
dir.h
Funcia returneaz directorul curent din dispozitivul specificat. Argumentul dispozitiv este
un numr atribuit dispozitivului (0 pentru dispozitivul implicit, 1 pentru A, 2 pentru B, etc).
Argumentul director puncteaz ctre o zon de memorie cu lungimea MAXDIR unde este
plasat un nume de director terminat cu caracterul NULL (\0). Numele nu conine specificaia
dispozitivului i nu ncepe cu caracterul \.
MAXDIR este o valoare predefinit n fiierul dir.h, egal cu 66 pentru aplicaii pe 16 bii,
i cu 260 pentru 32 bii, i reprezint lungimea maxim a irului care descrie directorul,
incluznd caracterele backslash (\).
Valoarea returnat este 0 n caz de succes sau -1 n caz de eroare.
#include <stdio.h>
#include <conio.h>
#include <dir.h>
main()
{char dir_vechi[MAXDIR]; char dir_nou[MAXDIR];
getcurdir(0,dir_vechi);
printf("Directorul curent initial este: \\%s\n",dir_vechi);
chdir("\\"); getcurdir(0, dir_nou);
printf("Acum directorul curent este: \\%s\n",dir_nou);
printf("Revenire la directorul initial: \\%s\n",dir_vechi);
chdir(dir_vechi); getch();
}
va produce afiarea:
Directorul curent initial este: \TCLITE\BIN
Acum directorul curent este: \
Revenire la directorul initial: \TCLITE\BIN
int getdisk(void);
dir.h
Funcia returneaz un numr ntreg reprezentnd dispozitivul curent: 0 pentru A, 1 pentru
B, 2 pentru C, etc.
int setdisk(int dispozitiv);
dir.h
Funcia stabilete ca dispozitiv curent unul asociat cu valorile: 0 pentru A, 1 pentru B, 2
pentru C, etc, i returneaz numrul total al dispozitivelor disponibile.
4.3.8. Funcii de alocare a memoriei
Funciile descrise n acest paragraf sunt referite prin intermediul fiierelor antet alloc.h sau
malloc.h.
void *calloc(size_t nrart, size_t mrime);
alloc.h sau malloc.h
Funcia aloc un spaiu (bloc) de nrart*mrime octei n memoria de baz. Blocul nu
poate depi 64K. Parametrul nrart reprezint numrul de articole iar mrime este lungimea
n octei a unui articol.
98
Valoarea returnat este un pointer ctre blocul de memorie alocat, sau NULL dac nu a
fost gsit suficient spaiu pentru alocarea blocului, sau dac unul dintre parametrii nrart sau
mrime este egal cu 0.
void *malloc(size_t mrime);
Funcia este similar cu calloc dar are un singur parametru reprezentnd mrimea total a
blocului de memorie de alocat. Valoarea returnat este un pointer ctre blocul de memorie
alocat, sau NULL dac nu a fost gsit suficient spaiu pentru alocarea blocului, sau dac
parametrul mrime este egal cu 0.
void *realloc(void *bloc, size_t mrime);
Funcia realoc memoria de baz, restrngnd sau extinznd blocul reprezentat prin
argumentul bloc care puncteaz ctre o zon de memorie alocat anterior cu calloc, malloc
sau realloc, la o nou mrime. Dac mrime este zero, blocul de memorie este eliberat i se
returneaz NULL. Dac bloc este un pointer NULL, funcia realloc lucreaz exact la fel ca
malloc. Mrimea blocului de realocat este ajustat la noua mrime prin copierea coninutului
la o nou adres, dac este necesar.
Valoarea returnat este adresa blocului realocat care poate fi diferit de adresa iniial a
blocului. Dac blocul nu poate fi realocat, se returneaz NULL.
void free(void *bloc);
Funcia elibereaz spaiul de memorie alocat anterior pentru bloc cu o funcie calloc,
malloc sau realloc.
void far *farcalloc(unsigned long nrart, unsigned long mrime); alloc.h sau malloc.h
Funcia se aseamn cu calloc dar lucreaz cu memoria ndeprtat. Ea poate folosi toat
memoria RAM disponibil i poate aloca blocuri mai mari de 64K. Pentru a accesa zona de
memorie alocat este necesar s se foloseasc pointeri far sau, dac blocurile alocate sunt mai
mari de 64K, pointeri huge.
Valoarea returnat este un pointer de tip far ctre blocul de memorie alocat sau NULL
dac nu exist spaiu suficient.
void far *farmalloc(unsigned long mrime);
Funcia este asemntoare cu farcalloc dar are un un singur parametru reprezentnd mrimea
total a blocului de memorie de alocat. Valoarea returnat este un pointer de tip far ctre blocul de
memorie alocat, sau NULL dac nu a fost gsit suficient spaiu pentru alocarea blocului.
void farfree(void far *bloc);
Funcia elibereaz spaiul de memorie alocat anterior pentru bloc cu o funcie farcalloc
sau farmalloc.
4.3.9. Funcii grafice DOS
Funciile descrise n acest paragraf sunt referite prin intermediul fiierului graphics.h i,
fiind utilizabile numai sub DOS, nu sunt portabile pe WINDOWS
void far arc(int xc, int yc, int ung_init, int ung_final, int raza);
graphics.h
Funcia deseneaz un arc de cerc centrat n punctul (xc,yc), cu raza dat i care ncepe de
la unghiul ung_init i se termin la ung_final, unghiurile fiind msurate n concordan cu
convenia trigonometric. Culoarea de desenare este cea curent. Stilul de linie nu afecteaz
trasarea arcului, ci numai grosimea.
99
void far bar(int stnga, int sus, int dreapta, int jos);
graphics.h
Funcia deseneaz o band plin rectangular bidimensional. Umplerea benzii se face cu
culoarea i modelul de umplere curente. Conturul benzii nu este evideniat. Pentru
evidenierea conturului benzii se folosete funcia bar3d cu grosimea egal cu zero. Parametrii
stnga i sus reprezint coordonatele x,y ale colului din stnga-sus, iar dreapta i jos
reprezint coordonatele x,y ale colului din dreapta-jos ale benzii.
void far bar3d(int stnga, int sus, int dreapta, int jos, int gros, int plafon); graphics.h
Funcia deseneaz o bar plin rectangular tridimensional. Umplerea barei se face cu
culoarea i modelul de umplere curente. Conturul barei nu este desenat cu stilul de linie i
culoarea curente. Parametrii stnga i sus reprezint coordonatele x,y ale colului din stnga-sus,
iar dreapta i jos reprezint coordonatele x,y ale colului din dreapta-jos ale barei. Profunzimea
barei este dat de parametrul gros. Parametrul plafon stabilete dac plafonul barei este desenat
(valoare nonzero) sau nu (valoare zero), permind desenarea de bare supraetajate.
void far circle(int xc, int yc, int raza);
graphics.h
Funcia deseneaz un cerc centrat n punctul (xc,yc), cu raza dat. Culoarea de desenare
este cea curent. Stilul de linie nu afecteaz trasarea cercului, ci numai grosimea.
void far cleardevice(void);
graphics.h
Funcia terge (adic umple cu culoarea fondului) ntregul ecran i mut poziia curent n
punctul (0,0).
void far clearviewport(void);
graphics.h
Funcia terge un port de vedere i mut poziia curent n punctul (0,0) relativ la portul de
vedere curent.
void far drawpoly(int nrnoduri, int far *defnod);
graphics.h
Funcia deseneaz un poligon cu numrul de noduri dat de parametrul nrnoduri, folosind
culoarea i stilul de linie curente. Parametrul *defnod puncteaz ctre o secven de ntregi n
numr de 2*nrnoduri, ordonat pe perechi de coordonate x,y ntregi, exprimate n pixeli,
reprezentnd coordonatele nodurilor poligonului. Pentru a desena o figur nchis cu n noduri
trebuie ca nrnoduri=n+1, astfel nct ultima pereche de coordonate s fie identic cu prima.
void far ellipse(int xc, int yc, int ung_init, int ung_final, int a, int b);
graphics.h
Funcia deseneaz o elips cu culoarea curent de desenare, avnd centrul n punctul xc,yc,
iar semiaxele orizontal i vertical de mrime a i b. Elipsa este desenat de la unghiul de
nceput ung_init pn la unghiul de sfrit ung_final. Dac ung_init este 0 iar ung_final este
360, elipsa este complet. Stilul de linie nu afecteaz trasarea cercului, ci numai grosimea.
void far fillellipse(int xc, int yc, int a, int b);
graphics.h
Funcia deseneaz o elips cu centrul n xc,yc, cu semiaxele orizontal i vertical a i b, i
o umple cu culoarea i modelul curente.
void far fillpoly(int nrnoduri, int far *defnod);
graphics.h
Funcia lucreaz la fel ca drawpoly dar poligonul generat este umplut cu culoarea i
modelul curente.
void getarccoords(struct arccoordstype far *coordarc);
graphics.h
Funcia completeaz structura arccoordstype punctat de pointerul coordarc, cu
100
informaia obinut la ultimul apel al funciei arc. Structura arccoordstype este definit n
fiierul graphics.h astfel:
struct arccoordstype{int x,y; int xstart, ystart, xend, yend;};
Membrii acestei structuri specific centrul arcului (x i y), punctul de nceput (xstart i
ystart) i punctul de sfrit (xend i yend).
void getaspectratio(int far *aspx, int far *aspy);
graphics.h
Funcia extrage valorile aspx i aspy care reprezint factorii de aspect ai pixelilor. La
standardul VGA, unde pixelii sunt ptrai, aspx=aspy=10000, ns, n general, relaia dintre
cele dou valori este aspy=10000, aspx<=10000.
int far getbkcolor(void);
graphics.h
Funcia returneaz culoarea curent a fondului (pentru detalii a se vedea setbkcolor).
int far getcolor(void);
Funcia returneaz culoarea curent de desenare a entitilor grafice lineare.
graphics.h
void far getfillpattern(char far *model);

graphics.h
Funcia copiaz modelul de umplere definit de utilizator, setat cu setfillpattern, ntr-o zon
de memorie de 8 octei punctat de parametrul model. Cnd unui bit din model i corespunde
valoarea 1 el va fi desenat.
void far getfillsettings(struct fillsettingstype far *infoumpl);
graphics.h
Funcia completeaz structura fillsettingstype, punctat de parametrul infoumpl, cu
informaia despre modelul i culoarea de umplere curente. Structura fillsettingstype este
definit n fiierul graphics.h, astfel:
struct fillsettingstype{int pattern; int color;};
Funciile bar, bar3d, fillpoly, floodfill i pieslice, umplu aria corespunztoare cu modelul i
culoarea curente. Exist urmtoarele modele predefinite, conform tabelului de mai jos. Dac
valoarea modelului este 12 (USER_FILL), atunci va fi utilizat un model definit de utilizator.
Nume
EMPTY_FILL
SOLID_FILL
LINE_FILL
LTSLASH_FILL
SLASH_FILL
BKSLASH_FILL
LTBKSLASH_FILL
HATCH_FILL
XHATCH_FILL
INTERLEAVE_FILL
WIDE_DOT_FILL
CLOSE_DOT_FILL
USER_FILL
Valoare
0
1
2
3
4
5
6
7
8
9
10
11
12
Model de umplere
culoarea fondului
umplere solid
haurare orizontal
haurare subire la 45 dreapta
haurare groas la 45 dreapta
haurare subire la 45 stnga
haurare groas la 45 stnga
haurare rar
haurare ncruciat deas
linii ntreesute
puncte rare
puncte dese
model definit de utilizator
void far getimage(int stnga, int sus, int dreapta, int jos, void far *bitmap); graphics.h
Funcia copiaz o imagine de pe ecran n memorie. Parametrii stnga, sus, dreapta i jos
definesc zona dreptunghiular de pe ecran care va fi copiat. Parametrul bitmap puncteaz
101
ctre o zon de memorie unde imaginea este memorat. Primii doi octei ai acestei zone sunt
folosii pentru lungimea i limea ferestrei, iar ceilali pentru stocarea imaginii.
void far getlinesettings(struct linesettingstype far *infolin);
graphics.h
Funcia completeaz structura linesettingstype, punctat de parametrul infolin, cu
informaia despre stilul liniei curente, modelul curent i grosimea curent. Structura
linesettingstype este definit n fiierul graphics.h, astfel:
struct linesettingstype{int linestyle; unsigned upattern; int thickness;};
Membrul linestyle specific tipul de linie cu care se vor desena liniile n continuare.
Stilurile de linie sunt urmtoarele:
Nume
SOLID_LINE
DOTTED_LINE
CENTER_LINE
DASHED_LINE
USERBIT_LINE
Valoare
0
1
2
3
4
Model de umplere
linie continu
linie punctat
linie-punct
linie ntrerupt
linie definit de utilizator
Membrul thickness specific grosimea liniei, astfel:

Nume
NORM_WIDTH
THICK_WIDTH
Valoare
1
3
Limea n pxeli
1 pixel
3 pixeli
Membrul upattern este un model pe 16 bii care este aplicat numai dac stilul de linie
(linestyle) este USERBIT_LINE. n acest caz, cnd un bit al modelului este 1, pixelul
corespunztor din linie este desenat cu culoarea curent. Dac linestyle nu este
USERBIT_LINE, dei parametrul upattern este ignorat, el trebuie totui s fie furnizat.
int far getmaxx(void);
graphics.h
int far getmaxy(void);
graphics.h
Cele dou funcii returneaz valorile maxime ale coordonatelor x i y alr ecranului curent
pentru dispozitivul grafic i modul grafic curente. Valorile sunt returnate n coordonate ecran.
unsigned far getpixel(int xpix, int ypix);
graphics.h
Parametrii xpix i ypix sunt coordonatele unui pixel. Funcia returneaz o valoare ntreag
fr semn reprezentnd culoarea pixelului.
void far gettextsettings(struct textsettingstype far *infotiptext);
graphics.h
Funcia completeaz structura textsettingstype, punctat de parametrul infotiptext, cu
informaia despre fontul curent al caracterelor, direcia, mrimea i alinierea lor. Structura
textsettingstype este definit n fiierul graphics.h astfel:
struct textsettingstype{int font; int direction; int charsize; int horiz; int vert;};
A se vedea funcia settextstyle pentru descrierea unora dintre membrii structurii.
void far getviewsettings(struct viewporttype far *portvedere);
graphics.h
Funcia completeaz structura viewporttype, punctat de parametrul portvedere, cu
informaia despre portul de vedere curent. Structura viewporttype este definit n fiierul
graphics.h astfel:
102
struct viewporttype {int left; int top; int right; int bottom; int clip;};
Membrii left, top, right i bottom sunt limitele stnga, sus, dreapta i jos ale portului de
vedere, iar clip, dac este nonzero, semnific decuparea tuturor desenelor la limitele portului
de vedere.
int far getx(void);
graphics.h
int far gety(void);
graphics.h
Funciile returneaz coordonatele x i y ale poziiei curente, n valori relative la portul de
vedere curent.
unsigned far imagesize(int stanga, int sus, int dreapta, int jos);
graphics;
Funcia determin i returneaz mrimea zonei de memorie necesar pentru stocarea unei
imagini cuprins ntr-un dreptunghi avnd limitele stnga, sus, dreapta i jos. Dac mrimea
zonei de memorie necesar stocrii imaginii este mai mare sau egal cu 64K-1, funcia
returneaz valoarea 0xFFFF (-1).
void initgraph(int far *dispgraf, int far *modgraf, char far *cale);
graphics.h
Funcia iniializeaz sistemul grafic prin ncrcarea de pe disc a unui dispozitiv grafic logic
specificat prin dispgraf i trecnd sistemul n modul grafic specificat prin modgraf. Funcia
poate folosi un dispozitiv grafic i un mod grafic anume, specificate, sau poate executa
aciunea prin autodetecie. De asemenea, initgraph reseteaz toate setrile grafice la valorile
lor implicite (poziie curent, palet de culori, porturi de vedere, etc) i reseteaz funcia
graphresult la zero. n mod normal, initgraph ncarc dispozitivul grafic alocnd memorie
pentru el, apoi ncarc fiierul corespunztor cu extensia .BGI de pe disc. Parametrul cale
specific calea spre directorul unde initgraph caut dispozitivele. Iniial initgraph caut pe
calea specificat de cale apoi, dac nu gsete acolo, caut n directorul curent. Cnd cale este
nul fiierul dispozitiv (*.BGI) trebuie s se afle n directorul curent.
Parametrul dispgraf poate avea diferite valori. Multe dintre ele reprezint diferite versiuni
de dispozitive grafice depite de evoluia tehnologic. Ele pot fi aflate consultnd help-ul
mediului de programare C n care se lucreaz. Cel mai frecvent este folosit valoarea
DETECT (0) care produce autodetecia. Dac este folosit valoarea DETECT pentru
dispgraf, valoarea modgraf nu mai are importan, modul grafic fiind stabilit prin
autodetecie.
Funcia nu returneaz valoare dar, prin efect lateral, seteaz codul intern de eroare (care
poate fi determinat cu funcia graphresult) la una din valorile:
grOK
0
Iniializare desfurat cu succes
grNotDetected
-2
Nu se poate detecta placa grafic
grFileNotFound -3
Nu poate fi gsit fiierul dispozitivului grafic logic
grInvalidDriver
-4
Dispozitiv grafic logic invalid
grNoLoadMem
-5
Memorie insuficient pentru ncrcarea dispozitivului
int far graphresult(void);
graphics.h
Funcia returneaz codul de eroare pentru ultima ultima operaie grafic euat i
restabilete nivelul de eroare la valoarea grOK. Codurile de eroare returnate sunt definite n
graphics.h i pot fi consultate prin help-ul mediului de programare C.
char far *grapherrormsg(int coderoare);
graphics.h
Funcia primete argumentul coderoare obinut anterior cu graphresult, i returneaz un
pointer ctre un ir de caractere mesaj de eroare.
103
void far *closegraph(void);

graphics.h
Funcia elibereaz toat memoria alocat sistemului grafic, apoi restabilete ecranul n
modul anterior apelului funciei initgraph.
void far line(int xi, int yi, int xf, int yf);
graphics.h
Funcia deseneaz o linie cu culoarea, stilul i grosimea de linie curente, ntre punctele
(xi,yi) i (xf, yf), fr actualizarea poziiei curente.
void far linerel(int deplx, int deply);
graphics.h
Funcia deseneaz o linie cu culoarea, stilul i grosimea de linie curente, ncepnd de la
punctul poziiei curente (xc, yc) considerat ca punct iniial, pn la punctul final (xc+deplx,
yc+deply). Poziia curent avanseaz la punctul final.
void far lineto(int xf, int yf);
graphics.h
Funcia deseneaz o linie cu culoarea, stilul i grosimea de linie curente, ncepnd de la
punctul poziiei curente (xc, yc) considerat ca punct iniial, pn la punctul final (xf,yf).
void far moverel(int deplx, int deply);
graphics.h
Funcia deplaseaz poziia curent cu deplx pixeli pe axa x i cu deply pixeli pe axa y.
void far moveto(int noux, int nouy);
Funcia mut poziia curent n poziia nou (noux, nouy)..
graphics.h
void far outtext(char far *irtext);

graphics.h
Funcia afieaz n modul grafic irul irtext, n portul de vedere folosind fontul, direcia i
mrimea de text curente. Afiarea textului are loc ncepnd de la poziia curent. Dac
alinierea textului pe orizontal este LEFT_TEXT i direcia textului este HORIZ_DIR,
coordonata x a poziiei curente este avansat cu textwidth(irtext). Altfel, poziia curent
rmne neschimbat. Pentru a menine controlul dimensiunilor rezultate cnd se folosesc
diferite stiluri de caractere, trebuie folosite funciile textwidth i textheight pentru a
determina dimensiunea irului. Dac irul este tiprit cu stilul de caractere implicit folosind
funcia outtext, orice parte a irului care depete marginea portului de vedere curent este
trunchiat. Funcia outtext poate fi folosit numai n modul grafic. Ea nu lucreaz n modul
text.
void far outtextxy(int x, int y, char far *irtext);
graphics.h
Funcia este asemntoare cu outtext, dar afieaz textul ncepnd nu de la poziia curent,
ci de la poziia specificat de punctul (x, y).
void far pieslice(int xc, int yc, int ungin, int ungfin, int raza);
graphics.h
Funcia deseneaz i umple un sector de disc cu raza dat, cu centrul n (xc, yc), ncepnd
de la unghiul ungin i sfrind la unghiul ungfin. Sectorul este conturat cu culoarea curent i
este umplut cu modelul i culoarea de umplere curente. Unghiurile sunt specificate n grade.
void far putimage(int stnga, int sus, void far *bitmap, int oper);
graphics.h
Funcia afieaz o imagine salvat anterior cu funcia getimage. Colul din stnga-sus al
imaginii este plasat n punctul de coordonate (stnga, sus). Parametrul bitmap puncteaz
ctre o zon de memorie unde este stocat imaginea surs. Parametrul oper specific un
operator de combinare care controleaz modul cum este calculat culoarea fiecrui pixel care
este pus pe ecran, bazndu-se pe pixelul deja existent pe ecran i pe cel din memorie.
104
Operatorii oper pot avea valorile definite n fiierul graphics.h, astfel:

Nume simbolic
COPY_PUT
XOR_PUT
OR_PUT
AND_PUT
NOT_PUT
Valoare
0
1
2
3
4
Descriere
Copiere
SAU exclusiv
SAU inclusiv
I
Copierea inversului sursei
void far putpixel(int xp, int yp, int culoare);

graphics.h
Funcia atribuie pixelului de coordonate (xp, yp) relative la portul de vedere curent,
valoarea specificat de parametrul culoare.
void far rectangle(int stnga, int sus, int dreapta, int jos);
graphics.h
Funcia deseneaz un dreptunghi avnd colurile diagunal opuse n punctele de coordonate
(stnga, sus) i (dreapta, jos). Desenarea se face cu tipul, grosimea i culoarea de linie curente.
void far sector(int xc, int yc, int ungin, int ungfin, int a, int b);
graphics.h
Funcia deseneaz un sector de elips cu centrul n punctul (xc, yc), ncepnd de la unghiul
ungin i sfrind la ungfin, exprimate n grade. Semiaxele orizontal i vertical ale elipsei
sunt a i b. Sectorul este conturat cu culoarea curent i este umplut cu modelul i culoarea
definite de setfillstyle sau setfillpattern. Dac apare o eroare la umplerea sectorului, funcia
graphresult returneaz valoarea grNoScanMem= -6.
void setaspectratio(int xasp, int yasp);
graphics.h
Funcia schimb raportul de aspect implicit al sistemului grafic. A se vedea funcia
getaspectratio.
void far setbkcolor(int culoare);
graphics.h
Funcia stabilete culoarea fondului la valoarea culoare, conform tabelului urmtor:
Val.
0
1
2
3
Nume simb.
BLACK
BLUE
GREEN
CYAN
Val.
Nume simb.
Val.
Nume simb.
Val.
Nume simb.
4
5
6
7
RED
MAGENTA
BROWN
LIGHTGRAY
8
9
10
11
DARKGRAY
LIGHTBLUE
LIGHTGREEN
LIGHTCYAN
12
13
14
15
LIGHTRED
LIGHTMAGENTA
YELLOW
WHITE
void far setcolor(int culoare);

graphics.h
Funcia stabilete culoarea de desenare curent la valoarea culoare, conform aceluiai tabel
de la funcia setbkcolor.
void far setfillstyle(int model, int culoare);
graphics.h
Funcia stabilete modelul i culoarea curent de umplere la valorile model i culoare
indicate. Dac un parametru al funciei este incorect, ea nu va avea nici un efect iar apelul
funciei graphresult va returna valoarea grError= -11.
void far setfillpattern(char far modelutil, int culoare);
graphics.h
Funcia este asemntoare cu setfillstyle, cu deosebirea c este folosit pentru a stabili un
model de umplere definit de utilizator (modelutil), ca matrice de 8X8 bii, n loc de un model
105
predefinit. Parametrul modelutil puncteaz ctre o secven de 8 octei, n care fiecrui octet
i corespund 8 pixeli din model. Pentru fiecare bit din modelutil egal cu 1, este desenat un
pixel corespunztor de pe ecran.
void setlinestyle(int stillinie, unsigned modelutil, int grosime);
graphics.h
Funcia stabilete stilul tuturor liniilor desenate cu funciile line, lineto, rectangle,
drawpoly, etc.
Parametrii stillinie i grosime necesare pentru a defini stilul i grosimea de linie cu care se
lucreaz, sunt cele definite la funcia getlinesettings. Modelul de desenare modelutil trebuie
s fie furnizat, dei el este luat n considerare numai dac stillinie are valoarea
USERBIT_LINE. Dac se introduce un parametru invalid, funcia nu are efect, iar funcia
graphresult va returna codul de eroare grError= -11.
void far settextjustify(int alinoriz, int alinvert);
graphics.h
Funcia stabilete modul de aliniere al textului. Parametrul alinoriz determin alinierea pe
orizontal iar alinvert stabilete alinierea pe vertical, n raport cu un centru de aliniere
considerat n poziia grafic curent. n mod implicit, iniial alinierea orizontal este
LEFT_TEXT iar cea vertical este TOP_TEXT. Valorile predefinite n fiierul graphics.h ale
parametrilor alinoriz i alinvert sunt cele din tabelul de mai jos:
Parametru
alinoriz
alinvert
Nume simbolic
LEFT_TEXT
CENTER_TEXT
RIGHT_TEXT
BOTTOM_TEXT
CENTER_TEXT
TOP_TEXT
Valoare
0
1
2
0
1
2
Aciune
text aliniat la stnga
text centrat pe orizontal
text aliniat la dreapta
text aliniat la baz
text centrat pe vertical
text aliniat la vrf
Dac alinoriz este LEFT_TEXT i direcia textului este HORIZ_DIR, componenta x a

poziiei curente este avansat, dup ce se apeleaz funcia outtext(ir), cu o valoare egal cu
lungimea irului. Funcia settextjustify afecteaz numai textul scris cu outtext, i nu poate fi
folosit n modul text.
Dac unul dintre parametri este invalid, nu se obine nici un efect, iar funcia graphresult
va returna codul de eroare grError= -11.
void far settextstyle(int font, int direcie, int mrime);
graphics.h
Funcia stabilete fontul, direcia i mrimea caracterelor cu care va fi afiat textul.
Apelarea funciei settextstyle afecteaz textele afiate de funciile outtext i outtextxy.
Parametrii font i direcie sunt descrii n tabelele urmtoare:
Constanta simbolic
pentru font
DEFAULT_FONT
TRIPLEX_FONT
SMALL_FONT
SANS_SERIF_FONT
GOTHIC_FONT
SCRIPT_FONT
Valoare
0
1
2
3
4
5
Constanta simbolic
pentru font
SIMPLEX_FONT
TRIPLEX_SCR_FONT
COMPLEX_FONT
EUROPEAN_FONT
BOLD_FONT
-
Valoare
6
7
8
9
10
-
106
Constanta simbolic pentru direcie

HORIZ_DIR
VERT_DIR
Valoare
0
1
Descriere
Scriere de la stnga la dreapta
Scriere de jos n sus
Parametrul mrime este factorul de amplificare a dimensiunii fiecrui caracter, ntr-un

dreptunghi de 8X8 pixeli. Dac mrime este egal cu 1, funciile outtext i outtextxy afieaz
fonturile de 8X8 ntr-un dreptunghi de 8X8 pixeli. Dac mrime este egal cu 2, afiarea se va
face ntr-un dreptunghi de 16X16 pixeli, etc.
void far setviewport(int stanga, int sus, int dreapta, int jos, int decupare); graphics;
Funcia stabilete o nou fereastr grafic avnd colurile exprimate n coordonate absolute
ale ecranului, n punctele (stnga, sus) i (dreapta, jos). Poziia curent este mutat n punctul
(0,0) al noii ferestre. Parametrul decupare este 1 dac desenele se ntrerup la marginile
ferestrei definite, sau 0 altfel. Dac unul dintre parametri este invalid, nu se obine nici un
efect, iar funcia graphresult va returna codul de eroare
grError= -11.
int far textheight(char far *irtext);
graphics.h
Funcia returneaz nlimea n pixeli a irului de text irtext pe baza dimensiunii fontului
curent i a factorului de multiplicare a dimensiunii.
int far textwidth(char far *irtext);
graphics.h
Funcia returneaz limea n pixeli a irului de text irtext pe baza dimensiunii fontului
curent i a factorului de multiplicare a dimensiunii.
107
Cap.5. Elemente de operabilitate sub Windows

Sistemul de operare Windows face parte dintr-o categorie mai larg de sisteme numit
Interfee grafice cu utilizatorul (GUI sau Graphic User Interface). Programarea aplicaiilor
care ruleaz sub acest sistem trebuie s in cont de o serie de concepte pe care le vom
prezenta n continuare.
Memorie virtual
UC
RAM
HDD
Mrime variabil
Sistem de operare
Resurse
comune
Aplicaie executabil
Resurse specifice
(proprii)
Schimb de comenzi
Schimb de date
Figura 5.1.1. Relaia calculator mediu de execuie
5.1. Relaia calculator mediu de execuie

Definiie: Prin calculator se nelege main fizic constituit din blocurile electronice
necesare prelucrrii semnalelor electrice care reprezint comenzi i date, adic informaia.
Definiie: Prin mediu de execuie se nelege configuraia informaiei din calculator
partajat ntre diferitele module de program care ruleaz la un moment dat.
n timpul lucrului ntre componentele principale ale calculatorului i mediul de execuie se
stabiliesc relaiile prezentate n figura 5.1.1.
Aplicaia executabil, compus dintr-unul sau mai multe module de program, comunic
cu sistemul de operare care i satisface cerinele de acces la memoria RAM sau la harddisc
(HDD). Datele aflate iniial pe harddisc sunt transferate la:
- UC unitatea central care realizeaz execuia propriu-zis a aciunilor programelor;
- RAM (Random Access Memory memorie cu acces aleatoriu) care stocheaz temporar
datele manevrate de program;
- Memoria virtual zon de pe hard disc tratat de sistemul de operare la fel ca memoria
RAM. n aceast zon sunt stocate datele care nu sunt de uz imediat, dar trebuie reinute fiind
necesare mai trziu.
Resursele folosite de mediul de execuie sunt acele blocuri de informaie (date, module de
program) care sunt folosite mai frecvent i care, avnd caracter de repetabilitate i
reutilizabilitate, sunt, ntr-o anumit msur standardizate. Ele constituie blocuri de informaie
distincte, apelabile la cerere. Se deosebesc dou tipuri de resurse:
- Resurse specifice sau resurse proprii ale aplicaiei. Acestea sunt module de program
108
incluse n setul de module ale aplicaiei i care execut funcii specifice, proprii numai
aplicaiai respective. Tot n aceast categorie intr o serie de fiiere de date sau care descriu
obiecte grafice de interaciune cum sunt cutiile de dialog, meniurile, cursoarele, etc.
- Resurse comune. Acestea sunt module de program executabile existente n sistemul de
operare i lansate n lucru de ctre sistemul de operare la cererea aplicaiei sau ca urmare a
unei decizii a sistemului de operare n urma apariiei unui eveniment tratabil de ctre sistem.
De exemplu, o serie de fiiere cu extensia .dll (dynamic link library bibliotec cu legare
dinamic) pot fi module de program ale sistemului Windows, dar i resurse proprii ale
aplicaiei. Tot n aceast categorie intr o serie de cutii de dialog standard cum sunt cele de tip
Open sau Save, folosite la deschiderea sau la salvarea fiierelor.
Tendina recomandat este de a se folosi pe ct posibil resurse comune, gestionate de ctre
sistemul de operare. Aceasta asigur pe de o parte robusteea funcionrii sistemului n
ansamblu, mpreun cu aplicaiile, dar i economicitatea muncii de programare a aplicaiilor
efort mai mic i fiiere executabile de dimensiuni mai mici.
5.2. Sarcini i tehnici de realizare a sarcinilor

5.2.1. Interdependena sarcinilor
Aplicaiile pentru a cror deservire sunt proiectate modulele de program pot avea un grad de
complexitate foarte ridicat. Ele se compun dintr-un numr de sarcini pe care, n continuare le vom
nota cu litera S, care trebuie ndeplinite i care particip la realizarea scopului final al aplicaiei.
n raport cu relaiile care pot exista ntre sarcini acestea pot fi privite ca fiind secveniale
sau concurente.
Fig.5.2.1.
Fig.5.2.2.
Fig.5.2.3.
Aciunea sarcinilor secveniale se poate descrie ca un ir de sarcini S1, S2, , Sn, figura
5.2.1, care trebuie ndeplinite n ordine pentru a realiza sarcina global Sg. n aceast situaie
109
ieirile unei sarcini servesc ca intrri pentru urmtoarea sarcin.

De exemplu, pentru a transforma o entitate grafic 2D se pot face operaiile de mutare,
scalare i rotire.
Ordinea lor ns nu este indiferent, ea influennd rezultatul obinut, aa cum se vede din
figurile 5.2.2 i 5.2.3.
Fig.5.2.4.
Fig.5.2.5.
Aciunea sarcinilor concurente. Conform figurii 5.2.4 sarcinile S1, S2, , Sn pot fi
ndeplinite n orice ordine pentru a realiza sarcina global Sg, nainte de a se trece la realizarea
sarcinii ulterioare Sn+1.
De exemplu, pentru un segment de linie deja desenat, al crui aspect trebuie modificat i
care trebuie apoi s fie copiat, este indiferent ordinea de aplicare a operaiilor indicate n
figura 5.2.5 pentru modificarea aspectului.
Privite deci sub aspectul interdependenei aciunilor de efectuat, n programarea aplicaiilor
n general i a aplicaiilor grafice n particular, se desprind evolutiv dou tehnici de
programare i de utilizare i anume:
- Tehnica unitasking;
- Tehnica multitasking.
5.2.2. Tehnica unitasking
Tehnica unitasking semnific n principal efectuarea unei lucrri care are n vedere o
sarcin unic din punctul de vedere al finalitii lucrrii respective. Procesul de lucru cu
calculatorul avnd un aspect dual, pe de o parte din punctul de vedere al programatorului i,
pe de alt parte din punctul de vedere al utilizatorului, problemele care caracterizeaz
unitaskingul pot fi privite de pe cele dou poziii.
Din punctul de vedere al programatorului, scrierea unui program de tip unitasking este
caracteristic programelor sistemului vechi de operare DOS, dar i unor module de program
din WINDOWS, i presupune acapararea total a resurselor mainii i controlul total al
acesteia de ctre programul sau modulul de program n curs de execuie. Pentru a se trece la
un alt program sau modul de program, sistemul trebuie s atepte recptarea controlului, deci
terminarea complet a execuiei sarcinii curente.
Din punctul de vedere al utilizatorului, unitaskingul este caracteristic efecturii unei sarcini
care condiioneaz total trecerea la execuia sarcinii urmtoare.
Din ambele puncte de vedere, toate aplicaiile complexe compuse dintr-un numr mare de
sarcini de acest fel necesit secvenializarea execuiei.
n consecin, pot fi evideniate urmtoarele sisteme de module de aciune (de program sau
de a operaii efectuate de utilizator), fiecare modul rezolvnd o anumit sarcin:
a. Structura liniar:
n figura 5.2.6 semnificaia notaiilor este urmtoarea: Mi, i=1,2,,n sunt module de
110
program sau de aciune, Fj, j=1,2,,n-1 sunt fiiere de date. Aa cum se observ, un fiier de
date Fk este rezultatul aciunii unui modul Mk, coninnd datele rezultate din acesta i necesare
unui modul ulterior, cruia i servesc ca date de intrare sau necesare n timpul lucrului.
Fig.5.2.6.
Fig.5.2.7.
Ca exemplu, o lucrare de tehnoredactare efectuat cu un procesor de text i grafic
complex, aa cum este programul WORD, poate necesita n cadrul documentului
tehnoredactat o serie de imagini care trebuie pregtite de alte programe. n figura 5.2.7 este
ilustrat o astfel de situaie.
Generarea imaginii se poate face cu ajutorul unui program de sintez de imagine, cel mai
cunoscut exemplu fiind acela al programului 3D Studio, sau pot fi obinute din scanarea unor
fotografii sau preluate de la o camer video digital.
Prelucrarea imaginii n Corel Photo Paint poate fi necesar pentru a introduce o serie de
efecte grafice speciale.
Tehnoredactarea n Word plaseaz imaginea n cadrul textului documentului, eventual o
scaleaz pentru a permite o bun ncadrare a ei i o coreleaz cu explicaiile din text.
Fig.5.2.8.
b. Structura inelar:
Dac rezultatul final al ultimului modul de aciune (sau de program) necesit ajustri care
impun reluarea de la nceput sau dintr-o anumit faz anterioar a lanului de aciuni, modulul
decizional Reluare, figura 5.2.8 poate decide reluarea ciclului.
Ca exemplu, dac n urma parcurgerii lanului de operaii necesare tehnoredactrii
documentului din exemplul anterior se constat nevoia unor retuuri sau modificri ale
imaginii care necesit reluarea procesului de lucru cu Corel Photo Paint, schema de aciune ar
putea fi cea din figura 5.2.9.
111
Fig.5.2.9.
c. Structura subordonat inelar (supervizat):
Acest tip de structur apare n cadrul unor lucrri mai complexe la care sarcinile de lucru
sunt de naturi diferite i efectuarea uneia sau a alteia dintre ele este decis pe baza unui
complex de condiii diverse.
n general, acest tip de structur poate fi sintetizat prin schema din figura 5.2.10.
Fig.5.2.10.
n cadrul acestei scheme exist un modul supervizor S al crui rol este realizarea
direcionrii execuiei ctre unul dintre modulele supervizate si, i=1,2,,n.
Direcionarea controlului se poate face:
- n cazul controlului programat, pe baza unor criterii de validare a calitii rezolvrii
(obinerea unui anumit efect sau precizie de rezolvare);
- n cazul controlului aciunilor utilizatorului, la cererea acestuia prin autoevaluarea
rezultatelor obinute.
De exemplu, la realizarea unei cri, album, sau pliant publicitar, redactorul n calitate de
factor supervizor, coordoneaz tipurile de lucrri care concureaz la elaborarea crii,
conform schemei din figura 5.2.11.
Fig.5.2.11.
112
d. Structuri combinate.
n funcie de situaiile practice concrete se poate concepe orice combinaie sau ncuibare pe
un anumit numr de nivele a structurilor de la punctele a, b, sau c, prezentate anterior.
5.2.3. Tehnica multitasking
Multitaskingul nseamn posibilitatea unui sistem de a efectua mai multe sarcini care i
mpart ntre ele resursele sistemului. n funcie de resursele pe care le posed sistemul
multitaskingul poate fi organizat diferit.
Resursa critic a sistemului este microprocesorul.
Dac sistemul are un singur microprocesor nu se poate folosi dect multitaskingul
secvenial. n aceast manier de lucru, diferitele sarcini i mpart ntre ele memoria
disponibil n sistem dar capt pe rnd accesul la microprocesorul unic. Aceasta nseamn
c, la un moment dat, numai o singur sarcin (aplicaie) este activ, celelalte fiind
suspendate (nregistrate n memoria disponibil) n starea n care se gseau cnd a survenit
ordinul de suspendare.
Dac sistemul are mai multe procesoare, se pot desfura concomitent un numr de sarcini
cel mult egal cu numrul de procesoare, rezultnd un multitasking simultan sau paralel.
Cu rare excepii, pentru nevoile utilizatorului obinuit, multitaskingul secvenial este
suficient, n ultimul timp el fiind mbuntit cu unele perfecionri legate de lucrul n
subteran (background) care desfoar automat unele activiti de transfer de date la periferice
de ieire (imprimant sau plotter), activiti care nu necesit intervenie i care pot folosi
pauzele de aciune ale utilizatorului. Astfel, dei secvenial, multitaskingul poate prea la
nivelul de precepie temporal al utilizatorului c ar fi paralel.
5.3. Mediul obiectual

5.3.1. Tehnica de programare orientat pe obiect
La nceputul anilor 1970 n proiectarea aplicaiilor pe calculator a intervenit o criz major.
Ea s-a datorat creterii spectaculoase a mrimii i complexitii programelor i, n consecin,
a volumului de munc necesar care nu mai putea fi acoperit de o singur persoan i ridica
probleme foarte mari de organizare a muncii n echip.
O prim rezolvare a acestei crize a fost efectuat prin crearea disciplinei de inginerie a
programrii i prin introducerea conceptului de programare structurat.
n programarea structurat se afirm i se demonstreaz c orice aplicaie poate fi
programat folosind numai trei structuri de control fundamentale, i anume:
- Structura secvenial (blocul de instruciuni), figura 5.3.1;
- Structura alternativ cu dou ramuri (blocul if), figura 5.3.2;
- Structura repetitiv condiionat anterior (blocul while), figura 5.3.3.
Fig.5.3.1.
Un program scris numai cu acest gen de instruciuni se numete program D-structurat,
litera D provenind de la Dijkstra, cel care a introdus conceptul de programare structurat.
Dei aceasta a nsemnat o revoluie n programare, i a rezolvat problema organizrii
eficiente a lucrului n nteriorul echipei de programatori, ea nu a rezolvat problema
comunicaiei dintre analist i programatori.
113
n tehnica de programare structurat analistul preia cererile clientului i identific funciile

ndeplinite de modulele de program, iar programatorii implementeaz modulele funcionale
astfel identificate folosind un limbaj de programare adecvat. Dezavantajul acestei maniere de
lucru este acela c, dac este exprimat o cerere de modificare a unor funcii ndeplinite de
modulele de program, efortul de modificare a programelor poate fi apreciabil.
Fig.5.3.2.
Fig.5.3.3.
Aceast tehnic de scriere a programelor a fost proprie

sistemului de operare DOS i este nc utilizat la dezvoltarea
unor poriuni de programe n WINDOWS.
date
Tehnica de programare orientat pe obiecte introduce un
metode
concept nou i anume obiectul.
Un obiect este un modul de program care simuleaz un
obiect
din lumea real.
Fig.5.3.4.
Obiectul, figura 5.3.4, are un set de atribute care l
caracterizeaz i care sunt stocate ntr-un stoc de "date" proprii.
De asemenea, obiectul are un mod propriu de prelucrare a datelor, mod bazat pe o baz de
"metode" proprii constnd din procedurile program incluse n structura lui.
n plus, obiectul comunic cu sistemul de operare prin "mesaje" pe care le primete de la
sistem sau pe care le emite ctre sistem. Prin aceasta obiectul ia cunotin de evenimentele
survenite n sistem sau ntiineaz sistemul cu privire la evenimentele survenite n interiorul
su, aa cum se vede n figura 5.3.5.
Starea la un moment dat a datelor obiectului constituie proprietile lui iar modul cum
obiectul trateaz datele pe care le conine constituie metodele obiectului.
Prin aceast tehnic de lucru analistul, dup ce ia cunotin de cerinele clientului, adic
definete "universul problemei", identific "obiectele" din acest univers, "proprietile"
obiectelor i stabilete un comportament adecvat al obiectelor, adic "evenimentele" din
exteriorul i interiorul obiectelor, "mesajele" prin care obiectele comunic i "metodele" de
care obiectele trebuie s fac uz pentru tratarea proprietilor lor ca rspuns la mesaje externe.
Mai departe, programatorii preiau aceast descriere i o implementeaz folosind tehnicile
de programare structurat numei n interiorul obiectelor, pentru exteriorul lor respectnd
conceptul i tehnicile de programare orientat spre obiecte.
n acest fel, modificarea unei funcii, cerut de client, nu mai afecteaz dect obiectul care
posed funcia respectiv i nu ntregul univers al problemei.
Din punctul de vedere al utilizatorului simplu, problema nu apare prea complicat,
deoarece el nu trebuie dect s manevreze corect obiectele grafice existente n cmpul su de
lucru.
mesaje
114
Fig. 5.3.5.
Pentru utilizatorul avansat care dorete s scrie programe care fac uz de entiti grafice care
reprezint obiecte din universul problemei, nu este necesar cunoaterea mecanismelor interne
de lucru ale obiectului ci numai denumirile proprietilor i metodelor obiectului. Acestea,
sunt de regul accesibile prin intermediul unor limbaje de programare orientate spre obiecte,
implementate n mediile de dezvoltare de aplicaii incluse n programele aplicative moderne.
Astfel, MicroSoft pune la dispoziia utilizatorilor de produse din pachetul Office un dialect de
Visual BASIC comun tuturor aplicaiilor din acest pachet, fiecare program din pachet avnd
diferite numai obiectele specifice aplicaiei.
Apelul proprietilor i metodelor obiectelor grafice se face folosind apelative a cror
denumire apare de forma obiect.proprietate i, respectiv, obiect.metod.
Obiectele la rndul lor se pot clasifica n obiecte recipient i obiecte coninute, un obiect
coninut putnd s fie, la rndul su, obiect recipient pentru alte obiecte.
Evenimente i mesaje
Un eveniment este o schimbare a strii sistemului. De exemplu:
- mutarea pe ecran a unei ferestre;
- nchiderea unei ferestre;
- acionarea unui meniu;
- apsarea unei taste;
- micarea mouse-ului;
- apsarea unui buton al mouse-ului;
- etc.
Cnd are loc un eveniment, este emis un mesaj. Mesajul este un tip de dat special care
este generat de ctre obiectul asociat cu evenimentul produs.
Mesajul este receptat mai nti de ctre sistem care l plaseaz ntr-o structur de date
denumit "coad de mesaje". Plasarea n coada de mesaje poate fi normal sau prioritar
(mesajul sare peste rnd).
115
Sistemul preia mesajele din coad n ordinea plasrii lor, le analizeaz i le transmite mai
departe obiectelor crora le sunt destinate. Acestea le trateaz conform semnificaiei lor,
genernd efecte sau alte evenimente.
Interaciunea obiectelor
O dat cu lansarea platformelor WINDOWS, s-a generalizat tehnica utilizrii obiectelor.
Deoarece sistemul de operare WINDOWS este un sistem de interfaare grafic cu
utilizatorul (GUI Graphic User Interface), toate elementele unei aplicaii au un corespondent
grafic n fereastra de lucru. Aceste entiti grafice sunt obiecte care interacioneaz aparent cu
utilizatorul prezent n mediul de lucru i cu sistemul de operare care supravegheaz
desfurarea ntregului proces de interaciune, ca n figura 17, proces dependent de caracterul
universului problemei i de configuraia mediului de lucru.
Mediul de lucru este complexul constituit din dispozitivele periferice prin care utilizatorul
interacioneaz cu universul problemei, modulele de program care deservesc aceste periferice
i programul aplicativ care solicit accesul la resursele sistemului.
n acest complex de componente, mediul de lucru genereaz evenimente pe care un anumit
obiect care este subiectul unui astfel de eveniment le transform n mesaje pe care le transmite
sistemului de operare. La nivelul sistemului de operare, mesajele se dispun ntr-o coad de
mesaje, n ordinea sosirii lor. Un analizor de mesaje asigur gestiunea cozii de mesaje
transmindu-le sistemului n ordinea lor normal. Unele dintre evenimente sunt prioritare (de
exemplu un clic pe fereastra altei aplicaii n vederea transferului controlului la aceasta este un
eveniment care, n funcie de tipul aplicaiilor concurente, poate genera un mesaj prioritar).
Astfel de mesaje sar peste rnd fiind trimise de ctre analizorul de mesaje imediat ctre
blocul de tratare a mesajelor. De aici, mesajele sunt interpretate de ctre sistem i, dac ele
conin cereri de natur s fie rezolvate de ctre sistem, sunt ndeplinite de ctre acesta. Dac
mesajele se adreseaz altor obiecte, sunt direcionate ctre obiectele destinaie.
O dat ajunse la obiectul destinaie, mesajele genereaz aciuni care acioneaz asupra
mediului de lucru, producnd din partea acestuia reacii care constituie alte evenimente.
Astfel, n mod indirect, sub controlul sistemului de operare, obiectele comunic ntre ele i
colaboreaz la ndeplinirea unor sarcini complexe.
5.4. Mediu de programare

Dup cum s-a vzut din capitolele anterioare, pentru a se realiza un program trebuie
parcurse anumite etape n funcie de procedeul de realizare folosit, compilator sau interpretor.
Acestor etape le corespund programe utilitare sau module de program utilitare, specializate.
Corespunztor celor dou procedee de realizare a programelor, programele utilitare
necesare sunt urmtoarele:
A. Pentru procedeul compilator, figura 5.4.1:
- Editorul de text, este necesar pentru scrierea i, eventual, modificarea programului surs;
- Compilatorul, este necesar pentru traducerea programului surs n coduri binare
reprezentnd instruciuni n limbaj main;
- Editorul de legturi, necesar pentru efectuarea legturilor ntre modulele care vor
compune programul complet;
- Depanatorul, necesar pentru analiza erorilor de diferite tipuri.
B. Pentru procedeul interpretor, figura 5.4.2:
- Editorul de text, necesar pentru scrierea i modificarea programelor surs;
- Interpretorul, care efectueaz funciile de compilare, legare, depanare i execuie la
nivelul unei singure instruciuni.
116
Editor de text
Compilator
Editor de text
Editor de legturi
Interpretor
Depanator
Execuie sub interpretor
Execuie sub sistemul de

operare
Fig.5.4.1. Programe necesare

la procedeul compilator
Fig.5.4.2. Programe necesare

la procedeul interpretor
5.4.1. Medii de programare integrate, medii integrate de dezvoltare a aplicaiilor

n fazele timpurii ale evoluiei tehnicilor de programare, programele utilitare descrise mai
sus apreau ca programe de sine stttoare. nc i astzi, anumite etape (cel mai adesea etapa
de editare de text) pot fi executate separat.
n prezent, programele utilitare concurente la realizarea unui program sunt integrate ntr-un
produs unic, trecerea de la o etap la alta, nainte i napoi, fcndu-se cu uurin maxim,
fapt cu influene benefice majore asupra productivitii muncii programatorului.
Acest tip de produs integrat poart denumirea de mediu de programare integrat.
Un caz deosebit, caracteristic n special interpretoarelor, este cazul n care mediul de
programare integrat, este implementat ntr-o aplicaie particular. Acesta este cazul mediilor
integrate de dezvoltare a aplicaiilor.
Un exemplu foarte popular este acela al limbajului Visual BASIC din MicroSoft Office,
folosibil att n WORD ct i n EXCEL. De asemenea, ncepnd din anul 2000, firma
AutoDesk a implementat acest limbaj i n produsul AutoCAD destinat proiectrii asistate de
calculator, aliniindu-se la o tendin existent nc din anii anteriori la alte produse program
specializate care foloseau implementri similare ale unor versiuni proprii de Visual BASIC
(de exemplu firma Bentley cu produsul Micro Station, tot pentru proiectare asistat de
calculator).
Prin implementarea unui limbaj ntr-o aplicaie se urmrete s se pun la dispoziia
utilizatorului un instrument de lrgire practic nelimitat a posibilitilor existente ale
aplicaiei.
Astfel, se pot crea comenzi noi, meniuri i cutii de dialog noi conectate la comenzile nou
create de ctre utilizator.
Pe aceast cale aplicaia iniial capt posibiliti noi i, ntr-o anumit msur chiar un
nou aspect, servind mai bine necesitile utilizatorului. Este chiar posibil crearea de aplicaii
noi, de sine stttoare, rulabile de sub aplicaia mam astfel mbogit.
117
n sintez, un mediu integrat de dezvoltare a aplicaiilor este compus din:

- O aplicaie suport. De exemplu: WORD, EXCEL, COREL DRAW, AutoCAD,
MicroStation:
- Un limbaj implementat (de regul un interpretor). De exemplu: MicroSoft Visual BASIC,
MicroStation BASIC, AutoLISP, AutoCAD Script, COREL Script;
- Un editor de text;
- Un editor de resurse (cutii de dialog, meniuri);
- Faciliti de depanare.
Editoare de text utilizabile pentru mediile de programare
Dei este din ce n ce mai rar cazul cnd o aplicaie care are integrat un interpretor de
limbaj de programare, nu are implementat i un editor de text, pot exista situaii cnd, din
diferite motive, utilizatorul nu dorete s lanseze n lucru mediul integrat de dezvoltare a
aplicaiilor (sau nu l are instalat pe calculatorul pe care lucreaz n acel moment), ci dorete
numai s fac o modificare n textul programului surs, restul prelucrrii fiind amnat pentru
mai trziu.
ntr-o atare situaie el poate folosi un editor de text de sine stttor (extern), neintegrat.
Totui, la alegerea editorului potrivit trebuie avut n vedere urmtoarea condiie:
Fiierele rezultate trebuie s conin numai caractere ASCII tipribile, nu i alte caractere
care nu pot fi nelese de traductorul de limbaj (compilator sau interpretor).
Exemple de editoare de text potrivite: EDIT, QEDIT, NOTEPAD.
Exemple de editoare de text nepotrivite: WORDPAD, WORD.
Obs.: chiar i aceste din urm editoare pot fi folosite la editarea programelor surs, cu
condiia de a nu se folosi caractere netipribile (tasta TAB, atribuiri de caracteristici de format
ca sublinierea ngroarea, colorarea, etc) i de a se alege la salvare ca tip de fiier tipul TXT.
n cazul integrrii ntr-un mediu de dezvoltare de aplicaii, un editor de text integrat trebuie
s realizeze urmtoarele funcii:
1. Generarea fiierului rezultat strict sub forma text (aceeai condiie ca mai sus);
2. Structurarea automat a textului surs. La aceast funcie contribuie setul de reguli
sintactice recunoscute de compilator (sau interpretor). Practic, este efectuat o preanaliz
sintactic a textului surs. n urma acestei preanalize se obin urmtoarele efecte:
- cuvintele cheie ale limbajului, denumirile tipurilor de variabile standard sau definite de
utilizator, sunt evideniate prin scrierea cu culori diferite de restul textului;
- la trecerea la o nou linie se efectueaz o decalare a nceputului de rnd n funcie de
apartenena la un bloc de structur predefinit (linie interioar unei funcii sau subrutine, linie
interioar unei structuri logice (if) sau repetitive (for, while, until).
5.4.2. Elaborarea unui program n limbaj C ntr-un mediu de programare integrat
Limbajul C este un limbaj pentru lucrul prin procedeul compilator. La ora actual este un
limbaj foarte rspndit. Existent n diferite versiuni ca mediu de programare de sine stttor,
el se afl chiar inclus n anumite medii integrate de dezvoltare din unele aplicaii.
Dat fiind, deci, rspndirea lui, se cuvine s prezentm cteva elemente privind concepia
lui i modul su de folosire.
Limbajul C are trei avantaje principale, i anume:
- este un limbaj de programare cu destinaie general. Cu ajutorul lui se pot construi orice
fel de programe, de la editoare de text i programe de calcul matematic, pn la jocuri dintre
cele mai complexe;
- este un limbaj structurat. Limbajul C posed capabiliti de structurare complet ceea ce
118
confer programelor o mare robustee i uurina modificrii;

- este un limbaj standardizat. Aceasta face ca n cea mai mare parte din cazuri, cu foarte
mici modificri sau fr nici o modificare, un program n C scris pe o anumit main s
poat fi compilat pe o alta.
Etapele de lucru pentru elaborarea programului sunt:
- Dup lansarea programului compilator, se scrie textul surs. Editorul de text este inclus n
mediul de programare i nu necesit accesare separat. Practic, programatorul se gsete tot
timpul n editorul de text;
- nainte de a se trece la urmtoarele etape, pentru a nu se pierde programul surs ca
urmare a unei erori de execuie care ar conduce la blocarea compilatorului (se poate ntmpla
oricnd din diferite motive, legate mai ales de o concepie defectuoas a programului), se
salveaz fiierul surs. Se va alege un director de depozitare a fiierului program surs i i se
va atribui un nume. Numele trebuie urmat de extensia C sau CPP dup cum este vorba de
folosirea limbajului C standard sau a versiunii sale extinse, i anume C++.
- Urmtoarea etap este cea de compilare. Aceasta produce fiierul cod obiect relocabil.
n aceast faz are loc depistarea erorilor de sintax i de definire. Compilatorul nu va
raporta ndeplinirea sarcinii de compilare dact atunci cnd toate erorile vor fi fost eliminate.
Dac apar erori, acestea sunt raportate ntr-o fereastr de mesaje.
- n cazul unei lucrri mai complexe, pentru crearea unui program din mai multe module,
se folosete un fiier proiect (nume.PRJ sau nume.IDE) care conine indicaiile privind
componena lucrrii.
- Urmtoarea etap este cea de legare a modulelor componente ale proiectului sau a
modulului curent cu modulele invocate din biblioteci, invocare explicit sau implicit prin
referinele vzute de compilator.
- O etap folosit adesea de programatorii profesioniti este aceea de depanare folosind un
program de depanare integrat n mediu (Debuger).
- Ultima etap este cea de rulare (Run), etap care se poate efectua fie din mediu, fie din
afara lui dac programul a fost pus la punct.
- Am putea folosi de la nceput comanda Run dar nu este indicat, deoarece nc nu am
eliminat erorile i ne expunem pericolului unei cderi a programului compilator din cauza
erorilor neeliminate.
O serie de erori greu detectabile sunt cele de execuie, cauzate de vicii de concepie. Aceste
erori nu sunt de tip sintactic, nici de definire, i nu sunt detactabile n faza de compilare. Ele
nu se manifest dect la execuie i pot cauza efecte nedorite dintre cele mai diverse, de la
simple rezultate eronate pn la cderi ale sistemului. De aceea, dac se doresc informaii
suplimentare privitoare la desfurarea execuiei programului, trebuie folosit meniul Debug,
de unde se pot impune anumite condiii de execuie gradual i se pot inspecta valorile i
strile variabilelor n cursul execuiei.
Nu mai insistm asupra detaliilor de operare cu compilatorul de C deoarece aceasta face
obiectul unui curs distinct, de specialitate. n plus, diferite firme productoare de astfel de
compilatoare, ofer produse cu diferite configuraii i un studiu amnunit al unui asemenea
produs este util numai unui programator profesionist.
119
Cap. 6. Mediul Visual BASIC pentru EXCEL

6.1. Generaliti
Mediul Visual BASIC este un sistem operaional complex destinat dezvoltrii aplicaiilor
cu interfaare grafic, i este compus, n principal, din urmtoarele elemente:
- un program supervizor al aplicaiei, care are rolul de a asigura funcionarea corect a
modulelor de aplicaie i a resurselor aplicaiei;
- o serie de module de program, concepute ca obiecte care primesc, prelucreaz i transmit
"mesaje" ctre alte obiecte, mesaje care constituie un mediu de comunicare ntre obiecte i
supervizorul de aplicaie n cadrul sarcinilor de prelucrarea a datelor n cuprinsul aplicaiei;
- un set de resurse comune, constituite din obiecte de interaciune grafic (cutii de dialog, butoane,
meniuri, etc) i care au rolul de a asigura interfaarea natural a dialogului dintre utilizator i aplicaie.
Limbajul folosit este un dialect al limbajului BASIC destinat nespecialitilor n informatic
i adaptat sarcinilor programrii aa zis "vizuale" a aplicaiilor sub WINDOWS. Termenul de
programare vizual se refer n special la programarea interfarii grafice cnd, n loc de a
scrie descrieri complicate ale resurselor grafice, ele sunt definite prin operaii de tipul
privete-alege-apuc i pune.
n cele ce urmeaz vor fi discutate acele probleme care particularizeaz limbajul Visual
BASIC folosit sub EXCEL ca supervizor de aplicaie, de limbajul BASIC obinuit, care este
mai mult sau mai puin cunoscut.
6.2. Obiecte i colecii
Fig.6.2.1.
Saltul major realizat de dialectele de Visual BASIC actuale este acela de a fi gndit ca un
limbaj de programare orientat pe obiecte. Aceasta face din el un concurent serios pentru
mediile de dezvoltare de aplicaii care permit dezvoltarea aplicaiilor fie n Visual Basic, fie n
C++. Adeseori, i n special utilizatorii cu mai puine, sau de loc, cunotine de programare
avansat, ceea ce este cazul majoritii, prefer limbajul visual BASIC, mai ales dac aplicaia
nu este critic sub aspectul vitezei de lucru.
120
n EXCEL, se definete ca obiect orice entitate controlabil prin limbajul Visual BASIC.
Orice element constitutiv al mediului EXCEL este un obiect. De asemenea, orice construcie
care folosete elemente EXCEL poate deveni un obiect.
Definirea obiectelor se face prin intermediul limbajului Visual BASIC iar manevrarea lor
se face prin intermediul procedurilor din Visual BASIC.
Obiectele EXCEL sunt grupate ntr-o ierarhie, structurat n recipiente i colecii.
Un recipient este un obiect care conine alte obiecte.
O colecie este o grupare de obiecte de acelai tip.
O metacolecie este o grupare de obiecte de mai mult dect un singur tip, aa cum sunt
obiectele desenate (DrawingObjects).
De exemplu, structura general a obiectelor din EXCEL este cea din figura 6.2.1.
6.2.1. Utilizarea obiectelor
Obiectele se caracterizeaz prin:
- proprieti, care descriu aspectul, starea sau comportarea lor. De exemplu, pentru
obiectul Workbook, cteva dintre cele mai semnificative proprieti sunt:
= Name, indicnd numele documentului;
= Precision As Displayed, indicnd modul de considerare a preciziei calculelor
conform modului de afiare a valorilor numerice n celule;
= Read Only, indicnd protecia documentului mpotriva modificrilor;
= Saved, indicnd starea de salvare a documentului, etc.
- metode, care reprezint aciunile pe care obiectele le pot efectua. De exemplu, pentru
obiectul Worksheet, sunt disponibile o serie de aciuni printre care se afl:
= Activate, reprezentnd aciunea de activare a unei foi de lucru;
= Copy, reprezentnd aciunea de a copia o ntreag foaie de lucru;
= Move, reprezentnd aciunea de a muta o foaie de lucru n alt poziie n
succesiunea foilor;
= Protect, reprezentnd aciunea de a proteja o foaie de lucru mpotriva modificrii;
= Select, reprezentnd aciunea de a selecta o foaie de lucru n vederea unor operaii
ulterioare, etc.
6.2.2. Variabile obiect
O variabil obiect este o variabil asociat unui anumit tip (sau clas) de obiect i care adreseaz un
obiect EXCEL anumit. Pentru a fi folosit, o variabil obiect trebuie mai nti s se fac declararea
folosind una din instruciunile Dim, Public, Private, Static sau ReDim i preciznd obiectul asociat.
Folosind instruciunea Dim, un obiect poate fi declarat n trei moduri:
Dim nume_obiect declar variabila nume_obiect de tipul Variant, cel mai general tip de
dat din EXCEL, tip care poate fi i un obiect;
Dim nume_obiect As Object
declar variabila nume_obiect de tipul Object, adic
obiect general care, ulterior poate particulariza orice obiect real;
Dim nume_obiect As obiect_concret declar explicit variabila nume_obiect ca obiect
de un anumit tip.
De exemplu:
Dim ObiectA As Object, ObiectB As Object declar variabilele ObiectA i ObiectB ca
fiind de tipul general Object, iar
Dim domeniuA As Range declar variabila domeniuA ca avnd tipul domeniu de celule.
O variabil obiect trebuie s refere un obiect existent. Asocierea variabilei cu obiectul
referit se face prin instruciunea Set, cu sintaxa:
Set nume_obiect = expresie_obiect
sau:
121
Set nume_obiect = nothing

Prima variant produce asocierea variabilei cu obiectul referit de expresie_obiect.
Expresie _obiect const din numele unui obiect, o alt variabil obiect de acelai tip, o
funcie (sau metod) care returneaz un obiect de tipul specificat.
A doua variant produce desfacerea referinei stabilite anterior.
6.2.3. Proprieti care reprezint obiecte
Proprietile care reprezint obiecte nu sunt caracteristici ale unor obiecte, ci sunt referine
ale obiectului ctre alte obiecte care dein proprieti.
Iat cteva exemple:
Proprietate
Application
ActiveCell
ActiveChart
ActiveDialog
ActiveSheet
ActiveWindow
ActiveWorkbook
Next
Parent
Previous
ThisWorkbook
Adreseaz
Aplicaia care a creat obiectul
Celula activ
Diagrama activ
Foaia de dialog n lucru
Foaia de lucru activ
Fereastra activ
Mapa (documentul Excel) activ
Foaia sau celula urmtoare
Obiectul printe al obiectului specificat
Foaia sau celula anterioar
Mapa n care se execut procedura curent
De exemplu, procedura:
Sub Nume_foaie()
Dim celula As Range
Set celula = Worksheets("Sheet1").Range("A1")
celula.Value = ActiveSheet.Name
End Sub
va afia n celula A1 din foaia de lucru Sheet1 numele foii de lucru active n momentul
execuiei procedurii.
6.2.4. Adresarea obiectelor
Pentru adresarea obiectelor, Visual BASIC permite utilizarea a trei sintaxe:
identificator![nume_obiect]
identificator("nume_obiect")
identificator(indice)
unde:
identificator poate fi numele coleciei care conine obiectul, sau numele unui
obiect a crui colecie implicit conine obiectul;
nume_obiect este numele obiectului adresat (eventual n forma ir)
indice este numrul de ordine al obiectului vizat, n colecia din care face
parte.
Astfel, de exemplu, dac n procedura de mai sus se nlocuiete ultima instruciune cu
celula.Value = Application.Worksheets(2).Name
n celula A1 din foaia de lucru Sheet1 va fi afiat numele celei de a doua foi de lucru din
document.
122
6.2.5. Folosirea sau manipularea proprietilor obiectelor

Pentru a folosi sau manipula o proprietate a unui obiect se pot efectua urmtoarele operaii:
- Atribuirea unei valori ctre o proprietate (operaie de scriere). Sintaxa atribuirii este:
obiect.proprietate=expresie
unde:
obiect este o referin ctre un obiect, eventual incluznd recipienii si;
proprietate este numele proprietii obiectului creia i se atribuie o valoare
expresie este un enun care genereaz valoarea de atribuit.
Sub Coloreaza()
ActiveWorkbook.Worksheets(1).Cells(1, 5).Interior.ColorIndex = 3
End Sub
va produce colorarea n rou a celului E1 (rndul 1 coloana 5) din prima foaie a documentului.
- Preluarea unei valori a unei proprieti (operaie de citire) se realizeaz cu sintaxa:
variabil=obiect.proprietate
unde
variabil este numele variabilei carea preia valoarea proprietii obiectului.
Exemplul anterior ar putea fi rescris ca:
Sub Coloreaza()
culoare=ActiveWorkbook.Worksheets(1).Cells(1, _
5).Interior.ColorIndex
ActiveWorkbook.Worksheets(1).Cells(2, _
5).Interior.ColorIndex=culoare
End Sub
i, n acest caz, celula E2, ce de sub E1, va primi culoarea preluat de variabila culoare de la
proprietatea ColorIndex a obiectului interior de celul E1.
Observaie: dei, n general sunt posibile ambele tipuri de operaii totui, proprietile
anumitor obiecte sunt de tipul read-only (citibile numai) astfel nct asupra acestor proprieti
se pot efectua numai aciuni de citire.
6.2.6. Activarea obiectelor
n afar de proprieti, obiectele posed metode. Metodele reprezint modul n care
informaia este tratat de obiecte, sau aciunile pe care aceste ale pot efectua i n urma crora
proprietile obiectelor sunt afectate.
Din punct de vedere formal, spre deosebire de proprieti care pot cpta o singur valoare,
metodele pot primi mai multe argumente, deoarece ele sunt de fapt funcii. Pot fi ntlnite
urmtoarele situaii, aceleai ca i la apelul unei funcii oarecare:
a. Metoda nu primete nici un argument. n acest caz se folosete sintaxa:
obiect.metod
De exemplu, instruciunea:
Application.Worksheets("Sheet1").Range("1:1").Delete
va terge coninutul ntregului rnd 1.

b. Metoda primete o list de argumente, dar valoarea returnat de metod nu trebuie
salvat. n acest caz sintaxa este:
obiect.metod lista_de_argumente
c. Dac valoarea returnat de metod trebuie salvat, transmiterea argumentelor se face cu
sintaxa:
obiect.metod(lista_de_argumente)
unde:
obiect este numele obiectului a crei metod se folosete (eventual incluznd
i numele recipienilor);
123
metod este numele metodei folosite;

lista_de_argumente este lista de argumente separate ntre ele prin caracterul separator de list
afiat n pagina Module General din cutia de dialog a comenzii Options din meniul Tools. Acesta
este de obicei virgula, atunci cnd ordinea enumerrii argumentelor este important. De exemplu:
Worksheets("Sheet1").Move(Worksheets("Sheet3"))
reprezint versiunea incomplet a apelrii metodei obiect.Move(before, after), unde argumentul

after a fost omis dar, n acest caz, unicul argument furnizat este interpretat ca fiind argumentul before.
De aceea, efectul apelului este de a muta foaia Sheet1 n faa foii Sheet3.
Dac ordinea argumentelor nu conteaz, trebuie folosit metoda transmiterii argumentelor
denumite. n acest caz, apelul:
Worksheets("Sheet1").Move after:=Worksheets("Sheet3")
folosete operatorul de asignare := pentru a specifica foaia Sheet3 drept argument after. n
acest caz, foaia Sheet1 va fi mutat dup foaia Sheet3.
6.3. Tipuri de date

Tipurile de date recunoscute de Visual BASIC sunt urmtoarele:
Tip de date
Identificator
logic
Boolean
ntreg
Integer
ntreg lung
Long
real simpl precizie
Single
real dubl precizie
monetar
dat calendaristic
ir de caractere
Double
Currency
Date
String
Memorie
2 octei
2 octei
4 octei
4 octei
Domeniu de valori
True sau False
-32768...32767
-2147483648... 2147483647
-3.402823E38...-1.401298E-45 (val. negative)
1.401298E-45... 3.402823E38 (val. pozitive)
8 octei
-1.79769313486232E308...4.94065645841247E-324 (valori negative)
4.94065645841247E-324...
1.79769313486232E308 (valori pozitive)
8 octei
-922337203685477.5808...
922337203685477.5807
8 octei
1 Ianuarie 100...31 Decembrie 9999
1 octet/caracter 0...~2000000000
n afar de aceste tipuri, mai sunt recunoscute urmtoarele tipuri speciale:

Tip de date
Obiect
Oricare
Identificator
Object
Variant
Definit
de
utilizator
Conform
definiiei
Tablou
Conform
definiiei
Memorie
4 octei
16 octei + 1
octet/caracter
numrul de
octei cerut de
elemente
ct este necesar
Domeniu de valori
Orice referin la un obiect
Orice valoare numeric sau text
Domeniul
component
fiecrui
element
Fr restricii asupra numrului de

elemente
6.4. Constante i variabile

6.4.1.Constante
Constantele reprezint valori care nu se pot modifica n timpul execuiei i sunt de dou tipuri:
- constante native sau predefinite n Visual BASIC. Ele se folosesc n legtur cu
124
obiectele EXCEL i pot fi reconoscute prin prefixele xl, vb sau db ataate numelui lor. De
exemplu: vbOK, vbCancel, vbNo,...etc.
- constante definite de utilizator, cu sintaxa:
[Public | Private] Const NUME_CONSTANTA [As nume_tip] = expresie
unde: Public sau Private determin domeniul de vizibilitate al constantei. n mod
implicit domeniul de vizibilitate al constantelor este Private;
Const este cuvntul cheie pentru declararea unei constante;
NUME_CONSTANTA este identificatorul constantei. El se formeaz, ca orice
nume de variabil, conform conveniilor Visual BASIC-ului (a se vedea mai jos)
dar, prin convenie, se scrie cu majuscule;
nume_tip este declaratorul de tip i este opional;
expresie este o expresie aritmetic sau logic a crei valoare este atribuit
constantei. Ea nu poate conine variabile, funcii, sau operatorii Is sau &.
Observaie: constantele definite n proceduri sunt locale, adic au vizibilitate numai n
interiorul procedurilor unde sunt definite.
Exemple de declaraii de constante:
Const ZECE As Integer = 10
Const ENAT As Single = 2.7182
Const NUME As String = "Geta"
6.4.2. Variabile
Variabilele sunt acele valori care pot fi modificate n timpul execuiei. Ele se declar cu
sintaxa:
[Public | Private | Static | Dim] nume_variabila [As nume_tip][,...]
unde:
Public sau Private determin domeniul de vizibilitate al variabilelor;
Static se refer la durata de via a variabilelor;
Dim se folosete pentru definirea variabilei si alocarea spaiului de stocare.
Dim este n special folosit pentru tablouri;
nume_tip este unul din numele de tipuri de date prezentate mai nainte. Dac
nume_tip este omis, tipul atribuit implicit este Variant;
nume_variabila trebuie scris conform urmtoarelor reguli valabile n Visual
BASIC:
- primul caracter trebuie s fie o liter;
- numele trebuie s conin numai litere, cifre i caracterul de subliniere "_";
- nu se admit caractere de punctuaie sau spaii;
- nu se face distincie ntre majuscule sau litere mici;
- lungimea maxim a numelui este de 255 de caractere;
- ca nume nu pot fi folosite cuvinte cheie ale limbajului Visual BASIC;
- numele trebuie s fie unice.
Exemple de declaraii de variabile:
Dim ValoareA, ValoareB
' ValoareA i ValoareB sunt declarate ca fiind implicit
' de tipul Variant i sunt iniializate cu valoarea Empty
Dim Indice As Integer
' Indice este declarat ca ntreg
Dim NumReal As Single
' NumReal este declarat ca numr de tip real simpl
' precizie
n cazul variabilelor de tip ir declaraia implicit este:
Dim SirCar As String
ceea ce comunic interpretorului de Visual BASIC s deschid o zon de memorie cu
lungime variabil dinamic, pentru stocarea irului.
125
Dac se dorete ca spaiul de memorie alocat s aib lungime fix, de exemplu de 30 de

caractere, explicitarea lungimii se face cu sintaxa:
Dim SirCar As String * 30
Observaie: ntr-o instruciune Public, Private, Static sau Dim se pot declara mai multe
variabile, fiecare dintre ele putnd fi de alt tip, declaraiile succesive fiind separate prin
virgule. De exemplu:
Dim NumarPuncte As Integer, NumeCurba As String, Linearitate As Boolean
Se pot folosi i nume de variabile nedeclarate, dar acest lucru poate produce erori greu de controlat.
Pentru a interzice folosirea unor nume de variabile nedeclarate se folosete instruciunea
Option Explicit, plasat n zona pentru declaraii a modulului de programe.
Pentru variabilele tablou declararea se face astfel:
[Public | Private | Static | Dim] nume_variabila ([[indice_initial1 To] indice_final1[,...
...[,[indice_ initial j To] indice_ final j]...]) [As nume_tip][,...]
unde: indice_ initialj, j=1...n, este valoarea de nceput a indicilor elementelor tabloului
pentru dimensiunea j;
indice_ finalj, j=1...n, este valoarea de sfrit a indicilor elementelor tabloului pentru
dimensiunea j.
Visual BASIC accept tablouri cu maxim 60 de dimensiuni.
Valoarea implicit pentru indice_ initial este 0. Ea poate fi modificat la nivel de modul
folosind instruciunea Option Base 0 sau Option Base 1.
nume_tip este numele tipului atribuit datelor tabloului. Dac este omis, se atribuie tipul
Variant.
Observaie: Visual BASIC accept, pentru elementele unui tablou, i indici negativi.
Exemple de declarare a tablourilor:
Dim TablouA(40)
' TablouA este de tipul Variant cu 41 de elemente indexate de la
' 0 la 40
Dim TablouB(2,5) As Integer'
TablouB este de tip ntreg, cu dou dimensiuni,
' cu indicii iniiali implicit egali cu 0
Dim TablouC(1 To 10, 6 To 15, 11 To 20) As Double
' TablouC este de tip real dubl precizie cu 3 dimensiuni, cu indici ntre limite
' explicitate
Dac dimensiunea tabloului nu poate fi precizat de la nceput, el poate fi declarat
dinamic, cu sintaxa:
Dim Nume_tablou() [As nume_tip]
Se observ c nu a fost specificat lungimea tabloului.
Un tablou dinamic poate fi redimensionat n timpul execuiei programului, cu sintaxa:
ReDim [Preserve] nume_tablou ([indice_initial1 To] indice_final1 [,...]) [As
nume_tip][,...]
De exemplu:
ReDim TabDinamic(10) As Object
La fiecare folosire a instruciunii ReDim, elementele tabloului sufer o reiniializare cu
valoarea Empty pentru tipul Variant, 0 pentru tipul numeric, irul nul "" pentru tipul ir de
caractere de lungime variabil, zerouri pentru tipul ir de caractere de lungime fix, i
Nothing pentru tipul Object.
Acelai lucru se ntmpl i n cazul variabilelor simple declarate cu Public, Private, Static
sau Dim.
Dac se dorete ca redimensionarea tabloului dinamic s lase nealterate valorile
anterioare, trebuie folosit cuvntul cheie Preserve.
126
De exemplu:
Redim Preserve TabDinamic(15) As Object
va pstra valorile anterioare ale tabloului, adugnd la ele alte 5 noi elemente iniializate cu
valoarea Nothing.
Variabilele Variant, sunt variabilele cu tipul cel mai general. Dac, la declarare, unei
variabile nu i se specific tipul, ea capt automat tipul Variant.
Tipul Variant poate memora orice alt tip de date (cu excepia tipurilor de date definite de
utilizator).
Tipul efectiv al unei variabile variant este tipul ultimei valori atribuite.
Variabila de tip Variant poate memora i tipurile de informaii speciale, ca:
- valoarea Empty - semnificnd valoarea unei variabile Variant nainte de prima atribuire;
- valoarea Null - adic valoare necunoscut sau valoare lips.
6.4.3. Vizibilitatea constantelor i variabilelor
Domeniul de vizibilitate al unei variabile este zona de program n cadrul creia este
recunoscut numele variabilei, i este definit prin cuvintele cheie Private i Public.
Domeniul de vizibilitate implicit este Private. Aceasta nseamn c, n lipsa altei specificri, o
constant sau variabil este vizibil local, n cuprinsul procedurii n care a fost declarat.
Dac se dorete ca unele variabile sau constante s fie vizibile peste tot, n toate modulele,
acestea se declar n afara oricrei proceduri, n zona de declaraii a oricrui modul de
programe, ca de exemplu:
Public Matrice(5,6) As Double
n consecin, dou sau mai multe variabile pot avea acelai nume dac au domenii de
vizibilitate diferite.
6.4.4. Durata de via variabilelor
Durata de via a unei variabile este timpul ct ea este memorat i, deci, accesibil. Din
acest punct de vedere se deosebesc trei categorii de variabile:
- Variabile permanente care pstreaz valoarea memorat pe toat durata execuiei
Visual BASIC. Acestea sunt variabilele declarate cu declaraia Public;
- Variabile temporare care sunt declarate n cuprinsul procedurilor (deci de tip Private) i
nu sunt memorate dect pe durata execuiei unei proceduri. Cnd procedura este apelat,
respectivele variabile sunt iniializate i folosite, iar la terminarea execuiei ele sunt "uitate",
adic spaiul de memorie alocat lor este eliberat;
- Variabilele statice sunt acelea declarate cu declaraia Static. Aceste variabile i
pstreaz valorile de la o execuie la alta a procedurilor, att timp ct modulul este n execuie.
De exemplu:
Function Functia1(x As Single)
Static y As Single
...
End Function
pstreaz valoarea variabilei y de la o execuie la alta a funciei Functia1;

pe cnd:
Static Function Functia2(x As Single, y As Single)
...
End Function
pstreaz valorile tuturor variabilelor locale ale funciei Functia2, de la o execuie la alta.
127
6.5. Tipuri de date definite de utilizator

Ca i n alte limbaje de programare moderne, i n Visual BASIC, utilizatorul are
posibilitatea de a crea o combinaie de tipuri de date standard ale limbajului care, apoi, s fie
recunoscut ca un tip nou de dat.
Sintaxa declarrii noului tip de date este:
[Public | Private] Type nume_tip_nou
membru1 As nume_tip1
membru2 As nume_tip2
...
End Type
Declaraia pentru tipuri noi se plaseaz numai n zona pentru declaraii a modulului.
Se observ c, aa cum este formulat sintaxa, ea se aseamn foarte mult cu sintaxa
declarrii structurilor din limbajul C.
Dup declararea tipului nou de dat, acesta poate fi folosit la declararea variabilelor la fel
ca i tipurile de date standard.
Folosirea variabilelor de tip nou se poate face:
- prin referire la ntregul tip, de exemplu:
variabila1=variabila2
unde variabila1 i variabila2 sunt variabile de acelai tip definit de utilizator. Prin aceasta,
fiecare membru al variabilei variabila1 preia valoarea membrului corespunztor din
variabila2;
- prin referire la un membru individual, de exemplu:
variabila1.membruk=expresie
atribuie membrului de rang k membruk din variabila variabila1 valoarea evalurii
expresiei expresie, valoare care trebuie s fie de tipul lui membruk, sau:
variabilax=variabila2.membruj
care atribuie variabilei variabilax valoarea membrului de rang j membruj al variabilei
variabila2, cu aceeai condiie a concordanei tipurilor.
6.6. Expresii
Expresiile sunt construcii care produc o valoare n urma unui proces de evaluare (proces
de calcul, manevrare a unui caracter, testare a unor date).
O expresie este alctuit din operanzi i operatori, i produce o valoare de un anumit tip.
Operanzii sunt elemente asupra crora acioneaz operatorii. La rndul lor, operanzii pot fi
expresii.
Operatorii indic modul cum se face combinarea operanzilor, adic operaiile care pot fi
efectuate.
Exist urmtoarele tipuri de operatori:
+
*
/
^
\
Mod
Operatori aritmetici
adunare
scdere
nmulire
nprire
ridicare la putere
nprire ntreag
Modulo (restul npririi)
<
>
=
<=
>=
<>
Is
Operatori relaionali
mai mic dect
mai mare dect
egal
mai mic sau egal
mai mare sau egal
diferit
Echivalen
128
Observaie: spre deosebire de operatorul =, operatorul Is verific dac dou variabile se

refer la acelai obiect.
Operatorii relaionali produc rezultat True sau False.
&
Like
Operatori pentru iruri de caractere

Concatenare (adugarea unui al doilea ir la sfritul primului)
Similitudine - verific dac al doilea ir se regsete n cadrul primului
Observaie: La operatorul Like, n al doilea ir de caractere se pot folosi i caractere

substitutive (wildcard), conform tabelului urmtor:
Caractere wildcard
?
nlocuirea unui caracter n poziia corespunztoare
*
nlocuirea unui grup de caractere
#
nlocuirea unei cifre zecimale
[lista_de_caractere] nlocuirea oricrui caracter individual, prezent n list
[!lista_de_caractere] nlocuirea oricrui caracter individual, absent din list
Operator
And
Eqv
Imp
Semnificaie
i
echivalen
implicaie
Not
Or
Xor
Nu
SAU
SAU exclusiv
Operatori logici
Rezultatul evalurii
True dac ambii operanzi sunt True, altfel False
True dac ambii operanzi au aceeai valoare, altfel False
True, cu excepia cazurilor cnd primul operand este True iar
al doilea False
True dac operandul este False, False dac operandul este True
True dac cel puin un operand este True, altfel False
True dac numai un operand este True, altfel False
6.7. Conversii de tip

Datele din celulele foilor de lucru EXCEL pot fi de tipuri foarte variate. Pentru a fi
prelucrate prin programe Visual BASIC ele sunt mai nti preluate din celule i apoi
prelucrate n expresii sau funcii. De asemenea, chiar declarate n program, o serie de variabile
pot fi de alt tip dect tipul variabilelor care le vor prelua valorile.
Ca i n limbajul C, se deosebesc dou tipuri de conversii de tip: conversia automat i cea explicit.
6.7.1. Conversia de tip automat
Cnd se lucreaz cu variabile de tipul Variant, Visual BASIC execut automat conversiile
de tip adecvate operaiilor de executat. Cu toate acestea, anumite precauii sunt necesare la
execuia operaiilor aritmetice cu acest tip de date. Mai precis, variabile de tip Variant care
urmeaz s fie convertit, trebuie sa conin fie valori numerice, fie valori de tip ir care s
poat fi convertite numeric.
Sub conv_date()
Dim C1, C2
C1 = "100 Lei"
C2 = C1 * 5
Application.Worksheets("Sheet1").Cells(1, 1) = C2
End Sub
129
poate fi executat fr erori, iar celula A1 din foaia de lucru Sheet1 va afia valoarea 500, n
timp ce, modificnd instruciunea a 2-a prin:
C1 = "100 Kg"
se va afia un mesaj de eroare semnalnd tip de dat nepotrivit.

Aceasta se ntmpl deoarece stilul monetar este recunoscut de EXCEL i, ca urmare,
valoarea de tip ir de caractere "100 Lei" este convertit corect la valoarea numeric 100
(practic subirul "Lei" este ignorat), n timp ce valoarea ir de caractere "100 Kg" este tratat
global ca un ir i nu poate fi convertit la valoare numeric.
Pentru a evita astfel de situaii, se folosete funcia de test numeric IsNumeric(valoare) care
returneaz True dac valoare este numeric sau este convertibil numeric, i False n caz contrar.
Sub conv_date()
C1 = Application.Worksheets("Sheet1").Cells(1, 1).Text
If IsNumeric(C1) Then
Application.Worksheets("Sheet1").Cells(2, 1) = C1 * 5
Else rasp = MsgBox("Tip gresit!", vbOKOnly, "Avertisment")
End If
End Sub
preia irul de text din celula A1 i, dac acesta este convertibil numeric, afieaz dedesubt,
adic n celula A2, valoarea numeric multiplicat cu 5. Dac nu este posibil conversia la
tipul numeric, este afiat o cutie de dialog cu mesajul Tip greit!
n general, funciile de test de tip au forma:
IsTest_de_tip(valoare)
unde Test_de_tip este un nume generic care indic tipul sau subtipul de date testat (de
exemplu: Array, Empty, Null, etc).
6.7.2. Conversia de tip explicit
Dac se dorete specificarea tipului de dat la care s se fac conversia, se procedeaz
astfel:
a. Se testeaz mai nti dac valoarea de convertit are tipul adecvat conversiei, folosinr
funcia de test de tip IsTest_de_tip(valoare);
b. Dac rezultatul testului este True se face conversia folosind funcia de conversie de tip,
cu forma general:
CTip_nou(valoare)
unde Tip_nou indic tipul de date la care se face conversia (de exemplu: Sng pentru
conversia la tipul Single, Dbl pentru conversia la tipul Double, Lng pentru conversia la tipul
Long, etc).
De exemplu:
Sub conv_date()
Dim C1 As Integer
C1 = 100
If IsNumeric(C1) Then
Application.Worksheets("Sheet1").Cells(1, 1) = CVar(C1)
Else rasp = MsgBox("Tip gresit!", vbOKOnly, "Avertisment")
End If
End Sub
convertete valoarea variabilei C1 n valoare de tip variant numei dac valoarea este de tip
numeric, i o transfer celulei A1 din foaia de lucru Sheet1.
130
6.8. Enunurile Visual BASIC

n Visual BASIC exist urmtoarele tipuri de enunuri:
- Declaraiile, sunt enunuri care anun intenia de folosire a unor variabile cu anumite
caracteristici (nume, tip de date, valori iniiale). Aceste probleme au fost deja discutate.
- Definiiile, sunt enunuri care permit introducerea constantelor simbolice, sau a
elementelor de structurare i de modularizare a programelor, numite proceduri. Acestea vor fi
discutate ulterior.
- Aciunile, sunt definite prin instruciuni, care pot fi de urmtoarele tipuri:
a. Instruciunea de atribuire, cu sintaxa:
[Let] variabil=expresie
b. Instruciunea With, se folosete pentru a efectua aciuni multiple de genul:
- stabilirea valorilor unor proprieti ale unui obiect,
- executarea metodei a unui obiect,
- atribuirea de valori unei variabile de tip definit de utilizator (structur).
Sintaxa instruciunii With este urmtoarea:
With obiect
secven_de_instruciuni
End With
unde
obiect este numele obiectului sau variabilei de tip definit de utilizator asupra
creia se acioneaz.
Sub aspect_celula()
With Application.Worksheets("Sheet1").Range("A1")
With .Interior
.ColorIndex = 4
.Pattern = xlGray16
End With
With .Font
.Size = 14
.ColorIndex = 7
End With
End With
End Sub
modific aspectul celulei A1 din foaia Sheet1, printr-o secven de instruciuni With
ncuibate.
c. Alte tipuri de instruciuni, pot fi apeluri de proceduri, apeluri de funcii, instruciuni de
decizie, etc., care vor fi discutate mai trziu.
Un enun se poate fi scris prin extindere pe mai multe linii folosind caracterul secvena
identificatoare de ntrerupere compus din caracterul spaiu urmat imediat de caracterul de
subliniere, cu sintaxa:
enun _
continuareenun
De exemplu:
Application.Worksheets("Sheet1").Cells(1, 5) _
= Application.Worksheets("Sheet1").Cells(2, 5)
6.9. Comentarii
Acolo unde se simte nevoia scrierii unor texte nsoitoare, cu simplul scop de adnotare, i
care nu trebuie luate n considerare de interpretorul Visual BASIC, se poate folosi marcatorul
de nceput de comentariu, cu sintaxa:
131
[enun]
'comentariu
unde:
enun este un enun Visual BASIC oarecare;
comentariu este un text oarecare scris de utilizator dup dorin
Apariia caracterului apostrof comunic interpretorului s ignore tot restul liniei.
De exemplu:
a=255
'atribuie lui a valoarea intreaga 255
Din vechiul dialect BASIC, este recunoscut i forma:
Rem comentariu
unde
Rem , este cuvntul cheie care face ca ntreaga linie s fie ignorat de interpretor.
6.10. Proceduri
Procedurile sunt module de program Visual BASIC.
Procedurile sunt de dou tipuri: subrutine i funcii.
6.10.1. Subrutine
O subrutin este un modul de program (procedur) care efectueaz aciuni n baza unei
liste de parametri.
Definirea unei subrutine se face cu sintaxa:
[Private | Public] [Static] Sub nume_subrutin ([list_de_parametri])
[secven_de_instruciuni]
[Exit Sub]
End Sub
unde:
Private se folosete pentru acele proceduri care trebuie s fie vizibile numai pentru
procedurile aflate mpreun cu ele n aceeai foaie de modul n care se face definiia;
Public se folosete pentru a face procedura vizibil de ctre toate procedurile
din toate modulele;
Static se folosete pentru a pstra valorile variabilelor locale (interne
procedurii) de la un apel la altul;
nume_subrutin este numele procedurii de tip subrutin;
list_de_parametri este lista parametrilor formali (separai prin virgule)
reprezentnd numele variabilelor care recepioneaz valorile datelor de intrare
(transmise la apelul procedurii).
Observaie: numele Public este implicit pentru proceduri.
Exemplu de definire de subrutine:
Sub Calcul_cerc(ByVal Raza As Single)
Dim Arie As Double, Perimetru As Double
If Raza < 0 Then
MsgBox ("Raza gresita")
Exit Sub
End If
Arie = 3.1415 * Raza ^ 2
Perimetru = 6.283 * Raza
Application.Worksheets("Sheet1").Cells(2, 1) = Arie
Application.Worksheets("Sheet1").Cells(3, 1) = Perimetru
End Sub
Sub Tratare_cerc()
Calcul_cerc (Application.Worksheets("Sheet1").Cells(1, 1))
End Sub
132
Scriind o valoare n celula A1 din foaia Sheet1 i apelnd apoi subrutina Tratare_cerc, valoarea
din celula A1 este transmis ca parametru subrutinei Calcul_cerc. Dac aceast valoare este
negativ este afiat o cutie de dialog cu un mesaj de avertizare i execuia se ncheie. n caz
contrar celula A2 primete valoarea ariei cercului iar celula A3 pe aceea a perimetrului lui.
6.10.2. Functii
O funcie este un modul de program (procedur) care primete o list de parametri i, pe
lng posibila efectuare a unor aciuni, returneaz un rezultat.
Definirea unei funcii se face cu sintaxa:
[Private | Public] [Static] Function nume_funcie ([list_de_parametri]) [As nume_tip]
[nume_funcie=expresie1]
[Exit Function]
[nume_funcie=expresie2]
End Function
unde: Private, Public i Static au acelai rol ca la definiia subrutinei;
nume_funcie este numele procedurii de tip funcie;
list_de_parametri este lista parametrilor formali (separai prin virgule) reprezentnd
numele variabilelor care recepioneaz valorile datelor de intrare (transmise la apelul procedurii).
nume_tip se folosete cnd funcia returneaz o valoare de un anumit tip.
n cazul listei de parametri, dac tipurile lor nu sunt specificate, Visual BASIC i consider
n mod implicit ca fiind de tipul Variant. Pentru a declara explicit alte tipuri de date ale
parametrilor, se folosete sintaxa:
[Optional][ByVal | ByRef][ParamArray] nume_parametru [As nume_tip]
unde: Optional indic un parametru opional i oblig ca toi parametrii care urmeaz s fie de
asemenea opionali i de tip Variant. Aceast declaraie nu se folosete mpreun cu ParamArray;
ParamArray se folosete numai la sfritul listei de parametri pentru a indica faptul
c ultimul parametru este un tablou opional i de tip Variant. Astfel se pot declara liste cu
numr de parametri arbitrar. Nu se folosete mpreun cu Optional, ByVal sau ByRef;
ByVal precizeaz c parametrii primesc argumente prin valoare. n acest caz, modificarea
valorilor parametrilor n procedur are efect local, adic nu conduce la modificarea valorii
argumentului n procedura apelant, deoarece parametrul din procedura apelat este o copie.
ByRef produce preluarea argumentului de ctre parametru ca referin (adres de
memorie). n acest fel, att parametrul din procedura apelat ct i argumentul din procedura
apelant puncteaz la aceeai adres de memorie i, ca urmare, orice modificare a valorii lui
n procedura apelat se reflect i n procedura apelant.
nume_parametru este numele parametrului;
nume_tip este tipul de dat al parametrului.
De exemplu:
Function Arie_patrat(ByVal Latura As Double) As Double
If Latura < 0 Then
MsgBox ("Latura incorecta!")
Exit Function
End If
Arie_patrat = Latura ^ 2
End Function
Observaie: Funciile pentru care nu este specificat o valoare de returnare, returneaz

valoarea Empty.
133
6.10.3. Apelul procedurilor

Apelul subrutinelor se realizeaz cu sintaxa:
nume_subrutin[[(]list_de_argumente[)]]
La apelul subrutinelor parantezele rotunde sunt opionale. Argumentele listei se separ prin
virgule.
Deoarece subrutinele nu returneaz nici o valoare ele nu pot fi folosite ca operanzi n
expresii.
Apelul funciilor se realizeaz cu sintaxa:
nume_funcie[(list_de_argumente)]
Argumentele listei se separ prin virgule. Ele pot fi i expresii sau alte funcii.
n momentul execuiei, valorile argumentelor listei sunt transmise funciei.
Observaie: Cnd un argument de apel al unei subrutine sau funcii este o expresie, el este
tratat ca i cum ar fi fost folosit cuvntul cheie ByVal, adic expresia nu va fi afectat de
procedur.
Observaie: Dac o funcie este folosit ca operand ntr-o expresie, este obligatorie
nchiderea listei ntre paranteze.
6.11. Foile pentru module

Foile pentru module sunt destinate scrierii modulelor de program. Ele sunt organizate astfel:
- nainte de a defini proceduri sau funcii, se declar constante sau variabile de uz general
(Public) i tipuri de date definite de utilizator;
- Se definesc procedurile necesare;
- n orice punct al foii de modul pot fi scrise comentarii.
Accesul la procedurile din aceeai foaie de modul este implicit.
Accesul la procedurile din alt foaie de modul a aceluiai document EXCEL se specific
cu sintaxa:
Valoare=[Alt_modul].Procedur(list_de_argumente)
Accesul la procedurile din alt document EXCEL se specific cu sintaxa:
Valoare=[Alt_document].[Alt_modul].Procedur(list_de_argumente)
n acest ultim caz, mai nti trebuie stabilit o referin la Alt_document care trebuie s fie
existent.
Referina se stabilete astfel:
- Se activeaz modulul Visual BASIC apelant;
- Din meniul Tools > References > se deschide cutia de dialog References;
- n cutia de dialog References se selecteaz numele Alt_document din cutia de listare
Available References. Dac numele Alt_document nu apare n list, se apas butonul
Browse pentru a-l selecta din directorul unde este stocat i a-l include n list;
- Se selecteaz caseta de opiune din dreptul numelui Alt_document;
- Se apas butonul OK.
Pentru protejarea procedurii aplicaiei contra unor apeluri nedorite ale unor proceduri din
alte module, se plaseaz cuvntul cheie Private naintea numelui procedurii.
Pentru protejarea ntregului modul, la nceputul modulului se plaseaz declaraia:
Option Private Module
134
6.12. Structuri de control al execuiei n Visual BASIC

Structurile prin care se obine controlul execuiei n Visual BASIC sunt urmtoarele:
6.12.1. Structura bialternan
Structura bialternan se realizeaz cu sintaxa:
If condiie1 Then
[secvena_S1]
[ElseIf condiie2 Then
[Secvena_S21]]
.....
[Else [Secvena_S2n]]
End If
De exemplu:
Function Tip_de_sir(sir As String) As String
nr_caractere = Len(sir)
If nr_caractere = 0 Then
Tip_de_sir = "Sir nul"
ElseIf nr_caractere = 1 Then
Tip_de_sir = "Caracter unic"
Else Tip_de_sir = "Pluricaracter"
End If
End Function
6.12.2. Structura monoalternan

Structura monoalternan se obine eliminnd din instruciunea If alternativele ElseIf i
Else.
Se pot folosi dou sintaxe:
- scrierea pe o singur linie:
If condiie Then Secven
End If ne mai fiind necesar n acest caz, i:
- scrierea pe linii separate:
If condiie Then
Secven
End If
6.12.3. Structura multialternan (selectoare)
Cnd structura decizional a unei probleme impune selectarea uneia dintre mai multe
alternative, se folosete structura selectoare, cu sintaxa:
Select Case expresie_test
[Case list_expresii_1
[secven_S1]]
[Case list_expresii_2
[secven_S2]]
.....
[Case Else
[secven_Sn]]
End Select
unde:
expresie_test este o expresie numeric sau de tip ir, care se evalueaz o
singur dat la nceputul execuiei structurii;
135
list_expresii_j poate avea una dintre formele:

a) expresie_1[, expresie_2[,...]] pentru a testa dac expresie_test are una
dintre valorile expresie_1, expresie_2, etc;
b) expresie_1 To expresie_2, cu expresie_1 < expresie_2, pentru a testa dac
expresie_test este cuprins ntre expresie_1 i expresie_2;
c) Is operator_relaional expresie, pentru a testa relaia dintre test_expresie
i expresie. Ca operator_relaional se poate folosi orice operator relaional cu excepia
lui Is i Like.
Modul de lucru al instruciunii Select este urmtorul:
- este evaluat expresie_test;
- se compar valoarea obinut din evaluare cu valorile din listele list_expresii_j, j=1,...,n,
i se execut acea alternativ Case care corespunde valorii gsite, adic se execut
secven_Sk, unde k este indicele listei detectate a corespunde. Execuia are loc pn la
primul Case, Case Else sau End Select;
- Dac nu a fost gsit nici o coresponden, se execut alternativa Case Else, adic Secven_n
sau, dac nu exist Case Else, se transfer controlul primei instruciuni de dup End Select.
6.12.4. Structura repetitiv contorizat explicit
Aceast structur, cunoscut i sub denumirea de ciclu For, are sintaxa:
For contor=valoare_iniial To valoare_final [Step pas]
[secvena_S1]
[Exit For]
[Secvena_S2]
Next [contor]
unde: contor este o variabil numeric;
valoare_iniial, valoare_final i pas sunt expresii numerice. Dac este omis, pas
este considerat automat egal cu 1;
Modul de lucru al ciclului For este urmtorul:
- este iniializat contor cu valoare_iniial;
- se testeaz dac contor+i*pas>valoare_final, (i=0,1,2,...), cnd pas>0, sau dac este
<valoare_final, cnd pas<0;
- dac nu, se execut ciclul pn la Exit For sau, dac acesta nu exist sau nici o condiie
din secven_S1 nu conduce la ntlnirea lui, pn la Next [contor];
- dac da, se transfer controlul primei instruciuni de dup Next [contor].
Observaie: menionarea variabilei contor dup Next este opional pentru ciclurile For
Next simple. La ciclurile ncuibate, variabila contor trebuie s nsoeasc cuvntul cheie
Next pentru a diferenia ciclurile ntre ele.
Sub colorare_celule()
imax = 5
jmax = 4
For i = 1 To imax
For j = 1 To jmax
Application.Worksheets("Sheet1").Cells(i,j).Interior. _
ColorIndex = (i - 1) * jmax + j
Next j
Next i
End Sub
va produce colorarea unai matrice de 5X4 celule, fiecare celul cu o alt culoare.
136
6.12.5. Structura repetitiv contorizat implicit

Aceast structur este o variant a ciclului For Next numeric, dar se folosete pentru
repetarea unei secvene de instruciuni pentru fiecare element al unei colecii de obiecte sau al
unui tablou. Ea are sintaxa:
For Each element In grup_de_elemente
[secvena_S1]
[Exit For]
[Secvena_S2]
Next [element]
Modul de lucru al acestui ciclu este urmtorul:
- variabila element primete referina ctre primul element din grup_de_elemente;
- se testeaz dac element este ultimul din grup_de_elemente;
- dac nu, se execut instruciunile din ciclu pn la ntlnirea unui Exit For sau, dac acesta nu
exist sau nici o condiie din secven_S1 nu conduce la ntlnirea lui, pn la Next [contor];
- dac da, se transfer controlul primei instruciuni de dup Next [element].
Observaie: n cazul coleciilor, element trebuie s fie o variabil Variant sau Object, iar n
cazul tablourilor, trebuie s fie o variabil Variant.
Sub colorare_celule()
i = 1
For Each c In Selection
c.Interior.ColorIndex = i
i = i + 1
Next c
End Sub
va produce un efect similar cu cel din exemplul anterior, dar asupra unor celule selectate
anterior apelului procedurii.
6.12.6. Structura repetitiv condiionat anterior
Aceast structur are sintaxa:
Do [While | Until] condiie
[secven_S1]
[Exit Do]
[secven_S2]
Loop
unde: While, cu semnificaia ct timp, se asociaz cu condiie True;
Until, cu semnificaia pn cnd, se asociaz cu condiie False;
Exit Do produce abandonarea ciclului;
Loop marcheaz sfritul ciclului.
Modul de aciune al ciclului este urmtorul:
- este evaluat condiie i este testat;
- dac:
= pentru While, condiie=False, sau
= pentru Until, condiie=True
ciclul este ncheiat, controlul fiind transferat primei instruciuni de dup instruciunea
Loop;
- altfel, ciclul este reluat.
137
O variant simplificat a ciclului de tip Do While este urmtoarea:

While condiie
secven
Wend
Sub indexare()
i = 1
While i <= 10
Application.Worksheets("Sheet1").Cells(1, i) = i
i = i + 1
Wend
End Sub
produce completarea celulelor A1 pn la A10 din foaia de lucru Sheet1 cu numerele 1...10
6.12.7. Structura repetitiv condiionat posterior
Aceast structur are sintaxa:
Do
[secven_S1]
[Exit Do]
[secven_S2]
Loop [While | Until] condiie
Semnificaiile elementelor folosite sunt aceleai, dar testarea condiiei are loc la nivelul
instruciunii Loop. De aceea, pe cnd la structura repetitiv condiionat anterior execuia
secvenelor de instruciuni poate s nu aib loc nici o dat, dac condiie nu este de la nceput
valabil, la structura repetitiv condiionat posterior execuia secvenelor va avea loc cel
puin o dat.
6.12.8. Instruciunea de salt
Instruciunea de salt GoTo este o reminiscen a perioadei anterioare introducerii noiunilor
de ingineria programrii i de programare structurat i de aceea folosirea ei nu este
recomandat. Sintaxa ei este:
On expresie GoTo list_de_etichete
unde:
expresie este o expresie a crei evaluare produce un rezultat numeric ntre 0 i 255;
list_de_etichete este o list cu etichete de instruciuni de forma:
etichet1, etichet2,..., etichetn
Etichetele de instruciuni au forma:
etichet:
Modul de aciune al instruciunii este urmtorul:
- se evalueaz expresie;
- dac valoarea lui expresie este 0 sau mai mare dect numrul de elemente ale listei, nu se
obine nici un efect;
- dac valoarea lui expresie este negativ sau mai mare dect 255 se obine o eroare;
- dac valoarea lui expresie se ncadreaz n intervalul 1...255, controlul execuiei este
transferat la instruciunea a crei etichet are, n list_de_etichete poziia de indice egal cu
valoarea lui expresie.
- transferul controlului este definitiv.
Instruciunea GoTo are varianta simplificat:
GoTo etichet
ceea ce produce saltul necondiionat la instruciunea cu eticheta specificat.
138
6.13. Pseudoprocedura
Pseudoprocedura este o secven de instruciuni care ncepe de la o etichet i se termin
cu o instruciune Return. Sintaxa saltului la pseudoprocedur este:
On expresie GoSub list_de_etichete
Mecanismul de aciune este acelai ca la instruciunea On GoTo, cu deosebirea c, la
ntlnirea instruciunii Return, controlul execuiei este transferat la prima instruciune de dup
linia On GoSub.
Varianta simplificat a acestei instruciuni este:
GoSub etichet
i este o reminiscen a versiunilor de limbaj BASIC vechi, nestructurate.
139
Cap. 7. Resurse de interfaare grafic

7.1. Generaliti
Prin resurse de interfaare grafic se neleg modulele de program care determin i gestioneaz
forma obiectelor grafice de interaciune. Prin obiect grafic de interaciune se nelege o reprezentare
grafic din cadrul ferestrei de aplicaie prin care aplicaia interacioneaz cu utilizatorul.
Printre tipurile de resurse grafice se pot enumera urmtoarele cteva exemple:
- Pictogram (icon);
- Cursor;
- Imagine bitmap;
- ir de caractete (etichet label);
- Cutie de dialog;
- Tast acceleratoare;
- Meniu;
- etc.
Crearea i gestiunea resurselor se poate rezolva n dou moduri diferite:
a) n cazul proiectrii aplicaiilor executate direct sub sistemul de operare (n general n
cazul programelor realizate prin compilare):
- Se scriu fiierele de resurse care conin descrierile resurselor, constnd din componena
lor, proprietile i geometria lor (mrime i dispunere n cmpul de lucru). Aceast faz de
generare a resurselor se poate face i prin tehnici interactive sau aa-numite "vizuale";
- Fiecare resurs este asociat cu un identificator care este referit n programul care
utilizeaz resursa;
- Se compileaz setul de module surs de program;
- Se compileaz fiierele resurse, faz din care rezult fiierele resurs compilate;
- Se editeaz legturile dintre modulele compilate i resursele compilate
b) n cazul proiectrii aplicaiilor executate sub mediul de dezvoltare de aplicaii, aa cum
este cazul aplicaiilor scrise n Visual BASIC sub WORD, EXCEL, MicroStation sau
AutoCAD 2000, adic n cadrul programelor executate n regim interpretor:
- Resursele sunt create vizual, n mod interactiv, prin generarea cu scule specializate. De
exemplu, sculele Group Box, Label, Edit Box, Combo Box, etc. n acest caz, definiiile lor
nu mai sunt vizibile n forma text, dei ele exist n fiierul document care conine aplicaia
respectiv. Ceea ce vede utilizatorul este numai aspectul resursei generate i, prin
intermediul unor instrumente de control speciale, proprietile modificabile ale resurselor.
- Cnd are loc prima utilizare n cadrul aplicaiei a resurselor generate, ele sunt compilate
de ctre interpretorul de program (n general un dialect de Visual BASIC).
n afar de cele expuse mai sus trebuie menionat faptul c resursele grafice exploatabile n
cadrul mediilor de dezvoltare a aplicaiilor, sunt mprite n dou:
- Meniurile sunt create prin mijloace distincte i pot fi exploatate prin module de program
scrise de utilizator.
- Celelalte resurse (cutii de dialog, bare cu scule) sunt create de ctre programator i
gestionate prin module de program scrise de ctre acesta.
Rostul acestei separri este acela de a nu expune aplicaia container unor modificri ale
instrumentelor de interaciune de baz de natur a o face necontrolabil.
Aadar, n cazul aplicaiilor create n mediile de dezvoltare a aplicaiilor se poate vorbi
despre dou categorii de resurse de interaciune i anume:
- Resurse de dialog, i
- Resurse de meniu.
140
7.2. Tehnici de interaciune

7.2.1. Dispozitive logice de intrare
Cea mai important caracteristic a unui program este interfaa cu utilizatorul, care se definete
ca fiind totalitatea mijloacelor i metodelor prin care utilizatorul poate dialoga cu programul.
Dintre diferitele metode de interfaare, interfaa sau interaciunea grafic este cea mai
eficient i este preferat de utilizatori.
Sistemele grafice pot avea ataate o mare diversitate de dispozitive fizice de intrare. Pentru
a fi portabile pe ct mai multe platforme, programele trebuie s "vad" dispozitive logice,
adic s lucreze cu un dispozitiv program, n loc de a lucra direct cu dispozitivul fizic.
n acest fel, natura exact a dispozitivului fizic nu mai trebuie s preocupe n mod deosebit
programatorul de aplicaie.
Fig.7.2.1.
Totui, se nate ntrebarea cum se rezolv problemele care in strict de natura dispozitivului
fizic? Aceasta este o sarcin care cade n seama sistemului de operare care, prelund datele
adresate prin intermediul dispozitivului logic le convertete n comenzile necesare lucrului cu
dispozitivul fizic, folosind un program special, aa numit "driver de intrare", figura 7.2.1.
Alteori, este necesar s existe alternative de accesare a intrrilor, iar programul s poat
accesa un dispozitiv fizic sau altul prin intermediul unor dispozitive logice diferite.
Astfel, o serie de programe de tip CAD pot comanda cursorul grafic de desenare-localizare
a entitilor pe ecran folosind fie micarea mouse-ului, fie micarea dispozitivului de urmrire
al tabletei grafice, fie apsarea tastelor sgei ale tastaturii. Sau, n cazul editoarelor de text
cum este WORD, defilarea n jos sau n sus a paginilor se poate face cu tastele Page Down
sau Page Up sau prin intermediul barei de defilare vertical acionat cu ajutorul mouse-ului.
Din aceste motive, standardele grafice GKS (Graphic Kernel System) i PHIGS
(Programmer's Hierarchical Graphical System) definesc ase clase de dispozitive logice de
intrare, i anume:
7.2.1.1. LOCATOR
Dispozitivul LOCATOR este un subprogram care citete o poziie de la un echipament de
intrare i o furnizeaz (o pune la dispoziie) programului ca valoare exprimat ntr-un sistem de
coordonate logice (de exemplu poziia cursorului grafic pe ecran). Poziiile pot fi determinate cu
mouse-ul, joy-stick-ul, tableta grafic sau folosind tastatura cu simboluri sgei.
Acest tip de dispozitiv este folosit cnd, de exemplu, ntr-un program de grafic se cere
desenarea unui segment de dreapt sau a unei polilinii introducnd succesiv punctele nodurilor.
7.2.1.2. STROKE
Acest tip de dispozitiv are acelai rol cu dispozitivul LOCATOR, dar pune la dispoziie un
set de poziii.
Astfel, dac se cere desenarea unui poligon regulat (triunghi, ptrat, pentagon, etc) setul de
puncte care definesc poziiile nodurilor pot fi introduse printr-o singur comand care
apeleaz dispozitivul STROKE.
141
7.2.1.3. VALUATOR
Acest dispozitiv se folosete pentru introducerea unei valori reale care se poate folosi ca:
- factor de scalare;
- unghi de rotire;
- grad de luminozitate (brightness) al unei imagini;
- grad de contrast al unei imagini;
- etc.
Valorile pot fi introduse fie specificnd valoarea dorit a parametrului, fie acionnd un
poteniometru desenat pe ecran, ca n figura 7.2.2, n care se prezint o parte din cutia de
dialog Format Object din WORD.
Fig.7.2.2.
7.2.1.4. CHOICE
Fig.7.2.3 a.
Fig.7.2.3 b.
Fig.7.2.3 c
Dispozitivul logic CHOICE este folosit la selectarea unei opiuni dintr-o list. Valoarea returnat
de subprogramul dispozitiv logic este un numr care reprezint indicele din list al articolului.
Cnd lista este afiat pe ecran, alegerea se poate face folosind mouse-ul sau defilarea cu tastele
sgei, iar selectarea se poate face prin punctare cu mouse-ul sau prin apsarea tastei ENTER.
n figurile 7.2.3 a, b i c sunt prezentate diferite forme de interfaare prin dispozitiv de tip
CHOICE, acestea fiind un meniul scris Help, lista derulant Font i, respectiv paleta de culori
Shading Color, toate extrase de pe bara de instrumente Formatting din programul WORD.
7.2.1.5. PICK
n aplicaiile grafice evoluate, elementele grafice pot fi grupate (asociate n cadrul unor
submulimi ierarhizate pe nivele). n funcie de nevoile lui utilizatorul poate selecta un grup
sau altul pentru a-l manipula sau pentru a-l modifica. Selectarea se face prin punctare cu
cursorul grafic pe ecran, tehnica curent fiind prin clic cu mouse-ul aplicat pe elementul grafic
dorit. n urma acestei aciuni programul dispozitiv logic PICK returneaz identificatorul
142
elementului grafic punctat, identificatorul grupului din care face parte i o informaie de stare
privind succesul sau insuccesul operaiei.
Insuccesul operaiei poate surveni ca urmare a unei punctri
necorespunztoare, fie n afara elementului grafic fie ntre
dou elemente grafice nvecinate. Dac se puncteaz ntr-o arie
n care se suprapun mai multe elemente grafice, dispozitivul
logic PICK returneaz identificatorul celui mai apropiat
element grafic i anume ultimul afiat. De exemplu, n figura
4, a fost aplicat un clic pentru selectare ntr-un punct n care
conturul dreptunghiului i cel al elipsei se suprapun. Ca urmare
Fig.7.2.4.
a fost selectat cel mai recent desenat element dintre cele dou
i anume elipsa, afiarea fcndu-se n ordinea desenrii dac
nu au fost aplicate comenzi de schimbare a ordinii de afiare.
7.2.1.6. STRING
Dispozitivul logic STRING este destinat furnizrii de iruri de caractere care n aplicaiile
grafice nsoesc reprezentrile grafice. Acest dispozitiv este exploatat prin intermediul tastaturii.
7.2.2. Modurile de operare ale dispozitivelor logice de intrare
Interaciunea dintre programul de aplicaie i echipamentele de intrare se poate realiza n
mai multe moduri. Astfel, datele de intrare pot fi introduse:
- la cererea programului;
PICK
STRING
- la intervenia operatorului, situaie n care programul ateapt
terminarea introducerii datelor dup care i continu execuia.
Sistemele GKS i PHIGS opereaz cu cele ase clase de
dispozitive logice n urmtoarele trei moduri:
7.2.2.1. Modul Cerere
n aceast modalitate de lucru programul solicit
efectuarea unei operaii i trece n ateptare pn cnd, prin
intervenia operatorului, dispozitivul logic apelat produce o
PICK
dat de intrare. n acest mod de lucru, programul controleaz
Fig.7.2.5.
n ntregime dialogul.
De exemplu, o cutie de dialog care cere introducerea unei
valori este un grup grafic compus din dispozitive logice de tipurile indicate n figura 7.2.5.
Programul nu permite utilizatorului s acceseze alte resurse pn cnd nu apas asupra
unuia dintre butoanele care sunt controlate de dispozitivele logice de tip PICK. Mai mult,
dac rezultatul returnat de dispozitivul logic STRING (cmpul de editare Valoare:) nu este
corect ca format (aceasta depinde de interpretarea valorii introduse de ctre un etaj de validare
coninut n dispozitivul logic STRING), programul poate afia o cutie de dialog cu un mesaj
de eroare i se poate formula o cerere nou pn la satisfacerea ei n mod corect.
7.2.2.2. Modul Eantionare
n cadrul acestui mod de operare al unui dispozitiv logic, operatorul poate aciona asupra
dispozitivului n orice moment, indiferent de starea programului. Sistemul grafic testeaz
periodic (extrage eantioane) determinnd i memornd ultima dat produs de dispozitiv i
considerat ca "valoare curent".
Acest mod de operare este propriu afirii pe ecran a cursorului grafic ca rezultat al
micrii mouse-ului.
143
7.2.2.3. Modul Eveniment

n acest mod de operare, operatorul preia din iniiativ proprie controlul sistemului.
Dispozitivul logic devine activ i toate datele introduse de operator prin aceast intervenie
sunt memorate de ctre sistemul grafic.
Acest mod de operare este propriu desfurrii operaiilor de intrare lente.
Exemple de evenimente pot fi: apsarea unor butoane grafice de tip Cancel sau Stop n
timp ce sistemul grafic desfoar deja o activitate, suspendarea din execuie a unei aplicaii
care se desfoar ntr-o fereastr pentru a activa desfurarea unei alte aplicaii dintr-o alt
fereastr, etc.
Aceste concepte se regsesc n variante destul de apropiate n diferitele medii de dezvoltare
de aplicaii existente n prezent n uz. Spre exemplificare vom prezenta modul n care se
opereaz cu acestea n dialectul de Visual BASIC implementat n programul EXCEL din
Pachetul Microsoft Office.
7.3. Resurse de dialog

Prin resurse de dialog se neleg obiectele grafice componente ale cutiilor de dialog
definibile de ctre utilizator prin care acesta poate interaciona cu subrutinele create n
limbajul Visual BASIC.
Fig.7.3.1.
Fig.7.3.2.
7.3.1. Crearea unei cutii de dialog definit de utilizator

Pentru a se obine accesul la facilitile de creare de cutii de dialog, din editorul de Visual
BASIC se acioneaz meniul Insert, submeniul UserForm. Ca urmare, va apare o ramificaie
din nodul Microsoft Excel Objects, denumit Forms. La aceast ramificaie se conecteaz o
alta, cu denumirea UserFormk (figura 7.3.1), unde k ia diferite valori, 1, 2, , etc. (de
exemplu UserForm1, UserForm2, , etc.), respectnd ordinea cronologic a crerii cutiilor
de dialog. Denumirile UserFormk sunt denumiri acordate automat i ele pot fi modificate de
ctre utilizator, cu condiia respectrii regulilor de denumire a subrutinelor.
Dup aceast comand, locul cmpului de editare a textului programelor este luat de un
cmp de lucru n care este afiat o cutie de dialog minimal i cutia cu butoane de comand a
crerii componentelor de dialog, denumit Toolbox (figura 7.3.2).
Cu ajutorul cutiei cu scule Toolbox pot fi create o serie de aa numite controale (obiecte
destinate controlului desfurrii execuiei) dintre care enumerm numai pe cele mai des
folosite i mai uor de neles pentru nceptor. Pentru a identifica instrumentele de control
utilizatorul trebuie s urmreasc denumirea instrumentului afiat ntr-o etichet galben la
144
trecerea cursorului grafic peste instrumentul respectiv. n figura 7.3.3 este prezentat o cutie
de dialog care conine o parte din controalele care pot fi create folosind cutia Toolbox.
Mai jos sunt date denumirile acestor butoane scule:
- Select Objects servete la selectarea unui obiect creat anterior, cu scopul modificrii
poziiei, mrimii i proprietilor acestuia;
- Label servete la crearea unei etichete. Eticheta este o inscripie care poate fi plasat n
apropierea unui control pentru a oferi informaii despre rolul acestuia (dac controlul nu este
generat cu propria lui etichet) sau poate fi un simplu text destinat s comunice ceva
utilizatorului;
- TextBox servete pentru a crea o cutie de editare de text. O astfel de cutie servete la
introducerea de ctre utilizator a unei informaii sub form de text, text care va fi apoi
prelucrat de programul asociat conform unei semnificaii specifice destinaiei informaiei
furnizate. Trebuie reinut c la acest tip de control rspunderea scrierii corecte a textului (din
punctul de vedere al informaiei) i a verificrii corectitudinii scrierii cade n seama
programatorului. Astfel dac urmeaz s se indice o valoare numeric, programul trebuie s
verifice mai nti dac textul scris poate fi tratat ca numr i apoi s foreze conversia textului
n dat numeric. n acest caz se poate folosi funcia de test IsNumeric. Mai mult, dac
numrul care va rezulta trebuie s se
ncadreze ntr-un anumit domeniu de
valori, i acest lucru trebuie s fie
verificat de subrutina asociat
controlului;
- ComboBox servete pentru a
crea o cutie combinat pentru listare
de articole i editare a unui text.
Articolele listate constituie un set de
texte asociat controlului. Utilizatorul
poate selecta un articol din list sau
poate scrie un text diferit. i aici
programatorul
aplicaiei
are
rspunderea tratrii corecte a
articolului/textului introdus;
Fig.7.3.3.
- ListBox servete pentru a crea
o cutie de listare din care utilizatorul poate selecta un anumit articol dintr-un set asociat;
- CheckBox servete pentru a crea o caset de opiune neexclusiv. O astfel de caset se
folosete pentru a activa o valoare asociat unei dintre strile bifat/nebifat. Dac exist un grup
care conine mai multe asemenea casete, ele nu se exclud una pe alta, deci pot exista mai multe
casete activate la un moment dat. Este rspunderea programatorului ca valorile asociate strilor
casetelor s nu fie contradictorii, cu consecine nefaste pentru desfurarea programului;
- OptionButton servete pentru a crea o caset de opiune exclusiv sau buton radio.
Asemenea casete se folosesc ntotdeauna cel puin cte dou, grupate mpreun i sunt folosite
pentru activarea de opiuni care se exclud reciproc. Dac se apas un astfel de buton dintr-un
grup, cel care erea activ anterior se dezactiveaz automat;
- ToggleButton - servete pentru a crea un buton bistabil, adic un buton care poate avea
dou stri stabile, apsat sau neapsat. Acest control este destul de asemntor, n ce privete
comportamentul, cu controlul CheckBox;
- Frame - servete pentru a crea un cadru de grup;
- CommandButton - servete pentru a crea un buton de comand. Un astfel de buton,
145
cnd este apsat, lanseaz n lucru subrutina asociat cu el, deci emite o comand al crei
efect este determinat de coninutul subrutinei asociate;
- SpinButton - servete pentru a crea o pereche de butoane pentru
incrementarea/decrementarea (creterea/descreterea) unei valori cu o cantitate fixat;
- Image - servete pentru a crea un buton care afieaz o imagine. El se comport la fel ca
butonul de comand dar, deoarece numele fiierului imagine de afiat este o proprietate variabil a
sa, prin programul (subrutina asociat) el poate afia imagini diferite n funcie de contextul de lucru.
Mai sunt i alte instrumente de creare de controale n cutia TextBox. Detalii suplimentare
asupra folosirii acestora pot fi aflate consultnd help-ul din editorul de Visual BASIC.
7.3.2. Controlul interactiv al proprietilor
obiectelor
Cnd un obiect de control este selectat, fereastra
Properties i schimb automat coninutul conform
naturii obiectului. n figura 7.3.4 este reprezentat o
parte din coninutul aferent situaiei cnd este
selectat cutia de dialog UserForm1.
n fereastr exist o list cu o serie de articole,
dispuse pe rnduri, cte unul pentru fiecare
proprietate, afind la stnga denumirea proprietii,
iar la dreapta valoarea proprietii.
Se pot observa trei tipuri de articole, conform
modului de completare al cmpului valorii
proprietii:
- cmpuri de editare, n care proprietatea se
introduce prin scriere. Acesta este cazul unor
proprieti cum sunt numele (Name) obiectului
Fig.7.3.4.
(nume care poate fi folosit ca identificator de obiect
n program), titlul cutiei de dialog afiat pe bara de captare (Caption), nlimea cutiei de
dialog (Height) sau limea ei (Width), etc;
- cmpuri cu valori selectate din lista de selecie ataat, cum sunt stilul de chenar (Border
Style), stare activat (Enabled), cursor de mouse afiat (Mouse Pointer), etc.;
- cmpuri cu valori selectate dintr-o cutie de dialog asociat, cum sunt corpul de liter
(Font), Imagine de fond (Picture), etc.
Utilizatorul poate folosi modalitile diverse de completare interactiv a cmpurilor
ferestrei Properties pentru a stabili starea iniial a controalelor la afiarea cutiei de dialog.
7.3.3. Controlul programat al proprietilor obiectelor
Pentru ca un obiect de control s execute o aciune trebuie s i se asocieze o subrutin.
Acest lucru se realizeaz ntr-un modul special de proceduri private, astfel:
- se selecteaz obiectul;
- cu obiectul selectat, se acioneaz meniul View>Code. Ca urmare, aria de editare din
dreapta, a editorului de Visual BASIC, va afia o schem de subrutin asociat constnd din
declaraiile de nceput i de sfrit ale subrutinei. De exemplu pentru obiectul
CommandButton1, subrutina privat asociat creat automat va avea forma:
Private Sub CommandButton1_Click()
End Sub
i nimic altceva.
146
Va rmne n sarcina utilizatorului s "umple" subrutina cu instruciunile care descriu

aciunile pe care le va efectua obiectul de control asociat.
Proprietile obiectelor se pot manevra n timpul rulrii prin program.
Deoarece este mai uor de nvat practic i vizual, vom efectua urmtorul exemplu:
A. Se creaz modulul Module1;
B. Se creaz cutia de dialog UserForm1;
C. n aceast cutie de dialog se vor crea un buton de comand (CommandButton1) i un
buton bistabil (ToggleButton1);
D. Din fereastra Properties se stabilesc urmtoarele proprieti:
- pentru cutia de dialog UserForm1:
= Caption = irul de caractere Schimbare de culori
- pentru butonul de comand CommandButton1:
= Caption = irul de caractere Gata!
= Pentru ForeColor se alege o nuan de Magenta (liliachiu)
= Pentru Font se alege Tahoma, Bold, 14
- pentru butonul bistabil ToggleButton1:
= Caption = irul de caractere Gri
= Pentru ForeColor se las culoarea prestabilit (negru)
= Pentru Font se alege Tahoma, Bold, 14
E. Folosind selecia obiectelor i meniul View>Code, se creaz subrutinele asociate pentru
butonul de comand i cel bistabil:
Unload UserForm1
End Sub
Private Sub ToggleButton1_Click()
If ToggleButton1.Value = True Then
UserForm1.BackColor = RGB(255, 0, 0)
ToggleButton1.Caption = "Rosu"
Else
UserForm1.BackColor = RGB(255, 255, 0)
ToggleButton1.Caption = "Galben"
End If
End Sub
F. n modulul Module1 se scrie subrutina:

Sub AfisareDialog()
Load UserForm1
UserForm1.Show
End Sub
Fig.7.3.5.
Pentru a testa efectul lucrrii, se revine ntr-o foaie de

lucru Excel. Din meniul Tools>Macro>Macros se deschide
cutia de dialog Macros de unde se selecteaz denumirea
AfisareDialog i se apas butonul Run. Va fi afiat cutia de
dialog Schimbare de culori, nou creat. La nceput, cutia de
dialog are culoare gri iar butonul bistabil este neapsat i
afieaz inscripia Gri. Cnd acest buton este apsat culoarea
cutiei de dialog devine roie iar inscripia butonului devine
147
Rosu iar cnd este dezapsat, culoarea cutiei de dialog trece n galben i inscripia butonului
devine Galben. Cutia va avea la un moment dat aspectul din figura 7.3.5. Cnd se apas
butonul Gata! cutia de dialog se nchide.
S discutm acum relaia cauzal dintre evenimentele din timpul rulrii aplicaiei, i
instruciunile scrise n subrutinele create.
- La apsarea butonului Run din cutia de dialog Macros este lansat n lucru subrutina
AfisareDialog. Aceasta, ncarc n memorie obiectul UserForm1 i, prin instruciunea
UserForm1.Show afieaz cutia de dialog Schimbare de culori. Prin crearea cutiei de
dialog, denumirea UserForm1 este recunoscut ca obiect de ctre programele Visual Basic
din documentul curent. Notaia .Show apeleaz metoda Show a obiectului UserForm1,
metod prin care are loc afiarea cutiei de dialog;
- n subrutina ToggleButton1_Click blocul decizional bialternan If, prin analiza
proprietii Value a obiectului ToggleButton1 detecteaz dac acesta este apsat (cnd Value
= True) sau neapsat (cnd Value = False). n consecin sunt modificate corespunztor
proprietatea BackColor (culoare de fond) a obiectului UserForm1 la valoarea rou, (funcia
RGB(rou, verde, albastru) ia valoarea maxim 255 pentru componenta roie) respectiv
combinaia rou = 255 i verde = 255 din care rezult galbenul, i proprietatea Caption
(inscripia) obiectului ToggleButton1 ia valoarea ir de caractere "Rou" respectiv "Galben";
- n subrutina CommandButton1_Click, care este lansat n lucru cnd este apsat
butonul de comand cu inscripie Gata!, instruciunea Unload UserForm1 produce
nchiderea cutiei de dialog i descrcarea ei din memorie pentru eliberarea spaiului ocupat.
7.4. Integrarea unei aplicaii n mediul de aplicaie

7.4.1. Generaliti
Exemplul anterior a prezentat numai modul de folosire a resurselor. Aplicaia creat
funciona cumva rupt de mediul n care era implementat din punctul de vedere al utilitii ei
n acel mediu.
Cnd se creaz o aplicaie integrat ntr-un mediu de dezvoltare de aplicaii, rolul ei este de
a lrgi posibilitile de lucru n aplicaia suport.
n principiu se urmrete ca prin procedurile create i prin obiectele (resursele) de
interaciune construite s se manipuleze obiectele componente native ale mediului.
Pentru c suntem n EXCEL vom ilustra integrarea aplicaiei n mediu prin exemple
specifice acestui program.
Exist dou modaliti de integrare a unei noi aplicaii n mediu:
- Prin posibilitatea nregistrrii unei macrocomenzi, cnd mediul nregistreaz un ir de
aciuni ale utilizatorului genernd un program scris automat sau,
- Prin construirea de macrocomenzi de ctre utilizator.
De asemenea, poate exista modalitatea combinat n care, se nregistreaz o
macrocomand i apoi ea este prelucrat (modificat, adugit, etc) de ctre utilizator prin
modificarea i completarea programelor generate automat.
Prima posibilitate se realizeaz prin facilitatea Record Macro din meniul
Tools>Macro>Record New Macro.
n toate situaiile, integrarea nu este complet dac nu este realizat i interfaarea (legtura
dintre mediu i procedurile i resursele nou create), astfel nct automatizarea lucrului s fie
complet.
Pentru mai mult claritate vom analiza pe rnd obiectivele de atins n cadrul construirii
unei aplicaii integrate cu mediul de dezvoltare de aplicaii.
148
7.4.2. Controlul prin program al obiectelor aplicaiei suport

S presupunem o aplicaie n care dorim s prelum o valoare din celula existent n stare
selectat n foaia de lucru activ, s nmulim acea valoare cu un numr la alegerea
utilizatorului i s plasm rezultatul n celula de dedesubt.
Pentru aceasta vom construi o cutie de dialog cu componentele din figura 7.4.1.
Proprietile pe care trebuie s le modifice programatorul sunt:
TextBox1
TextBox2
CommandButton1
CommandButton2
Fig.7.4.1.
Fig.7.4.2.
- Pentru TextBox1: Enabled=False (interzicerea accesului utilizatorului n cutie);

- Pentru CommandButton1: Accelerator=A, Default=True;
- Pentru CommandButton2: Accelerator=n.
Se creaz modulul Module1 n care se scriu subrutinele:
Sub Multiplicare_cu(numar)
Dim Celula As Range
Set Celula = ActiveCell
numar = CStr(numar)
Celula.Offset(1, 0).FormulaR1C1 = "=R[-1]C*" & numar
Celula.Offset(1, 0).Select
End Sub
Aceast subrutin primete la apel valoarea numeric numr. Se definete variabila Celul
ca avnd tipul de dat domeniu de celule (Range) (s-a verificat anterior ca domeniul s
conin o singur celul). Se convertete valoarea numeric numr n ir de caractere, folosind
funcia de conversie CStr. Prin referirea de deplasare Offset(nunr_de_rnduri,
numr_de_coloane) se plaseaz n celula de dedesubt formula de nmulire cu variabila
numr a coninutului celulei. n final se selecteaz celula de dedesubt.
Acest mod de manipulare a coninutului face operaia independent de poziia celulei
selectate iniial, n sensul c este valabil oricare ar fi celula selectat.
Sub Operare()
If Application.Selection.Count <> 1 Then
Call MsgBox("Selectati o singura celula!", vbExclamation + vbOKOnly, "Eroare!")
Exit Sub
Else
Dim Celula As Range
Set Celula = ActiveCell
If Not IsNumeric(Celula.Text) Then
Call MsgBox("Valoare nenumerica!", vbExclamation + vbOKOnly, "Eroare!")
Exit Sub
Else
UserForm1.TextBox1.Text = Celula.Text
Load UserForm1
149
UserForm1.Show
End If
End If
End Sub
Cu aceast subrutin se verific mai nti dac selecia din foaia de lucru Excel const
dintr-o singur celul. Dac nu, se afieaz o cutie cu un mesaj de avertisment, ca n figura
7.4.2 i execuia se termin forat.
Apoi, se verific dac coninutul celulei selectate (active) este numeric. n caz contrar se
emite un mesaj de eroare i execuia se termin forat.
Dac ambele condiii au fost satisfcute, coninutul celulei selectate este plasat n cutia de
editare TextBox1, se ncarc n memorie cutia de dialog i este afiat.
n modulul aferent cutiei de dialog UserForm1 se genereaz subrutinele urmtoare:
numar = TextBox2.Text
If Not IsNumeric(numar) Then
MsgBox "Introducere gresita!", vbExclamation + vbOKOnly, "Eroare!"
Else
Multiplicare_cu Val(numar)
End If
Unload UserForm1
End Sub
Aceast subrutin este executat la apsarea butonului CommandButton1 (de acceptare).

Ea verific dac textul scris de utilizator n cutia de editare TextBox2 are semnificaie
numeric. Dac nu, este emis un mesaj de avertisment iar dac da este apelat subrutina
Multiplicare_cu avnd ca parametru valoarea numeric rezultat din conversia cu fincia
Cval. Pe ambele alternative ale blocului de decizie If execuia se termin cu descrcarea din
memorie i nchiderea cutiei de dialog.
Unload UserForm1
End Sub
A doua subrutin este lansat la acionarea butonului CommandButton2 (de anulare). Are
loc numai descrcarea i nchiderea cutiei de dialog fr alt efect.
7.4.3. Personalizarea aplicaiei
La aceast etap se realizeaz o conexiune ntre un meniu sau un buton de comand creat
de utilizator i cutia de dialog pentru preluarea datelor variabile ale lucrrii.
n analiz final, lanul de interaciune este cel din figura 13:
Fig.7.4.3.
Elaborarea acestei scheme de interaciune constituie etapa de concepie top-down (de la
vrf la baz) a unui program modular, vrful fiind considerat interaciunea operator-meniu
150
(sau operator-buton) iar baza fiind constituit din setul de module de program (subrutine)
folosite pentru executarea aciunilor dorite.
Faza a doua a elaborrii unui program este faza down-top (baz vrf) n care, dup ce au
fost detectate problemele mari de rezolvat, se trece la elaborarea modulelor de program
capabile s le realizeze. n aceast faz modulele de program care se realizeaz trebuie s aib
o ct mai strict delimitare a funciilor realizate pentru ca, n cazul nevoii de depanare sau de
modificare a lanului de execuie, lucrrile corespunztoare s fie fcute ct mai uor iar
rezultatul obinut s fie ct mai sigur.
n cazul nostru, pentru simplitate preferm crearea unui buton de comand n foaia
EXCEL.
Pentru aceasta, din foaia Excel, acionm meniul View>Toolbars>Forms. Se va deschide
cutia cu scule Forms din care ne folosim de instrumentul Button pentru a desena un buton de
comand.
Imediat ce desenarea butonului este terminat se deschide cutia de dialog Assign Macro de
unde selectm numele Operare (subrutina definit mai sus).
Exist i faciliti de ajustare a aspectului scrierii de pe buton, de care ne vom servi pentru
a plasa pe buton inscripia Multiplicare.
Prin acest procedeu am realizat integrarea complet a aplicaiei.
Acum este suficient o apsare pe butonul Multiplicare pentru a putea opera cu cutia de
dialog creat mai sus.
n concluzie, execuia lucrrii trebuie s urmeze etapele:
- proiectarea prin metoda Top-down a componenei aplicaiei;
- dezvoltarea componentelor aplicaiei prin metoda Down-top (de la baz n sus) dar
respectnd obiectivele stabilite prin metoda Top-down.
151
Cap.8. Limbajul FORTRAN. Versiunea FTN95

8.1. Prezentare general
FTN95 este o versiune de limbaj FORTRAN elaborat la Universitatea SALFORD,
dedicat lucrului sub Windows pe 32 de bii i pe reele Microsoft.
Mediul integrat sub care se genereaz programele se numete Salford PLATO.
Un program n FORTRAN are forma general:
[PROGRAM nume ]
instruciuni
END [PROGRAM nume]
Articolele dintre paranteze drepte sunt opionale.

Pot fi incluse comentarii (dac este necesar), ca de exemplu:
PROGRAM Program1
PRINT *, "Salut!" ! Comentariu: Scrierea unui mesaj
END PROGRAM Program1
Aa cum l descrie numele, limbajul FORTRAN provine din prescurtarea FORmula

TRANslation. Majoritatea programelor Fortran se compun din trei pri:
- Introducerea datelor care sunt stocate ca variabile.
- Evaluarea formulelor folosind datele de intrare.
- Extragerea rezultatelor.
8.2. Convenii sintactice generale

Caracterele folosite n Fotran sunt urmtoarele:
- Literele mici i mari ale alfabetului, fr deosebire, caracterul de subliniere _ , i cifrele
0...9;
- Caractere speciale: = + - * / ( ) , . $ : caracterul spaiu ! % & ; < > ?
Pot fi create simboluri prin combinarea de caractere.
Caracterul spaiu servete la delimitarea simbolurilor. Mai multe spaii consecutive sunt
interpretate ca unul singur. De exemplu, scrierea:
a*b este echivalent cu a * b sau cu a * b
n Fortran 95 o instruciune este scris n general pe o linie cu lungimea de maximum 132
de caractere.
Comentariile sunt considerate din poziia de la care se ntlnete caracterul ! i pn la
captul liniei curente. De exemplu:
x = (y z)/2.0 ! Diferenta a doua numere impartita la numarul real 2
Totui, caracterul ! nu iniiaz un comentariu dac el face parte dintr-o construcie standard
a limbajului Fortran 95.
Dac o instruciune nu poate fi complet scris pe lungimea unei linii este permis
continuarea ei pe linia urmtoare dac linia de continuat se termin cu caracterul &.
Exemplul de mai sus se mai poate scrie:
x=
(y z)
/2.0
De asemenea, este permis s se scrie:
&
&
152
x=
& (y z)/2.0
&
Continuarea unei instruciuni este permis pn la limita a 39 linii adiionale.

n succesiunea de continuri este permis intercalarea de linii de comentariu fr ca acestea
s conteze la numrarea celor maxim 39 de linii de continuare.
Ca i n limbajul C, caracterul ; separ mai multe instruciuni scrise pe aceeai linie.
De exemplu:
a = 2; b = 5; c = a/b
Orice instuciune Fortran poate fi etichetat. Eticheta este o valoare numeric ntreag de
maximum 5 cifre, prima trebuind s nu fie nul. De exemplu:
200 CONTINUE
i
0200 CONTINUE
sunt echivalente, deoarece valoarea etichetei este considerat abia de la prima cifr
semnificativ (nonzero).
8.3. Tipuri de date, declarare, iniializare

n Fortran sunt 5 tipuri de date aa numite intrinseci (coninute de limbaj), definind dou
categorii:
a. tipuri de date numerice:
- tipul de date ntregi, desemnat de cuvntul cheie INTEGER
Datele ntregi (cu semn sau fr semn) sunt numere ntregi fr parte zecimal, de exemplu:
200, +32, -127
Domeniul de definiie al acestor numere este limitat la intervalul 2n-1 ... 2n-11, unde n este
16 (pentru stocarea pe 2 octei) sau 32 (pentru stocarea pe 4 octei). Este posibil schimbarea
domeniului prestabilit prin folosirea parametrului de tip KIND despre care vom discuta mai
trziu.
- tipul de date reale, desemnat de cuvntul cheie REAL
Datele reale sunt numere cu parte zecimal i pot fi exprimate n dou forme
= forma natural: 251.37 (mai numit i cu virgul fix)
= forma cu exponent zecimal: 2.5137E+02 (mai numit i cu virgul mobil)
n memoria intern ele sunt stocate n formatul binar cu virgul mobil. Ca i mai sus,
domeniul de definiie este limitat la anumite valori dar el poate fi modificat cu parametrul de
tip KIND.
- tipul de date complexe, desemnat de cuvntul cheie COMPLEX
Datele complexe constau ntr-o pereche de valori reale corespunztoare prii reale i celei
imaginare a unui numr complex.
De exemplu (1.0,-5.0) corespunde numrului imaginar 1 - 5i
b. tipuri de date nenumerice:
- tipul de date caracter, desemnat prin cuvntul cheie CHARACTER
Datele caracter sunt iruri de caractere ncadrate de o pereche de delimitatori, sau , de
exemplu:
Exemplu de sir
sau
Exemplu de sir
- tipul de date logice, desemnat prin cuvntul cheie LOGICAL, i ele pot avea numai
valorile .TRUE. sau .FALSE.
153
Declararea tipului unei date se face n forma general:

Nume_de_tip list_de_variabile
unde numele de tip poate fi unul dintre cele descrise mai sus iar lista de variabile este o
succesiune de nume de variabile separate prin virgule.
De exemplu:
INTEGER i, j, k
REAL a1, b1
COMPLEX z
LOGICAL stare
CHARACTER(6) sir
Iniializarea datelor se poate face ntr-una dintre formele:

Prin instruciunea DATA:
DATA i, a1, z, stare, sir / 10 , 0.04, (1.0,-5.0), .TRUE., SALUT! /
Sau, folosind separatorul ::, astfel:

INTEGER :: i = 10
REAL :: a1 = 0.04
COMPLEX :: z = (1.0,-5.0)
LOGICAL :: stare = .TRUE.
CHARACTER(6) :: sir='SALUT!'
8.4. Parametrizarea
Prin parametrizare, se nelege fixarea unui atribut, de valoare sau de tip.
Cuvntul cheie folosit este PARAMETER. El poate fi folosit astfel:
a. Pentru declararea de constante nemodificabile:
REAL, PARAMETER :: pi = 3.14159
Declarat n acest mod, pi nu mai este o variabil ci o constant care nu se mai poate
modifica pe parcursul programului.
b. Pentru declararea parametrului de tip. Legat de acest subiect trebuie spus c pe diferite
platforme (calculatoare, sisteme de operare) lungimea n octei a unui tip de dat, integer sau
real, poate fi diferit. Dac tipul de dat este definit ca n exemplele date mai sus,
compilatorul va folosi lungimea de tip implicit pe calculatorul pe care se face compilarea. Ca
urmare, transferat pe un alt calculator, programul ar putea s funcioneze defectuos sau de loc,
datorit modului diferit de exploatare a memoriei la scrierea/citirea datelor. De exemplu,
pentru tipul integer lungimea de stocare poate fi pe unele calculatoare de 2 octei iar pe altele
de 4. Pentru tipul real aceast lungime poate diferi de la 2 la 4 octei. Pentru a se putea realiza
portabilitatea deplin a programelor trebuie declarat lungimea tipului de date n mod explicit,
astfel:
INTEGER, PARAMETER :: tip_i = SELECTED_INT_KIND(5)
INTEGER, PARAMETER :: tip_r = SELECTED_REAL_KIND(6,99)
INTEGER (KIND=tip_i) i
REAL (KIND=tip_r) r
n acest exemplu, n primele dou instruciuni, se declar constantele de tip tip_i i tip_r
folosite pentru a stoca lungimile n octei folosite la stocarea variabilelor de tip ntreg (tip_i) i
de tip real (tip_r). Aceste lungimi sunt returnate de funciile intrinseci
SELECTED_INT_KIND i SELECTED_REAL_KIND. Folosirea acestor funcii se supune
urmtoarelor reguli:
154
SELECTED_INT_KIND(nci) returneaz parametrul de tip corespunztor pentru

memorarea numerelor ntregi cu pn la nci cifre, n dat nai sus nostru nci=5, deci cuprins
ntre 99999 i 99999.
SELECTED_REAL_KIND(ncs,exponent) returneaz parametrul de tip corespunztor
pentru stocarea numerelor reale cu un numr de ncs cifre semnificative i situat n domeniul
10-EXPONENT pn la 10EXPONENT. n exemplul nostru este vorba de 6 cifre semnificative i
domeniul ntre 10-99 pn la 1099.
Ulterior, valorile constantelor tip_i i tip_r pot fi atribuite parametrului KIND n
declaraiile de tip, ca n ultimele dou instruciuni, pentru variabilele i i r.
Pentru extragerea parametrilor de tip implicii ale tipurilor ntreg i real sub compilatorul
de Fortran Salford se poate folosi instruciunea:
PRINT *, KIND(1), KIND(1.0)
Aa cum se observ n acest exemplu, argumentele funciei KIND sunt o valoare ntreag
i, respectiv, una real.
8.5. Atribuirea implicit a tipului

Dac nu se specific nimic n mod explicit asupra tipurilor de date, vechile versiuni de
Fortran atribuie tipul de date n mod implicit pe baza conveniei c orice variabil al crei
nume ncepe cu una dintre literele IM este de tip ntreg, altfel fiind considerat de tip real.
Pentru a mpiedica aceast regul s acioneze, se va plasa instruciunea:
IMPLICIT NONE
la nceputul oricrei uniti de program. Ca urmare, compilatorul va reclama orice variabil

a crei declarare explicit a fost omis, la fel ca alte compilatoare ale altor limbaje.
8.6. Tipuri de date definite de utilizator (date structurate)

Ca i n alte limbaje moderne, i Fortran permite crearea de date structurate.
De exemplu, se poate defini o structura care s conin datele de identificare ale unei
persoane, ca mai jos:
TYPE persoana
CHARACTER(LEN=10) :: nume
CHARACTER(LEN=10) :: prenume
INTEGER :: an_nastere
END TYPE persoana
Pentru a declara o dat structurat de tipul de mai sus se va folosi instruciunea:

TYPE(persoana) :: student
Un membru al structurii student poate fi referit individual prin selectorul de component

%, astfel:
student%an_nastere
De asemenea, se pot defini date structurate care refer la rndul lor structuri, ca mai jos:
TYPE punct
REAL :: x,y
END TYPE punct
TYPE triunghi
TYPE(punct) :: a,b,c
END TYPE triunghi
155
Aadar, vom putea face declaraiile:

TYPE(punct) :: m,n,p
TYPE(triunghi) :: tr
m=punct(0,0)
n=punct(1,0)
p=punct(0,1)
tr=triunghi(m,n,p)
Ca urmare, coordonata y a punctului n va putea fi referit sub forma n%y sau sub forma
tr%b%y
8.7. Operatori i expresii

Operatorii sunt combinaii de caractere speciale care specific modul de atribuire i de
transformare a valorilor (operanzilor) i sunt folosii n construcia expresiilor. n funcie de
numrul de operanzi asupra crora se aplic, operatorii pot fi clasificai n operatori unari i
binari.
8.7.1. Operatori unari
Operatorii unari se aplic asupra unui singur operand. Regula general de aplicare este:
operator operand
De exemplu:
- a
.NOT. b
8.7.2. Operatori binari

Operatorii binari se aplic asupra a doi operanzi dup regula general:
operand1 operator operand2
De exemplu:
a b
c * d
a .NE. b
8.7.3. Precedena operatorilor

Precedena operatorilor reprezint prioritatea la aplicarea operaiilor atunci cnd nu se
folosesc paranteze pentru a se fora ordinea operaiilor n modul dorit de programator.
De exemplu, n expresia:
a + b * c
Operaia de nmulire are prioritatea cea mai nalt i va fi efectuat prima. Aadar, primul
rezultat parial va fi b * c i abia apoi acesta va fi adunat cu a.
Operaiile cu preceden egal vor fi efectuate n ordinea scrierii operaiilor.
De exemplu, n expresia:
a / b * c
operaiile de mprire (/) i cea de nmulire (*) au acelai nivel de preceden deci, se va
opera mai nti operaia a / b i apoi acest rezultat va fi nmulit cu c.
8.7.4. Operatori n expresii numerice
n expresiile numerice se folosesc urmtorii operatori:
156
Operator
**
*
/
+
-
Semnificaie
Ridicare la putere (ab)
nmulire (ab)
mprire (a/b)
adunare (a+b) sau plus unar (+a)
scdere (ab) sau minus unar (a)
Preceden (1 = cea mai nalt)

1
2
2
3
3
8.7.5. Conversia de tip

Atunci cnd un operator binar este aplicat asupra a doi operanzi de tipuri diferite,
operandul de tip mai slab (cel ntreg) este convertit la tipul mai tare (cel real) iar rezultatul
este de tipul cel mai tare.
De exemplu:
5 / 10.0 trece n 5.0 /10.0 ceea ce produce rezultatul 0.5
Sursa cea mai frecvent de erori apare la mpririle ntre numere ntregi cnd rezultatul
rezult ca un ntreg obinut prin trunchiere.
Deci, dac mai sus am fi scris:
5/10 rezultatul ar fi fost 0.
O eroare similar poate apare dac se atribuie rezultatul mpririi a dou numere reale unei
variabile ntregi. De exemplu, dac presupunem c n este un numr ntreg, expresia:
n=5.0/10.0
Ar avea ca efect rezultatul n=0 deoarece, dei rezultatul mpririi a fost cel corect, adic
0.5, el a fost convertit la tipul variabilei creia i se atribuie, adic la tipul ntreg, prin
trunchiere.
8.7.6. Operatori la nivel de caracter
Exist numai un singur astfel de operator, concatenarea, notat cu //. De exemplu:
'Tele' // 'fon' produce 'Telefon'
Fiind unul singur, acest operator nu are probleme cu precedena.
8.7.7. Operatori relaionali
Aceti operatori testeaz valabilitatea relaiei dintre doi operanzi numerici. Tipurile
operanzilor pot fi oricare dintre tipurile ntreg sau real. Deoarece expresiile n care intervin
aceti operatori nu conin succesiuni de operanzi, problema precedenei nu se pune.
Exist urmtorii operatori relaionali:
Operator
< sau .LT.
> sau .GT.
<= sau .LE.
>= sau .GE.
== sau .EQ.
/= sau .NE.
Expresie
a b sau a .GT. b
a <= b sau a .LE. b
a >= b sau a .GE. b
a == b sau a .EQ. b
a /= b sau a .NE. b
neles
a strict mai mic dect b
a strict mai mare dect b
a mai mic sau egal cu b
a mai mare sau egal cu b
a egal cu b
a diferit de b
8.7.8. Operatori logici

Operatorii logici sunt folosii n expresiile logice care manipuleaz date logice cu valorile
.TRUE. sau .FALSE. La aceti operatori apare problema precedenei.
Se folosesc urmtorii operatori logici:
Operator
.NOT.
.AND.
.OR.
.EQV.
.NEQV.
Semnificaie
Negare logic (.TRUE. trece n .FALSE. i
invers)
i logic (ambii operanzi sunt .TRUE.)
Sau logic (cel puin un operand este .TRUE.)
Echivalen logic (ambii operanzi sunt
.TRUE. sau ambii sunt .FALSE.)
Non-echivalen logic (un operand este
.TRUE. i cellalt este .FALSE.)
157
Preceden (1 = cea mai nalt)

1
2
3
4
4
8.8. Tablouri
Un tablou este o structur rectangular de elemente de acelai tip.
8.8.1. Tablouri de mrime fix
Tablourile de mrime fix se declar folosind instruciunea:
tip, DIMENSION(mrime) :: nume_tablou
De exemplu:
REAL, DIMENSION(3) :: u
are ca efect rezervarea unui spaiu fix de memorie, cu lungimea de 3 poziii de tip real
pentru tabloul unidimensional u, unde se vor putea scrie/citi valorile u(1), u(2) i u(3).
n acest caz, indicierea tabloului este implicit, ncepnd de la elementul cu indicele 1.
Dac se dorete o alt baz de indiciere, declaraia se face prin explicitare, astfel:
tip, DIMENSION(baz:capt) :: nume_tablou
unde capt=baz+mrime-1
n exemplul de mai sus, pentru baz=2 i mrime=3, se poate scrie declaraia:
REAL, DIMENSION(2:4) :: u
Ca urmare elementele tabloului vor fi u(2), u(3) i u(4).

Dac tabloul este multidimensional declaraia va fi de forma:
tip, DIMENSION(mrime_1, ..., mrime_n) :: nume_tablou
Pentru indicierea cu baz implicit, sau:

tip, DIMENSION(baz_1:capt_1, ..., baz_n:capt_n) :: nume_tablou
cu aceeai regul de calcul a valorilor de capt, pe baza valorilor bazelor i ale mrimilor
mrime_1, ..., mrime_n.
n cazul irurilor de caractere declaraia va avea forma:
CHARACTER, DIMENSION(mrime) :: ir
sau:
CHARACTER(LEN=mrime) :: ir
Este posibil referirea unui subir sub forma:

ir(i:j)
unde i < j < mrime sunt numere ntregi
Sunt de asemenea posibile notaii cu limite subnelese prestabilite:
ir(i:) este echivalent cu ir(i:mrime)
ir(:i) este echivalent cu ir(1:i)
ir(:) este echivalent cu ir(1:mrime)
Declaraia:
158
CHARACTER(LEN=lungime), DIMENSION(nr_rnduri) :: pagina
poate servi la stocarea unei pagini de text cu nr_rnduri fiecare avnd un numr de
caractere egal cu valoarea lungime.
8.8.2. Tablouri de mrime variabil
Tablourile de mrime variabil sunt acele tablouri pentru care se cunoate numai numrul
de dimensiuni, nu i mrimile corespunztoare dimensiunilor, acestea urmnd s fie stabilite
mai trziu n decursul derulrii programului. Regulile de lucru cu aceste tablouri sunt legate
de mecanismele de alocare i gestionare dinamic a memoriei.
Pentru un tablou cu n dimensiuni declararea se realizeaz astfel:
tip, DIMENSION(:, ,:), ALLOCATABLE :: nume_tablou
Mai trziu, n cursul programului, trebuie s aib loc alocarea memoriei cu instruciunea:
ALLOCATE(nume_tablou(mrime_1, , mrime_n))
Dup ce memoria folosit nu mai este necesar, ea trebuie dezalocat cu instruciunea:
DEALLOCATE(nume_tablou)
De exemplu, pentru un tablou cu dou dimensiuni se poate scrie:
REAL, DIMENSION(: , :), ALLOCATABLE :: b
ALLOCATE(b(2,3))
DEALLOCATE(b)
8.9. Structuri de control

8.9.1. Instruciunea de salt necondiionat, GO TO
Instruciunea de salt necondiionat GO TO are forma:
GO TO etichet
...
etichet instruciune_executabil
unde etichet este o valoare numeric ntreag.
Instruciunea GO TO este una controversat, a crei utilizare este n general
nerecomandabil, fiind contrar conceptului de inginerie a programrii i de programare
structurat. Totui, exist un numr de situaii n care ea nu produce efecte negative, i anume:
- Dac produce saltul la sfritul unui bloc;
- Dac produce saltul la sfritul programului.
n aceste situaii instruciunea GO TO este util, servind ca instruciune de ieire n situaii
de urgen.
8.9.2. Instruciunea alternativ, IF
Forma general a instruciunii IF este:
IF(expresie_logic) instruciune
Dac expresie_logic este satisfcut se execut instruciune, altfel controlul este transferat
la instruciunea care urmeaz dup IF.
De exemplu:
IF(indicator) GO TO 10
IF (a <= b) minab=a
159
8.9.3. Blocul de alternative IF

Formele pe care le poate lua blocul IF sunt urmtoarele:
Blocul IF cu o ramur vid:
IF(expresie_logic) THEN
...
END IF
Blocul IF cu dou ramuri:

IF(expresie_logic) THEN
secven_da
ELSE
secven_nu
END IF
Blocuri IF ncuibate:
IF(expresie logic_1) THEN
secven_da_1
ELSE IF (expresie_logic_2) THEN
secven_da_2
...
ELSE
secven_nu_1
END IF
Execuia decurge prin testarea fiecrei condiii logice n parte pn cnd una din ele este
ndeplinit, executnd alternativa afirmativ sau de tip else corespunztoare, dup care
controlul este transferat la sfritul ciclului.
Este recomandabil alinierea scrierii decalate a instruciunilor blocurilor ncuibate pentru a
se putea distinge uor apartenena lor la alternativele diferite, mai ales n cazul ncuibrii.
8.9.4. Blocul alternativ multipl SELECT CASE
Forma general a blocului alternativ multipl este:
SELECT CASE (expresie)
CASE (selector_1)
secven_1
CASE (selector_2)
secven_2
...
[CASE DEFAULT
secven_prestabilit]
END SELECT
unde:
expresie este o expresie care produce o valoare ntreag, de tip caracter sau de tip logic.
Cel mai adesea expresie este doar o simpl valoare;
secven_j este o succesiune de instruciuni;
selector_j este un set de valori pe care le-ar putea lua expresie. Selectorul poate avea una
dintre formele urmtoare:
- o valoare individual, de exemplu:
CASE (1)
- un domeniu de valori, cu forma general CASE(inferior:superior). Sunt admise formele
subnelese:
CASE(inferior:) toate valorile mai mari dect sau egale cu inferior
160
CASE(:superior) toate valorile mai mici dect sau egale cu superior

- o list care poate conine att valori individuale ct i domenii, cu virgula ca separator:
CASE(1, 3, 5:9, 12)
Forma:
CASE DEFAULT
este opional i este menit s asigure executarea unei alternative, n lipsa selectrii
oricreia dintre cele precedente.
Execuia blocului SELECT CASE are loc prin evaluarea expresiei i testarea succesiv a
corespondenei rezultatului produs de ea cu una dintre valorile coninute de alternativele
CASE oferite. Cnd aceast coresponden este detectat se execut secvena alternativ
corespunztoare, dup care controlul este transferat la sfritul blocului SELECT CASE.
Dac nici o coresponden nu a fost detectat, se execut alternativa CASE DEFAULT,
adic secven_prestabilit.
8.9.5. Ciclul repetitiv contorizat DO
Ciclul repetitiv contorizat DO are forma
DO indice = nceput, sfrit, pas
secven
END DO
Ciclul funcioneaz prin executarea secvenei de un numr de ori determinat de valorile de

nceput i sfrit ale lui indice, cu pasul dat.
Dac pas = 1 el poate s fie omis, forma ciclului fiind n acest caz:
DO indice = nceput, sfrit
secven
END DO
O form mai veche a instruciunii DO este cea cu etichet, n forma:

DO etichet indice=nceput, sfrit
secven
etichet CONTINUE
Instruciunea CONTINUE este folosit i n alte construcii unde se dorete s nu se

execute nimic, ea servind numai ca reper ctre care se dirijeaz execuia.
Dac nu se dorete executarea selectiv a instruciunilor ciclului se poate folosi
instruciunea CYCLE a crei ntlnire produce transferul controlului execuiei la instruciunea
END DO. De exemplu:
DO indice = nceput, sfrit
secven_1
IF (condiie) THEN CYCLE
secven_2
END DO
n exemplul de mai sus, ori de cte ori condiie este ndeplinit, se execut instruciunea
CYCLE al crei efect este de a se produce incrementarea indicelui i executarea unui nou
ciclu srindu-se peste secven_2 care nu mai este executat.
8.9.6. Ciclul DO indefinit
Ciclul DO indefinit are forma:
161
DO
secven
END DO
Folosit strict n aceast form ciclul DO devine infinit i conduce la blocarea programului
prin executarea la infinit a aceleiai secvene.
Ieirea din el se poate face folosind instruciunea EXIT, ca mai jos:
DO
secven
IF (condiie) EXIT
secven
END DO
Folosirea acestui tip de ciclu trebuie fcut cu deosebit grij pentru a se evita rmnerea
n bucl infinit dac CONDIIE nu este niciodat satisfcut.
8.9.7. Ciclul DO WHILE
Ciclul repetitiv condiionat anterior DO WHILE are forma:
DO WHILE (condiie)
secven
END DO
Ciclul funcioneaz att timp ct expresia logic CONDIIE este ndeplinit. Trebuie avut
grij ca, pe parcursul operaiilor derulate n secvena de instruciuni, expresia CONDIIE s
se modifice la un moment dat, lund valoarea .FALSE., altfel ciclul poate deveni infinit.
8.9.8. Ciclul DO implicit
Ciclul DO implicit este o structur folosit numai la operaiile de intrare/ieire.
De exemplu:
READ(* , *) (X(I), I=1,5)
are efectul de a citi de la dispozitivul de intrare prestabilit (tastatura) valorile X(1), ..., X(5)
n mod succesiv, ceea ce este echivalentul ciclului DO explicit:
DO I = 1, 5
READ (* , *) X(I)
END DO
8.9.9. Etichetarea (numirea) structurilor de control

n cazul structurilor de control IF i DO, datorit faptului c acestea pot fi ncuibate pe mai
multe nivele de adncime, este util identificarea uoar a nivelelor folosind denumiri.
Ca urmare se pot crea structuri de control de forma:
nume: IF (condiie) THEN
secven
END IF nume
sau:
nume: DO indice=nceput, sfrit, pas
secven
END DO nume
162
8.10. Uniti de program i proceduri

8.10.1. Generaliti
n Fortran exist patru tipuri de uniti de program:
Programe principale
Subrutine
Funcii
Module
Fiecare fiier surs conine unul sau mai multe uniti de program i este compilat separat,
dup compilare fiind necesar o etap de legare a codurilor obiect rezultate.
8.10.2. Programe principale
Fiecare program Fortan trebuie s conin un singur program principal care poate apela alte
subprograme.
Forma general n care se prezint un program principal este urmtoarea:
PROGRAM [nume]
instruciuni USE
[IMPLICIT NONE]
declaraii de tip
instruciuni executabile
END [PROGRAM [nume] ]
8.10.3. Subrutine
O subrutin este o unitate de program care execut aciuni i poate fi apelat dintr-o alt
unitate de program cu instruciunea:
CALL nume_subrutin (list_de_argumente)
Forma general a unei subrutine este urmtoarea:

[RECURSIVE] SUBROUTINE nume (list_de_argumente)
instruciuni USE
[IMPLICIT NONE]
declaraii de tip
END [SUBROUTINE [nume]]
Specificaia RECURSIVE este obligatorie dac subrutina este recursiv adic dac se
autoapeleaz.
Argumentele din lista de argumente sunt transmise prin referin. Aceasta nseamn c sunt
transmise adresele locaiilor de memorie unde se afl argumentele reale i deci orice
modificare a variabilelor corespunztoare din cuprinsul subrutinei se reflect n programul
apelant. Spre deosebire de acest mecanism de transfer, transmiterea argumentelor n C i C++
se face n mod normal prin nume (dac nu se folosesc pointerii), ceea ce nseamn c
argumentele formale din subprogram sunt copii ale argumentelor reale i modificrile lor nu
afecteaz programul apelant. Aadar, mecanismul de transfer al argumentelor din FORTRAN
nu respect principiul ncapsulrii datelor, ceea ce este un dezavantaj din punctul de vedere al
ingineriei programrii i al programrii structurate. Acelai lucru este valabil i pentru
transmiterea argumentelor funciilor, despre care se va vorbi mai jos. Din aceste motive
programatorul de FORTRAN trebuie s acorde o atenie deosebit evitrii efectelor laterale
care ar potea fi produse involuntar, spre deosebire de cei care programeaz n C i C++, unde
efectele laterale se obin n mod voit.
163
8.10.4. Instruciunea STOP

n mod normal execuia unitii de program se ncheie la instruciunea END.
Instruciunea STOP produce de asemenea ncheierea execuiei unitii de program n care
se afl inclus. Pot exista mai multe instruciuni STOP ntr-o unitate de program, la care se
poate ajunge pe diferite ci, fie prin instruciune de salt GO TO la o instruciune STOP cu
etichet fie prin includerea instruciunii STOP ntr-o structur IF, etc.
Forma general a instruciunii STOP este:
[etichet] STOP mesaj
8.10.5. Funcii
O funcie o unitate de program care primete o list de argumente i returneaz o valoare.
Funcie poate fi invocat prin simpla utilizare a numelui ei ntr-o expresie, de exemplu:
variabil = funcie(list_de_argumente)
n zona de fiier surs unde se face definirea funciei, numele acesteia este tratat ca o
variabil creia trebuie s i se defineasc tipul, acesta fiind tipul rezultatului returnat de
funcie.
Forma general a unei funcii este urmtoarea:
[RECURSIVE] [tip] FUNCTION nume (list_de_argumente) [RESULT (nume_rez)]
instruciuni USE
[IMPLICIT NONE]
declaraii de tip
END [FUNCTION [nume]]
Declaraia RECURSIVE este obligatorie dac funcia este recursiv (se autoapeleaz).
Declaraia RESULT definete o variabil care preia valoarea funciei pentru utilizare n
interiorul unei funcii recursive deoarece n interior, numele funciei nu poate fi folosit ca
variabil.
De exemplu, pentru a calcula suma primelor n numere se poate scrie funcia:
RECURSIVE INTEGER FUNCTION sum_n(n) RESULT (rez)
INTEGER n
INTEGER rez
if (n==0) then
rez=0
else
rez=n+sum_n(n-1)
end if
END FUNCTION sum_n
Dac se pune problema ca funcia s se ncheie altfel dect prin atingerea instruciunii
END, se va folosi instruciunea RETURN n aceleai condiii ca i instruciunea STOP la
subrutine sau programe principale.
Forma general a instruciunii RETURN este:
[etichet] RETURN
8.10.6. Argumente reale i formale. Argumente opionale

Argumentele reale sunt cele care apar la referirea unei proceduri (apel de subrutin sau de
funcie). Ele specific entitile reale pe care procedura le va folosi pe parcursul execuiei ei.
Aadar, aceste argumente pot fi valori efective sau variabile care pot avea valori diferite la
fiecare referire. Unele argumente sunt folosite ca valori de intrare n procedura referit (ele
164
pot fi valori sau variabile), altele sunt variabile care recepteaz rezultatele execuiei
procedurii, iar altele pot avea pot avea ambele destinaii.
Argumentele formale sunt cele care apar ca nume n interiorul procedurilor. Aceswte
nume sunt specificate cnd procedura este definit i sunt folosite n calculele din interiorul
procedurii.
Cnd procedura este referit are loc o asociere ntre argumentul real i cel formal pe
principiul poziionalitii. Aceasta nseamn c primul argument real din lista de argumente a
referirii (apel de subrutin sau funcie) este asociat cu primul argument formal al listei din
definiia procedurii, al doilea argument real cu al doilea argument formal, etc. Aceasta impune
corespondea de tip i dimensionalitate (n cazul tablourilor) ntre cele dou tipuri de argumente.
Argumentele opionale sunt acele argumente formale care pot s nu aib un corespondent
ca argument real la referirea unei proceduri, dac ntr-un anume caz de execuie particular
aceasta nu este necesar. n acest caz, la referirea procedurii, argumentele reale
corespunztoare pot lipsi din lista de argumente sau pot fi specificate n alt ordine.
n definiia procedurii opionalitatea argumentului se semnaleaz prin declaraia de atribut
OPTIONAL a crei form este:
OPTIONAL list_de_argumente_opionale
unde list_de_argumente_opionale este o list de nume de argumente formale (interne

procedurii) separate prin virgule.
Deoarece principiul corespondenei prin poziionalitate funcioneaz i n acest caz,
abaterea de la acest principiu constituie o excepie care trebuie semnalat.
Regula este aceea c, dac un argument opional este omis din lista de referire, atunci fie
toate argumentele opionale de la el pn la captul listei sunt omise fie, existena celor
rmase este semnalat prin scrierea argumentului real n forma:
nume_argument_formal=nume_argument_real
De exemplu:
PROGRAM atribuiri
IMPLICIT NONE
REAL a,b,c
INTERFACE
SUBROUTINE afisare(x,y,z)
OPTIONAL y,z
REAL x,y,z
END SUBROUTINE afisare
END INTERFACE
a=1.0; b=2.0; c=3.0
CALL afisare(a,z=c)
END PROGRAM atribuiri
SUBROUTINE afisare(x,y,z)
IMPLICIT NONE
OPTIONAL y, z; REAL x,y,z,u,v,w
u=x
IF (PRESENT(y))THEN; v=y; ELSE; v=1.0; END IF
IF (PRESENT(z))THEN; w=z; ELSE; w=1.0; END IF
WRITE(*,*)u,v,w
END SUBROUTINE afisare
Se pune ntrebarea ce se ntmpl totui dac un argument opional nu este furnizat la

apelul procedurii. Deranjeaz lipsa aceastuia execuia? Acest lucru este posibil, dac nu se
165
folosesc valori prestabilite pentru argumentele lips. Pentru a realiza acest lucru este util
funcia logic intrinsec (coninut n biblioteca de funcii a compilatorului) PRESENT(arg).
Ea returneaz un rezultat logic (.TRUE. sau .FALSE.) care poate fi folosit pentru a adopta
sau nu valoarea prestabilit, aa cum se vede n exemplul de mai sus.
n acest exemplu a trebuit construit o interfa ntre programul principal i procedura
apelat (subrutina) folosind blocul INTERFACE care repet n corpul programului principal
semntura subrutinei, adic numele (dac este funcie tipul de valoare returnat), lista de
argumente, tipurile argumentelor i proprietile lor.
n afar de aceste msuri mai trebuie luat i msura ca un argument formal opional care
nu este prezent s nu fie invocat. Astfel, se observ c instruciunea WRITE(*,*)u,v,w nu
folosete argumentele y i z deoarece, dup caz, ele ar putea sau nu s fie furnizate. Singura
funcie care poate folosi numele acestor argumente este funcia PRESENT.
n exemplul de mai sus rezultatul afiat dup rulare este:
1.000000
1.000000
3.000000
deoarece lipsind al doilea argument, adic y, el a primit valoarea 1.0 prin intermediul
blocului IF corespunztor.
Argumentele opionale pot fi furnizate i ntr-o alt ordine dect cea din lista
subprogramului dac excepia este semnalat prin menionarea numelor formale.
8.10.7. Conservarea valorilor. Atributul SAVE
n mod normal, la revenirea dintr-un subprogram (subrutin sau funcie) compilatorul
Fortran permite calculatorului s uite valorile variabilelor definite n subprogram. Dac este
necesar conservarea valorilor unora sau altora dintre aceste variabile, ele pot fi asociate cu
atributul de salvare, astfel:
tip, SAVE :: list _de_variabile
Dac declaraia de tip a avut loc anterior, instruciunea SAVE poate fi scris separat:
SAVE :: list _de_variabile
unde list_de_variabile are forma nume_var_1, ... nume_var_n

De exemplu:
REAL, SAVE :: a, b, c
O instruciune SAVE fr list de variabile produce salvarea valorilor tuturor variabilelor

subprogramului. Acest lucru nu este recomandabil, deoarece nu toate compilatoarele se
comport la fel de eficient n acest caz. De asemenea, trebuie s se analizeze cu atenie
posibila apariie de efecte laterale (transmitere nedorit de valori asupra altor variabile).
8.10.8. Module de program
Modulele de program sunt colecii de cod surs grupate n fiiere separate care pot fi
invocate n diferite uniti de program. Rolul lor, ca i n alte limbaje (de exemplu fiierele
antet din C) este de a realiza economia de efort, prin preluarea n unitile de program a unor
definiii, declaraii, subrutine i funcii deja scrise i verificate.
Forma general a unui modul este urmtoarea:
MODULE nume_de_modul
declaraii i definiii de date
...
CONTAINS
definiii de subprograme ale modulului
...
END [MODULE [nume_de_modul]]
166
Modulelor li se aplic urmtoarele reguli:

- Dac un modul este scris n acelai fiier cu programul principal, el trebuie plasat naintea
programului principal;
- Aa cum se observ n definiia general de mai sus, modulul ncepe i se termin cu
instruciunile:
MODULE nume_de_modul
END [MODULE [nume_de_modul]]
- Orice unitate de program care folosete coninutul modulului, trebuie s l invoce cu

instruciunea:
USE nume_de_modul
plasat imediat dup numele programului. Dup aceast instruciune variabilele i

subprogramele coninute n modul pot fi folosite. Dac variabilele au fost declarate i definite
n modul, ele nu mai trebuie declarate i definite din nou, simpla invocare a modulului prin
instruciunea USE fiind suficient;
- Este posibil ca un nume folosit n modul s intre n conflict (s fie acelai) cu un nume
folosit n unitatea de program invocatoare. Pentru a se evita conflictul, n instruciunea USE
se poate include o instruciune de schimbare local a numelui conflictual din modul, n forma:
USE nume_de_modul, nume_local => nume_din_modul
- Dac nu se dorete preluarea tuturor variabilelor din modul ci numai a unora, acest lucru
se specific astfel:
USE nume_de_modul, ONLY: variabila_1, ..., variabila_n
unde variabila_1, ..., variabila_n este lista variabilelor de preluat din modul;
8.10.9. Vizibilitatea datelor din module. Atributele PUBLIC i PRIVATE
Una dintre utilizrile cele mai rspndite ale modulelor este de a crea un stoc de date
comun pentru toate unitile de program care l folosesc. Din acest motiv, toate variabilele
unui modul sunt considerate n mod implicit publice.
Dac, din motive care in de separarea datelor comune de cele particulare, evitarea
efectelor laterale, etc, se dorete ca unele variabile s nu fie vizibile n exteriorul modulului,
iar altele da, se va explicita aceasta folosind atributele PUBLIC i PRIVATE, astfel:
tip, PUBLIC :: list_de_variabile
sau
tip, PRIVATE :: list_de_variabile
un atribut PUBLIC sau PRIVATE neurmat de o list de variabile declar toate variabilele
modului ca fiind publice sau private. De exemplu:
PRIVATE
REAL, PUBLIC :: A
declar toate variabilele modulului cu excepia variabilei reale A ca fiind private.

8.10.10. Fiiere externe. Directiva INCLUDE
Nevoia de a lucra cu fiiere care s conin poriuni de cod surs prefabricate, astfel nct
s se economiseasc efort la scrierea programelor mari, a fcut ca de la versiunea Fortran 77
s fie folosit directiva de compilator INCLUDE. Aceasta are forma:
INCLUDE nume_fiier
unde nume_fiier este numele fiierului text de inclus.
167
Fiierul de inclus poate conine orice secven de declaraii i instruciuni valide n contextul
poziiei din fiierul gazd n care vor fi incluse. Efectul directivei este de a compila programul ca i
cum secvena de cod surs ar fi inclus s-ar afla efectiv ncepnd de la linia directivei INCLUDE.
n FTN95 se poate include orice fel de fiier text, cu condiia ca el s fac parte din
structura unui fiier proiect. Cu toate acestea se prefer folosirea fiierelor cu denumirea
avnd forma NUME.INC, deoarece numai acestea beneficiaz de facilitatea de analiz
sintactic constnd din semnalarea corectitudinii scrierii cuvintelor cheie ale limbajului.
Ca exemplu vom restructura aplicaia prezentat mai sus la subcapitolul de funcii,
subiectul recursivitate, astfel:
Se va folosi un proiect care va conine fiierele urmtoare:
Fiierul programului principal CALCUL_SUMA.f95:
PROGRAM calcul
USE suma_de_n
INCLUDE 'date.inc'
INTEGER k
k=sum_n(i)
WRITE(*,*) k
END PROGRAM calcul
Fiierul de modul sum_n.f95:

MODULE suma_de_n
IMPLICIT NONE
CONTAINS
RECURSIVE INTEGER FUNCTION sum_n(n) RESULT (rez)
INTEGER n
INTEGER rez
IF (n==0) THEN
rez=0
ELSE
rez=n+sum_n(n-1)
END IF
END FUNCTION sum_n
END MODULE suma_de_n
Fiierul de includere date.inc conine numai declaraia de tip cu iniializare:

INTEGER ::i=5
Rezultatul afiat de program dup rulare va fi 15.

i fiierele de modul i cele de includere au acelai efect, i anume acela de creare din
buci a programului complet.
Deosebirea dintre fiierul de modul i fiierul de includere este aceea c pentru fiierul de
modul compilarea se face separat, nainte de etapa de legare a codurilor obiect individuale ale
componentelor proiectului, n timp ce compilarea codului surs al fiierului de includere se
face odat cu compilarea unitii n care el este inclus prin directiva INCLUDE.
8.11. Operaii de intrare/ieire

8.11.1. Instruciunea FORMAT
Instruciunea FORMAT este destinat descrierii modului cum vor fi citite sau scrise datele.
Forma ei general este:
etichet FORMAT (list_de_articole_de_format)
168
unde:
etichet este o valoare numeric ntreag i pozitiv. Ea este necesar pentru referirea
formatului n instruciunile de citire/scriere cu format explicit.
list_de_articole_de_format este o list cu articole de forma:
r descriptor_de_format
separate prin virgule. ntre valoarea r i descriptor_de_format nu se las spaiu separator.

De exemplu:
2I5
semnific dou valori ntregi cu 5 cifre.

r este repetitorul, constnd dintr-o valoare numeric ntreag pozitiv care stabilete
numrul de valori de citit/scris care au acelai format. Dac r=1 el nu se menioneaz.
n exemplul de mai sus repetitorul este 2.
descriptor_de_format este o combinaie de forma:
specificator_de_format
lungime_de_scriere
scrise fr spaiu separator

n exemplul de mai sus descriptorul de format este I, iar lungimea de scriere este 5.
Specificatorul de format poate fi unul dintre urmtoarele:
I pentru numere ntregi. n acest caz lungime_de scriere este un numr pozitiv ntreg
reprezentnd numrul de poziii rezervate pentru scrierea cifrelor numrului. De exemplu:
I5
F pentru numere reale. n acest caz lungime_de scriere va apare n forma:

nc.ncz
unde nc este numrul de cifre ale prii ntregi iar ncz este numrul de cifre ale prii
zecimale. De exemplu:
F5.3
E pentru numere reale reprezentate n format cu mantis i exponent zecimal. n acest caz
lungime_de scriere va apare n aceeai form ca i la specificatorul F. De exemplu:
E12.5
ar putea produce o scriere de forma 0.12345E+03 echivalent n scrierea normal cu

123.45. Deoarece semnul mantisei, cifra 0, punctul zecimal i exponentul E+nn totalizeaz 7
caractere, trebuie ca numrul de cifre zecimale specificat s fie mai mic dect lungimea total
(n acest caz 12) minus 7. Astfel, un format E12.6 nu ar putea fi folosit deoarece nu ar mai
rmne destule poziii pentru cele 7 elemente de scriere enumerate mai sus.
D pentru numere reale n format cu exponent zecimal dar n dubl precizie. Regula este
aceeai ca i la formatul E.
A pentru iruri de caractere. n acest caz lungime_de scriere este un numr pozitiv ntreg
reprezentnd numrul de poziii rezervate pentru scrierea caracterelor irului. De exemplu:
A20
X pentru scrierea unui spaiu gol sau ignorarea citirii unui caracter. De exemplu:
6X
semnific 6 spaii goale.
169
L pentru valori logice. n acest caz lungime_de scriere este un numr pozitiv ntreg
reprezentnd numrul de poziii rezervate pentru scrierea caracterelor valorii logice (.TRUE.
sau .FALSE.).
Exemple de formate de scriere:
100 FORMAT(I3, F5.2, 2I5, 3E12.5)
200 FORMAT(2(I3, F7.4), I4)
Cel de al doilea exemplu prezint un caz de folosire a listelor de articole de format ncuibate.
8.11.2. Instruciuni pentru transferul datelor
8.11.2.1. Instruciunea READ
Instruciunea READ, poate avea una dintre urmtoarele dou forme:
READ (list_specificatori_control_I/O) list_de_articole_de_citit
sau
READ etichet_de_format , list_de_articole_de_citit
unde list_specificatori_control_I/O este o list care poate conine articolele

urmtoare separate prin virgule. Cuvintele cheie scrise cu majuscule i ncadrate de paranteze
drepte nu sunt necesare dect dac nu se respect ordinea de scriere a articolelor:
[UNIT=] unitate
este numrul unitii de intrare/ieire de la care se citesc datele. Pentru dispozitivul

implicit, n acest caz tastatura, se folosete caracterul * iar pentru fiiere un numr definit n
instruciunea OPEN
[FMT=] etichet_de_format
este eticheta numeric care nsoete instruciunea FORMAT

[NML=] nume_de_list_de_variabile
specific citirea unor variabile declarate ca fcnd parte dintr-o list denumit. Citirea se face
n ordinea declarrii lor n list. Instruciunea care creaz lista este NAMELIST i are forma:
NAMELIST /nume_de_list/ list_de_variabile
De exemplu:
NAMELIST /date_personale/ an_nastere, luna_nastere, ziua_nastere
[IOSTAT= variabil_de_stare_I/O]
variabil_de_stareI/O va cpta una dintre valorile:

- 0 citirea a avut loc cu succes
- ntreg negativ a fost atins captul de fiier (EOF) sau de nregistrare (EOR). n FTN95
Salford valorile posibile sunt: -1 pentru EOF i 2 pentru EOR.
- ntreg pozitiv a survenit o eroare de alt tip
Valoarea acestei variabile este util atunci cnd se fac citiri dintr-un fiier. Analiza ei
ulterioar n program permite dirijarea execuiei pe ramurile de tratare a erorilor adecvate
cazului de eroare care a survenit n timpul operaiilor de citire/scriere din/n fiier;
[ERR=etichet]
instruiete programul s sar la eticheta unei ramuri de tratare a erorii survenite prin
apariia unei erori. Aici variabila de stare I/O este util pentru a discerne ntre cazurile de
eroare de intrare/ieire;
[END=etichet]
instruiete programul s sar la eticheta unei ramuri care trateaz cazul de atingere a
sfritului de fiier.
170
Lista de articole de citit este compus din variabilele a cror citire se va efectua, separate
prin virgule.
Dac instruciunea format folosete numai primele dou articole, UNIT i FMT
menionarea acestor dou cuvinte cheie nu este necesar i instruciunea are forma:
READ (unitate, etichet_de_format) list_de_articole_de_citit
De exemplu, instruciunile:
READ (*, 100) i, x
100 FORMAT (I5, F7.3)
vor produce citirea de la tastatur a valorilor ntreag i i real x cu formatul specificat la

eticheta 100.
Acelai efect l va avea i:
READ 100, i, x
citirea fcndu-se de la dispozitivul de intrare implicit, adic tastatura.

8.11.2.2. Instruciunea WRITE
Instruciunea WRITE are forma:
WRITE (list_specificatori_control_I/O) list_de_articole_de_scris
iar semnificaiile entitilor menionate sunt aceleai. Dispozitivul implicit este ecranul, iar
notaia pentru acesta este tot caracterul *.
Pentru a se evita ca la scriere s se introduc caracterul de salt la linie nou se poate folosi
n lista de specificatori de control I/O articolul:
ADVANCE = 'NO'
8.11.2.3. Instruciunea PRINT

Instruciunea PRINT are forma:
PRINT etichet_de_format, list_de_articole_de_scris
Se poate folosi i formatul implicit, n acest caz forma instruciunii fiind:

PRINT *, list_de_articole_de_scris
8.11.2.4. Instruciunea OPEN

Instruciune OPEN stabilete un canal de comunicaie cu un fiier i o unitate extern i
stabilete parametrii de comunicare. Forma instruciunii este urmtoarea:
OPEN (list_de_specificatori_de_comunicare)
list_de_specificatori_de_comunicare poate conine urmtoarele articole separate prin

virgule:
[UNIT =] numr_de_unitate
asociaz numrul de unitate cu fiierul de exploatat;

ACCESS = tip_de_acces
tip_de_acces poate fi unul dintre cuvintele cheie DIRECT sau SEQUENTIAL (implicit);
ACTION = metoda_de_aciune
metoda_de_aciune poate fi unul dintre READ, WRITE sau READWRITE;

BLANK = tratare_spaii_goale
tratare_spaii_goale poate fi:
NULL pentru a ignora spaiile goale din cmpurile numerice;
ZERO interpreteaz toate spaiile goale cu excepia primului ca fiind zerouri;
171
Observaie: specificatorul BLANK se menioneaz numai pentru fiierele conectate cu

intrare/ieire formatat. Valoarea prestabilit este NULL.
DELIM = tip_de_delimitator_de_ir
tip_de_delimitator_de_ir poate fi unul dintre cuvintele cheie:
APOSTROPHE folosete apostroful ca delimitator de ir de caractere. Dac ntr-un ir de
caractere va fi ntlnit un caracter apostrof, el va fi dublat;

QUOTE folosete ghilimelele ca delimitatori de ir. Dac ntr-un ir de caractere va fi
ntlnit un caracter ghilimea, el va fi dublat;
NONE este prestabilit, nu sunt folosii delimitatori de ir;
Observaie: acest specificator se folosete numai la fiierele conectate pentru operaii de
intrare/ieire formatat i este ignorat la fiierele pentru ieire formatat;
ERR = etichet
specific eticheta unei ramuri de program care trateaz apariia unei erori de comunicare
descris de specificatorul IOSTAT;
FILE = nume_de_fiier
nume_de_fiier trebuie s respecte regulile din sistemul de operare cu care se lucreaz;

FORM = tip_de_nregistrri
tip_de_nregistrri poate fi unul dintre cuvintele cheie:
FORMATTED toate nregistrrile sunt formatate;
UNFORMATTED toate nregistrrile sunt neformatate (valoare implicit dac fiierul este
conectat pentru acces direct i dac specificatorul FORM este absent);
IOSTAT = indicator_de_stare
indicator_de_stare poate avea una dintre valorile:
0 dac nu a intervenit nici o eroare;

ntreg pozitiv dac a intervenit o eroare;
PAD = completare
completare poate avea ca valoare unul dintre cuvintele cheie:
YES care produce completarea cu spaii goale dac list_de_articole_de_citit conine mai
multe articole dect conine nregistrarea. Aceast valoare este prestabilit;

NO dac se impune ca nregistrarea de citit s conin datele specificate de
list_de_articole_de_citit i de formatele specificate;
POSITION = stare_indicator_de_poziie
stare_indicator_de_poziie specific poziionarea n fiier a indicatorului de
poziie curent i poate fi unul dintre cuvintele cheie:

ASIS pentru meninerea neschimbat a poziiei (valoare prestabilit). Indicatorul de poziie
va avea o valoare nedeterminat dac fiierul nu este conectat;
REWIND (redeschidere) poziioneaz indicatorul la nceput de fiier;
APPEND (adugare) poziioneaz indicatorul la sfrit de fiier;
Observaie: Dac fiierul este nou creat indicatorul de poziie se va afla la nceput de fiier
indiferent de ce anume specific POSITION;
RECL = lungime_de_nregistrare
lungime_de_nregistrare specific lungimea unei nregistrri dac accesul se face n
mod direct, sau lungimea maxim a unei nregistrri dac accesul se face secvenial;
172
STATUS = indicator_de_stare_a_fiierului
indicator_de_stare_a_fiierului poate fi una dintre valorile:
OLD dac se impune ca fiierul s existe
NEW dac se impune ca fiierul s fie unul nou
UNKNOWN dac fiierul are o stare dependent de procesor
REPLACE impune ca, dac fiierul nu exist s fie creat i s i se atribuie starea OLD, iar
dac fiierul exist, s fie ters, creat ca fiier nou i s i se atribuie starea OLD;
SCRATCH dac se cere s se creeze un fiier temporar care va exista numai pn la
executarea instruciunii CLOSE sau pn la ncheierea programului.
8.11.2.5. Instruciunea CLOSE

Instruciunea CLOSE produce nchiderea comunicrii (conexiunii) cu un fiier al unei
uniti. Oricum, la terminarea execuiei programului, comunicaia cu fiierul se nchide cu
excepia cazului cnd a avut terminarea programului a avut loc ca urmare a unei erori.
Forma instruciunii este urmtoarea:
CLOSE (list_specificatori_de_nchidere)
list_specificatori_de_nchidere conine urmtoarele articole, cu aceleai
semnificaii ca la instruciunea OPEN:

[UNIT =] numr_de_unitate
definit anterior de instruciunea OPEN

IOSTAT = indicator_de_stare_I/O
ERR = etichet
STATUS = indicator_de_stare_a_fiierului
indicator_de_stare_a_fiierului poate avea una dintre valorile:

KEEP indicnd c fiierul va continua s existe i dup nchiderea conexiunii. Aceast
valoare este prestabilit dac fiierul a fost deschis cu valoarea lui STATUS oricare alta dect
SCRATCH. Indicatorul este ignorat dac fiierul nu exist, fiierul rmnnd inexistent;
DELETE indicnd tergerea fiierului dup nchidere. Aceast valoare este prestabilit dac
fiierul a fost desxchis cu STATUS=SCRATCH
8.11.2.6. Instruciunea INQUIRE
Instruciunea INQUIRE este folosit pentru a cere informaii cu privire la un fiier sau
unitate. Ea poate s fie executat nainte de, n timpul, sau dup ce un fiier este conectat la o
unitate. Toate valorile obinute prin instruciunea INQUIRE sunt cele existente la momentul
execuiei instruciunii. Forma general a instruciunii INQUIRE este:
INQUIRE (list_specificatori_de_cerere)
list_specificatori_de_cerere poate fi constituit din urmtoarele articole
separate prin virgule:

UNIT=numr_de_unitate
numr_de_unitate specific numrul unitii pentru o interogare pe baza unitii.
Valoarea trebuie s fie nenegativ, i trebuie s fie unic pentru toate unitile de program;
FILE=nume_de_fiier
nume_de_fiier specific numele fiierului ntr-o interogare bazat pe nume de fiier. n
acest caz nu se folosete articolul UNIT. Invers, dac se folosete UNIT nu se folosete FILE;
173
IOSTAT=variabil
variabil stocheaz starea de intrare/ieire (0 nici o eroare, ntreg negativ pentru eroare;
ERR=etichet
etichet este eticheta ramurii de program la care se sare n cazul apariiei unei erori;
EXIST=variabil
variabil specific o variabil logic care va avea valoarea .TRUE. dac fiierul exist
i .FALSE. n caz contrar;

OPENED=variabil
variabil specific o variabil logic care va avea valoarea .TRUE. dac fiierul sau
unitatea logic sunt conectate i .FALSE. n caz contrar;

NUMBER=variabil
variabil memoreaz numrul unitii ataate fiierului, sau 1 dac fiierul este neataat;
NAMED=variabil
variabil specific o variabil logic care va avea valoarea .TRUE. dac fiierul este
denumit sau .FALSE. n caz contrar;

NAME=variabil
variabil va conine numele fiierului (dac exist) sau va fi nedefinit dac fiierul nu
are nume sau nu este conectat la unitate;

ACCESS=variabil
variabil va conine tipul de acces pentru care a fost deschis fiierul sau unitatea.
Valorile sunt SEQUENTIAL, DIRECT sau UNDEFINED dac conexiunea nu exist;
SEQUENTIAL=variabil
variabil va conine valoarea YES, NO sau UNKNOWN dup cum fiierul sau unitatea
sunt deschise pentru acces direct, sau modul de acces nu poate fi determinat;
DIRECT=variabil
variabil va conine valoarea YES, NO sau UNKNOWN dup cum fiierul sau unitatea
sunt deschise pentru acces direct sau nu, sau procesorul nu cunoate starea accesului;
FORM=variabil
variabil va conine valoarea FORMATTED, UNFORMATTED n raport cu modul de
conectare la fiier sau unitate, sau UNKNOWN dac fiierul sau unitatea nu sunt conectate;
FORMATTED=variabil
variabil va conine YES, NO sau UNKNOWN dup cum fiierul sau unitatea sunt deschise
pentru operaii cu fiier formatat sau neformatat, sau procesorul nu cunoate starea acestuia;
UNFORMATTED=variabil
variabil va conine YES, NO sau UNKNOWN dup cum fiierul sau unitatea sunt deschise
pentru operaii cu fiier neformatat sau formatat, sau procesorul nu cunoate starea acestuia;
RECL=variabil
variabil va conine lungimea de nregistrare maxim pentru un fiier formatat sau
neformatat, sau va fi nedefinit dac nu exist conexiune;
174
NEXTREC=variabil
n cazul fiierelor cu acces direct, variabil va conine cu 1 mai mult dect ultimul numr
de nregistrare citit (indicele iniial este 1), sau va fi nedefinit dac poziia nu este cunoscut;
BLANK=variabil
n funcie de modul declarat de tratare a spaiilor goale (a se vedea instruciunea OPEN),

variabil va conine 'NULL', 'ZERO' sau 'UNDEFINED' dac fiierul nu este conectat
pentru intrare/ieire formatat sau nu este conectat de loc;
POSITION=variabil
n funcie de modul de poziionare al contorului de poziie, variabil va conine

'REWIND', 'APPEND', 'ASIS' sau 'UNDEFINED' dac fiierul este conectat pentru
acces direct sau nu este conectat;
ACTION=variabil
n funcie de tipul de acces la fiier , variabil va conine 'READ', 'WRITE',

'READWRITE' sau 'UNDEFINED' dac fiierul nu este conectat;
READ=variabil
n funcie de modul de acces pentru citire, variabil va conine 'YES', 'NO' sau
'UNKNOWN' dac procesorul nu poate determina admisibilitatea accesului pentru citire;
WRITE=variabil
variabil va conine 'YES', 'NO' sau 'UNKNOWN' n funcie de modul de acces la
fiier prin scriere admis, neadmis sau nedetectabil;

READWRITE=variabil
variabil va conine 'YES', 'NO' sau 'UNKNOWN' n funcie de modul de acces
citire/scriere n fiier admis, neadmis sau nedetectabil;

DELIM=variabil
n funcie de modul de tratare al delimitatorilor de iruri de caractere, variabil va

conine 'APOSTROPHE', 'QUOTE', 'NONE' sau 'UNDEFINED' dac fiierul nu este
conectat pentru intrare/ieire formatat sau nu este conectat de loc;
PAD=variabil
variabil va conine 'YES', sau 'NO' n funcie modul stabilit pentru completare cu
spaii goale (vezi instruciunea OPEN).

8.11.2.7. Instruciunile de poziionare n fiier BACKSPACE i REWIND
Instruciunea BACKSPACE
Instruciunea BACKSPACE are forma general:
BACKSPACE ([UNIT=] numr_unitate &
[,IOSTAT=indicator_de_stare_I/O] &
[,ERR=etichet])
La execuia instruciunii BACKSPACE fiierul conectat la unitatea specificat va avea contorul

de poziie poziionat naintea nregistrarii precedente. Dac nu exist o nregistrare precedent (la
nceput de fiier) indicatorul de poziie rmne nemodificat. Dac nregistrarea precedent este
sfritul de fiier, indicatorul va fi poziionat nainte de nregistrarea de sfrit de fiier. Nu se poate
merge napoi peste o nregistrare scris folosind formatul bazat pe o list sau nume de list.
175
Specificatorii instruciunii sunt urmtorii:

UNIT=numr_de_unitate
dac UNIT este singurul specificator menionat, instruciunea are forma:
BACKSPACE numr_de_unitate
IOSTAT=variabil
variabil va conine valoarea 0 dac operaia a avut loc cu succes, sau o valoare
pozitiv pantru a semnala o eroare;

ERR=etichet
etichet este eticheta ramurii de program care trateaz eroarea;
Instruciunea REWIND
Instruciunea REWIND are forma general:
REWIND ([UNIT=] numr_unitate &
[,IOSTAT=indicator_de_stare_I/O] &
[,ERR=etichet])
Semnificaiile specificatorilor din list sunt aceleai ca i la instruciunea BACKSPACE,

dar instruciunea are ca efect aducerea indicatorului de poziie la nceput de fiier.
8.12. Variabile pointer i inte

8.12.1. Definiia pointerilor i a intelor
O variabil pointer sau, pe scurt, un pointer, este un tip de variabil special folosit i de alte limbaje
(de exemplu C i C++) al crei rol este acela de referin ctre locaia de memorie unde este stocat o
alt variabil. Altfel spus, pointerul nu are ca valoare asociat valoarea variabilei ctre care intete
(sau ctre care puncteaz) ci are ca valoare asociat adresa locaiei de memorie a variabilei int.
Pointerii sunt folosii n special n operaiile de alocare dinamic a memoriei, al cror rol
este de a realiza consumul de memorie cu maximum de economie.
Pentru a defini un pointer (sau o list de pointeri) se folosete declaraia:
tip, POINTER [,list_de_atribute] :: list_de_variabile_pointer
unde:
tip este tipul de dat asociat pointerului
list_de_atribute este o list de alte atribute ale pointerului
list_de_variabile_pointer este lista variabilelor de tip pointer definite de
declaraia curent
Pentru a defini variabile posibile a constitui inte ale unor pointeri se folosete declaraia:
tip, TARGET
[,list_de_atribute] :: list_de_variabile
unde:
tip este tipul de dat al variabilelor int
list_de_atribute este o list de alte atribute ale variabilelor int
list_de_variabile este lista variabilelor int definite de declaraia curent
Observaie: tipurile de dat ale pointerilor i variabilelor int trebuie s fie aceleai pentru
a se asigura citirea corect a datelor din memorie.
Exemple de definiri de pointeri i inte:
REAL, POINTER :: pnt1
REAL, TARGET :: a, b, c
n acest exemplu pointerul pnt1 este destinat s inteasc ctre variabile individuale de tip
real, aa cum sunt definite ca inte variabilele a, b i c.
176
INTEGER, DIMENSION(:), POINTER:: pnt2

INTEGER, TARGET :: a(4), b(10)
n acest exemplu pointerul pnt2 este destinat s inteasc ctre variabile de tip tablou cu o
singur dimensiune, de tip ntreg, aa cum sunt definite ca inte variabilele tablou a i b.
INTEGER, POINTER :: pnt3(:,:)
INTEGER, TARGET, ALLOCATABLE :: a(:,:)
n acest exemplu pointerul pnt3 este destinat s inteasc ctre variabila de tip tablou cu
dou dimensiuni, de tip ntreg, cu atributul ALLOCATABLE, deci cu posibilitatea de alocare
dinamic ulterioar, aa cum este definit ca int variabila tablou bidimensional a.
8.12.2. Asocierea pointerilor cu intele. Dezasocierea pointerilor
Se folosesc doi operatori pentru operarea cu pointerii:
- Primul este operatorul de asociere, folosit sub forma:
variabil_pointer => variabil_int
- Al doilea este operatorul de atribuire, sintaxa corect de folosire fiind:

variabil_int_receptoare = variabil_pointer
cu semnificaia c variabila int receptoare primete de la pointer valoarea unei alte

variabile intit de pointer printr-o operaie de asociere anterioar.
De asemenea, se poate folosi sintaxa de atribuire:
variabil_pointer =variabil_donatoare
cu semnificaia c variabila intit de pointer printr-o operaie de asociere anterioar

primete de la pointer valoarea variabilei donatoare. Variabila donatoare trebuie s nu fie una
intit deoarece intirea ei schimb asocierea anterioar.
Urmtorul exemplu explic mecanismele descrise mai sus n cazul variabilelor simple:
PROGRAM manipulare_pointeri_simpli
IMPLICIT NONE
INTEGER, POINTER:: pnt
INTEGER, TARGET :: j=5, k=7
INTEGER :: l=11
WRITE(*,*)'
j
WRITE(*,*)'inainte
',j,k,l
pnt=>j
k=pnt
WRITE(*,*)'Dupa k=pnt ',j,k,l
pnt=l
WRITE(*,*)'Dupa pnt=l ',j,k,l
END PROGRAM manipulare_pointeri_simpli
l'
Dup execuie programul va afia:

inainte
dupa pnt k=pnt
dupa pnt pnt=l
j
5
5
11
k
7
5
5
l
11
11
11
n prima etap, la asocierea pnt=>j pointerul este fcut s vad ca int variabila j.
n urmtoarele dou etape de operaie pointerul pnt va vedea tot variabila j, deci inta nu se schimb.
La prima atribuire k=pnt variabila k va primi valoarea intei j, adic 5.
La a doua atribuire pnt=l inta j va primi valoarea variabilei l, adic 11.
Urmtorul exemplu ilustreaz folosirea pointerilor pentru variabile indexate (tablouri)
unidimensionale:
177
PROGRAM manipulare_pointeri_catre_tablouri
IMPLICIT NONE
INTEGER, DIMENSION(:), POINTER:: pnt
INTEGER, TARGET :: j(2), k(2), l(2)
j(1)=5; j(2)=7
k(1)=1; k(2)=2
l(1)=11; l(2)=13
write(*,*) 'ante ',j(1),j(2),k(1),k(2),l(1),l(2)
pnt=>j
pnt=k
write(*,*)'post1 ',j(1),j(2),k(1),k(2),l(1),l(2)
pnt=l
write(*,*)'post2 ',j(1),j(2),k(1),k(2),l(1),l(2)
END PROGRAM manipulare_pointeri_catre_tablouri
Acest program este identic ca etape de operare cu programul prezentat anterior, dar
lucreaz cu tablouri. Dup execuie el va afia:
ante
post1
post2
5
1
11
7
2
13
1
1
1
2
2
2
11
11
11
13
13
13
Se poate observa unul dintre avantajele lucrului cu pointerii tablou, i anume transferul
global de valori ale tablourilor printr-o singur atribuire. De altfel acest lucru este valabil i la
lucrul cu tablouri n general, fr a se face uz de pointeri.
Urmtorul exemplu ilustreaz folosirea pointerilor ctre tablouri alocate dinamic:
PROGRAM pointeri_tabl_dinamice
IMPLICIT NONE
INTEGER, DIMENSION(:), POINTER:: pnt
INTEGER, TARGET, allocatable :: k(:), j(:)
INTEGER i
ALLOCATE(k(3),j(3))
DO i=1,3
k(i)=i
END DO
j=2*k
WRITE(*,100) k(1),k(2),k(3),j(1),j(2),j(3)
pnt=>k
pnt=j
WRITE(*,100) k(1),k(2),k(3),j(1),j(2),j(3)
DEALLOCATE(k,j)
100 FORMAT(6I5)
ALLOCATE(k(2),j(2))
DO i=1,2
k(i)=i
END DO
j=k+1
WRITE(*,200) k(1),k(2),j(1),j(2)
pnt=>k
pnt=j
WRITE(*,200) k(1),k(2),j(1),j(2)
DEALLOCATE(k,j)
200 FORMAT(4I5)
END PROGRAM pointeri_tabl_dinamice
Dup execuie se obine afiarea urmtoare:
178
1
2
1
2
2
4
2
3
3
6
2
2
2
2
3
3
4
4
6
6
Dezasocierea pointerilor de intele lor se face cu instruciunea:

NULLIFY(list_de_pointeri)
Un pointer dezasociat va inti ctre nimic.

Starea unui pointer se poate testa folosind funcia:
ASSOCIATED (list_de_pointeri [,int] )
Rezultatul returnat de funcia ASSOCIATED este unul logic, adic .TRUE. sau .FALSE.
Dac argumentul int lipsete funcia va returna .TRUE. dac pointerul este asociat cu o
int oarecare, altfel, dac nu este asociat cu inta sau a fost nulificat, va returna .FALSE.
Dac argumentul int este prezent, funcia va returna .TRUE. numai dac toi pointerii
listei sunt asociai cu inta n cauz.
8.12.3. Alocarea dinamic a memoriei pentru tablouri
Aa cu s-a vzut nc din exemplele de mai sus, un pointer poate fi asociat nu numai cu
variabile int simple ci i cu variabile int de tip tablou crora li se specific numai forma
(numrul de dimensiuni) dar nu i mrimea (numerele de elemente pe dimensiunile
respective). Cu alte cuvinte, compilatorul este ntiinat numai asupra structurii generale a
zonei de memorie intit, nu i asupra structurii de detaliu, repectiv a spaiului exact pe care l
va ocupa zona. Mrimea acestei zone de memorie va fi specificat folosind instruciunea
ALLOCATE, ca n exemplul de mai jos:
REAL, POINTER :: pnt, pnt_spre_tablou(:)
INTEGER :: m=20
...
ALLOCATE( pnt, pnt_spre_tablou(m) )
...
DEALLOCATE( pnt, pnt_spre_tablou )
n exemplul de mai sus pointerul pnt este unul simplu care poate inti o variabil simpl,
pe cnd pnt_spre_tablou este un pointer care poate inti spre o variabil tablou cu o
singur dimensiune, Cnd se execut instruciunea ALLOCATE se specific faptul c

pnt_spre_tablou va putea inti o variabil de tip tablou cu o dimensiune pe care se pot
stoca 20 de elemente. La momentul cnd memoria folosit nu mai este necesar, se folosete
instruciunea DEALLOCATE.
8.13. Mediul PLATO3 IDE

8.13.1. Generaliti
Prescurtarea IDE provine de la Integrated Developing Environment, sau mediu integrat de
dezvoltare (a aplicaiilor).
Salford PLATO3 este un asemenea mediu, el reunind ntr-un singur instrument cele 3
funcii de baz minimale ale unui instrument modern de programare:
- Editorul de text;
- Compilatorul;
- Editorul de legturi.
PLATO poate genera programe simple, adic programe coninute integral ntr-un singur
fiier, sau poate genera programe ale cror componente sunt coninute n fiiere distincte
(fiier surs principal, fiiere modul, fiiere de includere). n acest din urm caz, se lucreaz
cu un aa numit proiect constnd dintr-un sistem de fiiere de tipurile enumerate mai sus care,
179
la ncrcarea proiectului, sunt ncrcate i deschise mpreun, iar prelucrarea produsului final,
fiierul cod executabil, se face corelat.
8.13.2. Construirea i rularea unui proiect
Crearea unui proiect se realizeaz folosind meniul File/New Project care deschide cutia de
dialog New Project din figura 8.13.1.
Se selecteaz natura proiectului dorit din lista Project Types, se stabilete numele n cutia
de editare Name i directorul de stocare a fiierului proiect folosind butonul Browse.
Dup executarea acestei comenzi fereastra aplicaiei PLATO are aspectul din figura 8.13.2.
Aa cum se observ n fereastra Project Explorer, un proiect poate conine fiiere surs,
fiiere de includere i fiiere referite.
Pentru adugarea de noi componente se poate folosi meniul contextual (clic dreapta pe
articolul nod selectat). Dup aplicarea unui asemenea set de operaii, un proiect poate arta ca
n figura 8.13.3.
Fiierele surs sunt fiiere care conin:
- Fiierul care conine programul principal i un anumit numr de proceduri (subrutine i funcii);
- Fiiere care conin module (uniti de program separate coninnd declaraii i proceduri)
utilizabile n diverse programe gazd prin invocarea lor de ctre instruciunea USE;
Fig.8.13.1.
- Fiiere de includere, care conin secvene de program n form surs (text) care pot fi
invocate i ncrcate din alte uniti din program ca i cum s-ar afla incluse ncepnd de la
instruciunea de includere (INCLUDE);
- Fiiere referite, care conin cod executabil extern cum sunt fiierele DLL (Dynamic Link
Library) sau LIB.
n figura 8.13.3 fiierele componente sunt:
- Programul principal coninut n fiierul Main.f95, coninnd instruciunile:
PROGRAM CALCUL
USE FACT_DE_N
INCLUDE 'DATE.INC'
INTEGER K,N
N=I
K=FACT_N(N)
write(*,*) "K!=",K
END PROGRAM
180
- Fiierul modul Modul_FTN.f95, coninnd instruciunile:

MODULE FACT_DE_N
IMPLICIT NONE
CONTAINS
RECURSIVE INTEGER FUNCTION FACT_N(n) RESULT (rez)
INTEGER n
INTEGER rez
if (n==0) then
rez=1
else
rez=n*FACT_N(n-1)
end if
END FUNCTION FACT_N
END MODULE FACT_DE_N
- Fiierul de includere DATE.INC, coninnd instruciunile:

INTEGER :: I=5
Fig.8.13.2.
Construirea programului se poate face:
- pe etape separate, apelnd comanda Compile separat pe fiecare component, fie din
meniul Build/Compile fie din meniul contextual direct de pe eticheta (Tab-ul) fiecrei ferestre
de component sau de pe articolul de proiect din fereastra Project Explorer, ca n figurile
8.13.4 i, respectiv, 8.13.5, i apoi folosind comanda Build din meniul Build.
- global, prin comanda Build/Build sau cu meniul contextual din fereastra Project explorer
cu articolul nume de proiect selectat.
181
Comanda Rebuild produce i recompilarea componentelor, lucru necesar atunci cnd ele au
suferit modificri.
Fig.8.13.3.
Fig.8.13.4.
Fig.8.13.5.
Mesajele rezultate n urma compilrii i construciei pot fi urmrite n fereastra Output de

la baza ferestrei mediului PLATO.
Rularea programului obinut se realizeaz folosind comanda Build/Start Run sau butonul
Start de pe bara cu butoane Build.
Mai multe despre manevrele realizabile n mediul PLATO pot fi aflate consultnd meniul
Help al mediului.
Cap.9. Limbajul AutoLISP pentru AutoCAD
182

9.1. Generaliti
Limbajul AutoLISP este un dialect de limbaj LISP destinat dezvoltrii aplicaiilor sub
AutoCAD.
Limbajul LISP este un limbaj care are ca unic structur lista. Denumirea limbajului deriv
din LISt Processor (procesor de list) definind sintetic filozofia acestui limbaj.
n LISP lista poate fi att stoc de date ct i funcie. Datorit acestei dualiti, limbajul
posed nsuirea unic de a se putea automodifica n timpul execuiei.
Limbajul AutoLISP este destinat scrierii de programe executabile n regim de interpretor.
Din acest motiv el nu este la fel de rapid ca programele scrise n limbaje compilabile i, ca
urmare, este mai raional s fie folosit pentru a transmite comenzi interpretorului de comenzi
al AutoCAD-ului, astfel nct, pe ct mai mult posibil, acesta s lucreze cu facilitile sale
proprii care sunt de fapt module de program compilate i, implicit, mult mai rapide.
9.2. Lista ca structur de baz n AutoLISP. Funcii

Att funciile ct i datele manipulate sub AutoLISP au structur de list. Acest aspect al
AutoLISP-ului l face deosebit de flexibil deoarece funciile pot fi construite nu numai de
ctre programator ci i de ctre program pe baza unor reguli de algoritmizare.
9.2.1. Lista
O list este un ir de aa-numite entiti (atomi, date, liste, funcii sau expresii) desemnate
prin simboluri incluse ntre paranteze, dup cum urmeaz:
(e1 e2 en)
Fiecare dintre aceste entiti poate fi, la rndul ei, o list, ceea ce conduce la o structur
arborescent, ca n figura 9.2.1.
(e1 e2 en)
(e11 e12 e1k)
(e21 e22 e2j)
(en1 en2 enm)
(e211 e212 e21q)
Fig.9.2.1.
Este important de reinut c aceste liste pot fi eterogene (constituite din entiti de tipuri diferite).
De exemplu, fie lista TRIUNGHI coninnd datele care definesc cele trei vrfuri ale unui
triunghi:
TRIUNGHI (V1 V2 V3)
V1, V2 i V3 sunt la rndul lor liste care conin caracterul de notare al vrfului i lista
coordonatelor sale x, y i z:
V1 (A CV1)
V2 (B CV2)
V3 (C CV3)
CV1 (0 0 0)
CV2 (100 0 0)
CV3 (0 100 0)
183
9.2.2. Funcia
Spre deosebire de lista de date, funcia este constituit dintr-un ir de entiti dintre care
primul este numele funciei iar restul sunt argumentele ei. De exemplu:
(command LINE (0 0 0) (100 0 0) (0 100 0) C)
constituie o funcie care transmite interpretorului de comenzi din AutoCAD comanda de

trasare a segmentelor componente ale unui triunghi cu vrfurile n punctele definite de
sublistele argumente. Ultimul argument, adic irul de caractere C este directiva de
nchidere a triunghiului.
Funciile din AutoLISP sunt de trei tipuri principale:
a. Funcii standard (cum este funcia command din exemplul de mai sus) coninute de
AutoLISP la iniializare;
b. Funcii definite de utilizator care pot fi create n scopul realizrii de faciliti noi. n
acest scop se folosete funcia definitoare de funcii DEFUN;
c. Funcii de comand AutoCAD definite de utilizator. Acestea sunt tot funcii definite
de utilizator dar care sunt recunoscute i de ctre interpretorul de comenzi AutoCAD.
Acemenea funcii se creaz prin prefixarea numelui funciei cu caracterele C:. Pe aceast
cale, repertoriul de comenzi din AutoCAD poate fi mbogit cu noi comenzi.
Tipuri de argumente ale unei funcii AutoLISP
Argumentele unei funcii AutoLISP sunt de dou tipuri:
- argumente de intrare (sau formale);
- argumente interne (sau variabile locale).
Cnd se definete o funcie prin intermediul funciei DEFUN, argumentele se include n
interiorul unei liste de argumente.
Pentru nelegere, vom lua exemplul unei funcii simple care calculeaz media a dou
valori. Definirea funciei se face astfel:
(defun MID (a b / c)
(setq c (/ (+ a b) 2) d (+ c 2))
c
)
Numele funciei este MID.

Lista de argumente (a b / c) conine dou cmpuri:
- cmpul argumentelor formale a i b. Simbolurile a i b au valabilitate numai n interiorul
funciei i reprezint valorile argumentelor transmise la apelul funciei sub forma (MID u v),
unde u i v sunt argumentele de apel;
- cmpul argumentelor locale conine aici numai simbolul c. Argumentele menionate n
acest cmp sunt folosite numai n interiorul funciei i nu sunt vizibile n exteriorul acesteia
(alocarea de memorie pentru aceste argumente este tears la terminarea execuiei funciei).
Dac n interiorul funciei apar simboluri neincluse n nici unul dintre cmpurile listei de
argumente, aceste simboluri reprezint variabile globale, vizibile att din interiorul ct i din
exteriorul funciei, aa cum este variabila cu simbolul d.
Caracterul / joac rolul de separator de cmpuri de argumente.
n corpul funciei este folosit funcia de atribuire cu nghearea evalurii setq. Forma
acestei funcii este:
(setq acceptor1 donator1 acceptor2 donator2 acceptorn donatorn)
Aici exist o dou perechi acceptor-donator, astfel:
184
Acceptor1 este variabila local c iar donator1 este lista funcie (/ (+ a b) 2);
Acceptor2 este variabila global d iar donator2 este lista lista funcie (+ c 2).
Noiunea de ngheare se refer la blocarea evalurii simbolului acceptorului, astfel nct,
orice valoare ar fi avut anterior, el primete o nou valoare provenit din evaluarea donatorului.
Au fost folosite funciile:
(/ denprit npritor) i (+ numr1 numr2).
Conform conveniei LISP, numele funciilor de mai sus sunt operatorii / i + , celelalte
simboluri din list fiind operanzii.
Modul de utilizare a funciei MID definit mai sus rezult din urmtorul exemplu, extras
dintr-un program:
(setq u 1 v 2 d 0)
(setq f (mid u v))
atribuie simbolurilor u, v i d valorile 1, 2 i 0

atribuie lui f valoarea medie a lui u i v
Dup execuia ultimei funcii setq vom constata c f primete valoarea (1 + 2)/2 =1.5, iar d
nu mai are valoarea 0 ci valoarea (1.5 + 2) = 3.5. Acest lucru se ntmpl deoarece d este
variabil global.
Dac n loc de (setq f (mid u v)) am fi scris numai (mid u v), rezultatul 1.5 ar fi fost pierdut
nefiind preluat de nici un alt simbol, singurul rezultat conservat fiind valoarea 3.5 atribuit lui
d. Ca i n limbajul C acest efect poart denumirea de efect lateral i, dac nu este urmrit n
mod special, este recomandabil s fie evitat prin controlul strict al vizibilitii variabilelor
(programatorul trebuie s tie exact care sunt variabilele locale i care cele globale).
Rmne o ntrebare: de ce, n funcia de definire a funciei MID a fost scris ca ultim
argument simbolul c?
Pentru a nelege, trebuie expus ciclul funcional de baz al limbajului LISP, aa cum urmeaz.
9.3. Evaluarea n AutoLISP

9.3.1. REP ciclul de funcional baz n AutoLISP
REP este prescurtarea de la Read - Eval Print, adic succesiunea etapelor de lucru n
AutoLISP:
R citete simbolul
E evalueaz simbolul prin valoarea atribuit lui
P tiprete (returneaz) rezultatul ultimei evaluri.
Conform acestei succesiuni, o funcie va returna ntotdeauna numai rezultatul ultimei
evaluri, indiferent cte alte evaluri ar mai fi avut loc anterior n interiorul ei.
Din acest motiv, pentru ca funcia s returneze media argumentelor a i b, adic c, acesta a
trebuit s fie scris ca ultim argument al funciei (defun MID ). Altfel, ultima evaluare ar fi
fost aceea dat de lista (+ c 2), adic cu totul altceva dect se urmrea.
Eliminnd efectul lateral cauzat de invocarea simbolului d n corpul funciei defun i
folosind judicios ciclul REP, se poate scrie o variant mai simpl i mai robust a funciei de
mai sus, astfel:
(defun MID (a b /)
(/ (+ a b) 2)
)
n general, cu riscul risipei de spaiu, preferm scrierea pe linii separate, dei am fi putut
scrie totul pe un singur rnd:
(defun MID (a b /) (/ (+ a b) 2))
Prima modalitate este preferabil, permind scrierea conform cu regulile de structurare i

uurnd efortul de a controla corectitudinea nchiderii parantezelor, esenial pentru LISP.
185
9.3.2. Evaluarea simbolurilor

Pentru a aprecia corect efectele obinute cu un program AutoLISP trebuie cunoscute
regulile dup care are loc aciunea de evaluare a simbolurilor folosite n program. Acestea
sunt urmtoarele:
- Evaluarea unei date de tip valoare numeric sau ir de caractere se face prin ea nsi;
- Un simbol se evalueaz prin ultima valoare care i-a fost atribuit;
- O list se evalueaz n concordan cu primul ei argument care reprezint un nume de
funcie. Dac acest argument nu a fost definit ca nume de funcie, AutoLISP semnaleaz
eroare i oprete execuia.
De exemplu, dac nu a fost folosit funcia DEFUN pentru definirea funciei mid din
exemplul anterior, la apelul:
(mid 2 5)
n loc de rezultatul 3.5 ateptat, AutoLISP va emite mesajul:

error: null function
9.4. Convenii sintactice n AutoLISP

La scrierea unui program AutoLISP trebuie s se in seama de urmtoarele reguli sintactice:
- Numele unui simbol se poate scrie folosind orice caractere, cu excepia urmtoarelor:
( ) . ; i caracterul spaiu
- Numele simbolurilor trebuie s fie separate prin cel puin un spaiu.
- O expresie, funcie sau list poate fi scris pe oricte linii, dac este necesar. Totui, nu se
trece la o alt linie n cuprinsul unui ir de caractere ncadrat ntre ghilimele. n acest caz
caracterul ENTER nu este filtrat (ignorat). Dac o astfel de trecere la linie nou are loc n
cuprinsul unui ir de caractere de afiat ca mesaj, respectivul mesaj va apare fragmentat pe
linii succesive exact n locul unde, n program a avut loc trecerea la o nou linie. Dac irul de
caractere reprezint o comand transmis interpretorului de comenzi AutoCAD, prezena
caracterului ENTER va perturba succesiunea normal aparametrilor comenzii i rezultatul va
fi o execuie defectuoas sau imprevizibil.
- Valorile ntregi sunt cuprinse n intervalul 32768+32767;
- Valorile reale se exprim n forma parte_ntreag.parte_zecimal sau n format E;
- Un ir de caractere este incadrat de o pereche de ghilimele, de exemplu SIR DE
CARACTERE;
- n interiorul unui ir de caractere caracterul \ se folosete pentru desemnarea de caractere
de control, astfel:
\e pentru caracterul ESCAPE
\n pentru salt la linie nou
\r pentru caracterul ENTER
\t pentru caracterul TAB
De asemenea, se folosesc combinaiile:
\\ pentru caracterul spaiu
\ pentru caracterul
- Caracterul apostrof se folosete ca abreviaie a funciei QUOTE (nghearea evalurii).
- O linie care ncepe cu caracterul ; este complet ignorat fiind considerat comentariu.
9.5. Funcii primitive n AutoLISP

Funciile primite constituie un set de funcii standard care pot fi utilizate ca set minimal de
funcii. Acestea sunt:
186
(CONS nou_element_prim list)

Aceast funcie adaug un nou element la nceputul unei liste.
De exemplu, fie lista l(b c d). Atunci, funcia:
(cons a l)
produce lista l(a b c d).
Dac, n loc de o list, al doilea argument al funciei CONS este un atom, funcia
returneaz o pereche cu punct, astfel:
(setq a 1 b 2)
(cons a b)
produce lista (1 . 2)
(CAR list)
Aceast funcie extrage primul element al listei. De exemplu, fie lista l(b c d). Atunci,
funcia:
(car l)
produce ca rezultat b.
(CDR list)
Aceast funcie returneaz o list creia i lipsete primul argument.
De exemplu, fie lista l(b c d). Atunci, funcia:
(cdr l)
returneaz ca rezultat lista (c d).

(QUOTE expresie)
Aceast funcie blocheaz (nghea) evaluarea simbolului expresie i l returneaz
neevaluat. Sintaxa prescurtat a acestei funcii este expresie. De exemplu:
(quote a)
sau echivalent a
returneaz simbolul a
(quote a b)
sau echivalent (a b)
returneaz lista (a b)
(SET simbol expresie)
Aceast funcie evalueaz expresie, evalueaz simbol, i apoi atribuie valoarea de evaluare
a expresiei valorii evaluate a lui simbol. De exemplu, s presupunem c am atribuit
simbolului b valoarea simbol a, folosind funcia:
(setq b a)
Atunci:
(set b 10)
l evalueaz pe 10 prin el nsui, produce a prin evaluarea lui b i atribuie lui a valoarea 10.
Dac acum scriem funcia:
(eval a)
obinem ca rezultat 10.

n schimb, dac am fi scris:
(setq b 2)
i apoi:
(setq b 10)
am fi obinut mesajul de eroare:
187
error: bad argument type
deoarece s-ar fi ncercat atribuirea valorii constante 10 nu unui simbol care reprezint o
locaie de memorie care poate stoca o valoare ci unei alte valori constante, i anume 2.
(SETQ simbol expresie)
este echivalent cu
(set (quote simbol) expresie)
Aceast funcie evalueaz expresie, blocheaz evaluarea lui simbol i atribuie simbolului
neevaluat valoarea rezultat din evaluarea expresiei. De exemplu:
(setq a 9)
atribuie valoarea 9 simbolului a.

Dac s-ar scrie:
(setq a 1)
(setq (eval a) 9)
ar rezulta o eroare la fel ca mai sus, deoarece s-ar ncerca atribuirea valorii 9 valorii 1.
n schimb, scriind:
(setq a b)
(setq (eval a) 9)
lucrurile vor decurge normal producnd atribuirea valorii 9 simbolului b.

(LIST e1 e2 en)
Aceast funcie produce o list compus din valorile de evaluare ale elementelor e1, e2,
en. De exemplu:
(setq a 1 b doi c d)
(list a b c)
produce lista
(1 doi d)
unde simbolul d este neevaluat.

(APPEND lista1 lista2 listan)
Aceast funcie alipete elementele neevaluate ale listelor lista1, lista2, listan,
producnd o nou list.
De exemplu, fie secvena de program:
(setq a 1 b W c 2.3 d SIR)
(setq l1 (list a b) l2 (list c d) l3 (list a l2))
va avea ca efect producerea listelor:

l1(1 W)
l2(2.3 SIR)
l3(1 (2.3 SIR))
Atunci:
(setq lap (append l1 l2 l3))
va produce lista:
lap(1 W 2.3 SIR (2.3 SIR))
9.6. Predicate de baz n AutoLISP

Un predicat este o funcie care realizeaz un test i produce un rezultat logic (T pentru
TRUE i NIL ca echivalent al lui FALSE din alte limbaje).
AutoLISP lucreaz cu urmtoarele predicate:
188
(ATOM simbol)
Un atom este o entitate AutoLISP care nu mai refer alte componente (nu este o list, sau,
conform terminologiei grafurilor arborescente este frunz de arbore i nu nod).
Funcia ATOM produce rezultat T dac simbol este un atom AutoLISP i NIL n caz
contrar. De exemplu:
(atom 1)
produce rezultatul T pentru c 1 este o entitate constant;
(atom lap)
produce rezultatul nil pentru c lap este list (a se vedea exemplul de mai sus);
(atom nil)
produce rezultatul T pentru c nil este o constant logic.
(EQUAL e1 e2)
Aceast funcie testeaz dac dou expresii sunt identice. De exemplu, scriind:
(setq e1 (1 2 3) e2 (1 2 3) e3 (1 5 2))
(equal e1 e2) produce rezultat T, iar
(equal e1 e3) produce rezultat nil.
(NULL simbol)
Funcia testeaz lipsa referinei unui coninut de ctre simbol, caz n care produce T, altfel
produce NIL. De exemplu:
(setq a SIR b 1.2 c nil)
(null a)
produce nil
(null b)
produce nil
(null c)
produce T.
(MEMBER simbol list)

Aceast funcie testeaz dac valoarea evaluat a simbolului se regsete printre membrii
listei. Rezultatul returnat este o sublist care ncepe de la prima apariie a valorii de evaluare a
lui simbol i continu pn la capt, sau NIL n caz contrar.
De exemplu, considernd lista lap din exemplul de la funcia APPEND, se poate scrie:
(member 2.3 lap) produce ca rezultat sublista (2.3 SIR (2.3 SIR))
(member X lap) produce nil.
(NUMBERP simbol)
Aceast funcie testeaz dac rezultatul evalurii lui simbol este un numr i, n acest caz,
returneaz T, altfel returneaz NIL. De exemplu, considernd lista:
lap(1 W 2.3 SIR (2.3 SIR))
i scriind:
(numberp (car lap)) se returneaz T deoarece primul element al listei lap este atomul
numeric 1, pe cnd:
(numberp (cdr lap)) va returna NIL deoarece (cdr lap) este sublista (W 2.3 SIR (2.3
SIR)) i nu un numr.
(ZEROP simbol)
Aceast funcie returneaz T dac rezultatul evalurii lui simbol este o valoare numeric
nul, sau NIL n caz contrar.
De exemplu:
(setq a 1)
(zerop a)
returneaz NIL
(zerop (- a 1)) returneaz T
189
(MINUSP simbol)
Aceast funcie returneaz T dac rezultatul evalurii lui simbol este un numr egal cu
zero, sau NIL n caz contrar.
De exemplu:
(setq a 1)
(minusp a)
(minusp (- a 2))
returneaz NIL
returneaz T.
(LISTP simbol)
Aceast funcie returneaz T dac rezultatul evalurii lui simbol este o list, sau NIL n caz contrar.
De exemplu, considernd lista lap de mai sus:
(listp lap)
returneaz T
(list (car lap)) returneaz NIL.
9.7. Funcii de test logic n AutoLISP

AutoLISP folosete urmtoarele funcii de test logic:
(NOT simbol)
Aceast funcie returneaz T dac simbol se evalueaz prin NIL, sau NIL n caz contrar.
De exemplu, scriind:
(setq a 1 b nil)
(not a) returneaz NIL
(not b) returneaz T.
(AND e1 e2 en)
Aceast funcie returneaz NIL dac n cursul evalurii de la stnga la dreapta a expresiilor
e1, e2, , en, a fost ntlnit o expresie care, prin evaluare, produce un rezultat NIL.
Evaluarea se oprete imediat ce a fost ntlnit prima expresie evaluat prin NIL, fr a le mai
evalua i pe celelalte. Dac toate expresiile sunt diferite de NIL este returnat rezultatul T.
De exemplu, considernd atribuirile de mai sus pentru a i b:
(and a b)
returneaz NIL
(and a (not b)) returneaz T.
(OR e1 e2 en)
Aceast funcie returneaz T dac n cursul evalurii de la stnga la dreapta a expresiilor
e1, e2, , en, a fost ntlnit o expresie care este evaluat prin T. Evaluarea se oprete
imediat ce a fost ntlnit o asemenea expresie, fr a le mai evalua i pe celelalte. Dac, prin
evaluare, nici o expresie nu produce T, este returnat rezultatul NIL.
De exemplu, considernd atribuirile de mai sus pentru a i b:
(or a b)
returneaz T
(or (not a) b) returneaz NIL.
9.8. Funciile READ i EVAL

AutoLISP are posibilitatea de a transforma iruri de caractere n simboluri i de a le evalua.
Acest lucru se realizeaz prin intermediul a dou funcii:
(READ expresie)
Aceast funcie citete irul de caractere expresie i returneaz simbolul expresie
neevaluat.
190
De exemplu:
(read (+ 2 1))
returneaz
(+ 2 1)
(EVAL expresie)
Aceast funcie returneaz valoarea evaluat a expresiei.
De exemplu:
(eval (+ 2 1)) returneaz 3
9.9. Funcii alternativ

AutoLISP folosete urmtoarele funcii alternativ:
(IF expresie_de_test expresie_da [expresie_nu])
Aceast funcie evalueaz expresie_de_test. Dac rezultatul acestei evaluri este diferit de
nil atunci se evalueaz expresie_da. Dac expresie_de_test este nil este evaluat expresie_nu
dac aceasta este prezent, iar dac nu, funcia if se ncheie fr efect.
(COND
(expresie_de_test_1 expresie_1)
(expresie_de_test_2 expresie_2)
(expresie_de_test_n expresie_n)
)
Aceast funcie evalueaz pe rnd expresiile expresie_de_test_j pn cnd o ntlnete pe
prima care este diferit de nil i evalueaz expresia expresie_j corespunztoare.
Se poate construi o alternativ default (ca n limbajul C la instruciunea switch), astfel:
(COND
(T expresie_prestabilit)
)
Exemplu de folosire a funciilor alternativ:
(setq a 1)
(if (< a 0) t)
(cond ((< a 0) negativ)
((= a 0) zero)
((> a 0) pozitiv)
)
va returna nil (efect identic cu minusp)
va returna irul de caractere pozitiv
9.10. Expresii ciclice

AutoLISP folosete urmtoarele funcii ciclice:
(WHILE expresie_de_test expresie_1 expresie_2 expresie_n)
Aceast funcie evalueaz expresiile expresie_1 expresie_n att timp ct
expresie_de_test este diferit de nil. De exemplu:
(setq i 1 f 1)
(while (< i 6) (setq f (* f i) i (1+ i)))
returneaz ca rezultat f=5!
(REPEAT numr expresie_1 expresie_2 expresie_n)

Aceast funcie repet evaluarea expresiilor expresie_1 expresie_n de numr ori. De
exemplu:
(setq prod 1 baza 2)
(repeat 5 (setq prod (* prod baza)))
returneaz ca rezultat prod=25
191
9.11. Funcia program

(PROGN expresie_1 expresie_2 expresie_n)
Aceast funcie este folosit n acele funcii care accept un singur argument specific, ca de
exemplu IF i COND, atunci cnd este nevoie, totui, s se efectueze o succesiune de
evaluri. Funcia returneaz ca rezultat ultima evaluare efectuat (pe aceea a lui expresie_n).
n cazul funciei IF, folosirea funciei progn conduce la o structur de forma:
(if test (progn () () ) (progn () ()))
9.12. Funcii de test numeric

Funciile de test numeric folosite de AutoLISP sunt urmtoarele:
(= en1 en2 enn)
Aceast funcie evalueaz expresiile numerice en1, en2, , enn, n ordine de la stnga la
dreapta. Imediat ce este obinut o evaluare care produce un rezultat cu valoare diferit de en1,
evaluarea este oprit (celelalte expresii nu mai sunt evaluate) i este returnat rezultatul nil. Dac
toate expresiile numerice au fost evaluate i au fost egale cu en1 este returnat ca rezultat T.
(/= en1 en2 enn)
Aceast funcie evalueaz expresiile numerice en1 enn, n ordine de la stnga la dreapta
i returneaz nil la ntlnirea primei evaluri care produce un rezultat de egalitate cu oricare
dintre expresiile evaluate anterior, oprind evaluarea celorlalte expresii. Dac evaluarea tuturor
expresiilor a produs rezultate diferite, este returnat T.
(< en1 en2 enn)
i returneaz nil la ntlnirea primei evaluri care produce un rezultat mai mic sau egal cu
evaluarea anterioar, oprind evaluarea celorlalte expresii. Dac toate evalurile au produs
rezultate care sunt strict cresctoare, este returnat T.
(<= en1 en2 enn)
Aceast funcie evalueaz expresiile numerice en1 enn, n ordine de la stnga la dreapta i returneaz
nil la ntlnirea primei evaluri care produce un rezultat mai mic dect evaluarea anterioar, oprind
evaluarea celorlalte expresii. Dac toate evalurile au produs rezultate care sunt cresctoare, este returnat T.
(> en1 en2 enn)
i returneaz nil la ntlnirea primei evaluri care produce un rezultat mai mare sau egal cu
rezultate care sunt strict descresctoare, este returnat T.
(>= en1 en2 enn)
i returneaz nil la ntlnirea primei evaluri care produce un rezultat mai mare dect
rezultate care sunt descresctoare, este returnat T.
9.13. Funcii de prelucrare a listelor

Fiind un limbaj de prelucrare de liste, AutoLISP folosete o serie de funcii destinate
acestui scop, dup cum urmeaz:
192
(CXXXXR list)
n funcia de mai sus avem de a face cu o notaie generic, X putnd fi A sau D, rezultnd
combinaii de funcii CAR i CDR pn la nivelul 4. De exemplu:
(CADR (list a b c d)) produce acelai rezultat ca i (CAR (CDR (list a b c d))) adic
evaluarea simbolului b.
(REVERSE list)
Aceast funcie returneaz o list inversat. De exemplu:
(reverse (list (list a b) c (list d e f) g h)) returneaz lista
(h g (d e f) c (a b))
Se observ din exemplul de mai sus c sublistele interne sunt tratate ca simple argumente
nefiind afectate de inversare.
(ASSOC articol list_asociativ)
Pentru a nelege modul de lucru al acestei funcii reamintim efectul funciei CONS: cnd
ambele argumente sunt atomi funcia returneaz o pereche cu punct.
O list asociativ este o list avnd ca elemente subliste formate din perechi cu punct de
tipul (a . b), sau asociaii.
Dac articol exist n interiorul unei subliste a listei asociative, atunci funcia ASSOC
returneaz prima pereche cu punct ntlnit, care conine argumentul articol, ignornd
celelalte subliste care urmeaz acesteia (chiar dac printre ele se mai gsesc i altele care
conin articolul). De exemplu:
(setq l (list (cons c 1) (cons a 2) (cons a 3) (cons b 2)))
(assoc a l) returneaz sublista (a . 2), aceasta fiind prima ntlnit care conine atomul a.
(NTH expresie_numeric list)

Aceast funcie extrage din list elementul cu indicele de ordine egal cu
expresie_numeric, indicierea fiind considerat ncepnd de la 0. De exemplu:
(setq l1 (a b c d) l2 ((a b c) d))
(nth 1 l1) returneaz b
(nth 0 l2) returneaz (a b c).
(LAST list)
Aceast funcie returneaz ultimul element al listei. De exemplu:
(setq l1 (a b c d))
(last l1)
returneaz d.
(LENGTH list)
Aceast funcie returneaz o valoare numeric egal cu lungimea listei (numrul de
argumente ale listei). De exemplu:
(setq l1 (a b c d) l2 ((a b c) d))
(length l1)
returneaz 4
(length l2)
returneaz 2.
(SUBST articol_nou articol_vechi list)

Aceast funcie substituie toate apariiile n list a lui articol_vechi cu articol_nou. De exemplu:
(setq l (list 2 1 1 5))
(setq l (subst 3 1 l))
modific lista l la forma (2 3 3 5).
9.14. Funcii numerice

n scopul facilitrii calculelor necesare ntr-un algoritm, AutoLISP pune la dispoziia
programatorului urmtoarele funcii de calcul numeric:
193
(+ en1 en2 enn)

Aceast funcie evalueaz expresiile numerice en1, , enn i returneaz suma valorilor
lor. De exemplu:
(+ 1 7 3)
returneaz 11.
(- en1 en2 enn)
Aceast funcie scade din en1 valorile lui en2, , enn. De exemplu:
(- 7 3 1)
returneaz 3.
(* en1 en2 enn)
Aceast funcie returneaz produsul valorilor expresiilor en1, , enn. De exemplu:
(* 2 3 4)
returneaz 24.
(/ en1 en2 enn)
Aceast funcie mparte valoarea expresiei en1, pe rnd, la en2, , enn. De exemplu:
(/ 24 4 3) returneaz 2.
(1+ en)
Aceast funcie realizeaz incrementarea valorii expresiei numerice en. De exemplu:
(setq a 5)
(1+ a)
returneaz 6.
(1- en)
Aceast funcie realizeaz decrementarea valorii expresiei numerice en. De exemplu:
(setq a 5 b (1- a)) returneaz 4 ca valoare atribuit lui b.
(ABS en)
Aceast funcie returneaz valoarea absolut a valorii de evaluare a expresiei en. De exemplu:
(abs 3)
returneaz 3.
(EXPT baz exponent)
Aceast funcie returneaz valoarea bazei ridicat la puterea exponent. De exemplu:
(expt 2 3) returneaz 8
(EXP en)
Aceast funcie returneaz valoarea numrului natural e ridicat la puterea dat de evaluarea
expresiei numerice en.
(SQRT en)
Aceast funcie returneaz rdcina ptrat a valorii expresiei numerice en.
(SIN en)
Aceast funcie returneaz sinusul valorii expresiei numerice en considerat n radiani. De
exemplu:
(sin (/ pi 6.0))
returneaz valoarea 0.5.
Observaie: simbolul pi este recunoscut de AutoLISP ca valoare a numrului .
(COS en)
Aceast funcie returneaz cosinusul valorii expresiei numerice en considerat n radiani.
De exemplu:
194
(cos (/ pi 3.0))
(ATAN en1 [en2])

Aceast funcie returneaz arcul tangentei valorii en1, sau, dac argumentul en2 este
prezent, arcul tangentei valorii en1/en2, n intervalul - + .
(LOG en)
Aceast funcie returneaz logaritmul natural al valorii expresiei en.
(FIX en)
Aceast funcie truncheaz valoarea expresiei numerice en la ntregul cel mai apropiat. De
exemplu:
(fix 2.6)
returneaz 2.
(FLOAT en)
Aceast funcie convertete valoarea expresiei numerice en de la numr ntreg la numr
real. De exemplu:
(float 2)
returneaz 2.0
9.15. Comenzi definite de utilizator

Utilizatorul i poate defini comenzile proprii folosind funcia DEFUN, astfel:
(defun C:comand_nou (/ argloc1 argloc2 arglocn)
)
Aadar, o funcie definit de utilizator cu scopul de a fi recunoscut ca o comand nou de
ctre interpretorul de comenzi din AutoCAD, trebuie s aib numele prefixat de caracterele
C:.
Se observ o caracteristic ntlnit i n alte limbaje, ca de exemplu n Visual Basic la
crearea de macrocomenzi, i anume, funcia nou creat cu rolul de a servi drept comand nu
are parametri de intrare (cmpul argumentelor formale al listei de argumente este vid).
Motivul acestei caracteristici este evident: pentru uurina manipulrii, o comand este
invocat ca un simplu nume, neexistnd posibilitatea de a se transmite i parametri.
De exemplu:
(defun c:tri ()
(command line (0 0) (2 0) (1 2) C)
)
Aceast funcie definete o comand nou cu numele TRI. Scriind acest nume ca linie de
comand AutoCAD, programul va desena un triunghi isoscel cu vrfurile n punctele de
coordonate 0,0, 2,0 i 1,2.
9.16. Comunicarea prin AutoLISP

AutoLISP permite comunicarea cu mediul de aplicaie AutoCAD (n principal cu
interpretorul de comenzi al acestuia, dar i cu alte faciliti), folosind urmtoarele categorii de
funcii:
9.16.1. Funcii de conversie valoric
Pentru a opera conversia valorilor de diferite tipuri AutoLISP folosete funciile urmtoare:
(ANGTOS unghi [mod [precizie]])
Aceast funcie convertete valoarea argumentului unghi exprimat n radiani ntr-un ir de
caractere.
195
Argumentul mod ndeplinete rolul variabilei de sistem AUNITS din AutoCAD, care
stabilete unitile de exprimare a unghiurilor.
Argumentul precizie ndeplinete rolul variabilei de sistem AUPREC din AutoCAD, care
stabilete precizia de exprimare a unghiurilor.
Dac mod i precizie sunt omise, conversia este fcut conform strii variabilelor de sistem
menionate. Dac argumentele sunt menionate, sunt folosite urmtoarele valori i semnificaii:
Pentru argumentul mod
0 grade sexagesimale exprimate cu punct zecimal
1 grade minute secunde
2 grade centesimale
3 radiani
4 uniti de navigaie
De exemplu:
(setq p1 (5.0 1.33) p2 (2.4 1.33) a (angle p1 p2))
(angtos a 0 0)
returneaz 180
(angtos a 0 4)
returneaz 180.0000
(angtos a 1 4)
returneaz 180d00
(angtos a 4 2)
returneaz W.
(ANGTOF ir [mod])
Aceast funcie convertete argumentul de tip ir de caractere ir reprezentnd un unghi ntr-o
valoare real exprimat n radiani. Modul n care este interpretat irul de caractere depinde de
argumentul mod care, ca i la funcia ANGTOS, are aceeai semnificaie. De exemplu:
(angtof 180d00\ 1)
(ATOI ir)
Aceast funcie convertete un ir de caractere ASCII n numr ntreg. De exemplu:
(atoi 2)
returneaz 2
(atoi 2.3)
returneaz 2.
(ATOF ir)
Aceast funcie convertete un ir de caractere ASCII n numr real. De exemplu:
(atof 2)
returneaz 2.0
(atof 2.3)
returneaz 2.3.
(ITOA eni)
Aceast funcie convertete expresia numeric ntreag eni n ir de caractere ASCII. De
exemplu:
(itoa 2)
returneaz 2
(itoa 2.3)
produce mesajul error: bad argument type.
(RTOS enr)
Aceast funcie convertete expresia numeric real enr n ir de caractere. De exemplu:
(rtos 2)
returneaz 2.0000
(rtos 2.3)
returneaz 2.3000.
9.16.2. Funcii de operare asupra irurilor de caractere
Operarea asupra valorilor de tip ir de caractere se realizeaz cu funciile urmtoare:
(STRCAT ir1 ir2 irn)
Aceast funcie leag (concateneaz) ntr-un singur ir de caractere irurile ir1, ir2,
196
irn. De exemplu:
(setq disp C: dir1 Alfa dir2 Beta sep \\)
(setq cale (strcat disp sep dir1 sep dir2)) atribuie simbolului cale valoarea ir de caractere
C:\\Alfa\\Beta.
(STRLEN ir)
Aceast funcie returneaz o valoare numeric ntreag reprezentnd numrul de caractere
din ir. De exemplu:
(strlen Abcd)
returneaz 4.
(STRCASE ir [mod])
Aceast funcie convertete argumentul ir de caractere ntr-o alt form determinat de
valoarea argumentului mod.
Dac mod este prezent i este diferit de nil, caracterele sunt convertite n litere mici, altfel
sunt convertite n litere mari.
(strcase Abcd) sau (strcase Abcd nil) returneaz ABCD
(strcase Abcd t)
returneaz abcd.
(SUBSTR ir nceput [lungime])
Aceast funcie extrage din argumentul ir un subir ncepnd de la caracterul de indice
egal cu valoarea argumentului numeric ntreg nceput i attea caractere cte indic
argumentul numeric ntreg lungime. Dac lungime este omis, sau dac este mai mare dect
restul de caractere rmase, subirul este extras pn la capt. De exemplu:
(substr ABCD 2 2)
returneaz BC
(substr ABCD 2)
returneaz BCD
(substr ABCD 2 5)
returneaz BCD.
9.16.3. Funcii de intrare/ieire
Operaiile de intrare/ieire din AutoLISP se realizeaz cu funciile urmtoare:
(OPEN nume_fiier mod)
Aceast funcie deschide un fiier identificat prin argumentul nume_fiier conform
modului de deschidere specificat prin argumentul mod. Funcia returneaz un descriptor de
fiier care trebuie atribuit unui simbol, altfel rezultatul se pierde i nu se poate face operaia de
nchidere a fiierului.
Numele de fiier trebuie s descrie calea complet ctre fiier conform regulilor sistemului
de operare DOS. Separatorul de cale este perechea de caractere \\ n loc de obinuitul
caracter \, aceasta datorit semnificaiei de prefix pentru caractere speciale acordat
caracterului backslash (a se vedea exemplul de la funcia STRCAT).
Argumentul mod poate avea valorile:
r
deschidere pentru citire. Dac fiierul nu exist se returneaz nil.
w
deschidere pentru scriere. Dac fiierul nu exist este creat unul nou.
a
deschidere pentru adugare. Dac fiierul nu exist este deschis unul nou. Dac
fiierul exist este deschis, iar pointerul de eviden este poziionat la sfritul fiierului, astfel
nct noile date sunt scrise n continuarea celor existente.
Descriptorul de fiier returnat va fi folosit ulterior pentru:
- citire de date cu funcia read-char sau read-line la fiierele deschise pentru citire;
- scriere de date cu funcia write-char sau write-line la fiierele deschise pentru scriere
(modurile w i a);
197
- nchiderea fiierului cu funcia close.

De exemplu:
(setq df (open C:\\ALFA\\BETA\\NUME.DTA)) returneaz descriptorul de fiier df.
(CLOSE descriptor_de_fiier)
Aceast funcie nchide fiierul specificat de argumentul descriptor_de_fiier obinut
anterior folosind funcia open.
(READ-CHAR [descriptor_de_fiier])
Aceast funcie citete un caracter din fiierul specificat prin argumentul
descriptor_de_fiier. Dac acest argument lipsete citirea se face din bufferul de caractere al
tastaturii. Funcia returneaz o valoare ntreag reprezentnd codul ASCII al caracterului citit.
De exemplu:
(read-char) returneaz 97 dac se apas tasta a sau 65 dac se apas tasta A
Dac se dorete obinerea caracterului citit se va folosi funcia:
(CHR cod)
Aceast funcie returneaz caracterul ASCII al crui cod este furnizat ca argument. De exemplu:
(chr 97)
returneaz a.
(WRITE-CHAR cod [descriptor_de_fiier])
Aceast funcie scrie n fiierul deschis specificat prin argumentul descriptor_de_fiier
caracterul al crui cod este furnizat ca argument. Dac descriptor_de_fiier lipsete scrierea se
face pe ecran n poziia curent a cursorului.
Pentru a se obine codul caracterului de scris se folosete funcia:
(ASCII ir)
Aceast funcie returneaz codul primului caracter din ir. De exemplu:
(ascii abc)
returneaz 97
(write-char (ascii abc)) scrie pe ecran caracterul a deoarece descriptorul de fiier
lipsete.
(READ-LINE [descriptor_de_fiier])
Aceast funcie citete o linie (un ir de caractere terminat cu caracterul ENTER) din
fiierul deschis specificat de argumentul descriptor_de_fiier sau, dac acesta lipsete, de la
tastatur.
(WRITE-LINE ir [descriptor_de_fiier])
Aceast funcie scrie n fiierul deschis specificat de argumentul descriptor_de_fiier irul
de caractere ir ca pe o linie terminat prin caracterul ENTER. Dac descriptor_de_fiier
lipsete scrierea se face pe ecran n poziia curent a cursorului.
(PROMPT mesaj)
Aceast funcie scrie pe ecran irul de caractere constituit de argumentul mesaj.
(TERPRI)
Aceast funcie scrie pe ecran o linie de text goal. Funcia este folosit prin includerea ei
pe ultima linie a unui program AutoLISP ca ieire tcut, pentru a evita afiarea ultimei
evaluri a unei funcii.
(LOAD fiier_lisp)
Aceast funcie servete la ncrcarea unui fiier surs AutoLISP specificat ca argument.
Identificatorul fiierului trebuie s conin dispozitivul i calea ctre fiier, conform
198
conveniei DOS, ca la funcia OPEN. Numele unui fiier AutoLISP are extensia de tip .LSP,
dar aceasta nu este necesar s fie specificat.
9.16.4. Realizarea dialogului dintre AutoCAD i AutoLISP
Exist un numr de funcii care pot fi folosite pentru a construi un dialog ntre interpretorul
de comenzi AutoCAD i un program scris n AutoLISP. Prin utilizarea lor se pot cere sau
introduce informaii din/n baza de date a AutoCAD-ului, sau se pot transmite comenzi ctre
interpretorul de comenzi AutoCAD.
(COMMAND arg1 arg2 argn)
Aceast funcie este cea mai folosit i servete la transmiterea ctre interpretorul de comenzi din
AutoCAD a unei succesiuni de cuvinte de comand rezultate din evaluarea argumentelor arg1, ,
argn. Setul de argumente transmis poate fi incomplet, urmnd o succesiune de alte funcii de naturi
diferite, dar comanda, odat iniiat, trebuie ncheiat, folosind alte funcii command ulterioare.
La scrierea irurilor de caractere ale argumentelor sintaxa comenzii AutoCAD trebuie
respectat, dup exact aceleai exigene ca i n cazul scrierii ei de la tastatur. De exemplu:
(command line (0 0) (1 1) )
are acelai efect ca i setul de comenzi AutoCAD urmtor:

command:LINE
From point:0,0
To point:1,1
To point:<ENTER>
adic trasarea unei linii drepte de la punctul de coordonate 0,0 la punctul de coordonate 1,1.
Observaie: simbolul predefinit PAUSE poate fi folosit ca argument al funciei
COMMAND pentru a realiza o pauz n succesiunea transmiterii de argumente ctre
interpretorul de comenzi. La momentul pauzei utilizatorul poate interveni furniznd
argumentul el nsui. De exemplu:
(command circle 5,5 pause)
are ca efect desenarea unui cerc cu centrul n punctul de coordonate 5,5 i raza furnizat de
utilizator.
Observaie: funcia COMMAND returneaz ntotdeauna rezultatul nil.
(ANGLE punct1 punct2)
Aceast funcie returneaz unghiul cu orizontala fcut de linia care trece prin punctele
punct1 i punct2, msurat n radiani. De exemplu:
(angle (0 0) (1 1)) returneaz valoarea 0.785398, adic /4.
(DISTANCE punct1 punct2)
Aceast funcie returneaz distana dintre punctele punct1 i punct2. De exemplu:
(setq p1 (list 0 0) p2 (list 1 1) d (distance p1 p2)) returneaz 1.41421.
(GETANGLE [punct1] [mesaj])
Aceast funcie poate apare n urmtoarele forme:
(getangle)
ateapt plasarea cu cursorul grafic a dou puncte n cmpul de
lucru al AutoCAD i returneaz unghiul cu orizontala al liniei care unete punctele;
(getangle punct1)
ateapt plasarea celui de al doilea punct de ctre utilizator i
returneaz unghiul cu orizontala al dreptei rezultante;
(getangle mesaj)
acelai efect ca i la (getangle) dar n prealabil afieaz irul de
caractere mesaj;
(getangle punct1 mesaj) acelai efect ca i la (getangle punct1) dar n prealabil afieaz
mesaj.
199
(GETDIST [punct1] [mesaj])

Aceast funcie prezint aceleai patru forme ca i funcia getangle, dar returneaz distana
dintre dou puncte.
(GETINT [mesaj])
Aceast funcie preia de la utilizator o valoare ntreag i o returneaz ca rezultat. Dac
argumentul mesaj este specificat el este afiat ca mesaj de cerere. Dac utilizatorul introduce
altceva dect o valoare ntreag este afiat mesajul: Requires an inetger value. Try again:.
(GETREAL [mesaj])
Aceast funcie preia de la utilizator o valoare real i o returneaz ca rezultat. Dac
argumentul mesaj este specificat el este afiat ca mesaj de cerere. Dac utilizatorul
introduce altceva dect o valoare numeric este afiat mesajul: Requires a value. Try again:.
(GETORIENT [punct1] [mesaj])
Aceast funcie se comport la fel cu funcia GETANGLE dar unghiul returnat este
raportat la direcia de referin stabilit prin comanda UNITS.
(GETPOINT [mesaj])
Aceast funcie preia de la utilizator un punct i returneaz lista coordonatelor sale. Dac
argumentul mesaj este prezent el este afiat ca mesaj de cerere.
(GETSTRING [caz] [mesaj])
Aceast funcie preia de la utilizator un ir de caractere i l returneaz ca rezultat. Dac
argumentul caz este prezent i diferit de nil, irul de caractere poate conine i spaii. Dac
argumentul mesaj este prezent el este afiat ca mesaj de cerere.
(GETVAR nume_variabil)
O larg serie de comenzi din AutoCAD funcioneaz n concordan cu o gam de
parametri de lucru stabilii de aa-numitele variabile de sistem AutoCAD identificate prin
nume_variabil. Marea lor majoritate sunt de tip read-write, altele fiind doar de tip read-only.
Aceste variabile de sistem pot fi citite din AutoLISP cu funcia GETVAR, iar cele care nu
sunt de tip read-only pot fi i modificate cu funcia SETVAR.
(SETVAR nume_variabil valoare)
Aceast funcie permite modificarea valorii unei variabile specificate prin nume_variabil,
dac aceasta este de tip read-write.
(GRAPHSCR)
Aceast funcie comut regimul de lucru n fereastra grafic AutoCAD. Returneaz nil.
(TEXTSCR)
Aceast funcie deschide fereastra text AutoCAD. Returneaz nil.
(REDRAW [nume_de_entitate [mod]])
Aceast funcie poate avea ca unul dintre argumente un aa-numit nume de entitate,
returnat de una din funciile speciale de acces la baza de date a entitilor grafice din
AutoCAD, funcii despre care vom discuta mai trziu. Argumentul mod determin modul de
redesenare a entitii de nume specificat, astfel:
1 redesenarea pe ecran a entitii;
2 ascunderea de pe ecran a entitii;
200
3 evidenierea entitii;
4 dezactivarea evidenierii entitii.
Dac mod nu se specific are loc redesenarea entitii. Dac nume_de_entitate i mod nu
se specific este redesenat portul de vedere curent. Funcia returneaz ntotdeauna nil.
(INITGET [opiune] [list_de_cuvinte_cheie])
Aceast funcie iniializeaz modul de aciune pentru urmtorul apel al unei funcii de
forma GETXXXX, mai puin GETSTRING i GETVAR, i returneaz nil.
Argumentul opiune poate avea valorile:
1 interzicerea rspunsului nul (binar 00000001);
2 interzicerea valorilor numerice nule (binar 00000010);
4 interzicerea valorilor numerice negative (binar 00000100);
8 ignor ncadrarea n limitele desenului chiar dac variabila LIMCHECK este ON (binar
00001000);
etc, pn la 128 cu semnificaii diferite (a se vedea manualul de utilizare).
Prin nsumarea valorilor de mai sus se pot obine combinaii pentru valoarea opiunii.
Astfel 5=1+4 (00000101) poate fi folosit pentru a specifica simultan opiunile
corespunztoare (nu este permis introducerea ca rspuns a caracterului ENTER i nici
valoare negativ).
Dup iniializarea cu INITGET, dac rspunsul utilizatorului la o cerere a o funcie
GETXXXX este neconform ce cerinele este afiat un mesaj de eroare i este repetat cererea.
Argumentul list_de_cuvinte_cheie este un ir de caractere sau set de iruri de caractere
separate prin spaii i care constituie posibile rspunsuri. De exemplu:
(initget CENtru RAZa)
(getkword Metoda?:)
permite un rspuns prin centru, raza, cen sau raz. Aadar majusculele specific
prescurtrile prin care se poate furniza rspunsul.
Funcia INITGET returneaz nil, iar efectul ei nceteaz dup primul apel al unei funcii
GETXXXX.
(GETKWORD mesaj)
Aceast funcie testeaz introducerea de ctre utilizator a unui cuvnt cheie autorizat de
ctre funcia INITGET folosit anterior i repet aciunea pn la obinerea rspunsului corect
pe care l returneaz ca rezultat.
9.17. Accesul la baza de date a entitilor AutoCAD

Utilizatorul poate accesa baza de date pentru entiti AutoCAD folosind urmtoarele
categorii de funcii.
9.17.1. Funcii de manipulare a entitilor grafice
Entitile grafice ale AutoCAD-ului pot fi manipulate folosind urmtoarele funcii
AutoLISP:
(ENTSEL [mesaj])
Aceast funcie permite selectarea manual de ctre utilizator a unei entiti grafice de pe ecran.
Rezultatul returnat este o list de forma: (nume_de_entitate punct_de_selectare)
Argumentul mesaj este opional i este afiat ca mesaj de cerere. De exemplu:
Command:LINE
From point:1,1
To point:6,6
201
To point:<ENTER>
Command:(setq ent (entsel \nAlegeti o entitate:))
Alegeti o entitate:3,3
(<Entity name: 3180520> (3.0 3.0 0.0))
Numele de entitate va putea fi folosit ulterior la operaii de indicare a entitii. De exemplu:

(setq nument (car ent))
returneaz
<Entity name: 3180520>
Observaie: Numele de entitate este un indicator de poziie n baza de date a fiierului
temporar cu care lucreaz AutoCAD. El difer de la o sesiune de lucru la alta.
(ENTGET nume_de_entitate)
Aceast funcie folosete argumentul nume_de_entitate obinut anterior cu funcia
ENTSEL, ENTLAST, ENTNEXT sau SSNAME, i returneaz o list compus din subliste
care definesc entitatea.
De exemplu, pentru entitatea selectat la exemplul anterior:
(setq elist (entget nument))
returneaz lista urmtoare (list de entitate):
((-1 . <Entity name: 3180520>) numele entitii
(0 . "LINE")
tipul entitii
(8 . "0")
(62 . 1)
(10 1.0 1.0 0.0)

(11 6.0 6.0 0.0)
stratul entitii
culoarea entitii
punctul iniial al entitii
punctul final al entitii
(ENTLAST)
Aceast funcie returneaz numele ultimei entiti introdus n baza de date. Dac, n
exemplul anterior, linia 1,1-6,6 ar fi fost ultima generat, se putea folosi cu acelai rezultat:
(entget (entlast))
(ENTNEXT [nume_de_entitate])
Aceast funcie are ca efecte:
- dac nume_de_entitate lipsete este returnat numele primei entiti din baza de date;
- dac nume_de_entitate este specificat se returneaz numele entitii urmtoare din baza de date;
- cnd nume_de_entitate reprezint ultima entitate din baza de date funcia returneaz nil.
(ENTDEL nume_de_entitate)
Aceast funcie terge din baza de date entitatea de nume specificat. Dac entitatea a fost
deja tears ea va fi restaurat.
(ENTMOD list_de_entitate)
Acestei funcii i se transmite ca argument o list de entitate n care au fost operate
modificri prin intermediul funciilor prelucrtoare de liste (n special folosind SUBST), dar
fr a se opera asupra asociaiei cu 1 (cea care conine numele de entitate a se vedea
exemplul de mai sus). Funcia modific entitatea conform modificrii operate n list.
De exemplu, pentru linia de mai sus:
(setq oldcul (assoc 62 elist))
returneaz perechea cu punct (62 . 1) coninnd vechea
culoare a entitii
(setq elist (subst (cons 62 5) oldcul elist)) returneaz o list nou de entitate in care
202
perechea cu punct (62 .1) este nlocuit cu perechea (62 . 5)

(entmod elist)
modific entitatea conform noii componene a listei elist
Observaie: n cazul entitilor simple modificarea operat de ENTMOD este imediat vizibil pe
ecran. n cazul entitilor complexe modificarea va fi vizibil abia dup folosirea funciei ENTUPD.
(ENTUPD nume_de_entitate)
Aceast funcie actualizeaz entitatea de nume specificat prin redesenarea ei conform
ultimelor modificri operate asupra ei n baza de date.
9.17.2. Funcii de acces la tabela de simboluri
Obiectele predefinite i avnd denumiri atribuite, cum ar fi straturile, tipurile de linii,
stilurile de text i blocurile de entiti grafice, se reflect ntr-o tabel de simboluri la care se
poate avea acces numai pentru citire, prin intermediul funciilor TBLNEXT i TBLSEARCH.
(TBLNEXT tip_de_obiect [redeschidere])
Aceast funcie caut n tabela de simboluri prima nregistrare care urmeaz ultimei
nregistrri returnate de un apel anterior de cutare pentru obiectul de tipul specificat. Dac o
asemenea nregistrare exist este returnat o list de definiie, altfel se returneaz nil.
Dac argumentul redeschidere exist i este diferit de nil, rezultatul este returnarea primei
nregistrri de tipul specificat existent n baza de date.
De exemplu:
(tblnext BLOCK)
ar putea returna urmtoarea list:
((0 . BLOCK)
numele tipului de obiect cutat
(2 . CUTIE)
numele obiectului
(70 . 0)
indicator de stare
(10 9.0 2.0 0.0)
punct de inserare
(-2 . <Entity name : 3180552>) numele primei entiti coninut n bloc
)
(TBLSEARCH tip_de_obiect nume_atribuit [corelare])

Aceast funcie caut n tabela de simboluri o nregistrare pentru un obiect de tip specificat i
avnd numele atribuit specificat. Dac argumentul corelare este prezent i este diferit de nil, atunci
urmtoarea evaluare a funciei TBLNEXT va returna nregistrarea care urmeaz dup cea
returnat de apelul curent al funciei TBLSEARCH, altfel cele dou funcii lucreaz independent.
Ca exemplu, rezultatul obinut mai nainte de funcia TBLNEXT putea fi obinut i direct
prin funcia:
(TBLSEARCH BLOCK CUTIE)
9.17.3. Funcii pentru manipularea seturilor de selecie

Un set de selecie n AutoLISP este o colecie de nume de entiti. El constituie o baz de
date temporar care permite manipularea mai comod a entitilor. Funciile care manipuleaz
seturile de selecie sunt urmtoarele:
(SSGET [mod] [punct1 [punct2]] [lista_de_puncte] [lista_de_filtrare])
Aceast funcie selecteaz o colecie (set) de entiti. Argumentul opional mod, de tip
ir de caractere, poate fi unul dintre irurile de caracterele acceptate la selecia de entiti sub
AutoCAD, adic:
W metoda Window (numai entitile complet incluse ntr-o fereastr dreptunghiular);
WP metoda WPolygon (numai entitile complet incluse ntr-o fereastr poligonal);
C metoda Crossing (toate entitile care traverseaz o fereastr dreptunghiular);
203
CP metoda CPolygon (toate entitile care traverseaz o fereastr poligonal);

L ultima entitate generat (Last);
P setul de selecie selectat anterior (Previous);
F metoda Fence (toate entitile care traverseaz un traseu poligonal nenchis;
X toate entitile din baza de date.
Argumentele punct1 i punct2 sunt liste de coordonate de puncte folosite pentru definirea
colurilor diagonal opuse ale unor ferestre la metodele W i C. Dac argumentul punct2
lipsete AutoCAD ateapt introducerea lui de ctre utilizator.
Argumentul list_de_puncte este o list de liste de coordonate de puncte i este folosit la
metodele WP, CP i F.
Dac SSGET este folosit fr argumente, AutoCAD invit la selectarea manual
obinuit, ncheiat prin ENTER.
Argumentul lista_de_filtrare este o list de asociaii (perechi cu punct) care descriu
proprieti ale entitilor de selectat. Din totalitatea entitilor ncadrabile n aria descris de
argumentul mod vor fi reinute n set numai cele care se potrivesc cu cerinele listei de filtrare.
De exemplu:
(setq cercuri_rosii (ssget X (list (cons 0 CIRCLE) (cons 62 1))))
va reine din toat baza de date numai entitile de tip cerc de culoare roie.
Numrul maxim de seturi de selecie este de 128, orice ncercare de a crea un set n plus se
va solda cu returnarea rezultatului nil.
Pentru a desfiina un set de selecie devenit inutil acesta trebuie asociat cu nil, de exemplu:
(setq cercuri_rosii nil)
(gc)
Funcia GC (Garbage collection colectare de gunoaie) restituie sistemului memoria

ocupat de entitile AutoLISP desfiinate.
(SSLENGTH set_de_selecie)
Aceast funcie returneaz numrul de entiti din setul de selecie. Valoarea returnat este
de tip ntreg dac este de pn la 32767 de entiti i de tip real pentru un numr mai mare.
(SSNAME set_de_selecie indice)
Aceast funcie returneaz numele de entitate coninut ntr-un set de selecie, al crei
indice de ordine (ncepnd de la 0) este specificat de argumentul indice.
(SSADD [nume_de_entitate [set_de_selectie]])
Aceast funcie are variantele urmtoare:
(ssadd)
construiete un nou set de selecie vid;
(ssadd nume_de_entitate)
construiete un nou set de selecie coninnd entitatea de
nume specificat;
(ssadd nume_de_entitate set_de_selectie) adaug entitatea de nume specificat la setul de
selecie specificat.
(SSDEL nume_de_entitate set_de_selectie)
Aceast funcie elimin entitatea de nume specificat din setul de selecie specificat. Dac
entitatea nu face parte din set este returnat nil.
(SSMEMB nume_de_entitate set_de_selectie)
Aceast funcie testeaz apartenena entitii de nume specificat la setul de selecie
specificat i returneaz T sau nil, dup caz.
Cap.10. Aplicaii de programare n C i C++
204

10.1. Elaborarea unui program n limbaj C ntr-un mediu de
programare integrat
10.1.1. Generaliti asupra mediului de lucru
Limbajul C este un limbaj pentru lucrul prin procedeul compilator. La ora actual este un
limbaj foarte rspndit. Existent n diferite versiuni ca mediu de programare de sine stttor,
el se afl chiar inclus n anumite medii integrate de dezvoltare din unele aplicaii.
Dat fiind, deci, rspndirea lui, se cuvine s prezentm cteva elemente privind concepia
lui i modul su de folosire.
Limbajul C are trei avantaje principale, i anume:
- este un limbaj de programare cu destinaie general. Cu ajutorul lui se pot construi orice
fel de programe, de la editoare de text i programe de calcul matematic, pn la jocuri dintre
cele mai complexe;
- este un limbaj structurat. Limbajul C posed capabiliti de structurare complet ceea ce
confer programelor o mare robustee i uurina modificrii;
- este un limbaj standardizat. Aceasta face ca n cea mai mare parte din cazuri, cu foarte
mici modificri sau fr nici o modificare, un program n C scris pe o anumit main s
poat fi compilat pe o alta.
Pentru simplitate, vom prezenta un produs de natur didactic, cu funcionalitate limitat
dar foarte potrivit pentru programatorul nceptor. Este vorba de compilatorul de C care
nsoete cartea lui Tom Swan, "nvm C pas cu pas", Editura Tehnic, Bucureti, 1996.
Acest compilator este o variant simplificat a unui mediu de programare foarte popular la un
moment dat, produs de firma Borland, i anume TURBO C++.
Acest adevrat mediu de programare este destinat exclusiv sistemului de operare DOS.
Pentru un nceptor, imposibilitatea folosirii acestui compilator pentru scrierea de programe
pentru WINDOWS este un lucru bun deoarece simplific mult lucrurile, permind
nceptorului s se concentreze pe problemele de esen ale lucrrilor de programare, evitnd
multele detalii ale programrii pentru WINDOWS care l-ar putea descuraja.
Fig. 10.1.
205
10.1.2. Lansarea n lucru a compilatorului de C

Versiunea de compilator descris mai sus este instalat sub denumirea de TCLITE.
Programul se poate lansa fie cu ajutorul butonului Start>Programs>TcLite, fie cu
ajutorul pictogramei TcLite de pe Desktop, dac aceasta a fost creat.
La lansare, compilatorul deschide o fereastr ca n figura 10.1.
Componena ferestrei compilatorului reflect o etap de interfaare grafic premergtoare
sistemului WINDOWS. Se observ i aici o componen destul de asemntoare cu aceea a
ferestrelor de aplicaie din sistemul WINDOWS, i anume:
- o bar de meniu scris, cu articolele File, Edit, Search, , Window i Help;
- un chenar al cmpului de lucru de mrime reglabil prin tragere cu mouse-ul;
- un buton de nchidere a ferestrei cmpului de lucru (la stnga, sus - []):
- un buton de maximizare restaurare a ferestrei de lucru (la dreapta, sus - [ ]);
- dou bare de defilare, pe vertical i, respectiv, pe orizontal;
- o bar de meniu rapid, la baza ferestrei aplicaiei, cea care conine simbolurile tastelor
funcionale F1, F2, F3, Alt-F9, F9 i F10.
Inscripia NONAME.CPP de pe chenarul ferestrei de lucru reprezint denumirea fiierului
surs acordat automat la lansarea aplicaiei.
10.1.3. Utilizarea meniului mediului de programare
n continuare vom prezenta pe scurt numai acele meniuri i articole ale lor strict necesare
pentru un nceptor.
Fig.10.1.2.
Fig.10.1.5.
Fig.10.1.3.
Fig.10.1.4.
Fig.10.1.6.
Fcnd o scurt examinare a figurilor 10.1.2 ... 10.1.8, se observ c unele dintre articolele
de meniu sunt afiate cu negru iar celelalte cu gri. Motivul este acelai ca i n Windows, i
anume contextualitatea comenzilor cu situaia de lucru curent. Dac o comand este
aplicabil ntr-un anumit moment al lucrului ea va fi afiat cu negru, altfel este afiat cu gri.
206
Ca i n Windows, comenzile direct executabile nu sunt urmate de un alt simbol (de

exemplu New, Save, ... , Quit). Comenzile care deschid o nou list de meniu sunt urmate de
o sgeat sub form de triunghi (de exemplu n meniul Options, comanda Environment) n
sfrit, comenzile care deschid o cutie de dialog sunt urmate de trei puncte ... (de exemplu
Open, Save as, ..., etc.).
Meniul File (figura 10.1.2) este destinat lucrului cu fiiere i conine articolele:
- Open - pentru deschiderea unui fiier program surs existent;
- New - pentru crearea unui fiier program surs nou;
- Save - pentru salvarea fiierului curent, cu numele existent i n directorul asociat;
- Save as - pentru salvarea fiierului curent, cu un alt nume i ntr-un alt director;
- Save all - pentru salvarea tuturor fiierelor deschise n sesiunea de lucru curent, ca i
Save, adic avnd denumirile i directoarele deja stabilite;
- Change dir - pentru schimbarea directorului de lucru curent;
- Print - pentru transmiterea la imprimant a coninutului fiierului curent;
- Get info - pentru obinerea informaiilor referitoare la fiierul curent;
- DOS shell - pentru prsirea temporar a mediului de lucru pentru a efectua o operaie
sub sistemul de operare DOS. n condiiile lucrului sub sistemul Windows, aceast comand
nu i mai gsete utilitatea de alt dat;
- Quit - pentru ieirea din mediul de programare.
Fig.10.1.7.
Fig.10.1.8.
Meniul Edit (figura 10.1.3) este destinat operaiilor de editare (modificare) n fiierul de
lucru curent i conine articolele:
- Restore line - este echivalentul comenzii Undo din programele Windows, restaurnd
situaia anterioar ultimei modificri;
- Cut, Copy i Paste, au aceleai semnificaii ca i n Windows;
- Copy example. Mediul TcLite pune la dispoziie o serie de exemple care, cu aceast
comand, pot fi copiate n Clipboard n ntregime;
- Show Clipboard - deschide fereastra Clipboard n care se afl stocat textul copiat
anterior cu comenzile Copy sau Cut;
- Clear - terge textul selectat fr a-l mai copia n Clipboard.
Meniul Search (figura 10.1.4) este destinat operaiilor pentru cutare i/sau nlocuire de
secvene de text i conine articolele:
- Find - pentru cutarea unui ir de text selectat;
- Replace - pentru nlocuirea unui ir de text selectat cu un altul specificat;
- Search again - pentru repetarea cutrii unui ir de text;
- Go to line number - pentru poziionarea cursorului la o linie de text de numr indicat;
- Previous error - pentru poziionarea cursorului la eroarea semnalat de compilator
anterioar erorii la care se afl n mod curent cursorul (n timpul operaiilor de depanare a
programelor);
207
- Next error - pentru poziionarea cursorului la eroarea semnalat de compilator ulterioar

erorii la care se afl n mod curent cursorul;
- Locate function - se folosete n programele mari pentru poziionarea cursorului la
nceputul definiiei unei funcii cu numele indicat de utilizator.
Comenzile Previous error, Next error i Locate function pot fi folosite numai pe
parcursul lucrului cu depanatorul.
Meniul Run (figura 10.1.5) este destinat operaiilor de rulare a programelor de sub mediul
de programare i conine articolele:
- Run - ruleaz programul curent;
- Program reset - efectueaz urmtoarele aiuni: oprete sesiunea curent de depanare;
elibereaz memoria pe care programul i-a alocat-o; nchide orice fiier pe care l-a deschis
programul n cursul rulrii i care a rmas eventual nenchis de ctre program;
- Go to cursor - ruleaz programul pn la linia la care se afl cursorul;
- Trace into - transfer rularea pas cu pas din timpul depanrii la prima linie a funciei
curente. n caz contrar, dac se folosete rularea de depanare cu Step over, este efectuat
rularea ntregului cod al funciei, dup care cursorul sare la linia de program ulterioar
funciei;
- Step over - vezi mai sus;
- Arguments - permite specificarea argumentelor de care programul curent ar avea nevoie
dac el ar fi rulat de sub sistemul DOS. Dac programul nu are asemenea argumente aceast
comand nu trebuie folosit;
Meniul Compile (figura 10.1.6) este destinat compilrii programului curent i conine
articolele:
- Compile to OBJ - se folosete n prima faz de compilare pentru a se produce codul
obiect din codul surs (text) al programului. n aceast faz este fcut analiza sintactic i
este semnalat majoritatea erorilor;
- Make EXE file - se folosete n a doua faz de compilare n cazul programelor care au la
baz un fiier proiect (nume.PRJ) n care sunt specificate i alte module. Rezultatul acestei
faze este codul obiect executabil rezultat din codurile obiect separate ale fiierelor necurente
i editarea legturilor dintre modulul rezultat din fiierul curent compilat cu Compile to OBJ
i modulele obiect ale fiierelor program necurente;
- Link EXE file - este folosit la editarea legturilor dintre module compilate anterior
separat cu Compile to OBJ;
- Build all - execut toate fazele de compilare i legare ale tuturor fiierelor din proiect
indiferent de starea lor de actualitate;
- Remove messages - elimin toate mesajele din fereastra Message.
Meniul Debug conine comenzi necesare n timpul depanrii. Deocamdat vom sri peste
acest subiect, urmnd s revenim la el mai trziu cnd se vor acumula mai multe cunotine.
Meniul Project este destinat gestionrii fiierelor proiect. Aceste fiiere descriu programe
complexe definite din mai multe module. Vom sri i peste acest subiect care va fi tratat mai trziu.
Meniul Options (figura 10.1.7) administreaz opiunile de lucru cu compilatorul i
conine articolele:
- Compiler defines - este o comand destinat nlocuirii unei directive DEFINE care nu
este prezent n textul surs;
- Directories - deschide cutia de dialog din figura 8 care permite specificarea
urmtoarelor:
= Include Directories - directoarele care conin fiierele n cod surs invocate de
directiva INCLUDE;
208
= Library Directory - directoarele care conin fiiere de bibliotec n cod obiect sau
executabil care trebuie legate cu fiierul de compilat sau sunt apelate de acesta n cursul execuiei;
= Output directory - directorul de ieire, adic acela n care este stocat produsul
compilrii sub form de fiier obiect (OBJ).
- Environment - pentru stabilirea setrilor de lucru ale mediului de programare (preferine
de folosire a ecranului, opiuni privind editorul de text, modul de comportare al mouse-ului);
- Save - comand de salvare a opiunilor de lucru stabilite cu meniul Options.
Meniul Window este destinat lucrului cu ferestrele mediului de programare. Este destul de
explicit i uor de neles, astfel nct, pentru economia acestei lucrri vom renuna la
prezentarea lui, cu att mai mult cu ct meniul Help pune la dispoziia utilizatorului
lmuririle necesare.
10.1.4. Aplicaie
Vom trece acum la un exemplu de program C++, prin care vom ncerca s parcurgem
practic etapele de lucru cu acest mediu de programare.
#include <stdio.h>
/* directive preprocesor */
#include <conio.h>
void main()
/* functia principala */
{int i;
/* declaratii de tipuri de variabile */
char c;
i=0;
/* urmeaza instructiunile */
while ((c=getchar()) != '\n') {i=i+1;}/* asteapta apasarea tastei
ENTER si numara apasarile
de taste */
cout << "Inainte de a apasa ENTER ati apasat " << i << " taste\n";
getch();
/* asteapta apasarea unei taste */
}
Componena programului:
Programul conine dou blocuri, i anume:
- blocul directivelor preprocesor. n acest bloc apar directivele include. El ntiineaz
compilatorul ca, pentru funciile nedefinite n corpul programului s se efectueze o cutare n
fiierele stdio.h, conio.h i iostream.h. Aceste cutri sunt necesare pentru funciile getchar,
getch i cout, care nu sunt definite n program.
- funcia principal, main. n aceast funcie sunt coninute instruciunile programului.
Textele incluse ntre perechile de caractere /* i */ constituie comentarii i sunt ignorate de
compilator.
Etapele de lucru pentru elaborarea programului sunt:
- Dup lansarea programului compilator, se scrie textul surs (cel prezentat mai sus).
Editorul de text este inclus n mediul de programare i nu necesit accesare separat. Practic,
programatorul se gsete tot timpul n editorul de text;
- nainte de a se trece la urmtoarele etape, pentru a nu se pierde programul surs ca
urmare a unei erori de execuie care ar conduce la blocarea compilatorului (se poate ntmpla
oricnd din diferite motive, legate mai ales de o concepie defectuoas a programului), se
salveaz fiierul surs. La prima salvare se va folosi comanda Save as din meniul File. Se va
alege un director de depozitare a fiierului program surs i i se va atribui un nume. Numele
209
trebuie urmat de extensia C sau CPP dup cum este vorba de folosirea limbajului C standard
sau a versiunii sale extinse, i anume C++.
- Urmtoarea etap este cea de compilare. Pentru aceasta se folosete meniul Compile, din
care se selecteaz comanda Compile to OBJ. Aceasta produce fiierul cod obiect relocabil.
Dac la salvare s-a ales numele DID1.CPP, la compilare va fi produs fiierul DID1.OBJ.
n aceast faz are loc depistarea erorilor de sintax i de definire. Compilatorul nu va
raporta ndeplinirea sarcinii de compilare dact atunci cnd toate erorile vor fi fost eliminate.
Dac apar erori, acestea sunt raportate ntr-o fereastr de mesaje (Message Window) care se
deschide la baza ferestrei compilatorului.
- n cazul unei lucrri mai complexe, pentru crearea unui program din mai multe module,
se folosete un fiier proiect (nume.PRJ) care conine indicaiile privind componena lucrrii.
n cazul nostru, deoarece nu exist un proiect, se pot folosi numai comenzile Compile to
OBJ i Make EXE file. Pentru simplitate, vom folosi numai Compile to OBJ pentru a activa
analiza erorilor. Nu vom mai folosi Make EXE file deoarece comanda Run din meniul Run
ndeplinete funciile cumulate ale comenzilor Compile to OBJ i Make EXE file.
Am putea folosi de la nceput comanda Run dar nu este indicat deoarece nc nu am
eliminat erorile i ne expunem pericolului unei cderi a programului compilator din cauza
erorilor neeliminate.
Obs. O serie de erori greu detectabile sunt cele de execuie, cauzate de vicii de concepie.
Aceste erori nu sunt de tip sintactic, nici de definire, i nu sunt detectabile n faza de
compilare. Ele nu se manifest dect la execuie i pot cauza efecte nedorite dintre cele mai
diverse, de la simple rezultate eronate pn la cderi ale sistemului.
10.2. Programe simple n C

Fiecare dintre exerciiile urmtoare trebuie realizat ca fiier program surs de sine stttor.
Ele pot avea extensia de tip C, deoarece nu conin instruciuni caracteristice variantei C++.
Desigur, ele sunt recunoscute i n cazul realizrii unui program C++, caz n care trebuie s
aib extensia de tip CPP. Putei opta pentru oricare variant dintre cele dou.
Primul exerciiu are ca scop producerea afirii unui text. Se observ din textul surs de
mai jos succesiunea blocurilor de program:
- mai nti directivele de includere a textului surs din fiierele antet (nume.h) n care se
gsesc definiiile funciilor de bibliotec ale limbajului C;
- apoi, directivele de definire a constantelor de tip ir de text care se regsesc ulterior n
textul surs al programului i pe care compilatorul le va nlocui cu textul din definiie;
- definiiile de tipuri de date noi;
- definiiile funciilor apelate n programul principal i care trebuie cunoscute de
compilator n momentul ntlnirii apelurilor acelor funcii, n situaia cnd acele funcii sunt
definite de programator i nu sunt funcii de bibliotec;
- n sfrit, programul principal, sub forma funciei main.
Exercitiul A
#include <stdio.h>
#include <conio.h>
#define UNU 1
typedef int intreg;
/*directive preprocesor*/
/*definitii de tipuri noi*/

/*definirea unei functii*/
{printf("acesta este programul numarul %i\n", numar);}
void main(void)
{intreg primul=UNU;
mesaj(primul);
getch();
}
210
/*functia main = programul principal*/
Funciile definite de utilizator pot fi definite i dup funcia main. Totui, compilatorul are
nevoie s tie mcar tipurile argumentelor de intrare n funcie i tipul rezultatului returnat de
funcie, altfel, la ntlnirea apelurilor respectivelor funcii n funcia main, nu va putea aloca
spaiile necesare n memorie.
Din acest motiv, dac definirea unei funcii se va face dup funcia main, trebuie ca
inaintea funciei main s se plaseze un "prototip" al respectivei funciei, prototip al crui rol
este de a defini tipurile datelor de intrare i ieire n/din funcie.
Observaie: funcia getch are numai rolul de a conserva starea ecranului pn cnd
utilizatorul apas pe o tast. Altfel, mediul de programare ar prelua imediat controlul
reafind textul surs din editorul de text al mediului TcLite. Pentru un program rulabil direct
de sub sistemul DOS, aceast instruciune nu ar fi necesar.
Exemplul al doilea este o variant a primului exemplu, dar cu folosirea unui prototip de
funcie.
Exercitiul B
#include <stdio.h>
#include <conio.h>
#define UNU 1
typedef int intreg;
/* definitii de tipuri */
void mesaj(intreg)
/* prototipul functiei mesaj */
void main(void)
{intreg al_doilea=UNU+1;
mesaj(al_doilea);
getch();
}
/* programul principal */

/*definirea functiei mesaj*/
{printf("acesta este programul numarul %i\n", numar);}
Al treilea exemplu ilustreaz folosirea funciilor n scopul simplificrii scrierii unui program.
Funcia intrebare afieaz pe ecran textul unei ntrebri folosind funcia de bibliotec printf.
Funcia raspuns afieaz pe ecran textul preluat de la utilizator prin intermediul funciei de
bibliotec gets.
Exercitiul C
#include <stdio.h>
#include <conio.h>
void intrebare(void)
/* definirea functiilor */
{printf("Cum te cheama?\n");}
void raspuns(char &nume)
{printf("Ma bucur de cunostinta, %s\n",&nume);}
211
void main(void)
{char nume[50];
intrebare();
gets(nume);
raspuns(*nume);
getch();
}
Al patrulea exemplu este o variant a celui de al treilea n care irul de caractere al

rspunsului este receptat n cuprinsul funciei intrebare. Astfel, programul principal este
simplificat la maximum.
Exercitiul D
#include <stdio.h>
#include <conio.h>
char * intrebare(void)
/* definirea functiilor */
{char nume[100];
printf("Cum te cheama?\n");
gets(nume);
return nume;
}
void raspuns(char &nume)
{printf("Ma bucur de cunostinta, %s!\n", &nume);}
void main(void)
{char * numestud;
numestud=intrebare();
raspuns(*numestud);
getch();
}
10.3. Folosirea structurilor ca tipuri de date complexe

n cadrul acestui exemplu este definit structura de date denumit punct2D relundu-se
aplicaia prezentat la punctul 2.3.5.
n cuprinsul funciei oglinda din Aplicaia 1 este folosit tehnica de transfer a datelor prin
pointeri i adrese ct i aa numitul efect lateral (vizibilitatea datelor prin intermediul
adreselor comune programului principal i funciei - se observ c funcia oglind nu
returneaz nici o valoare dar variabila pct este vizibil din exterior). Aceast tehnic ncalc
principiul ncapsulrii datelor n favoarea economiei de memorie. Folosirea ei necontrolat
poate fi duntoare siguranei aplicaiei.
Aplicaia 1 pentru structuri
struct punct2D {float x,y;};
void oglinda_oy(struct punct2D *pct)
{pct->x=-pct->x;}
void main ()
{struct punct2D A={5,3};
cout << "Punctul original A are x=" << A.x << " si y=" << A.y << "\n";
oglinda_oy(&A);
cout << "Punctul oglindit A' are x=" << A.x << " si y=" << A.y << "\n";
}
212
n Aplicaia 2 a fost evitat nclcarea principiului ncapsulrii datelor prin folosirea

transferului datelor prin valoare (p1 i p2 sunt copii interne ale valorilor a i b din programul
principal, iar pm este copiat n programul principal sub forma variabilei c).
Aplicaia 2 pentru structuri
punct2D punct_mediu(punct2D p1, punct2D p2)
{punct2D pm, ptemp;
pm.x=0.5*(p1.x+p2.x);
pm.y=0.5*(p1.y+p2.y);
ptemp=p1; p1=p2; p2=ptemp;
return pm;
}
void main ()
{punct2D a={0,0}, b={6,6}, c;
cout << "a(" << a.x << "," <<
cout << "b(" << b.x << "," <<
cout << "c(" << c.x << "," <<
c=punct_mediu(a,b);
cout << "a(" << a.x << "," <<
cout << "b(" << b.x << "," <<
cout << "c(" << c.x << "," <<
}
a.y << ")\n";

b.y << ")\n";
c.y << ")\n";
a.y << ")\n";
b.y << ")\n";
c.y << ")\n";
10.4. Aplicaii simple n C++

Aplicatia 1: Selectarea numerelor naturale dupa paritate.
#include <conio.h>
void selpar(int nr)
/* selectarea numarului par*/
{if((nr%2)!=0) cout << "x;"; else cout << nr << ";";
return;
}
void selimpar(int nr) /* selectarea numarului impar*/
{if((nr%2)==0) cout << "x;"; else cout << nr << ";";
return;
}
void main()
{int a1,a2,a3,a4,a5,a6;
cout << "\nIntroduceti 6 numere naturale!";
cout << "\na1="; cin >> a1;
cout << "\na2="; cin >> a2;
cout << "\na3="; cin >> a3;
cout << "\na4="; cin >> a4;
cout << "\na5="; cin >> a5;
cout << "\na6="; cin >> a6;
cout << "\nNumerele pare sunt:";
selpar(a1); selpar(a2); selpar(a3);
selpar(a4); selpar(a5); selpar(a6);
cout << "\nNumerele impare sunt:";
213
selimpar(a1); selimpar(a2); selimpar(a3);

selimpar(a4); selimpar(a5); selimpar(a6);
cout << "\n";
getch();
Aplicatia 2: Suma primelor n numere naturale.

#include <conio.h>
void main()
{int suma=0,i=0,n;
cout << "\nSpecificati numarul n:";
cin >> n;
while(i<n){i++; suma=suma+i;}
cout << "\nSuma primelor " << n << " numere naturale=" << suma << "\n";
getch();
}
Aplicatia 3: Produsul primelor n numere naturale (factorial).

#include <conio.h>
void main()
{int prod=1,i=0,n; char c;
cout << "\nSpecificati numarul n:";
cin >> n;
while(i<n){i++; prod=prod*i;}
cout << "\nFactorial de " << n << "=" << prod << "\n";
cin >> c;
getch();
}
10.5. Aplicaii de utilizare a tablourilor

Aplicatia 1 - Incrementarea elementelor unui tablou
#include <conio.h>
#define DIM1 2
#define DIM2 2
void increment(float tablou[DIM1][DIM2])
{int i,j;
for(i=0;i<DIM1;i++)
for(j=0;j<DIM2;j++) tablou[i][j]++;
}
void tiptab(float tablou[DIM1][DIM2])
{int i,j;
for(i=0;i<DIM1;i++)
for(j=0;j<DIM2;j++)
cout << "tabl(" << i << "," << j << ")=" << tablou[i][j] << "\n";
}
void main()
{float tabl[DIM1][DIM2]={{11,12},{21,22}};
cout << "Tabloul initial\n";
214
tiptab(tabl);
increment(tabl);
cout << "Tabloul incrementat\n";
tiptab(tabl);
getch();
}
Aplicatia 2 - Determinarea elementului minim al unui tablou

#include <conio.h>
#define DIM 5
float min2v(float a, float b)
{return(a<b ? a : b);}
int sorttab(float tablou[DIM])
{int i,indmin;
float valmin;
valmin=tablou[0];
indmin=0;
for(i=1;i<DIM;i++)
{valmin=min2v(valmin,tablou[i]);
if(valmin==tablou[i]) indmin=i;
}
return indmin;
}
void tiptab(float tablou[DIM])
{int i;
for(i=0;i<DIM;i++) cout << "tabl(" << i << ")=" << tablou[i] << "\n";
}
void main()
{float tabl[DIM]={2,5,1,4,6};
int imin;
cout << "Tabloul initial\n";
tiptab(tabl);
imin=sorttab(tabl);
cout << "Elementul minim din tablou este: tabl(" << imin << ")=" <<
tabl[imin] << "\n";
getch();
}
10.6. Aplicaii la transmiterea tablourilor ca pointeri

Aplicaia 1: tablouri unidimensionale
#include <conio.h>
#define DIM 3
float cere_element(int i)
{float elem;
cout << "a(" << (i+1) << ")=";
cin >> elem; cout << "\n";
return elem;
}
215
void afis_tablou(float *ptablou)

{int i;
for(i=0;i<DIM;i++)
cout << "a(" << (i+1) << ")=" << *(ptablou+i) << "\n";
}
void main()
{float tablou[DIM];
int i;
float *ptablou;
ptablou=tablou;
cout << "Introduceti elementele tabloului\n";
for(i=0;i<DIM;i++) tablou[i]=cere_element(i);
cout << "Elementele tabloului sunt:\n";
afis_tablou(ptablou);
getch();
}
Aplicaia 2: tablouri multidimensionale

#include <conio.h>
#define DIM1 3
#define DIM2 2
float cere_element(int i, int j)
{float elem;
cout <<"a("<<(i+1)<<","<<(j+1)<<")=";cin>>elem;cout<<"\n";
return elem;
}
void afis_tablou(float **ptablou)
{int i,j;
for(i=0;i<DIM1;i++)
for(j=0;j<DIM2;j++)
cout <<"a("<<(i+1)<<","<<(j+1)<<")="<<*((*ptablou)+i*DIM2+j)<<"\n";
}
void main()
{float tablou[DIM1][DIM2];
int i,j;
float *ptablou;
ptablou=*tablou;
cout << "Introduceti elementele tabloului\n";
for(i=0;i<DIM1;i++)
for(j=0;j<DIM2;j++) tablou[i][j]=cere_element(i,j);
afis_tablou(&ptablou);
getch();
}
10.7. Alocarea dinamic a memoriei

Un dezavantaj al limbajelor compilate (Fortran, Pascal, C, C++, etc) este alocarea fix
de memorie, n cazul folosirii tablourilor.
Pentru a lucra cu tablouri, compilatorul trebuie s cunoasc mrimea acestuia i s-i aloce
spaiu de memorie. Acest spaiu rmne alocat pe toata durata vieii programului, indiferent
216
dac spaiul este folosit integral sau nu. n plus, ncercarea de a folosi spaiu peste cel alocat,
se soldeaz cu o eroare de execuie si cu abandonarea programului.
Limbajele interpretoare (Basic, LISP, s.a.), nu au, n general, acest dezavantaj, n
schimb au viteza mic de execuie.
Pentru a nltura acest dezavantaj, pstrnd n acelai timp i avantajul vitezei mari de
execuie, limbajul C (i C++) posed funcii de alocare/eliberare de memorie n cursul
execuiei. In acest caz, n loc de a utiliza tablouri, se folosete tehnica de lucru cu pointeri
combinat cu folosirea funciilor de alocare/eliberare a memoriei.
Pentru alocarea memoriei, sub DOS, se folosete funcia calloc care are prototipul:
void *calloc(size_t nrart, size_t marime)

unde: size_t este tipul de date de stocat; nrart este numrul de date de stocat; marime
este lungimea n octei a tipului de date de stocat. Pentru a scuti programatorul de cunoaterea
mrimii tipului n functie de implementarea limbajului C i pentru a asigura portabilitatea
programelor pe diferite platforme, se folosete funcia sizeof(tip) la calculul mrimii n octei
a tipului de date de stocat. Funcia calloc aloc un spaiu (bloc) de memorie de
nrart*marime octei n memoria de baz si returneaza un pointer (void * nseamn
pointer ctre orice tip) ctre blocul de memorie alocat, sau valoarea NULL dac nu a putut fi
gsit disponibil pentru alocare spaiul de memorie cerut sau dac nrart sau marime este 0.
Functia calloc nu poate aloca mai mult de 64 Kbytes de memorie.
O alt funcie de alocare de memorie este malloc cu sintaxa:
void *malloc(size_t marime)
care funcioneaza asemntor, cu deosebirea c i se transmite un singur argument calculat

anterior, i anume marime=nrart*marime_tip
Eliberarea memoriei se face prin funcia free cu sintaxa:
void free(*bloc)
unde *bloc este pointerul ctre un bloc de memorie alocat anterior cu funcia calloc sau
malloc.
Schema general de lucru la alocarea dinamic de memorie este:

- calculul mrimii blocului de memorie de alocat;
- alocarea blocului;
- testarea succesului alocrii:
dac alocarea a avut succes
se execut exploatarea memoriei n scopul dorit;
se elibereaz memoria;
altfel se emite mesaj de avertisment;
Exemplul 1. Alocarea de spatiu pentru un tablou unidimensional

#include <conio.h>
#include <alloc.h>
float cere_element(int i)
{float elem;
cout << "a(" << (i+1) << ")="; cin >> elem; cout << "\n";
return elem;
}
void afis_tablou(int n,float *tablou)
217
{int i;
for(i=0;i<n;i++) cout << "a(" << (i+1) << ")=" << *(tablou+i) << "\n";
}
void main()
{int n,i; float *tablou;
cout << "Specificati numarul de elemente ale tabloului, n=";
cin >> n;
tablou=(float *)calloc(n,sizeof(float));
if(tablou!=NULL)
{cout << "\nIntroduceti elementele tabloului\n";
for(i=0;i<n;i++) *(tablou+i)=cere_element(i);
afis_tablou(n,tablou);
free(tablou);
}
else cout << "Alocare esuata!\n";
getch();
}
Testarea programului:
1. La cererea Specificati numarul de elemente ale tabloului, n= rspundei
introducnd valoarea 0. Vei obine rspunsul Alocare esuata!
2. Acelai efect l vei obine i introducnd valoarea 20000 (deoarece sizeof(float)=4,
nrart*sizeof(float)=4*20000>64 Kbytes);
3. Rspunznd cu o valoare corespunztoare posibilitilor funciei, de exemplu 5, rularea
programului va decurge normal.
Exemplul 2. Alocarea de spaiu pentru un tablou bidimensional de caractere
n acest exemplu fiecare dintre irurile de caractere SIR DE STOCAT IN MEMORIE
este un tablou unidimensional format din valori de tip caracter. Acest tablou este iniializat ca
pointer. Variabila psir este un pointer ctre un pointer, constituind un tablou bidimensional.
Alocarea de spaiu pentru acest tablou a fost fcuta cu functia malloc astfel: mai nti a fost
alocat un bloc de memorie pentru un tablou care stocheaza pointerii catre pointeri (psir) i
apoi, de nrart ori, n acest tablou au fost stocai pointerii ctre blocurile de memorie n care
se vor stoca ulterior irurile SIR DE STOCAT IN MEMORIE.
Funcia strcpy a fost folosit pentru a copia la adresele coninute de aceti pointeri
irurile de caractere menionate.
Funcia exit(1) produce ncheierea forat a programului.
Eliberarea memoriei se face n ordine invers: mai nti se elibereaz blocurile de
memorie alocate pentru iruri i apoi se elibereaz blocul de memorie n care sunt stocai
pointerii catre iruri.
#include
#include
#include
#include
#include
<iostream.h>
<conio.h>
<alloc.h>
<string.h>
<stdlib.h>
void main()
{char *sirstoc="SIR DE STOCAT IN MEMORIE"; char **psir;
int nrart=5,i;
218
if((psir=(char **) malloc(nrart*sizeof(char*)))==NULL)

{cout << "Alocare esuata!\n"; exit(1);}
else
{for(i=0;i<nrart;i++)
if(
(psir[i]=(char *)malloc((strlen(sirstoc)+1)*sizeof(char)))
==NULL
)
{cout << "Alocare esuata!\n"; exit(1);}
else strcpy(psir[i],sirstoc);
}
cout << "Sirul " << sirstoc << " a fost alocat in " << nrart
<< "blocuri distincte.\n";
for(i=0;i<nrart;i++) cout << psir[i] << "\n";
cout << "Memoria pentru cele " << nrart << " blocuri \"" << sirstoc
<< "\"\n va fi eliberata apasand o tasta\n";
getch();
for(i=0;i<nrart;i++)free(psir[i]);
free(psir);
10.8. Funcii de acces la ecranul text

Aplicaia 1
#include <stdio.h>
#include <conio.h>
void main()
{clrscr();
printf("Apasa o tasta pentru a sterge linia de la cursor pana la capat");
gotoxy(14,1);
getch();
clreol();
printf("Apasa o tasta pentru a sterge tot ecranul");
getch();
clrscr();
printf("Apasa o tasta pentru a iesi din program");
getch();
}
Rezultatul rulrii acestui program este apariia succesiv pe prima linie a ecranului, la
fiecare apsare de tast, a urmtoarelor afiri:
Apasa o tasta_pentru a sterge linia de la cusor pana la capat
Apasa o tastaApasa o tasta pentru a sterge tot ecranul
Apasa o tasta pentru a iesi din program
Aplicaia 2
#include <conio.h>
void main()
{int i,n=9;
clrscr();
for(i=1;i<=n;i++) {gotoxy(i,i); cprintf("*");}
for(i=1;i<=n;i++) {gotoxy(i,n+1-i); cprintf("*");}
getch();
}
Rezultatul rulrii acestui program este apariia pe ecran a urmtoarei configuraii:
219
*_
*
*
*
*
*
*
* *
*
* *
*
*
*
Aplicaia 3
#include <conio.h>
void main()
{char tampon[62]; int i;
clrscr();
gotoxy(10,10);
cprintf("Text de control. Apasa o tasta."); getch();
gettext(10,10,40,10,tampon);
for(i=1;i<=5;i++)
{clrscr(); puttext(10+i,10,40+i,10,tampon); getch();}
}
Rezultatul rulrii acestui program este deplasarea textului afiat cu cte o poziie ctre
dreapta la fiecare apsare a unei taste.
Textul are lungimea de 31 de caractere dar tabloul tampon n care este el stocat are
lungime dubl (62) deoarece, pentru a fi manipulat prin funciile gettext i puttext fiecare
caracter trebuie memorat pe 2 octei, unul pentru codul ASCII al caracterului iar cellalt
pentru codul de culoare.
Funcia gettext culege textul existent pe ecran ntr-un dreptunghi cu coordonatele col
stnga sus - col dreapta jos exprimate n coordonate ntregi indice coloan, indice rnd.
Textul cules este memorat n tabloul tampon.
Funcia puttext pune textul din tampon ntr-un dreptunghi cu coordonatele colurilor
exprimate n acelai mod.
Pentru detalii a se vedea HELP-ul mediului de programare.
Aplicaia 4
Fig.10.8.1.
#include <conio.h>
void main()
{char sir[]="ABCDEFGHIJ"; int i;
clrscr();
for(i=0;i<=7;i++)
{gotoxy(10,10+i);
textbackground(i);
textcolor(i+1);
cprintf(sir);
}
getch();
}
Rezultatul rulrii acestui program este afiarea pe ecran a unei

succesiuni de iruri de text cu diferite culori pe diferite fonduri, ca n figura 10.8.1.
Afiarea are loc ncepnd din coloana 10 i de la rndul 10 n jos.
220
10.9. Accesul la ecranul grafic

Urmtorul exemplu prezint succesiunea unor etape de lucru cu ecranul grafic.
Aplicaia 1
#include
#include
#include
#include
#include
<graphics.h>
<stdlib.h>
<stdio.h>
<conio.h>
<string.h>
void main()
{/* parametrii de autodetectare grafica */
int gdriver = DETECT, gmode, errorcode;
/* definirea unor date din program */
int i, maxcolor, maxx, maxy, xmed, ymed;
char dest[40], mesaj[]="Numarul maxim de culori este ", numcolor[3];
/* initializarea tabloului sir de caractere de concatenare */
for(i=0;i<40;i++) dest[i]=0;
/* initializarea modului grafic */
initgraph(&gdriver, &gmode, "");
/* citirea rezultatului initializarii */
errorcode = graphresult();
if (errorcode != grOk) /* daca a survenit o eroare */
{printf("Eroare grafica: %s\n", grapherrormsg(errorcode));
printf("Apasa o tasta pentru oprire:");
getch();
exit(1);
/* iesire in caz de eroare */
}
maxcolor=getmaxcolor();
/* numarul maxim de culori */
maxx=getmaxx();
/* numarul maxim de pixeli pe orizontala */
maxy=getmaxy();
/* numarul maxim de pixeli pe verticala */
xmed=maxx/2;
/* coordonatele centrului ecranului */
ymed=maxy/2;
/* pregatire pentru afisarea unui text grafic */
setcolor(MAGENTA);
settextjustify(CENTER_TEXT,CENTER_TEXT);
settextstyle(DEFAULT_FONT,HORIZ_DIR,2);
/* text cu marime dubla */
itoa(maxcolor+1,numcolor,10); /* conversia din intreg in sir de
caractere exprimat zecimal */
strcat(dest,mesaj);
/* concatenarea sirurilor de caractere */
strcat(dest, numcolor);
outtextxy(xmed,ymed,dest); /* afisarea textului */
getch();
/* pauza pana la apasarea unei taste */
for(i=0;i<=maxcolor;i++) /* ciclare pentru toate culorile */
{setbkcolor(i);
/* stabilirea culorii fondului */
cleardevice();
/* stergerea ecranului grafic */
setfillstyle(SOLID_FILL,maxcolor-i); /* stabilirea stilului si a
culorii de umplere */
bar(maxx/4,maxy/4,0.75*maxx,0.75*maxy); /* desenarea unui dreptunghi
cu interiorul umplut */
getch();
/* pauza pana la apasarea unei taste */
}
closegraph();
/* inchiderea dispozitivului grafic */
}
221
Rezultatul rulrii acestui program este desenarea unui text i a unei succesiuni de fonduri
de ecran i de dreptunghiuri pline.
Urmtorul exemplu ilustreaz modul de compunere a culorilor pe ecranul grafic DOS.
Aplicaia 2
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <alloc.h>
#include <mem.h>
/* definire structuri*/
struct centru {int x, y;};
struct imagine {void * bloc;};
/* functie de generare si stocare a imaginii */
imagine stocare_cerc(int culoare, centru cent, int raza)
{imagine imag_cerc; int marime;
/* stabilirea stilului si a culorii de umplere */
setfillstyle(SOLID_FILL,culoare);
/* stabilirea culorii conturului */
setcolor(culoare);
/* desenarea unui disc umplut */
pieslice(cent.x,cent.y,0,360,raza);
/* determinarea marimii imaginii */
marime=imagesize(cent.x-raza,cent.y-raza,cent.x+raza,cent.y+raza);
/* alocarea spatiului de memorie pentru stocarea imaginii */
imag_cerc.bloc=malloc(marime);
/* stocarea imaginii in spatiul alocat */
getimage(cent.x-raza,cent.y-raza,cent.x+raza,cent.y+raza,
imag_cerc.bloc);
return imag_cerc;
}
void main()
{int gdriver = DETECT, gmode, errorcode;
int maxx,maxy,xc,yc,raza=70,raza1,dist;
centru c1, c2, c3, c4;
imagine imag_cerc;
void * cerc1, * cerc2, * cerc3, * cerc4;
/* initializarea grafica */
initgraph(&gdriver, &gmode, "");
errorcode = graphresult();
if (errorcode != grOk)
{printf("Eroare grafica: %s\n", grapherrormsg(errorcode));
printf("Apasa o tasta pentru oprire:");
getch();
exit(1);
}
/* calcul parametri geometrici */
maxx=getmaxx(); maxy=getmaxy();
xc=maxx/2; yc=maxy/2;
dist=0.5*raza/cos(M_PI*30/180);
222
c1.x=xc-0.5*raza; c1.y=yc-0.5*raza*tan(M_PI*30/180);
c2.x=xc+0.5*raza; c2.y=c1.y;
c3.x=xc; c3.y=yc+dist;
c4.x=xc; c4.y=yc;
/* stergerea ecranului, stabilirea culorii de fond */
cleardevice(); setbkcolor(0);
/* generarea si stocarea succesiva a imaginilor */
imag_cerc=stocare_cerc(RED, c1, raza);
cerc1=imag_cerc.bloc;
imag_cerc=stocare_cerc(GREEN, c2, raza);
imag_cerc=stocare_cerc(BLUE, c3, raza);
raza1=0.8*raza;
imag_cerc=stocare_cerc(DARKGRAY, c4, raza1);
/* stergerea ecranului si afisarea aditionala a imaginilor */
cleardevice();
putimage(c1.x-raza,c1.y-raza,cerc1,OR_PUT);
putimage(c4.x-raza1,c4.y-raza1,cerc4,OR_PUT);
/* pauza de afisare */
getch();
/* eliberarea memoriei si inchiderea dispozitivului grafic */
free(cerc1); free(cerc2); free(cerc3); free(cerc4);
closegraph();
}
Fig.10.9.1.
Cuvintele simbolice folosite pentru culori n C sub DOS, pentru majoritatea dispozitivelor
grafice mai actuale, sunt date n tabelul de mai jos.
223
Cuvnt simbolic
Culoare
Valoare zecimal
BLACK
BLUE
GREEN
CYAN
RED
MAGENTA
BROWN
LIGHTGRAY
DARKGRAY
LIGHTBLUE
LIGHTGREEN
LIGHTCYAN
LIGHTRED
LIGHTMAGENTA
YELLOW
WHITE
Negru
Albastru
Verde
Turcoaz
Rou
Liliachiu
Brun
Gri deschis
Gri nchis
Albastru deschis
Verde deschis
Turcoaz deschis
Rou deschis
Liliachiu deschis
Galben
Alb
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Cod binar
0000LRGB
00000000
00000001
00000010
00000011
00000100
00000101
00000110
00000111
00001000
00001001
00001010
00001011
00001100
00001101
00001110
00001111
10.10. Aplicaie grafic pentru construcia diagramelor

Aplicaia 1
#include <conio.h>
#define NINT 100
#define NPCT NINT+1
void sir_val_func
(int ordin, float termeni[], int nvalsir_x, float sir_x[], float sirval[])
{int i,j;
for(i=0;i<nvalsir_x;i++)
{sirval[i]=termeni[ordin];
for(j=ordin-1;j>=0;j--) sirval[i]=termeni[j]+sirval[i]*sir_x[i];
}
}
float valmax(int nval, float sir_val[])
{int i; float vmax;
vmax=sir_val[0];
for(i=1;i<nval;i++) if(vmax<sir_val[i]) vmax=sir_val[i];
return vmax;
}
float valmin(int nval, float sir_val[])
{int i; float vmin;
vmin=sir_val[0];
for(i=1;i<nval;i++) if(vmin>sir_val[i]) vmin=sir_val[i];
return vmin;
}
void desen_diag(float sir_valx[], float sir_valy[], int x1, int y1,
int lung, int inalt, int culfond, int culdiag, int culcadru, char
*titlu)
{float xmin, xmax, ymin, ymax, scx, scy;
224
int i; viewporttype vinfo;

setcolor(YELLOW);
outtextxy(x1+lung/2,0.5*y1,titlu);
getviewsettings(&vinfo);
setviewport(x1,y1,x1+lung,y1+inalt,1);
setfillstyle(SOLID_FILL,culfond);
bar(0,0,lung,inalt);
xmin=valmin(NPCT,sir_valx); xmax=valmax(NPCT,sir_valx);
ymin=valmin(NPCT,sir_valy); ymax=valmax(NPCT,sir_valy);
scx=(xmax-xmin)/lung; scy=(ymax-ymin)/inalt;
if(scy==0) scy=1;
setcolor(culdiag); setlinestyle(SOLID_LINE,0,3);
for(i=0;i<NINT;i++)
line((sir_valx[i]-xmin)/scx,inalt-(sir_valy[i]-ymin)/scy,
(sir_valx[i+1]-xmin)/scx,inalt-(sir_valy[i+1]-ymin)/scy);
setcolor(culcadru); setlinestyle(SOLID_LINE,0,1);
rectangle(0,0,lung,inalt);
setviewport(vinfo.left,vinfo.top,vinfo.right,vinfo.bottom,vinfo.clip);
}
void main()
{float fx[NPCT], x[NPCT], term[NINT], xs, xd, dx;
int ord, i, dispgr=DETECT, modgr;
int xmaxecran, ymaxecran, lungdiag, inaltdiag, xc, yc;
cout << "Introduceti ordinul polinomului: "; cin >> ord;
for(i=0;i<=ord;i++)
{cout << "a(" <> term[i];}
cout << "Introduceti domeniul de calcul: ";
cout << "x minim="; cin >> xs;
cout << "x maxim="; cin >> xd;
initgraph(&dispgr, &modgr, "");
xmaxecran=getmaxx(); ymaxecran=getmaxy();
setbkcolor(BROWN); clrscr();
dx=(xd-xs)/NINT;
for(i=0;i<NPCT;i++) x[i]=xs+i*dx;
sir_val_func(ord,term,NPCT,x,fx);
cleardevice();
lungdiag=0.4*xmaxecran; inaltdiag=0.8*ymaxecran;
xc=0.25*xmaxecran; yc=0.5*ymaxecran;
desen_diag(x,fx,xc-lungdiag/2,yc-inaltdiag/2,lungdiag,inaltdiag,
LIGHTMAGENTA,BLUE,LIGHTCYAN,"FUNCTIA");
ord=ord-1; /* Calculul coeficientilor derivatei polinomului */
for(i=0;i<=ord;i++) term[i]=(i+1)*term[i+1];
sir_val_func(ord,term,NPCT,x,fx);
desen_diag(x,fx,xmaxecran/2+xc-lungdiag/2,yc-inaltdiag/2,lungdiag,
inaltdiag,LIGHTMAGENTA,RED,LIGHTCYAN,"DERIVATA");
getch();
}
Explicaii
n funcia sir_val_func se calculeaz valorile unei funcii polinomiale ntr-un sir de puncte
x pe baza formulei iterative:
225
f(x)=a0+a1x1+a2x2+a3x3+...+an-1xn-1+anxn=a0+x(a1+x(a2+x(a3+... +x(an-1+x(an))...)))
Derivata polinomului este:
f '(x)=a1+2a2x1+3a3x2+...+(n-1)an-1xn-2+nanxn-1
i este tratat la fel ca i funcia.
Fig.10.10.1.
Funciile valmin i valmax extrag valoarea minim i pe cea maxim dintr-un ir de valori.
Funcia desen diag afieaz diagrama functiei.
Programul permite desenarea diagramelor unui polinom i a derivatei acestuia pentru orice
ordin. Ca rezultat al rulrii lui pentru setul de valori:
ordin = 2
a[0]= -4
a[1]= 0
a[2]= 1
x minim = -3
x maxim = 3
se va obine afiarea din figura 10.10.1.

Aplicaie grafic folosind structuri cu membri funcii
Urmtoarea aplicaie este o restructurare a primei aplicaii. Aici diferitele valori ale
diagramei apar ca proprieti ale unui obiect, iar funciile de generare ale diagramei apar ca
metode de tratare a datelor obiectului diagram. Dei nc nu este vorba de o programare
orientat pe obiecte n sensul actual al noiunii, aplicaia prefigureaz aceast tehnic de
programare.
#include <conio.h>
#define NINT 100
#define NPCT NINT+1
typedef struct
{int ordin;
float termeni[NPCT], sir_x[NPCT], sir_y[NPCT], xs, xd;
226
int xdiag1, ydiag1; char * titlu;

int lung, inalt, culfond, culdiag, culcadru;
/* functii membre ale structurii */
void sir_val_func(void);
float valmax(int, float *);
float valmin(int, float *);
void desen_diag(void);
} diagrama;
/* definitiile functiilor membre ale structurii */
void diagrama::sir_val_func(void)
{int i,j;
for(i=0;i<NPCT;i++)
{sir_y[i]=termeni[ordin];
for(j=ordin-1;j>=0;j--) sir_y[i]=termeni[j]+sir_y[i]*sir_x[i];
}
}
float diagrama::valmax(int nval, float sir_val[])
{int i; float vmax;
vmax=sir_val[0];
return vmax;
}
float diagrama::valmin(int nval, float sir_val[])
{int i; float vmin;
vmin=sir_val[0];
return vmin;
}
void diagrama::desen_diag(void)
setcolor(YELLOW);
outtextxy(xdiag1+lung/2,0.5*ydiag1,titlu);
setviewport(xdiag1,ydiag1,xdiag1+lung,ydiag1+inalt,1);
setfillstyle(SOLID_FILL,culfond);
bar(0,0,lung,inalt);
xmin=valmin(NPCT,sir_x); xmax=valmax(NPCT,sir_x);
ymin=valmin(NPCT,sir_y); ymax=valmax(NPCT,sir_y);
scx=(xmax-xmin)/lung; scy=(ymax-ymin)/inalt;
if(scy==0) scy=1;
setcolor(culdiag); setlinestyle(SOLID_LINE,0,3);
for(i=0;i<NINT;i++)
line((sir_x[i]-xmin)/scx,inalt-(sir_y[i]-ymin)/scy,
(sir_x[i+1]-xmin)/scx,inalt-(sir_y[i+1]-ymin)/scy);
setcolor(culcadru); setlinestyle(SOLID_LINE,0,1);
rectangle(0,0,lung,inalt);
}
227
void main()
{float dx;
int i, dispgr=DETECT, modgr, xmaxecran, ymaxecran, xc, yc;
diagrama diagfunc, diagderiv;
cout << "Introduceti ordinul polinomului: "; cin >> diagfunc.ordin;
for(i=0;i<=diagfunc.ordin;i++)
{cout << "a(" <> diagfunc.termeni[i];}
cout << "x minim="; cin >> diagfunc.xs;
cout << "x maxim="; cin >> diagfunc.xd;
initgraph(&dispgr, &modgr, "");
xmaxecran=getmaxx(); ymaxecran=getmaxy();
setbkcolor(BROWN); clrscr();
dx=(diagfunc.xd-diagfunc.xs)/NINT;
for(i=0;i<NPCT;i++) diagfunc.sir_x[i]=diagfunc.xs+i*dx;
diagfunc.sir_val_func();
cleardevice();
diagfunc.lung=0.4*xmaxecran; diagfunc.inalt=0.8*ymaxecran;
diagfunc.culfond=LIGHTMAGENTA; diagfunc.culdiag=BLUE;
diagfunc.culcadru=LIGHTCYAN; diagfunc.titlu="FUNCTIA";
xc=0.25*xmaxecran; yc=0.5*ymaxecran;
diagfunc.xdiag1=xc-diagfunc.lung/2;
diagfunc.ydiag1=yc-diagfunc.inalt/2;
diagfunc.desen_diag();
diagderiv=diagfunc;
diagderiv.ordin=diagderiv.ordin-1;
for(i=0;i<=diagderiv.ordin;i++)
diagderiv.termeni[i]=(i+1)*diagderiv.termeni[i+1];
diagderiv.sir_val_func();
diagderiv.xdiag1=xmaxecran/2+xc-diagderiv.lung/2;
diagderiv.culdiag=RED; diagderiv.titlu="DERIVATA";
diagderiv.desen_diag();
getch();
}
Au fost folosite dou structuri: diagfunc pentru diagrama funciei i diagderiv pentru
diagrama derivatei.
Deoarece o anumit parte dintre datele diagramei derivatei sunt aceleai ca i pentru
diagrama funciei, instruciunea diagderiv=diagfunc copiaz toate aceste date de la o
structur la alte, ulterior fiind modificate numai datele diferite.
Se observ c scrierea programului principal devine mai explicit i, totodat, mai
flexibil, chiar dac aparent, sunt ceva mai multe instruciuni de scris. Aceast impresie este
fals deoarece aplicaia este de mic amploare. n realitate, n cazul aplicaiilor mari,
programele devin mai scurte, deoarece se manevreaz numai asupra datelor i doar sunt
invocate funciile de tratare din cazul structurilor.
10.11. Aplicaie grafic la utilizarea claselor

Vom relua aplicaia anterioar fcnd un pas nainte prin introducerea conceptului de clas.
Acesta permite crearea de obiecte, adic de module de program care, pe lng date, conine i
metodele de tratare a acestora.
n aplicaia de mai jos este creat clasa de obiecte diagrama care conine ca date dou
membre structuri:
228
- structura de tip datefunctie denumit dfun i

- structura de tip paramdiag denumit pdiag.
Structura dfun conine datele de tratat de ctre clas i anume: tabloul termeni care
conine coeficienii polinomului, tabloul sir_x care conine irul de valori x n care este
discretizat intervalul dintre limita stnga xs i dreapta xd, i tabloul sir_y care conine
valorile calculate ale polinomului n punctele din sir_x.
Structura pdiag conine parametrii de constructie i afiare ai diagramei, i anume:
dimensiunile n pixeli ai ecranului xmaxecran i ymaxecran, coordonatele ecran ale colului
din stnga sus al diagramei xdiag1 i ydiag1, un pointer ctre irul de caractere de afiat ca
titlu al diagramei, lungimea i limea n coordonate ecran ale diagramei lung i inalt, i
codurile de culoare pentru fondul diagramei (culfond), curba diagramei (culdiag) i
chenarul diagramei (culcadru).
n cadrul clasei este definit o funcie constructor de copiere cu autoreferire denumit
copie_date. Ea servete la copierea unei instane a clasei ntr-o alta, cu scopul de a reduce
numrul de instruciuni de stabilire a caracteristicilor unei diagrame dac ele sunt deja definite
n obiectul diagram surs.
Astfel, dup ce este creat obiectul diafun pentru diagrama polinomului i i sunt definite
caracteristicile, obiectul nou creat diaderiv pentru diagrama derivatei va copia instana
diafun i vor fi stabilite prin declaraiile corespunztoare numai acele caracteristici care
difer de acelea ale diagramei polinomului.
#include <conio.h>
#define NINT 100
#define NPCT NINT+1
/* definitii de structuri de date */
struct datefunctie
{int ordin;
float termeni[NPCT], sir_x[NPCT], sir_y[NPCT], xs, xd;
};
struct paramdiag
{int xmaxecran, ymaxecran, xdiag1, ydiag1;
char * titlu;
int lung, inalt, culfond, culdiag, culcadru;
};
/* definirea clasei de obiecte pentru generarea de diagrame */
class diagrama
{public:
/* datele membre ale clasei */
datefunctie dfun; paramdiag pdiag;
/* functiile membre ale clasei */
diagrama& copie_date(diagrama& sursa) /* constructor de copiere cu
autoreferire */
{dfun=sursa.dfun; pdiag=sursa.pdiag; return * this;};
void sir_val_func(void);
/* generarea valorilor funciei */
float valmax(int, float *); /* extragerea valorii maxime dintr-un sir */
float valmin(int, float *); /* extragerea valorii minime dintr-un sir */
229
void desen_diag(void);
};
/* desenarea diagramei */
/* definitiile functiilor membre ale clasei */

void diagrama::sir_val_func(void)
{int i,j;
for(i=0;i<NPCT;i++)
{dfun.sir_y[i]=dfun.termeni[dfun.ordin];
for(j=dfun.ordin-1;j>=0;j--)
dfun.sir_y[i]=dfun.termeni[j]+dfun.sir_y[i]*dfun.sir_x[i];
}
}
float diagrama::valmax(int nval, float sir_val[])
{int i; float vmax;
vmax=sir_val[0];
return vmax;
}
float diagrama::valmin(int nval, float sir_val[])
{int i; float vmin;
vmin=sir_val[0];
return vmin;
}
void diagrama::desen_diag(void)
setcolor(YELLOW);
outtextxy(pdiag.xdiag1+pdiag.lung/2,0.5*pdiag.ydiag1,pdiag.titlu);
setviewport(pdiag.xdiag1,pdiag.ydiag1,
pdiag.xdiag1+pdiag.lung,pdiag.ydiag1+pdiag.inalt,1);
setfillstyle(SOLID_FILL,pdiag.culfond);
bar(0,0,pdiag.lung,pdiag.inalt);
xmin=valmin(NPCT,dfun.sir_x); xmax=valmax(NPCT,dfun.sir_x);
ymin=valmin(NPCT,dfun.sir_y); ymax=valmax(NPCT,dfun.sir_y);
scx=(xmax-xmin)/pdiag.lung; scy=(ymax-ymin)/pdiag.inalt;
if(scy==0) scy=1;
setcolor(pdiag.culdiag); setlinestyle(SOLID_LINE,0,3);
for(i=0;i<NINT;i++)
line((dfun.sir_x[i]-xmin)/scx,pdiag.inalt-(dfun.sir_y[i]-ymin)/scy,
(dfun.sir_x[i+1]-xmin)/scx,pdiag.inalt-(dfun.sir_y[i+1]-ymin)/scy);
setcolor(pdiag.culcadru); setlinestyle(SOLID_LINE,0,1);
rectangle(0,0,pdiag.lung,pdiag.inalt);
}
void main()
{float dx; int i, dispgr=DETECT, modgr;
diagrama diafun;
/* este creat obiectul diafun */
230
/* se definesc datele diagramei */

cout << "Introduceti ordinul polinomului: "; cin >> diafun.dfun.ordin;
for(i=0;i<=diafun.dfun.ordin;i++)
{cout << "a(" <> diafun.dfun.termeni[i];}
cout << "x minim="; cin >> diafun.dfun.xs;
cout << "x maxim="; cin >> diafun.dfun.xd;
dx=(diafun.dfun.xd-diafun.dfun.xs)/NINT;
/* se genereaza sirul de valori x pe intervalul de definitie */
for(i=0;i<NPCT;i++) diafun.dfun.sir_x[i]=diafun.dfun.xs+i*dx;
diafun.sir_val_func(); /* se genereaza sirul de valori al functiei */
initgraph(&dispgr, &modgr, ""); /* initializarea grafica */
cleardevice();
/* stergerea ecranului */
setbkcolor(BROWN);
/* stabilirea culorii ecranului */
/* se definesc parametrii grafici de afisare ai diagramei */
diafun.pdiag.xmaxecran=getmaxx(); diafun.pdiag.ymaxecran=getmaxy();
diafun.pdiag.lung=0.4*diafun.pdiag.xmaxecran;
diafun.pdiag.inalt=0.8*diafun.pdiag.ymaxecran;
diafun.pdiag.xdiag1=0.25*diafun.pdiag.xmaxecran-diafun.pdiag.lung/2;
diafun.pdiag.ydiag1=0.5*diafun.pdiag.ymaxecran-diafun.pdiag.inalt/2;
diafun.pdiag.culfond=LIGHTMAGENTA;
diafun.pdiag.culdiag=BLUE; diafun.pdiag.culcadru=LIGHTCYAN;
diafun.pdiag.titlu="FUNCTIA";
diafun.desen_diag(); /* se deseneaza diagrama polinomului */
diagrama diaderiv;
/* se creaza obiectul diaderiv */
diaderiv.copie_date(diafun);
/* se copiaza diafun in diaderiv */
/* se modifica datele din diaderiv diferite de cele din diafun */
/* se definesc coeficientii derivatei polinomului */
diaderiv.dfun.ordin=diaderiv.dfun.ordin-1;
for(i=0;i<=diaderiv.dfun.ordin;i++)
diaderiv.dfun.termeni[i]=(i+1)*diafun.dfun.termeni[i+1];
diaderiv.sir_val_func(); /* se genereaza valorile derivatei */
/* se definesc parametrii grafici diferite */
diaderiv.pdiag.xdiag1=0.75*diaderiv.pdiag.xmaxecran-diaderiv.pdiag.lung/2;
diaderiv.pdiag.ydiag1=0.5*diaderiv.pdiag.ymaxecrandiaderiv.pdiag.inalt/2;
diaderiv.pdiag.culfond=CYAN; diaderiv.pdiag.culdiag=RED;
diaderiv.pdiag.titlu="DERIVATA";
diaderiv.desen_diag();
/* se deseneaza diagrama derivatei */
getch();
}
Se observ c prin aceast tehnic programul principal, funcia main, s-a redus la o
succesiune de atribuiri de valori pentru datele membre ale obiectelor clasei diagrama, i la
invocarea funciilor membre.
Diagrama care se obine pentru datele:
ordin = 2
a[0]= -4
a[1]= 0
a[2]= 1
x minim = -3
x maxim = 3
este aceea prezentat n figura 10.11.1.
231
Aceasta este o metod de lucru foarte avantajoas. Pe lng uurina manevrrii obiectelor
n cadrul programului, apare i posibilitatea ca, o dat ce un obiect a fost pus la punct, el s fie
stocat n biblioteci de tip fiiere antet (header, cu extensia .h) de unde s poat fi extras prin
instruciunea #include. n programarea orientat pe obiecte folosit n WINDOWS, aceast
tehnic este folosit cu preponderen i, mai mult, chiar limbaje necompilate cum este Visual
BASIC prezent n mediile de dezvoltare integrate din diferite aplicaii, prin conveniile
limbajului reproduc procedeele acestei tehnici.
Fig.10.11.1.
Cap.11. Aplicaii n mediul de programare Visual Basic sub EXCEL
232
Cap.11. Aplicaii n mediul de programare Visual Basic sub

EXCEL
11.1. Generaliti privind lucrul n EXCEL
11.1.1. Structura documentelor EXCEL
Fig.11.1.1.
EXCEL este un program de calcul

tabelar destinat elaborrii documentelor
interactive.
Un document EXCEL, denumit
map de lucru, este un fiier cu numele
nume.XLS compus dintr-un numr de foi
de lucru.
O foaie de lucru este o arie de celule
organizate pe rnduri i pe coloane.
n funcie de formatul paginii
imprimantei, aria de celule determinat
de dreptunghiul de ncadrare al celulelor
nevide extreme se extinde pe un anumit
numr de pagini de imprimare. Aadar,
noiunile de foaie de lucru i pagin de
imprimare sunt distincte i nu trebuie
confundate (a se vedea figura 11.1.1).
Un rnd este identificabil prin antetul
de rnd care poart un numr ntre 1 i 65536.

O coloan este identificabil prin antetul de coloan care poart un simbol literal A...Z,
AA...AZ, BA...BZ,...IV (n total 256 coloane).
Celula este situat la intersecia dintre o coloan i un rnd i este identificat prin referin.
Referina celulei este combinaia indicatorilor de rnd i de coloan care se intersecteaz
n celul.
Stilul referinei este modul n care se simbolizeaz referina. Deosebim urmtoarele stiluri:
Stilul A1, n care celula se indic prin combinaia: simbol_coloan indice_rnd
De exemplu: $C$5 este celula de la intersecia coloanei C cu rndul 5;
Stilul R1C1, folosete combinaia: indice_rnd indice_coloan.
De exemplu, celula C5 apare n acest stil cu notaia R5C3 (rndul 5 coloana 3);
Tipul referinei poate fi:
Absolut, cnd este indicat poziia celulei n foaia de lucru. De exemplu: $C$5 sau R5C3;
Relativ, cnd este indicat poziia unei celule n raport cu celula curent. De exemplu:
celula D3 n raport cu celula C5, n stilul R1C1 relativ, are simbolizarea R[-2]C[1];
Mixt. De exemplu, aceeai celul D3 n raport tot cu celula C5 poate fi simbolizat n
forma R[-2]C4.
11.1.2. Coninutul celulelor
O celul poate conine urmtoarele tipuri de date:
ir de text, adic o combinaie de maxim 255 de caractere tipribile;
Numr, alctuit din cifre i caractere speciale ca:
+ sau - pentru semn;
separator zecimal (. sau , n funcie de setarea regional a sistemului WINDOWS 9X);
233
/ pentru fracii;
$ pentru stilul monetar;
% pentru procent;
E sau e pentru exponentul zecimal din notaia tiinific.
Formatele pentru numere pot fi: ntreg, zecimal fracionar i zecimal tiinific;
Dat calendaristic i marc de timp;
Valori logice: TRUE sau FALSE;
Coduri de eroare:
#DIV/0!
mprire cu zero;
#N/A
Valoare lips;
#NAME?
Nume invalid al unei celule referit prin nume;
#NULL!
Intersecie de domenii vid;
#REF!
Referin invalid;
#VALUE!
Valoare incorect;
###....##
Spaiu insuficient pentru afiare;
Referin, caz n care celula gazd a coninutului afieaz coninutul celulei referite;
Formule i funcii, caz n care celula gazd afieaz rezultatul evalurii formulei sau
funciilor.
11.1.3. Utilizarea formulelor i funciilor
11.1.3.1. Formule
O formul este constituit din operatori i operanzi i ncepe ntotdeauna cu caracterul =.
Operatorii pot fi:
Operatori aritmetici: + pentru adunare, - pentru scdere, * pentru nmulire, / pentru
mprire, % pentru procent (dup o valoare), ^ pentru ridicare la putere;
operatorul de concatenare de texte: &. De exemplu, formula =Tasta&tura are ca
rezultat irul de text Tastatura;
Operatori de referine la celule:
: se folosete pentru a indica un domeniu. De exemplu, A2:C4 reprezint celulele cu
tent gri din figura 11.1.2;
spaiul este folosit pentru a indica o interscie de domenii. De exemplu, A3:C2 B2:C4
reprezint celula B3 din figura 11.1.3;
, se folosete pentru la enumerarea elementelor dintr-o uniune. De exemplu,
A2:A4,C2:C4 reprezint uniunea domeniilor marcate cu gri din figura 11.1.4.
Fig.11.1.2.
Fig.3.
Operanzii pot fi:
Fig.11.1.5.
Fig.11.1.4.
valori constante;
referine la celule sau domenii de celule;
funcii predefinite sau definite de utilizator.
Formulele pot conine paranteze rotunde ( ) pentru separarea
grupurilor de operaii.
234
11.1.3.2. Exemplu de utilizare a formulelor. Calculul perimetrului i suprafeei cercului

Pentru a construi un tabel de calcul al perimetrului i suprafaei unui cerc (figura 11.1.5) se
procedeaz astfel:
n celula B1 se scrie valoarea razei, n acest caz 10;
n celula B2 se scrie formula =3.14*B1*2
n celula B3 se scrie formula =3.14*B1^2
Ca urmare, celulele B2 i B3 vor afia
rezultatul calculelor.
Orice modificare a valorii din celula B1 se
reflect imediat prin reafiarea automat a
celulelor implicate care vor conine noul rezultat.
Atenie! Nu scriei din greeal altceva n
celulele B2 i B3 pentru c formulele
coninute n ele vor fi terse.
Observaie: referina B1 nu trebuie scris de
la tastatur ci este suficient s fie selectat printrun clic pe celula B1. EXCEL va scrie singur n
formul referina celulei selectate. Acest lucru
este de mare ajutor pentru c scutete utilizatorul
de a urmri indicii de rnd i de coloan n scopul
Fig.11.1.6.
aflrii simbolizrii referinei. De asemenea,
procedeul este valabil i pentru formule mai complexe ca i pentru funcii care necesit indicarea ca
argumente a unor domenii. Selectarea unui domeniu se face prin tragere peste domeniul dorit.
11.1.3.3. Funcii EXCEL predefinite
EXCEL conine o varietate mare de funcii predefinite sau native, organizate pe
categorii.
Accesul la funciile predefinite EXCEL se face prin apsarea butonului fx. Acesta se
gsete pe bara de scule Standard. La apsarea acestui buton se deschide cutia de dialog
Paste Function, figura 11.1.6.
Din cutia de listare Function Category se selecteaz categoria de funcii dorit. Din cutia
de listare Function Name se selecteaz funcia dorit i apoi se apas pe butonul Next. Ca
urmare, se deschide o cutia de dialog ulterioar al crei aspect depinde de funcia selectat. Se
furnizeaz parametrii cerui de funcie i apoi se apas pe butonul OK.
11.1.4. Formatarea celulelor
Formatul este modalitatea de afiare a rezultatelor (coninutului) celulelor. Pentru stabilirea
formatului unor celule care, n prealabil, trebuie selectate, din meniul Format se selecteaz
articolul Cells. Ca urmare se deschide cutia de dialog Format Cells care conine 6 pagini:
Number. Aceast pagin conine controale de formatare a categoriilor de coninut
urmtoare:
- General (coninut general);
- Number (coninut numeric);
- Currency (afiare n stil monetar n funcie de setrile regionale ale sistemului
WINDOWS);
- ...
- Percentage (afiare n procente);
- Fraction (afiare n form de fracie);
- Scientific (afiare n format tiinific - este util pentru numere foarte mari);
235
- Text (este ignorat caracterul coninutului care este tratat ca un simplu text).
Alignment. Aceast pagin conine controale de aliniere a afirii rezultatului evalurii
coninutului celulei.
Font. Aceast pagin conine controale de stabilire a tipului de caracter folosit, mrime
culoare i stil de scriere.
Border. Aceast pagin conine controale de stabilire a trasrii chenarului celulei.
Patterns. Aceast pagin conine controale de stabilire a modelului de umplere a celulei.
Protection. Aceast pagin conine controale de protejare a celulei, controale care au
efect numai dac i foaia de lucru este protejat.
Pentru operare rapid, pe bara de scule Formatting exist butoane care asigur o parte
dintre operaiile de formatare accesibile din cutia de dialog Format Cells fr a mai fi
necesar deschiderea acesteia.
O combinaie de atribute de formatare constituie un stil. Stilul poate fi memorat cu o
denumire, folosind cutia de dialog Style care se deschide din meniul Format, articolul Style.
O dat memorat, stilul poate fi aplicat altor celule.
11.1.5. Macro comenzi i macro funcii
Un macro este un grup de aciuni sau de operaii, identificate printr-un nume. Aciunile
i operaiile coninute de macro sunt scrise n limbajul Visual Basic ntr-o anex special a
documentului, denumit modul, gestionat de editorul de macrocomenzi.
Macro-urile sunt de dou tipuri:
macro-comand, constnd dintr-o secven de operaii nregistrate cu ajutorul
nregistratorului de macro-uri. Acesta scrie operaiile nregistrate sub forma unei subrutine n limbaj
Visual Basic. Macro-comenzile pot consta chiar din subrutine scrise direct de ctre utilizator;
macro-funcie, constnd dintr-o funcie n limbaj Visual Basic scris de ctre utilizator.
11.1.5.1. nregistrarea macro-comenzilor
nregistratorul de macrocomenzi este o facilitate EXCEL care permite:
declanarea nregistrrii, din meniul Tools > Macro > Record New Macro;
nregistrarea oricrei aciuni efectuat de utilizator pe durata ct nregistratorul este activ:
oprirea nregistrrii, din meniul Tools > Macro > Stop Recording;
Ca rezultat, este creat acea anex special a documentului care conine module de Visual
Basic. Ca structur, anexa pentru module apare ca un container denumit Modules, n care
sunt coninute modulele denumite Modulej, j=1,2,3,..., n care EXCEL scrie automat o
subrutin coninnd secvena de instruciuni n limbaj Visual Basic corespunztoare aciunilor
nregistrate. Macro-ul scris are structura urmtoare:
'Linii de
'comentariu
Sub nume_de_macro()
secventa de instructiuni
End Sub
Numele nume_de_macro este numele introdus de utilizator n cmpul de editare din cutia de
dialog Record New Macro, sau atribuit automat de EXCEL sub forma Macroj, j=1,2,3...
Accesul la editorul de Visual Basic se face din meniul Tools>Macro>Visual Basic Editor.
11.1.5.2. Execuia unei macro-comenzi
O macro-comand poate fi executat n dou moduri:
Prin declanare explicit din meniul Tools > Macro >Macros cutia de dialog
236
Macro. De aici, din cutia de listare Macro Name se selecteaz numele macro-comenzii dorite
i se apas butonul Run;
Prin asociere cu un element de interaciune grafic (meniu sau buton) definit de
utilizator.
11.1.5.3. Definirea unei macro-funcii
Vom explica acest subiect printr-o aplicaie, relativ la figura 11.1.5, conform urmtoarelor etape:
Ne situm ntr-un modul de Visual Basic, n care scriem funcia:
Function Supraf_cerc(Raza)
Supraf_cerc=3.1418*Raza^2
End Function
Se revine ntr-o foaie de lucru;

ntr-o celul, de exemplu n celula B1, scriem valoarea 10;
ntr-o alt celul, de exemplu n celula B3, se face un clic pentru a o selecta;
Se scrie caracterul =
Se apas butonul fx. Ca urmare, se deschide cutia de dialog Paste Function;
Din cutia de listare Function Category se selecteaz categoria User Defined, iar din
cutia de listare Function Name se selecteaz funcia Supraf_cerc i se apas butonul OK. Se
deschide cutia de dialog Supraf_cerc;
Se introduce argumentul Raza prin selectarea celulei B1 i se apas butonul OK;
Ca urmare, n celula B3 apare afiat rezultatul evalurii ariei cercului cu raza avnd
mrimea coninut n celula B1.
11.1.5.4. Asocierea unei macro-comenzi cu un element de interaciune
O macro-comand poate fi asociat cu un element de interaciune cu utilizatorul n dou moduri:
Prin asociere cu un obiect grafic de comand sau cu un buton de comand creat
ntr-o foaie de lucru. Sunt necesare urmtoarele etape de lucru:
Crearea obiectului grafic de comand:
- Se apas butonul Drawings din bara de scule Standard. Ca urmare, se deschide bara cu
scule Drawings;
- Din bara cu scule Drawings se folosete o scul pentru desenarea unui obiect grafic
mrginit de un contur nchis (dreptunghi sau elips);
- Se aplic obiectului creat formate de aspectualizare (culoare, contur, etc), eventual este
grupat cu o cutie de text prin care i se asociaz i o denumire;
- Se selecteaz obiectul (grupul) grafic cu ajutorul butonului dreapta al mouse-ului. Ca urmare
se deschide meniul contextual care conine articolul Assign Macro.
Crearea obiectului grafic de comand:
- Din meniul View>Toolbars>Forms se deschide cutia cu scule Forms;
- Se selecteaz scula Button i se deseneaz butonul de comand;
- Se selecteaz butonul existent cu ajutorul butonului dreapta al mouse-ului. Ca urmare se
deschide meniul contextual care conine articolul Assign Macro.
Asocierea butonului cu macro-comanda:
- Prin selectarea articolului Assign Macro, se deschide cutia de dialog Assign Macro. Din
cutia de listare Macro Name se selecteaz numele macrocomenzii dorite apoi se apas
butonul OK. n acest moment asocierea este stabilit i orice apsare a butonului asociat va
declana macro-comanda asociat cu el.
237
Sau:
- Dac macrocomanda nu exist n momentul ncercrii de asociere, ea poate fi creat. Pentru
aceasta, n cmpul de editare Macro Name din cutia de dialog Assign Macro, se scrie
numele noii macro-comenzi i apoi se apas butonul Record. n continuare se execut
operaia de nregistrare a aciunilor utilizatorului. La terminarea acesteia butonul este asociat
cu macro-comanda nregistrat.
Prin asociere cu un articol de meniu definit de utilizator.
Pentru a crea un meniu nou, se procedeaz astfel:
- se selecteaz o foaie pentru module;
- din meniul Tools > Customize. Se deschide cutia de dialog Customize;
- se opereaz n cutia de dialog Customize (cum anume, se va vedea la aplicaii).
Un meniu EXCEL este o structur arborescent pe mai multe nivele. El se compune dintrun nume de meniu, submeniuri i articole. Articolele meniului pot fi asociate cu macrocomenzi.
11.2. Utilizarea programului EXCEL pentru crearea unui document de

calcul simplu: calculul variaiilor unor funcii i crearea unei diagrame
centralizatoare
11.2.1. Intrarea n program
Din butonul Start, se selecteaz articolul de lansare a programului Excel, conform
configurrii specifice a calculatorului pe care se lucreaz.
Ca urmare, apare fereastra EXCEL din fig.11.2.1.
Fig.11.2.1.
11.2.2. Operaii elementare frecvente
11.2.2.1. Operaii de selectare
- Selectare de foaie de lucru unic: clic simplu cu butonul stnga mouse pe eticheta de foaie;
238
- Selectarea unui sir de foi consecutive (de exemplu, foile din irul Sheet3,4,5,6):
= se face clic pe eticheta primei foi din ir (Sheet3);
= se apas tasta SHIFT i se menine apsat;
= se face clic pe eticheta ultimei foi din ir (Sheet6);
= se elibereaz tasta SHIFT.
- Selectarea unui ir de foi neconsecutive (de exemplu irul Sheet3,5,7,9):
= se face clic pe eticheta primei foi din sir (Sheet3);
= se apas tasta CTRL i se menine apsat;
= se face clic pe eticheta urmtoarei foi din sir (Sheet5), apoi Sheet7, etc;
= se elibereaz tasta CTRL.
- Selectarea unui domeniu de celule: regulile sunt asemnatoare cu cele pentru selectarea foilor;
- Selectarea unui domeniu rectangular de celule: se face clic pe un col al domeniului, se menine
apsat butonul stnga mouse, se trage n diagonal pna la colul opus i se elibereaz butonul.
- Selectarea unui ntreg rnd sau coloan de celule: se face clic pe antetul de rnd sau de coloan;
- Selectarea unui ir de rnduri sau coloane: asemanator ca la etichetele de foi, dar pe antete.
11.2.2.2. Operaia de mutare a unei entiti (foaie, celul, rnd, coloan)
- Se selecteaz entitatea;
- Se poziioneaza cursorul pe chenarul seleciei pn la apariia formei de sgeat;
- Se trage n noua poziie.
Sau:
- Se selecteaz entitatea de mutat;
- Cu cursorul poziionat pe entitatea selectat, se selecteaz articolul Cut din meniul
contextual,
- sau din meniul Edit, se selecteaz articolul Cut. Efectul obinut este de a terge entitatea
din fiier transfernd-o n memoria tampon (Clipboard);
- Se selecteaz entitatea n faa creia se va face inplantarea entitii transferate n memoria
tampon;
- Cu ajutorul articolului Paste din meniul Edit sau din meniul contextual se face implantarea.
11.2.2.3. Operaia de copiere a unei entiti
Se face analog cu mutarea, dar cu tasta CTRL apsat n timpul operaiei de tragere, sau
folosind articolul Copy n locul articolului Cut.
11.2.2.4. Operaia de inserare a unei entiti
- Se face selectarea entitii n faa creia se va introduce noua entitate (de acelai tip);
- Din meniul Insert se selecteaz articolul Cells, Rows, sau Columns.
11.2.2.5. Operaia de tergere a unei entiti
- se selecteaz entitatea de ters;
- se apas tasta Delete, sau se selecteaz articolul articolul Delete din meniul Edit sau din
meniul contextual.
11.2.2.6. Intrarea n regimul de editare intracelular
- Se selecteaz celula vizat prin simplu sau dublu clic i se ncepe editarea.
- editarea poate fi facut direct n celul sau pe bara pentru formule.
11.2.3. Aranjarea convenabil a documentului
Deoarece n aceast aplicaie este necesar o singur foaie tabelar, vom pstra numai foaia
239
de lucru Sheet1. Celelalte foi, Sheet2, Sheet3 (i eventual altele) vor fi terse. Pentru aceasta
se face selectarea irului de foi consecutive Sheet2,..., etc (vezi punctul 11.2.2.1), dup care se
opereaz tergerea irului (vezi punctul 11.2.2.5).
11.2.4. Crearea tabelului
Tabelul conine valorile de calcul pentru funciile f ( x) = 1 e x i g( x) = 1 cos( x ) e x
- Se selecteaz domeniul dreptunghiular de celule de la C3 la E14 (vezi punctul 11.2.2.1);
- Se aplic formatele de chenar necesare pentru a desena tabelul din figura 11.2.2, cu
ajutorul butonului scul Borders de pe bara de scule Formatting;
- Se completeaz capul de tabel;
- Se completeaz celulele de tabel de la C4 la C14 cu valorile de la 0 la 10 ale coordonatei x;
- Celulele de la D4 la D14 conin formulele de calcul pentru f(x). De exemplu, celula D4
va conine formula =1-EXP(-C4). Funcia EXP se obine prin apsarea butonului fx de pe
bara cu scule Standard sau de pe bara de editare, cu care se deschide cutia de dialog
Function Wizard. De aici, din categoria Math&Trig se selecteaz funcia EXP.
Argumentele funciilor se introduc prin punctare pe celulele argumente. Formulele celorlalte
celule se completeaz asemntor.
- Celulele de la E4 la E14 conin formulele de calcul pentru g(x). De exemplu, celula D4
va conine formula =1-COS(X)*EXP(-C4). Completarea se face la fel ca mai nainte.
Fig.11.2.2.
11.2.5. Crearea diagramei centralizatoare
O diagram este reprezentarea grafic a unor dependene reciproce ale unor mrimi. n
acest caz, ne propunem s reprezentm grafic dependena mrimilor x, f(x), i g(x).
Etapele de lucru sunt urmtoarele:
- Pe rnd, se selecteaz: domeniul de valori al abscisei x (inclusiv capul de tabel) adic
domeniul $C$3:$C$14, apoi domeniul de valori al funciei f adic domeniul $D$3:$D$14 i
240
apoi domeniul de valori al funciei g adic domeniul $D$3:$D$14. La selectare se folosete

tehnica de "tragere" separat pentru fiecare ir vertical de celule. nainte de a se trece la al
doilea ir de celule se apas tasta CTRL i se ine apsat ct timp dureaz selecia (la fel i
pentru al treilea ir de celule pentru valorile funciei g).
Fig.11.2.3.
Fig.11.2.4.
- Din meniul Insert > Chart > As New Sheet, se declaneaz procedura de creare a unei
diagrame ntr-o foaie distinct (nou), care va conine numai diagrama. Aceast procedur
folosete setul de cutii de dialog Chart Wizard Step n of 4, unde n=1...4;
- Este foarte probabil c EXCEL i
va alege singur tipul de diagram
Column. n cazul nostru este necesar
alegerea tipulu Scatter i deci se va
face un clic pe acest tip, pentru a-l
selecta (fig.3.). Ca subtip de diagram
se va alege tipul cu curb continu.
Dup aceasta se apas butonul Next.
Ca urmare se deschide cutia de dialog
Chart Wizard Step 2 of 4 (figura
11.2.4);
- De aici se selecteaz opiunea
Series in Columns. Dup ce se apas
butonul Next se deschide cutia
Fig.11.2.5.
Chart Wizard Step 3 of 4 (figura
11.2.5). Aici se scriu irurile de text
care vor apare ca inscripii pentru titlul diagramei (Diagrame functii), denumirea abscisei x i
denumirile funciilor f,g.
- Dup ce se apas din nou butonul Next este afiat cutia de dialog Chart Wizard Step 4 of 4
unde se selecteaz opiunea As new sheet pentru a se realiza o diagram n foaie separat.
Dac ne aflm la prima ncercare reuit de construcie a diagramei, foaia cu diagrama
capt automat numele Chart1 i va avea aspectul din figura 11.2.6.
241
Fig.11.2.6.
11.2.6. Crearea de macrocomenzi prin nregistrare
EXCEL dispune de o tehnic de mare ajutor, att pentru utilizatori ct i pentru
programatori, care const din scrierea automat de programe n limbaj Visual BASIC prin
simpla nregistrare a aciunilor utilizatorului, fr ca acesta s aib nevoie s cunoasc
limbajul.
Un macro, sau macrocomanda, este o succesiune de aciuni care pot fi executate printr-o
singura activare. EXCEL are posibilitatea de inregistra aciunile efectuate de utilizator ntre o
pornire i o oprire a inregistrarii. Trebuie s fiti atenti pentru ca EXCEL inregistreaza absolut
tot, inclusiv greselile.
Vom nregistra urmtoarele aciuni:
11.2.6.1. Comutare de la foaie de lucru la foaie de diagram
Fig.11.2.8.
Pentru comutare ntre foaia Sheet1 i foaia
Chart1, etapele de lucru sunt urmtoarele:
- Se selecteaz meniul Tools > Macro >
Fig.11.2.7.
Record New Macro. Ca urmare, se deschide
cutia de dialog Record Macro, figura 11.2.7.
n cmpul Macro Name, n loc de numele de macrocomand atribuit automat Macro1, se
scrie numele PrezDiag i se apas butonul OK.
- Ca urmare, apare bara cu scule Stop Recording, figura 11.2.8, coninnd butonul de
242
oprire a nregistrrii (cel cu pictograma de forma unui ptrat negru). nregistrarea poate fi
oprit i cu meniul Tools > Macro > Stop Recording. Toate aciunile efectuate de utilizator
pn la oprirea nregistrrii vor fi transpuse n limbaj Visual BASIC ntr-o foaie special
(foaie de module de program) care, dac ne aflm la prima nregistrare va purta numele de
Module1. Este nevoie de mult atenie pentru a nregistra strict ceea ce este necesar i pentru
a nu uita s fie oprit nregistrarea;
- Din foaia de lucru Sheet1 se apas eticheta de foaie Chart1;
- Se oprete nregistrarea. Ca urmare, n foaia Module1 va apare scris urmtorul modul de
program:
Sub PrezDiag()
Sheets("Chart1").Select
End Sub
Se observ c modulul scris este de tip subrutin i conine numai instruciunea de

selectare a foii Chart1.
11.2.6.2. Comutarea de la foaia de diagram la foaia de lucru
Procedeul de lucru este asemntor. Trebuie s ne gsim n foaia Chart1, s pornim
nregistratorul de macrocomenzi, s selectm eticheta Sheet1 i s oprim nregistratorul. Vom
atribui macrocomenzii numele PrezFoaie. Modulul de program scris va fi urmtorul:
Sub PrezFoaie()
Sheets("Sheet1").Select
End Sub
Macrocomenzile nregistrate pot fi activate cu meniul Tools > Macro, sau pot fi asociate
ulterior cu un obiect de interaciune grafic.
11.2.7. Crearea de obiecte de interaciune grafic
11.2.7.1. Crearea unui buton de comutare din foaia de lucru n foaia cu diagrama
Dac privii din nou figura 11.2.2 vei observa un buton mare cu inscripia Diagrama.
Pentru a crea un buton se procedeaz astfel:
- Se selecteaz meniul View>Toolbars>Forms. Ca urmare se deschide bara cu
instrumente Forms (fig.11.2.11.);
- Se deseneaz butonul prin tehnica "drag and drop";
- Imediat ce desenarea s-a terminat se deschide cutia de dialog Assign Macro (fig. 11.2.9.)
Se
selecteaz
macrocomanda
PrezDiag i se apas butonul OK;
- Butonul rmne selectat (marcat cu
mnere), sau poate fi selectat pentru
modificare, folosind butonul dreapta al
mouse-ului. Se intr prin clic cu butonul
stnga i se schimb numele atribuit
automat (Button1) cu numele Diagrama.
Fig.11.2.9.
11.2.7.2. Crearea unui buton de

comutare din foaia cu diagrama n foaia
de lucru
Procedura de lucru este identic: se
selecteaz foaia Chart1, se genereaz butonul
Revenire (vezi figura 11.2.6), i se asociaz
acest buton cu macrocomanda PrezFoaie.
243
Folosind butoanele Diagrama i Revenire, un utilizator care nu cunoate modul de lucru

n EXCEL se poate plimba uor i sigur din foaia cu tabela n foaia cu diagrama.
11.2.7.3. Crearea unei cutii de dialog pentru comutarea de la tabel la diagram
Macrocomenzile pot fi asociate i cu alte obiecte de interaciune grafic, cum ar fi cutiile
de dialog. O cutie de dialog este o resurs de interaciune special care se creaz ntr-o foaie
special, numit foaie de dialog. Aceasta este o facilitate mai veche a Excel-ului, n prezent
tolerat, dar foarte accesibil programatorului nceptor prin simplitatea sa mult mai mare
dect noua tehnic de creare de resurse n mediul integrat Visual BASIC.
n continuare este prezentat o aplicaie simpl care realizeaz acelai lucru cu butonul intitulat
Diagrama bilantului, avnd n plus i posibilitatea de a renuna la procedura de comutare.
Etapele de lucru sunt urmtoarele:
1. Se plaseaz cursorul mouse-ului pe eticheta de foaie de lucru curent i se face clic pe
butonul dreapta;
Din meniul contextual deschis acum articolul Insert, dup care, din cutia de dialog Insert,
din pagina General se selecteaz pictograma MS Excel 5.0 Dialog.
Ca urmare este creat o foaie nou, special,
denumit Dialog1.
n aceast foaie este plasat automat o cutie de dialog
sumar (figura 11.2.10). Elementele ei sunt: un cadru cu
bar de titlu (Dialog Frame), i dou butoane (Button)
cu inscripiile OK i Cancel.
Aceste obiecte pot fi:
- selectate printr-un clic n cuprinsul lor;
- apucate i trase (mutate);
Fig.11.2.10.
- apucate i derivate ca mrime;
- cele care posed inscripii, prin dublu clic pe inscripie, pot fi aduse n faza de editare
(modificare) a inscripiei;
- selectate i terse (cu tasta Del);
- selectate i supuse operaiilor Cut, Copy i Paste;
- selectate i formatate (cu meniul Format, articolul Object, sau cu meniul contextual,
articolul Format Object).
Alturat cutiei de dialog n construcie, se gsete o cutie cu butoane denumite scule. Cutia
are titlul Forms iar butoanele au destinaiile notate n figura 11.2.11.
2. Se face dublu clic n bara de titlu a cutiei de dialog i se schimb titlul din Dialog
Caption n Afisare Diagrama;
3. Se redenumete butonul OK cu numele Da i butonul Cancel cu numele Nu;
4. Se redimensioneaz cutia de dialog i se reamplaseaz butoanele Da i Nu conform
dispunerii din figura 11.2.2;
5. Cu cursorul poziionat pe butonul selectat (de exemplu pe butonul Da) se deschide
meniul contextual, din care se selecteaz articolul Format Control sau se selecteaz meniul
Format, articolul Control. Ca urmare, se deschide cutia de dialog Format Control care,
pentru butonul Da (fostul buton OK), are coninutul paginii Control conform figurii 11.2.12.
6. n cmpul Accelerator Key se scrie caracterul D. Aceasta va apare subliniat pe
inscripia butonului Da i, ca urmare, va face ca tasta D s devin tast acceleratoare, adic se
va putea aciona butonul Da nu numai prin apsare cu cursorul dirijat de mouse ci i prin
apsarea tastei D;
Fig.11.2.11.
Fig.11.2.12.
244
7. Se procedeaz la fel
pentru
butonul
Nu,
atribuindu-i-se
ca
tast
acceleratoare caracterul N;
Observaie: nu operai
alte modificri n cutia
Format Object, pentru c se
poate altera specificul de
aciune al butonului selectat.
8. Se selecteaz meniul
Tools > Record Macro >
Record New Macro. n cutia
de dialog Record New
Macro se atribuie numele PrezDialog
macrocomenzii a crei nregistrare se va
efectua. Ca urmare, nregistratorul de
macrocomenzi este pornit;
9. Se apas butonul Run Dialog de
pe bara cu scule Forms. Cutia de dialog
este afiat aa cum apare ea cnd este
folosit n dialogul cu utilizatorul;
10. Se apas butonul Nu al cutiei de
dialog definit de utilizator;
11.
Se
oprete
nregistrarea
macrocomenzii. Ca urmare, n foaia de
module apare modulul de program urmtor:
Sub PrezDialog()
DialogSheets("Dialog1").Show
End Sub
12. Se selecteaz butonul Da;

13. Se selecteaz meniul Tools, articolul Assign Macro, sau, din meniul contextual se
selecteaz articolul Assign Macro;
14. Din cutia de dialog Assign Macro se selecteaz macrocomanda PrezDiag pentru a fi
asociat butonului Da.
Prin aceste procedee a fost creat cutia de dialog. Dac ea este activ (afiat), apsarea pe
butonul Da produce comutarea pe foaia cu diagrama.
Totui, a mai rmas de rezolvat o problem: cum s fie afiat nsi cutia de dialog creat?
Exist o posibilitate i anume, selectarea meniului Tools, articolul Macro. Se deschide
cutia de dialog Macro din care se selecteaz macrocomanda PrezDialog. Aceast posibilitate
este utilizabil numai pentru testare, n practic fiind necesar nc o asociere, de data aceasta
ntre macrocomanda PrezDialog i un obiect grafic. Acest obiect grafic poate fi un buton
creat de utilizator (ca butonul Diagrama de mai nainte).
11.2.8. Salvarea fiierului
Din meniul File, se selecteaz articolul Save As i se atribuie numele, de exemplu
Diagfunc.
245
11.3. Folosirea nregistrrilor de macrocomenzi n construirea

aplicaiilor
11.3.1. Fazele de realizare a unei aplicaii prin folosirea nregistratorului de
macrocomenzi
Construirea unei aplicaii "de la zero", nelegnd prin aceasta scrierea programelor
necesare instruciune cu instruciune, este o tehnic laborioas, mare consumatoare de timp i
efort din partea programatorului, acesta fiind solicitat s rein n memorie un mare volum de
denumiri de obiecte, metode i proprieti ale obiectelor. Pe de alt parte, programatorul
trebuie s conceap i schemele de aciune cu obiectele, lucru care se reflect printr-o anumit
succesiune a instruciunilor de scris n program, succesiune care, dac nu este corect,
conduce la obinerea altor efecte dect cele urmrite.
Pentru aceste motive, n practica construirii aplicaiilor n Visual BASIC pentru EXCEL,
se folosete o metod combinat. Baza conceptual a tehnicii de lucru este tot metoda topdown, aplicat n urmtoarea succesiune de faze:
1. Se analizeaz aplicaia de programat i se elaboreaz o list a procedurilor (subrutinelor)
componente;
2. Dintre procedurile stabilite mai sus se selecteaz acelea care pot fi rezolvate total sau
parial folosind tehnicile de lucru manuale (neprogramate);
3. Se folosete tehnica de nregistrare a macrocomenzilor pentru a realiza subrutine scrise
automat de ctre nregistratorul de macrocomenzi pentru procedurile de la punctul 2;
4. Subrutinele realizate la punctul 3 se modific folosind mediul Visual BASIC, pentru a se
realiza acele funcionaliti care nu pot fi create prin nregistrarea de macrocomenzi i pentru
a se mri gradul de generalitate i aplicabilitate;
5. Se scriu manual procedurile care nu fi create prin tehnica de nregistrare de
macrocomenzi;
6. Se asambleaz ntreaga aplicaie prin armonizarea (punerea de acord) a diferitelor
proceduri ntre ele.
Succesiunea de mai sus ar fi incomplet dac nu ar fi luat n considerare i
interdependena evenimentelor.
n realitate, fa de programarea procedural care "vede" un program ca pe o succesiune
prestabilit de evenimente, programarea orientat pe obiecte "vede" o aplicaie ca pe un
"univers" de obiecte, univers n care au loc evenimente ntr-o ordine destul de liber i la care
obiectele particip prin aciunile pe care le pot efectua. Strile pe care obiectele le pot cpta
n urma evenimentelor din universul lor trebuie bine analizate i luate n considerare la
realizarea componentelor aplicaiei (fazele 1...5), precum i la asamblarea ei n faza 6.
n continuare vom exemplifica cele expuse mai sus printr-o aplicaie de construire a
diagramei unei funcii definite prin puncte.
11.3.2. Definirea problemei
Fie o funcie y=f(x) definit prin 5 puncte: Pi(xi,yi), i=1,...,5.
Punctele pot fi date la ntmplare, urmnd ca apoi s fie sortate n ordinea cresctoare a
valorilor abscisei x.
Se cere s se genereze diagrama funciei y, a derivatei ei dy/dx i a integralei pe domeniul
de definiie dintre xmin i xmax.
11.3.3. Rezolvarea neprogramat
Pentru nceput, vom rezolva problema prin mijloacele obinuite ale EXCEL-ului, fr a
face uz de facilitile de programare.
246
Etapele de lucru sunt

urmtoarele:
- Se creaz liniatura tabelelor
din figura 11.3.1, n foaia de
lucru Sheet1;
- Se completeaz tabelele
astfel:
= Se completeaz capelele
de tabel cu inscripiile din
figura 11.3.1;
= n celulele A2:A6 se scriu
valorile
absciselor x (0.5, 1.0,
Fig.11.3.1.
1.5, 2.0, 3.0);
= n celulele B2:B6 se scriu valorile
ordonatelor y (0.7, 1.0, 1.5, 2.5, 2.0);
= n celula D3 se introduce formula
=A3-A2 (adic x2-x1);
= Se selecteaz celula D3 i, prin
tragere de mnerul de extindere al
celulei, se extinde formula din celul pe
domeniul celulelor D4...D6;
= n celula E3 se introduce formula
=B3-B2 (adic f(x2)-f(x1));
= Se selecteaz celula E3 i, prin
domeniul celulelor E4...E6;
= n celula F3 se introduce formula
=E3/D3 (adic (f(x2)-f(x1))/ (x2-x1) care
constituie formula aproximativ de
derivare lateral la stnga);
= Se selecteaz celula F3 i, prin
Fig. 11.3.2.
domeniul celulelor F4...F6;
= n celula G3 se introduce formula =0.5*(B3+B2) (adic 0.5*[f(xi+1)-f(xi)]);
= Se selecteaz celula G3 i, prin tragere de mnerul de extindere al celulei, se extinde
formula din celul pe domeniul celulelor G4..G6;
= n celula H2 se introduce valoarea 0 (adic se iniializeaz formula de integrare prin
nsumare a metodei trapezelor);
= n celula H3 se introduce formula =H2+G3*D3 (adic formula de integrare prin
metoda trapezelor);
= Se selecteaz celula H3 i, prin tragere de mnerul de extindere al celulei, se extinde
formula din celul pe domeniul celulelor H4..H6;
- Se creaz diagramele y=f(x), ydx i dy/dx astfel:
= Se selecteaz domeniul de celule A2:B6;
= Se apas tasta CTRL i, meninnd-o apsat, se selecteaz domeniul de celule
H2:H6;
247
Fig.11.3.3.
= De pe bara de instrumente Standard a foii de lucru, se apas butonul Chart Wizard. Se
procedeaz ca la lucrarea de laborator 11.2: diagram de tip Scatter (perechi x,y
dispersate), dar specificnd subtipul Scatter with data points connected by lines;
= La pasul 2 (Step 2 of 4 - figura 11.3.2) se comut n pagina Series a cutiei de dialog
Chart Wizard i:
~ se schimb denumirea seriei 1 de date din Series1 n y=f(x) prin scrierea noului
nume n cmpul Name;
~ se aplic un clic pe articolul Series2 i se schimb denumirea seriei 2 de date din
Series2 n integrala, la fel ca mai sus;
~ se aplic un clic pe butonul Add pentru a se crea o serie nou de date. Aceasta se
denumete derivata;
~ la seria nou creat se aplic un clic n cmpul X values (eventual se terge
coninutul acestuia dac exist vreunul) apoi, din foaia de lucru cu datele diagramei, se
selecteaz domeniul de celule A3:A6;
~ se aplic un clic n cmpul Y values (eventual se terge coninutul acestuia dac exist
vreunul) apoi, din foaia de lucru cu datele diagramei, se selecteaz domeniul de celule F3:F6;
= Restul operaiilor de construire a diagramelor decurge dup cum se cunoate de la
lucrarea 11.2, cu efectul final de creare a unei diagrame n foaie separat (Chart1), avnd
aspectul din figura 11.3.3 (dup unele ajustri).
11.3.4. Rezolvarea programat. Automatizarea aplicaiei
O automatizare complet, n sensul generrii n ntregime a tabelului, implantrii
formulelor de calcul, i generrii diagramei, n condiiile unui numr variabil de perechi de
puncte x,y este mult mai laborioas.
De aceea, n continuare, ne vom mulumi cu o automatizare parial a aplicaiei n sensul
introducerii datelor i a sortrii lor n ordinea cresctoare a valorilor coordonatelor x.
Pentru a se putea vedea datele introduse anterior, trebuie realizat comutarea n foaia de
lucru Sheet1. Pentru aceasta, ca la lucrarea anterioar, se va comuta n foaia pentru diagram
Chart1 i se va nregistra comutarea n foaia de lucru Sheet1. Va fi creat subrutina
Afisare_date, cu componena de mai jos:
248
Sub Afisare_date()
End Sub
Pentru a se putea vizualiza diagrama, analog, se nregistreaz comutarea n foaia Chart1.

Va fi creat subrutina Afisare_diagrama cu componena de mai jos:
Sub Afisare_diagrama()
End Sub
Pentru a se putea sorta datele introduse nesortate se

va opera procedeul urmtor:
- n tabelul din foaia Sheet1 se inverseaz primele
dou perechi de puncte (sau oricare altele);
- Se pornete nregistratorul de macrocomenzi
(Tools>Macro>Record New Macro) indicnd ca nume
de macro denumirea Sortare_tabel;
- Se selecteaz o celul din tabelul x,y (fie aceasta
chiar A1);
- Din meniul Data, se activeaz articolul Sort...;
- Ca urmare, datele de sub capul de tabel vor apare
selectate i va fi afiat cutia de dialog Sort (figura 4);
- Se verific dac n cmpul Sort by este selectat
criteriul x (aspectul cutiei trebuie s fie cel din figura
11.3.4);
Fig.11.3.4.
- Se apas butonul OK;
- Se oprete nregistratorul de macrocomenzi.
Acum tabelul redevine ordonat dup valorile cresctoare ale lui x. n plus, este creat
subrutina Sortare_tabel, cu componena de mai jos:
Sub Sortare_Tabel()
Range("A1").Select
Selection.Sort Key1:=Range("A2"), Order1:=xlAscending, Header:=xlGuess, _
OrderCustom:=1, MatchCase:=False, Orientation:=xlTopToBottom
End Sub
Pentru introducerea valorilor putem folosi o cutie de dialog ca aceea din figura 11.3.5. Deoarece
operaiile de introducere sunt simple, putem folosi o cutie de dialog de tip vechi, din categoria MS
Excel 5.0 Dialog (vezi lucrarea 11.2.2, punctul 11.2.7.3). Va fi creat foaia de dialog Dialog1.
n aceast cutie de dialog facem urmtoarele operaii:
- Se redenumete butonul OK cu denumirea Acceptare i i se atribuie tasta acceleratoare A;
- Se redenumete butonul Cancel cu denumirea Revocare i i se atribuie tasta acceleratoare R;
- Folosind instrumentul Label din cutia cu instrumente Forms se creaz etichetele x1...x5 i y1...y5;
- Folosind instrumentul Edit Box din cutia cu instrumente Forms se creaz cmpurile de
editare alturate etichetelor. La creare aceste obiecte primesc denumiri automate de tipul Edit
Box j, unde j are o valoare numeric oarecare. Deoarece este incomod (neintuitiv) s se
foloseasc aceste denumiri, le putem schimba astfel: printr-un clic se selecteaz cmpul de
editare dorit; se aplic un clic pe cmpul Name Box din partea stnga-sus a ferestrei cutiei de
dialog - ca efect denumirea existent va fi selectat i afiat n video negativ; se scrie noua
denumire. Vom folosi denumiri identice cu inscripiile etichetelor;
Pentru a se putea folosi cutia de dialog creat se va utiliza nregistratorul de macrocomenzi
pentru crearea unei subrutine de afiare a cutiei de dialog. Aceasta se realizeaz la fel ca la
.11.2, punctul 11.2.7.3. se va obine subrutina de mai jos:
249
Sub Afisare_dialog_date()
End Sub
Fig.11.3.5.
Din acest moment posibilitile de interfaare folosind

macrorecorderul au fost epuizate. Pentru a se putea opera
efectiv cu cutia de dialog Dialog1, trebuie elaborate
subrutine de gestiune prin scrierea manual a
instruciunilor necesare.
Se vor scrie urmtoarele subrutine n foaia de module
Module1:
- Subrutin de preluare a coordonatelor unui punct din
foaia de lucru Sheet1 n cmpul de editare corespunztor
al cutiei de dialog Dialog1:
Sub Prelevare_punct(celx, cely, rand)

DialogSheets("Dialog1").EditBoxes(celx).Text = _
Application.Worksheets("Sheet1").Cells(rand, 1)
DialogSheets("Dialog1").EditBoxes(cely).Text = _
Application.Worksheets("Sheet1").Cells(rand, 2)
End Sub
- Subrutin de iniializare a coordonatelor punctelor afiate de cutia de dialog Dialog1:

Sub Initializare_coordonate()
Prelevare_punct "x1", "y1", 2
End Sub
- Subrutin de introducere n foaia de lucru Sheet1 a coordonatelor unui punct preluate din
cmpurile corespunztoare ale cutiei de dialog Dialog1:
Sub Introducere_punct(celx, cely, rand)
Application.Worksheets("Sheet1").Cells(rand, 1) = _
Val(DialogSheets("Dialog1").EditBoxes(celx).Text)
Application.Worksheets("Sheet1").Cells(rand, 2) = _
Val(DialogSheets("Dialog1").EditBoxes(cely).Text)
End Sub
- Subrutin de introducere n foaia de lucru Sheet1 a coordonatelor celor 5 puncte preluate

din cmpurile cutiei de dialog Dialog1:
Sub Introducere_coordonate()
Introducere_punct "x1", "y1", 2
End Sub
- Subrutina de introducere a datelor n foaia de lucru Sheet1. Este apelabil cnd cutia de
dialog Dialog1 este afiat n foaia de lucru Sheet1. Apeleaz subrutina
Introducere_coordonate i apoi sorteaz tabelul prin apelul subrutinei Sortare_Tabel:
Sub Introducere_date()
Introducere_coordonate
Sortare_Tabel
End Sub
250
- Subrutin de introducere a datelor. Produce comutarea n foaia de lucru Sheet1, apeleaz

afiarea cutiei de dialog Dialog1, apoi comut napoi n foaia pentru diagram Chart1.
Sub Introd_coord()
Afisare_date
Afisare_dialog_date
Afisare_diagrama
End Sub
De asemenea, se modific subrutina Afiare_dialog_date, astfel:

Sub Afisare_dialog_date()
Initializare_coordonate
End Sub
n final, folosind comanda Assign Macro, se fac urmtoarele asocieri butonmacrocomand:

- butonul Introducere date noi din foaia Sheet1 se asociaz cu subrutina
Afisare_dialog_date;
- butonul Afiare Diagram din foaia Sheet1 se asociaz cu subrutina Afisare_diagrama;
- butonul Introducere date noi din foaia Chart1 se asociaz cu subrutina Introd_coord;
- butonul Vedere date din foaia Chart1 se asociaz cu subrutina Afisare_date.
11.4. Folosirea funciilor definite de utilizator sub EXCEL

Ca aplicaie se va realiza calculul volumului de ap dislocat de nav.
11.4.1. Baze teoretice
Metoda de calcul tradiional este foarte simpl. Ea const n aplicarea metodei de
integrare numeric aa numit "a trapezelor".
Fig.11.4.1.
Fig.11.4.2.
Conform figurii 11.4.1, integrala funciei f pe domeniul a-b poate fi scris sub forma
aproximativ a formulei trapezelor:
n 1 f + f
i
i +1 ( x x )
i +1 i
f ( x)dx =
2
=
i
1
a
(11.4.1)
Aceast valoare reprezint mrimea ariei dintre curba funciei f i axa ox. Se observ c
prin acest procedeu aceast arie este divizat n arii elementare cuprinse ntre axa x i arcul de
curb S dintre verticalele de mrime fi i fi+1. La rndul lor aceste arii sunt nlocuite de ariile
251
trapezelor formate prin nlocuirea arcului de curb S cu coarda C a curbei. Eroarea metodei
este dat de mica arie cuprins ntre arcul de curb S i coarda C.
Cu ct diviziunea intervalului a-b este mai fin, cu att eroarea este mai mic.
Pentru a calcula volumul de ap dislocuit de nav se procedeaz n urmtorii pai:
- Se consider volumul de sub ap al navei tiat n "felii" verticale denumite "cuple"
(figura 11.4.2), la anumite intervale pe lungimea navei, lungime msurat pe axa x orientat
de la prova ctre pupa. Fiecare dintre aceste cuple are un contur curb definit prin "semilimi"
msurate pe o ax y orientat de la planul longitudinal vertical central (numit plan diametral)
ctre bord. Abscisa curbei cuplei este msurat dup o ax z orientat pe vertical de la fundul
navei ctre punte;
- Se calculeaz ariile cuplelor prin integrarea funciei contur a fiecrie cuple n parte.
Astfel, rezult o serie de suprafee Ai, i=1,...,n ale cuplelor. Aceste valori Ai pot fi considerate
ca descriind o "funcie a ariilor imerse" (scufundate) de variabil x;
- Se calculeaz volumul de sub ap al navei prin integrarea pe lungimea x a ariilor imerse.
11.4.2. Realizarea aplicaiei sub EXCEL
Se vor parcurge urmtoarele etape de lucru:
- Se deschide un document EXCEL n care se deseneaz tabelul din figura 3. n celulele
marcate cu culoarea gri se vor introduce formule, restul celulelor fiind folosite pentru scrierea
datelor i a inscripiilor;
- Dup introducerea datelor n domeniile de celule C4:N10 i D12:N12 se genereaz
diagrama din figura 11.4.4, numit "transversal al planului de forme al navei". Procedura de
lucru pentru crearea acestei diagrame este urmtoarea:
= Se selecteaz domeniul de celule C4:D10;
= Se apas butonul Chart Wizard de pe bara de instrumente Standard;
= Din cutia de dialog Chart Wizard Step 1 of 4 se selecteaz tipul Scatter, subtipul
Scatter with data points connected by lines without markers;
= Din cutia de dialog Chart Wizard Step 2 of 4 se selecteaz pagina Data Range n
care se bifeaz Series in Columns. Apoi se comut n pagina Series. Dac am lsa datele
aa cum le accept automat Excel, cuplele navei ar apare culcate pe orizontal. De aceea,
trebuie inversate seriile de valori x i y ntre ele. Pentru aceasta, se selecteaz referinele de
celule din cmpul X Values i se mut cursorul, selectnd domeniul de celule D4:D10.
Apoi se selecteaz referinele de celule din cmpul Y Values i se reselecteaz celulele din
domeniul C4:C10. Pentru ca numele de identificare a diagramei astfel construite s nu fie
cel acordat automat (adic Series1) se introduce cursorul n cmpul Name i se scrie C0;
= Se pot introduce acum serii noi de date folosind butonul Add i procednd la
introducerea datelor n cmpurile X Values, Y Values i Name la fel ca mai sus;
= Se apas butonul Next pentru a se trece la pasul 3 al cutiei de dialog Chart Wizard.
Aici, dac se dorete se pot introduce inscripii de identificare a diagramei. n figura 11.4.4
aceste faciliti nu au fost folosite aa nct se poate trece la pasul 4 unde se alege opiunea
As new Sheet.
- Se aplic comanda Tools>Macro>Visual Basic Editor pentru a se deschide editorul
Visual Basic;
- n editorul Visual Basic se creaz o foaie de module n care se scriu funciile de mai jos:
- O funcie pentru calculul ariei imerse a unei cuple. Aceast funcie preia valorile de diviziune
ale axei z prin introducerea domeniului de celule care conine aceste valori i, analog, valorile
semilimilor. Deoarece aceste valori sunt situate pe coloane, se folosete proprietatea Count a
subobiectului Rows a obiectului Range pentru a se determina numrul de rnduri ale domeniului.
252
Fig.11.4.3.
Fig.11.4.4.
Se compar egalitatea lungimii domeniilor abscise - valori ale funciei contur al cuplei.
Dac aceste lungimi nu sunt egale (ca o consecin a unei selectri greite), funcia
returneaz ca rezultat irul de caractere "Eroare".
Dac lungimile sunt egale se efectueaz calculul integralei ntr-un ciclu For. Deoarece aria
astfel calculat este numai jumtate din aria efectiv (considernd i partea din bordul
simetric) valoarea obinut este multiplicat cu 2 i este returnat de funcie ca rezultat.
Function Arie_cupla(Dom_z As Range, Dom_y As Range)
lungz = Dom_z.Rows.Count
lungy = Dom_y.Rows.Count
If lungz = lungy Then
Arie_cupla = 0
For i = 1 To lungz - 1
z1 = Dom_z(i, 1)
253
z2 = Dom_z(i + 1, 1)
y1 = Dom_y(i, 1)
y2 = Dom_y(i + 1, 1)
Arie_cupla = Arie_cupla + 0.5 * (y2 + y1) * (z2 - z1)
Next i
Arie_cupla = 2 * Arie_cupla
Else
Arie_cupla = "Eroare"
End If
End Function
- O funcie pentru calculul volumului de ap dislocuit. Aceast funcie este conceput

similar, cu urmtoarele deosebiri:
= Datele sunt preluate din domenii de celule organizate pe rnduri, motiv pentru care
este folosit proprietatea Count a subobiectului Columns a obiectului Range;
= Nu se mai face multiplicare cu 2 deoarece volumul imers rezult direct din calcul.
Function Volum_imers(Dom_x As Range, Dom_Arii As Range)
lungx = Dom_x.Columns.Count
lungar = Dom_Arii.Columns.Count
If lungx = lungar Then
Volum_intre_cuple = 0
For i = 1 To lungar - 1
x1 = Dom_x(1, i)
x2 = Dom_x(1, i + 1)
ar1 = Dom_Arii(1, i)
ar2 = Dom_Arii(1, i + 1)
Volum_ imers = Volum_ imers + 0.5 * (ar2 + ar1) * (x2 - x1)
Next i
Else
Volum_imers = "Eroare"
End If
End Function
Pentru a se putea folosi aceste funcii se procedeaz astfel:

- Mai nti se selecteaz domeniul de celule C4:C10;
- Se aplic comanda Insert>Name>Define;
- n cutia de dialog Define Name se va observa: existena n cmpul Refers to a referinei
de cmp care ar putea s apar sub forma =Sheet1!$C$4:$C$10. Dac referina este incorect
se va selecta irul de caractere al referinei i se va repeta selecia cmpului referit din foaia de
lucru; existena n cmpul Names in Workbook a unei denumiri - n cazul de fa notaia z
culeas automat de ctre EXCEL din prima celul de deasupra cmpului selectat. Vom terge
aceast denumire i vom scrie n locul ei domz;
Folosirea formulei de calcul a unei arii imerse se face astfel:
- Se planteaz cursorul n celula D11;
- Se apas butonul fx de pe bara de scule Standard;
- Dup deschiderea cutiei de dialog Paste function se selecteaz categoria de funcii User
Defined iar din lista de funcii se selcteaz funcia Arie_cupla;
- Dup ce se apas pe butonul OK i este afiat cutia de dialog Arie_cupla se introduc,
prin selecie cu mouse-ul, domeniile de celule pentru valorile z (Dom_z) i pentru valorile
semilimilor (Dom_y);
254
- O dat ce prima celul pentru funcia de arie a fost completat, celelalte celule se
autocompleteaz folosind metoda extinderii prin tragere, astfel: se selecteaz celula
completat (D11), se "apuc" cu cursorul mouse de "mnerul de extindere" (din partea din
dreapta-jos a celulei) i se "trage" peste celulele E1:N11;
- n sfrit, pentru a calcula volumul imers, se selecteaz cursorul n celula N13 i se apas
pe butonul fx de unde se selecteaz funcia Volum_imers;
- n cutia de dialog a funciei Volum_imers se introduc domeniile de celule D12:N12
pentru abscisele x i D11:N11 pentru mrimile ariilor transversale imerse.
Observaie: n aplicaia de mai sus valorile au fost exprimate n m pentru lungimi, m2
pentru arii i m3 pentru volum. Din acest motiv deplasamentul navei rezult imediat n tone
din nmulirea volumului cu greutatea specific a apei.
11.5. Folosirea obiectelor simple de interaciune grafic din EXCEL

n cele ce urmeaz vom exemplifica modul de utilizare al obiectelor de interaciune din
EXCEL.
Fig.11.5.1.
Pentru a oferi un suport practic, concret, vom considera funcia parametric de gradul 2
urmtoare:
f (x ) = a x 2 + b x + p
unde p este un parametru variabil, iar pentru constantele a i b vom considera valorile a=5
i b=2.
Se cere construirea diagramei acestei funcii pe intervalul x=0...3 i crearea unei modaliti
de interfaare care s permit variaia interactiv a parametrului p, altfel dect prin scriere n
celula de depozitare a parametrului.
Lucrarea va decurge n etapele descrise mai jos.
11.5.1. Crearea tabelului funciei
- Se selecteaz foaia Sheet2;
- Se deseneaz tabelul din figura 11.5.1 i se completeaz inscripiile acestuia (parametru, x, f(x));
255
- n celula C4 se scrie o valoare oarecare a parametrului p;

- Se completeaz domeniul de celule C5:I5 cu valorile variabilei x;
- Folosind comanda Insert>Name>Define se denumete celula C4 cu numele param;
- n celula C6 se introduce formula =5*C5^2+2*C5+param
- Se extinde formula din celula C6 la restul celulelor domeniului valorilor funciilor (D6:I6).
11.5.2. Generarea diagramei funciei
- Se selecteaz domeniile de celule C5:I5;
- cu comanda Insert>Chart se genereaz diagrama folosind tipul Scatter, subtipul Scatter
with data points connected by smoothed lines without markers. n pasul al 4-lea se va
folosi opiunea As object in Sheet1.
Diagrama va rezulta cu aspectul din figura 11.5.1.
11.5.3. Crearea unui duplicat al tabelului funciei prin metoda referinelor
Deoarece dorim s realizm o aplicaie sigur, protejat contra erorilor de manevrare,
trebuie interzis accesul direct al utilizatorului la formulele din celulele tabelului, oferind totui
posibilitatea vizualizrii coninutului lui.
Pentru aceasta se procedeaz astfel:
- Se selecteaz celula B4 din foaia Sheet1;
- Se scrie caracterul =
- Se selecteaz foaia Sheet2 i se aplic un clic pe celula B4 a acestei foi, dup care se
apas tasta ENTER. n mod automat are loc revenirea la foaia Sheet1, iar in celula B4
din aceast foaie va apare formula de referire sub forma =Sheet2!B4. Aceast formul
este vizibil n bara de editare a formulelor atunci cnd se selecteaz celula B4 iar n
celul se va vedea coninutul celulei referite, n cazul de fa textul parametru;
- Se procedeaz la fel pentru celelalte celule ale tabelului. Mai simplu este s se
procedeze prin extinderea prin tragere a formulei deja introduse. Se completeaz
operaia prin formatarea chenarelor celulelor tabelului duplicat;
- Se aplic comanda Tools>Protection>Protect Sheet. Va avea loc deschiderea cutiei
de dialog Protect Sheet unde se aplic doar un clic pe butonul OK, fr a scrie nici o
parol i fr a modifica opiunile existente;
- La finalul acestei etape se selecteaz foaia Sheet2 i se aplic comanda
Format>Sheet>Hide. Prin aceasta foaia este ascuns, adic eticheta de foaie dispare
de pe bara de etichete i foaia nu mai poate fi selectat dect dac se dezascunde cu
comanda Format>Sheet>Unhide.
n urma acestei proceduri, pn la deprotejarea foii Sheet1, orice ncercare de a modifica o
celul oarecare din cuprinsul foii va fi respins de ctre EXCEL, concomitent fiind afiat un
mesaj de avertisment.
Nu s-a aplicat acest procedeu direct asupra foii Sheet2 deoarece acolo exist celule pe care
programul va trebui s le modifice, iar protejarea foii ar fi interzis i programului accesul la
celule.
11.5.4. Crearea unei cutii de dialog pentru interaciune
Pentru a putea modifica interactiv parametrul funciei trebuie construit o cutie de dialog
cu acest rol. n acest scop vom folosi o facilitate mai veche de creare a cutiilor de dialog
introdus de la EXCEL 5.0.
Acestea au avantajul de a fi mai uor de manipulat i de programat, dar i dezavantajul de a
oferi o gam de posibiliti de interfaare mai redus dect omoloagele lor introduse de la
versiunea EXCEL 97.
256
Cutia de dialog care trebuie creat va avea aspectul din figura 11.5.2 i va conine
urmtoarele instrumente de control:
- O etichet (Label) cu inscripia Valoare=
- O cutie de editare (EditBox) n care se va scrie
valoarea parametrului;
- O caset de opiune neexclusiv (Check Box) cu inscripia
Variaie dinamic. Rolul ei este de a activa modificarea valorii
parametrului direct n foaia de lucru Sheet2, efect vizibil prin
referin i n foaia Sheet1. Cnd aceast caset este nebifat
orice variaie incremental/decremental determinat de apsri
pe
butoanele Creste i Descreste nu va fi vizibil dect n cutia
Fig.11.5.2.
de editare;
- Butonul incremental Creste, care produce majorarea parametrului cu o unitate;
- Butonul decremental Descreste care produce micorarea parametrului cu o unitate;
- Butonul Aplicare provenit din modificarea butonului prestabilit OK. Cnd acest buton este
apsat valoarea scris pentru parametru este aplicat n celula corespunztoare din foaia Sheet2;
- Butonul Iesire provenit din modificarea butonului Cancel, al crui rol este de a nchide
cutia de dialog fra a mai efectua nici o alt aciune.
Crearea cutiei de dialog se face, ca i n lucrrile anterioare, prin inserarea unei foi de
dialog MS Excel 5.0 Dialog (vezi lucrarea 11.2, punctul 11.2.7.3).
Deoarece cutia de editare i caseta de opiune vor trebui s fie accesate de macrocomenzile care
se vor scrie, este indicat s li se schimbe denumirile acordate automat la creare cu denumiri noi.
Pentru aceasta se selecteaz cu un clic obiectul dorit, apoi se aplic un clic n cmpul
Name Box din stnga/sus a ferestrei foii de dialog, dup care se scrie numele dorit. De
asemenea, se poate face uz de meniul Insert>Name>Define, de o manier similar cu cea
folosit ntr-o foaie de calcul tabelar.
Se vor denumi: cutia de editare cu numele ValParam, iar caseta de opiune cu numele vardin.
La creare, obiectele din cuprinsul cutiei de dialog au o serie de atribute prestabilite care le
determin comportamentul. Unele dintre ele vor trebui modificate astfel:
- Se selecteaz obiectul n cauz;
- Se aplic comanda Format>Control;
- Dup deschiderea cutiei de dialog Format Control se selecteaz pagina Control.
Obiectele i atributele de modificat sunt urmtoarele
- Pentru cutia de editare ValParam, din grupul Edit Validation se bifeaz opiunea Number;
- Pentru caseta de opiune vardin, n cmpul Accelerator Key se scrie litera V;
- Pentru butonul cu inscripia Aplicare (iniial denumit OK) se dezactiveaz opiunea
Dismiss (butonul nu va mai nchide cutia de dialog) i se las activ numai opiunea Default.
De acemenea, se atribuie ca tast acceleratoare litera A (n cmpul Accelerator Key);
- Pentru butonul cu inscripia Ieire (iniial denumit Cancel) se atribuie ca tast
acceleratoare litera I;
- Pentru butonul nou creat cu inscripia Creste nu se activeaz nici unul din atributele
Default, Cancel, Dismiss, Help, i se atribuie tasta acceleratoare C;
- Pentru butonul nou creat cu inscripia Descreste nu se activeaz nici unul din atributele
de buton i se atribuie tasta acceleratoare D;
11.5.5. Crearea macrocomenzilor de interaciune
Instrumentele de interaciune create mai sus vor rmne inactive dac ele nu declaneaz
aciuni. Aceste aciuni au loc ca urmare a unor macrocomenzi care trebuie scrise ntr-o foaie
pentru module de program.
257
Pentru a se crea o astfel de foaie trebuie mai nti s se deschid editorul de Visual Basic
folosind comanda Tools>Macro>Visual Basic Editor.
Deoarece nu a fost folosit nregistratorul de macrocomenzi, aplicaia (fiierul EXCEL) nu
conine nici o foaie de module. Ea se ataeaz folosind comanda Insert>Module aplicat din
fereastra editorului.
O dat foaia de module creat (Module1), n ea se vor scrie urmtoarele macrocomenzi:
Sub Afisare_Dialog()
DialogSheets("Dialog1").CheckBoxes("vardin").Value = Unchecked
DialogSheets("Dialog1").EditBoxes("ValParam").Text = _
Application.Worksheets("Sheet2").Range("param")
End Sub
Aceast subrutin realizeaz urmtoarele aciuni:

- Indiferent care ar fi fost starea anterioar a casetei de opiune vardin (bifat sau nu) ea
este debifat;
- Se preia coninutul din celula C4 a foii Sheet2 - cea denumit param (cu valoarea
parametrului p) i este atribuit ca text n cutia de editare ValParam;
- Se afieaz cutia de dialog Parametru.
Sub Accept_parametru()
valparam = DialogSheets("Dialog1").EditBoxes("ValParam").Text
If Not IsNumeric(valparam) Then
MsgBox "Introducere gresita!", vbCritical, "Atentie!"
Exit Sub
End If
valparam = Val(valparam)
Application.Worksheets("Sheet2").Range("param") = valparam
End Sub

- Variabila de tip Variant valparam preia textul din cutia de editare ValParam;
- Dac textul este neconvertibil la valoare numeric este afiat o cutie cu un mesaj de
avertisment i orice aciune este abandonat;
- Dac textul are semnificaie numeric valoarea de tip text este convertit n valoare
numeric folosind funcie Val a limbajului Visual Basic pentru EXCEL;
- Celula C4 din foaia Sheet2 capt valoarea numeric a variabilei valparam.
Sub Creste_parametru()
Exit Sub
End If
valparam = Val(valparam) + 1
DialogSheets("Dialog1").EditBoxes("ValParam").Text = CStr(valparam)
If DialogSheets("Dialog1").CheckBoxes("vardin").Value = Checked Then
End If
End Sub

258
- Dac textul are semnificaie numeric valoarea de tip text este convertit n valoare
numeric folosind funcie Val a limbajului Visual Basic pentru EXCEL i apoi este
incrementat;
- Cutia de editare ValParam primete ca valoare de tip text valoarea curent a variabilei
valparam convertit la forma text;
- Dac caseta de opiune vardin este bifat (Checked) atunci celula param din foaia
Sheet2 primete valoarea parametrului.
Sub Descreste_parametru()
Exit Sub
End If
valparam = Val(valparam) - 1
DialogSheets("Dialog1").EditBoxes("ValParam").Text = CStr(valparam)
If DialogSheets("Dialog1").CheckBoxes("vardin").Value = Checked Then
End If
End Sub

- Dac textul are semnificaie numeric valoarea de tip text este convertit n valoare numeric
folosind funcie Val a limbajului Visual Basic pentru EXCEL i apoi este decrementat;
- Cutia de editare ValParam primete ca valoare de tip text valoarea curent a variabilei
valparam convertit la forma text;
- Dac caseta de opiune vardin este bifat (Checked) atunci celula param din foaia
Sheet2 primete valoarea parametrului.
11.5.6. Realizarea legturilor de interaciune
Toate macrocomenzile de mai sus trebuie s trateze evenimentele create prin apsarea
instrumentelor de control ale cutiei de dialog. De aceea, ntre ele i aceste instrumente de
control trebuie realizate legturi. Acest lucru se obine pe urmtoarea cale general:
- Se selecteaz instrumentul de control n cauz;
- Se aplic un clic pe butonul dreapta al mouse-ului;
- Din meniul contextual deschis astfel, se selecteaz articolul Assign Macro, ceea ce
deschide cutia de dialog Assign Macro;
- n cutia de dialog Assign Macro, din lista Macros in, se selecteaz This Workbook;
- Din lista de macrocomenzi de sub cmpul Macro Name se selecteaz macrocomanda de
asociat: Ca urmare, aceasta va apare n cmpul Macro Name;
- Se apas butonul OK.
nainte de a se proceda la realizarea legturilor mai trebuie creat un instrument de interaciune.
Acesta este butonul Variatie Parametru de deasupra tabelului vizibil n figura 11.5.1 n
foaia Sheet1. Acest lucru trebuie realizat cu foaia deprotejat, folosind cutia cu instrumente
Forms care se deschide folosind comanda View>Toolbars>Forms.
Legturile (asignrile de macrocomenzi) de realizat sunt urmtoarele:
259
- Butonul Variatie Parametru din foaia Sheet1 se asociaz cu macrocomanda

Afisare_Dialog;
- Butonul Aplicare din cutia de dialog se asociaz cu macrocomanda Accept_parametru;
- Butonul Creste din cutia de dialog se asociaz cu macrocomanda Creste_parametru;
- Butonul Descreste din cutia de dialog se asociaz cu macrocomanda
Descreste_parametru;
Cu aceasta aplicaia este complet i poate fi folosit.
11.6. Folosirea obiectelor de interaciune grafic programabile din EXCEL

n cele ce urmeaz vom exemplifica modul de utilizare al obiectelor de interaciune
programabile din EXCEL, nou introduse n editorul de Visual BASIC de la versiunea EXCEL 97.
11.6.1. Definirea temei
Fie funcia de gradul al 2-lea
y = f (x ) = a x 2 + b x + c
Se pune problema determinrii coeficienilor a, b i c. Deoarece acetia apar ca trei

necunoscute, sunt necesare trei ecuaii pentru a-i putea determina. Aceste trei ecuaii se pot obine
dac se consider trei puncte prin care trece curba funciei P1(x1,y1), P2(x2,y2) i P3(x3,y3).
Se poate scrie sistemul de trei ecuaii cu trei necunoscute a, b i c:
ax 2 + bx1 + c = y1
1
2
ax + bx 2 + c = y 2
2
ax 2 + bx3 + c = y 3
3
Se pot scrie determinanii:
x12 x1 1
x12 y1 1
x12 x1 y1
y1 x1 1
= x22 x2 1 a = y2 x2 1 b = x22 y2 1 c = x22 x2 y2
y3 x3 1
x32 x3 1
x32 y3 1
x32 x3 y3
ceea ce conduce la soluiile sistemului sub forma:
a
b
c
a=
b=
c=
, evident cu condiia 0
Considernd acum setul de funcii fi(x) definite prin setul de puncte P1i(x1,y1i), P2i(x2,y2i),
P3i(x3,y3i), i=1,...,n, se cere s se construiasc o aplicaie care s afieze la cerere diagrama
unei funcii oarecare de indice i i, mai mult, ca valorile y1, y2, y3 ale unei funcii oarecare din
set s poat fi modificate.
11.6.2. Construirea foii de calcul
Se construiete foaia de calcul Sheet1, incluznd n ea urmtoarele elemente, vizibile n
figura 11.6.1. Se parcurg urmtoarele etape:
11.6.2.1. Atribuiri de nume pentru domenii de celule
- celula F2 capt denumirea indice;
- celula C3 capt denumirea crtf1;
- celula D3 capt denumirea crtf2;
- celula E3 capt denumirea crtf3;
260
- domeniul B7:E18 capt denumirea tabel;

- domeniul C7:C18 capt denumirea fun1;
- domeniul D7:D18 capt denumirea fun2;
- domeniul E7:E18 capt denumirea fun3;
- celula M6 capt denumirea coef_a;
- celula M10 capt denumirea coef_b;
- celula M14 capt denumirea coef_c;
Fig.11.6.1.
Aceste denumiri ajut la o mai bun gestionare a celulelor prin programul care se va
construi n Visual BASIC i, totodat, evitnd lucrul cu adrese de celul efective, face
programul insensibil la eventuale modificri ale foii de lucru (adugri/suprimri de
rnduri/coloane).
11.6.2.2. Completarea coninutului celulelor
Cu excepia capetelor de tabel (domeniile B2:B3, C6:E6 i B7:B18) i a celulelor cu date
(domeniile C2:E2, C7:E18) care se scriu aa cum se vd n figura 11.6.1, pentru celelalte
celule se procedeaz astfel:
- n celula F2 se scrie o valoare oarecare (de exemplu 2, dar nu mai mare de 11)
- n celula C3 se introduce formula =INDEX(fun1,indice+1)
- n celula D3 se introduce formula =INDEX(fun2,indice+1)
- n celula E3 se introduce formula =INDEX(fun3,indice+1)
- n celula G2 se scrie formula =C2^2
- n celula G3 se scrie formula =D2^2
- n celula G4 se scrie formula =E2^2
- n celula H2 se scrie formula =C2
- n celula H3 se scrie formula =D2
- n celula H4 se scrie formula =E2
- n celulele I2:I4 se scrie valoarea 1
- n celula J2 se scrie formula =C3
261
- n celula J3 se scrie formula =D3

- n celula J4 se scrie formula =E3
- n celula G6 se scrie formula de referire =G2
- Se extinde celula G6 prin tragere peste domeniul G6:I6 pe orizontal;
- Cu domeniul G6:I6 selectat se opereaz extinderea lui peste domeniul G6:I8 pe vertical;
- Se procedeaz la fel pornind de la celula G10 i apoi G14, obinndu-se astfel duplicate
prin referire ale matricii coeficienilor sistemului de ecuaii din domeniul G2:I4;
Se nlocuiesc pe rnd coloanele 1, 2 i 3 ale duplicatelor matriciale, astfel nct ele s
refere vectorul termenilor liberi, dup cum urmeaz:
- n celula G6 se introduce formula de referire =J2, apoi se extinde pe vertical peste
domeniul G6:G8;
- n celula H10 se introduce formula de referire =J2, apoi se extinde pe vertical peste
domeniul H10:H12;
- n celula I14 se introduce formula de referire =J2, apoi se extinde pe vertical peste
domeniul I14:I16;
Se calculeaz determinanii matricilor:
- n celula L2 se introduce formula =MDETERM(G2:I4)
Se calculeaz soluiile sistemului:
- n celula M6 se introduce formula =L6/L2
11.6.3. Construirea diagramei funciei
Diagrama funciei va avea la baz datele din domeniile C2:E2 pentru x i C3:E3 pentru y.
Construcia diagramei de tip Scatter, subtipul Compares pairs of values decurge ntocmai ca
i la aplicaiile anterioare. Ea va fi creat ca obiect n foaia Chart1, i va conine numai
reprezentarea celor trei puncte date.
n continuare, pentru a se obine cu adevrat o diagram de funcie ptratic se procedeaz astfel:
- Se aplic un clic pe unul dintre punctele diagramei;
- Se aplic comanda Chart>Add Trendline, ceea ce are ca efect deschiderea cutiei de
dialog Add Trendline;
- n pagina Type a cutiei de dialog Add Trendline, din grupul Trend/Regression type se
selecteaz tipul Polynomial i Order=2;
- Se comut n pagina Options unde se bifeaz opiunea Display equation on chart i se
apas butonul OK.
- Folosind instrumentele de formatare se ajusteaz diagrama astfel nct s aib aspectul
din figura 11.6.2.
11.6.4. Construirea cutiei de dialog
De aceast dat vom face uz de posibilitile de construire a dialogurilor implementate n
editorul de Visual BASIC din EXCEL.
Pentru aceasta, din editorul de Visual BASIC, n fereastra Project-VBA Project, se aplic un
clic pe nodul VBA Project (nume_fisier.xls) i apoi se lanseaz comanda Insert>Userform. Ca
urmare la acest nod este conectat un nod nou, denumit Forms cu obiectul subordonat UserForm1
ca n figura 11.6.3, iar n fereastra din dreapta apare un cadru de cutie de dialog i cutia cu
instrumente ToolBox (figura 11.6.4) pentru crearea componentelor de dialog.
262
Fig.11.6.2.
Fig.11.6.3.
Fig.11.6.4.
Fig.11.6.5.
Folosind aceste instrumente se vor crea elementele vizibile n figura 11.6.5, i anume:
- eticheta (Label) cu inscripia Coeficienii funciei;
- un rnd orizontal de trei etichete cu inscripii stabilite prin program care vor afia a=, b=, c= urmate
de valorile coeficienilor funciei calculai n foaia Sheet1 n celulele denumite coef_a, coef_b, coef_c;
- o cutie de listare (ListBox) care va afia denumirile funciilor i coordonatele y ale celor
trei puncte prin care trec curbele lor;
- un cadru de grup (Frame) cu inscripia Set de valori pentru functie;
- trei etichete cu inscripiile y1=, y2=, y3=;
- trei cutii de editare (TextBox) cu rolul afirii/introducerii coordonatelor y1, y2 i y3 ale
funciei selectate din cutia de listare;
- butonul Aplicare cu rolul modificrii coordonatelor y1, y2 i y3 ale funciei selectate;
- butonul Terminare, cu rolul nchiderii cutiei de dialog.
Dup crearea acestor elemente se trece la stabilirea proprietilor lor n fereastra
Properties de sub fereastra Project-VBA Project. n tabelul de mai jos sunt indicate
stabilirile de proprieti necesare.
263
Tip de obiect
Denumire
(Name)
Proprieti i observaii
(Proprietile nemenionate rmn la valorile
prestabilite)
Caption=Functii, Height=210, Width=275
Font=Tahoma, Bold, 10
Cutia de dialog (Userform)

UserForm1
Etichet (Label)
Label1
la partea superioar a cutiei
de dialog
Etichete (Label)
- prima din setul de trei de sus
Coef_a
- a doua
Coef_b
Font=Tahoma, Bold, 12, Height=20, Width=80
- a treia
Coef_c
Cutia de listare
valori_functii ColumnCount=4,
ColumnHeads=True,
(ListBox)
Height=72, Width=260
Chenar de grup (Frame)
Frame1
Caption=Set de valori pentru functie
Etichete (Label)
- prima din setul de trei din
Label5
Caption: y1=, Height=13, Width=18
grupul Frame1
- a doua
Label6
Caption: y2= , Height=13, Width=18
- a treia
Label7
Caption: y3= , Height=13, Width=18
Cutii de editare
(TextBox)
- prima din setul de trei din
valy1
Height=17, Width=60
grupul Frame1
- a doua
valy2
- a treia
valy3
Butoane de comand
(CommandButton)
- din stnga
Aplicare
Accelerator=A, Height=25, Width=110
- din dreapta
Terminare
Accelerator=T, Height=25, Width=110
11.6.5. Crearea subrutinelor de comand ale instrumentelor de dialog
La acest tip de instrumente de comand subrutinele asociate sunt destinate tratrii
evenimentelor ocazionate de aciunile asupra lor, evenimente de tip Click (clic pe un element
de control) sau Change (modificarea prin editare a cutiilor de editare).
Aceste subrutine sunt create ntr-o foaie de modul privat ataat direct obiectului container
UserForm1.
n general, pentru crearea unei astfel de subrutine se procedeaz astfel:
- Printr-un clic, se selecteaz componenta de dialog al crui eveniment trebuie tratat;
- Cu componenta selectat, se aplic comanda View>Code. Ca urmare vor fi create dou
instruciuni de forma:
Private Sub Numecomponenta_EvenimentDeTratat ()
End Sub
fr nici un alt coninut. Programatorul va trebui s scrie el nsui instruciunile care

descriu modul de tratare al evenimentului.
Urmnd aceast procedur vor fi scrise subrutinele de mai jos. Scopul lor este explicat
dup textul subrutinei.
264
Private Sub valori_functii_Click()

Application.Range("indice") = UserForm1.valori_functii.ListIndex
vala = Application.Worksheets("Sheet1").Range("coef_a")
valb = Application.Worksheets("Sheet1").Range("coef_b")
valc = Application.Worksheets("Sheet1").Range("coef_c")
UserForm1.Coef_a.Caption = "a=" & CStr(vala)
UserForm1.Coef_b.Caption = "b=" & CStr(valb)
UserForm1.Coef_c.Caption = "c=" & CStr(valc)
UserForm1.valy1.Text = Application.Range("crtf1").Text
End Sub
Aceast subrutin trateaz evenimentul de clic pe unul dintre articolele afiate de cutia de
listare i efectueaz urmtoarele aciuni:
- Scrie n celula F2 din foaia Sheet1 valoarea indicelui de list (numrul articolului selectat
din list). Primul indice este zero. Prin modificarea survenit n celula F2, formulele din
celulele C3, D3 i F3 din foaia Sheet1 vor afia valorile coordonatelor y1, y2 i y3 ale
funciei selectat din cutia de listare;
- variabilele vala, valb i valc preiau valorile din celulele M6, M10 i M14 din foaia
Sheet1;
- Se convertesc valorile de tip numeric vala, valb i valc n valori de tip ir de caractere i
se concateneaz (alipesc) cu irurile de text a=, b= i c=, dup care sunt atribuite ca iruri de
afiat de ctre etichetele Coef_a, Coef_b i Coef_c ale cutiei de dialog (prin preluarea
irurilor de ctre proprietile Caption ale acestor obiecte);
- Sunt preluate valorile de tip text ale celulelor C3, D3 i F3 reprezentnd valorile
coordonatelor y1, y2 i y3 ale funciei curente (cea selectat din list) i sunt atribuite ca text
de afiat de ctre cutiile de editare ale cutiei de dialog (prin atribuirea lor ca valori pentru
proprietile Text ale acestor obiecte).
Private Sub Aplicare_Click()
y1 = UserForm1.valy1.Text
If Not (IsNumeric(y1) And IsNumeric(y2) And IsNumeric(y3)) Then
MsgBox "Date gresite!", vbCritical, "Eroare"
Exit Sub
Else
indfunc = Val(Application.Range("indice"))
Application.Range("fun1").Item(indfunc + 1) = y1
End If
End Sub
Aceast subrutin trateaz evenimentul Click pe butonul Aplicare i efectueaz

urmtoarele aciuni:
- Variabilele y1, y2 i y3 preiau valorile de tip text din cutiile de editare ale cutiei de
dialog;
- Se aplic un test pentru a determina dac cel puin una dintre aceste valori nu are
semnificaie numeric. n acest caz este afiat o cutie de mesaj cu avertismentul "Date
gresite!" i tratarea evenimentului se ncheie fr alt efect;
- Dac testul de nesemnificativitate numeric a fost negativ, variabila indfunc preia
265
valoarea din celula F2 a foii Sheet1 convertit de la forma text la forma numeric folosind
funcia Val;
- Valorile variabilelor y1, y2 i y3 prelevate din cutiile de editare sunt scrise n celulele
corespunztoare ale domeniului B7:E18 din foaia Sheet1. Valoarea variabilei indfunc este
majorat cu 1 deoarece regula de numerotare a rndurilor unui domeniu presupune c primul
rnd al domeniului are indicele 1.
Private Sub Terminare_Click()
Unload UserForm1
End Sub
Aceast subrutin trateaz evenimentul Click pe butonul Terminare. Singura aciune

efectuat este aceea de a nchide cutia de dialog descrcnd-o din memorie.
Pentru ca mai sus prezentata cutie de dialog s poat fi folosit mai este necesar o
subrutin care s o pregteasc de afiare i apoi s o afieze. Spre deosebire de celelalte
subrutine de mai sus, aceasta se va scrie ntr-o foaie de module obinuit, foaia Module1, i
va avea urmtoarea componen:
Sub afisare_dialog()
Load UserForm1
UserForm1.valori_functii.ListIndex = 0
Application.Range("indice") = 0
vala = Application.Worksheets("Sheet1").Range("coef_a")
valb = Application.Worksheets("Sheet1").Range("coef_b")
valc = Application.Worksheets("Sheet1").Range("coef_c")
UserForm1.Coef_a.Caption = "a=" & CStr(vala)
UserForm1.Coef_b.Caption = "b=" & CStr(valb)
UserForm1.Coef_c.Caption = "c=" & CStr(valc)
UserForm1.Show
End Sub
Aceast subrutin efectueaz urmtoarele aciuni:

- ncarc n memorie cutia de dialog UserForm1;
- Iniializeaz indicele cutiei de listare la valoarea 0, astfel nct, cnd cutia de dialog va fi
afiat, primul ei articol s fie selectat. Acest lucru este foarte important deoarece indicele de
list este cel care, n aceast aplicaie face legtura dintre datele afiate de diagrama din foaia
Chart1 i datele afiate de cutia de dialog n etichetele pentru coeficieni i n cutiile de editare
pentru coordonatele y1, y2 i y3;
- Variabilele vala, valb i valc preiau valorile din celulele M6, M10 i M14 din foaia Sheet1;
- Proprietile Caption ale obiectelor etichete pentru coeficieni primesc valorile
variabilelor vala, valb i valc convertite la forma ir de caractere i concatenate cu inscripiile
a=, b= i c=;
- Proprietile Text ale obiectelor cutii de editare pentru coordonatele y1, y2 i y3 preiau
valorile de tip text ale acestor coordonate extrase din celulele C3, D3 i E3 din foaia Sheet1;
- Este afiat cutia de dialog.
11.6.6. Finalizarea aplicaiei
Pentru ca aplicaia s funcioneze mai trebuie creat o legtur ntre foaia cu diagrama
funciei selectate i cutia de dialog care servete la selectare.
Pentru aceasta se mai execut urmtoarele operaii:
266
- Folosind cutia cu instrumente Forms se creaz n foaia Chart1 un buton, cu dispunere la

baza diagramei, ca n figura 11.6.2;
- Folosind cutia de dialog Assign Macro se asociaz acest buton cu macrocomanda
afisare_dialog;
- Se scrie pe buton inscripia Selectare.
Din acest moment aplicaia este utilizabil.
Dac se dorete i protecia datelor i formulelor din foaia Sheet1, se poate proceda la
ascunderea acestei foi folosind comanda Format>Sheet>Hide. Nu se va folosi protecia foii
deoarece exist celule n foaia Sheet1 pe care programul trebuie s le modifice iar protecia
foii, prin blocarea modificrilor n foaie, ar bloca la rndul ei programul.
11.7. Aplicaie de folosire programat a instrumentelor pentru

rezolvarea i aproximarea funciilor
n cele ce urmeaz vom exemplifica modul de folosire a instrumentului de rezolvare a
funciilor de o variabil, Goal Seek, i a facilitilor de aproximare a funciilor date prin puncte.
Fie funcia de gradul 3 de forma:
f (x ) = a x 3 + b x 2 + c x + d
Se cere aflarea soluiilor ecuaiei f(x)=0 pe un interval dat [xin, xfin]. Dea semenea, se cere
automatizarea rezolvrii prin crearea unor instrumente de interfaare care s permit:
- Modificarea coeficienilor a, b, c i d;
- Modificarea valorilor limitelor intervalului [xin, xfin];
- Reprezentarea diagramei funciei conform valorilor modificate.
11.7.2. Rezolvarea neprogramat
ntr-o prim faz vom efectua lucrarea cu mijloacele simple ale programului EXCEL, n
urmtoarele etape:
11.7.2.1. Crearea fiierului
- Se creaz un fiier nou din care se rein numei
primele dou foi de lucru, Sheet1 i Sheet2, restul
fiind eliminate.
- n foaia Sheet2 se creaz liniatura i capetele de
tabel (cele cu litere groase), conform figurii 11.7.1.
11.7.2.2. Completarea tabelului
Tabelul creat mai sus se completeaz astfel:
- Domeniul de celule A3:A13 se completeaz cu
indicii valorilor de discretizare a intervalului [xin, xfin];
- Folosind comanda Insert>Name>Define celula
B3 se denumete xin;
- Celula B13 se denumete xfin;
Fig.11.7.1.
- Se completeaz celulele xin i xfin cu valorile -2 i 2;
- n celula B4 se introduce formula =xin+(xfin-xin)*A4/10
- Coninutul celulei B4 se extinde prin tragere peste domeniul B5:B12;
- Celulele E2, E3, E4 i E5 se denumesc, respectiv, coefa, coefb, coefc i coefd;
- Se completeaz celulele coeficienilor cu valorile -3, -3, 4, 1;
267
- n celula C3 se introduce formula:

=coefa*B3^3+coefb*B3^2+coefc*B3+coefd
- Coninutul celulei C3 se extinde prin tragere peste domeniul C4:C13;
Fig.11.7.2.
11.7.2.3. Crearea diagramei funciei
Diagrama funciei se creaz n mod obinuit, ca i la celelalte aplicaii, prin selectarea
domeniului B3:C13, lansarea comenzii Insert>Chart i selectarea tipului Scatter, subtipul
Compares pairs of values, iar la sfritul procedurii de creare (pasul 4), se selecteaz As
object in Sheet1 (n loc de Sheet2 cum propune EXCEL, deoarece selecia datelor a fost
fcut n foaia Sheet2).
Aa cum a fost creat diagrama afieaz numai punctele date. Pentru a afia i o curb
conform cu ecuaia de gradul trei se procedeaz astfel:
- Se aplic un clic pe unul dintre punctele diagramei;
- Se aplic comanda Chart>Add Trendline;
- n cutia de dialog Add Trendline se selecteaz pagina Type n care se opteaz pentru
tipul Polynomial, Order=3, dup care se selecteaz pagina Options de unde se bifeaz
opiunea Display equation on chart i se apas butonul OK.
Ca urmare, diagrama va cpta aspectul din figura 11.7.2.
11.7.2.4. Determinarea soluiilor din intervalul de definiie
Ca urmare a afirii curbei funciei, devine vizibil modul ei de variaie i se pot observa
locurile n care ea intersecteaz axa ox, deci locurile unde se gsesc soluiile din interval.
Desigur, observaia vizual este aproximativ i se pune problema determinrii soluiilor cu o
aproximaie mai bun.
n acest scop se procedeaz astfel:
- Celula E6 din foaia Sheet2 se denumete x0 iar celula E7 din aceeai foaie se denumete fx0;
- n celula x0 se introduce o valoare oarecare, de exemplu -1;
- n celula fx0 se introduce formula coefa*x0^3+coefb*x0^2+coefc*x0+coefd
- Se selecteaz celula fx0;
- Se aplic comanda Tools>Goal Seek;
- n cutia de dialog Goal Seek se verific dac n cmpul Set Cell este nscris referina
268
celulei fx0, adic E7. Dac nu, se face un clic pe aceast celul pentru a o selecta;
- Se aplic un clic n cmpul To value din cutia Goal Seek, pentru a-l activa, i apoi se
scrie valoarea 0;
- Se aplic un clic de activare n cmpul By changing cell, apoi se selecteaz celula x0
(adic E6);
- Se apas butonul OK. Dup scurt timp apare cutia de dialog Goal Seek Status care
raporteaz gsirea (sau nu) a unei soluii aproximative i valoarea lui f(x) pentru acea soluie.
Pentru a accepta soluia gsit se apas butonul OK.
11.7.3. Automatizarea aplicaiei prin programare
11.7.3.1. Crearea elementelor de control
Pentru nceput, este necesar crearea

instrumentului de dialog ntre aplicaie
i utilizator sub forma unei cutii de
dialog, aa cum se observ din figura
11.7.3.
Pentru aceasta, n editorul de Visual
BASIC se creaz obiectul UserForm1
care va conine urmtoarele obiecte
menionate n ordinea creerii lor:
- un cadru de grup (Frame) cu
inscripia Coeficienti, n care se creaz:
= etichetele (Label) cu inscripiile
Fig.11.7.3.
a=, b=, c= i d=;
= cutiile de editare (TextBox) de
la dreapta etichetelor, cu rolul de a afia/prelua la/de la operator valorile coeficienilor
ecuaiei;
= butonul de comand (CommandButton) cu inscripia Aplicare coeficienti, care
introduce n document coeficienii dai de operator;
- un cadru de grup (Frame) cu inscripia Limite, n care se creaz:
= etichetele (Label) cu inscripiile X initial= i X final=;
= cutiile de editare (TextBox) de la dreapta etichetelor) cu rolul de a afia/prelua la/de la
operator limitele intervalului [xin, xfin] al funciei;
= butonul de comand (CommandButton) cu inscripia Aplicare limite, care introduce
n document limitele indicate de operator;
- eticheta (Label) cu inscripia Solutie de start (X0):;
- cutia de editare (TextBox) de sub etichet, pentru a afia/prelua la/de la operator valoarea
soluiei obinute anterior/dat de operator ca valoare de pornire;
- butonul de comand (Command Button) cu inscripia Rezolvare, care apeleaz procedura
de rezolvare Goal Seek;
- cadrul de grup (Frame) cu inscripia Retine solutia, care va conine:
= butonul de opiune (OptionButton) cu inscripia Da;
= butonul de opiune (OptionButton) cu inscripia Nu;
- butonul de comand (CommandButton) cu inscripia Iesire, cu rolul nchiderii cutiei de
dialog;
Dup crearea acestor elemente de control se trece la ajustarea proprietilor lor la valorile
necesitate de aplicaie, conform tabelului de mai jos:
269
Tip de obiect
Denumire
(Name)
UserForm1
Cutia de dialog
(Userform)
Cadru de grup
Frame1
(Frame)
Etichete (Label) n Label1, Label2,
grupul Coeficienti Label3, Label4
Cutii de editare
(TextBox)
n
grupul Coeficienti
- prima
coef_a
- a doua
coef_b
- a treia
coef_c
- a patra
coef_d
Buton de comand
(CommandButton)
Aplic_coef
n
grupul
Coeficienti
Cadru de grup
Frame2
(Frame)
Etichete (Label)
Label5,
n grupul Limite
Label6,
Cutii de editare
(TextBox)
n
grupul Limite
- prima
x_in
- a doua
x_fin
Buton de comand
(CommandButton)
n grupul Limite
Etichet (Label)
Cutie de editare
(TextBox)
Buton de comand
(CommandButton)
Cadru de grup
(Frame)
Butoane de opiune
(OptionButton) n
grupul
Retine
solutia
- primul
- al doilea
Buton de comand
(CommandButton)
Aplic_lim
Label7
x_start
Rezolvare
Frame3
retine_da
retine_ne
Iesire
(Proprietile nemenionate rmn la valorile prestabilite)
Caption=Cautare solutii, Height=158, Width=276
Caption=Coeficienti, Height=128, Width=95

Caption: a=, b=, c= i d=, Height=14, Width=15
Height=16, Width=58
Caption= Aplicare Coeficienti, Accelerator= C,

Height=27, Width=82
Caption=Limite, Height=55, Width=164
Caption: X initial= i X final=, Height=14, Width=35
Height=16, Width=58
Caption=Aplicare Limite, Accelerator=L, Height=36,

Width=54
Caption=Solutie de start (X0):, Height=14, Width=80
Height=16, Width=76
Caption=Rezolvare,
Accelerator=R,
Height=25,
Width=76
Caption=Retine solutia, Height=32, Width=76
Caption=Da, Accelerator=D, Height=16, Width=27

Caption=Nu, Accelerator=N, Height=16, Width=27
Caption=Iesire, Accelerator=e, Height=25, Width=76
270
11.7.3.2. Crearea modulelor de program

n foaia privat a obiectului UserForm1 se creaz subrutinele private urmtoare. Crearea
lor se face, ca i n 11.6 prin selectarea obiectului, aplicarea comenzii View>Code, i
completarea cu instruciunile necesare a intrrii de subrutin creat automat. Face excepie
subrutina urmtoare care trebuie scris manual n foaia privat:
Private Sub userform_Initialize()
coef_a.Text = Range("coefa").Text
coef_b.Text = Range("coefb").Text
coef_c.Text = Range("coefc").Text
coef_d.Text = Range("coefd").Text
x_in.Text = Range("xin").Text
x_fin.Text = Range("xfin").Text
x_start.Text = Range("x0").Text
End Sub
Aceast subrutin are rolul de a pregti cutia de dialog nainte de a fi afiat. Ea efectueaz
urmtoarele aciuni:
- Atribuie obiectului cutie de editare coef_a valoarea de tip text culeas din celula coefa
din foaia Sheet2;
- Atribuie obiectului cutie de editare coef_b valoarea de tip text culeas din celula coefb
din foaia Sheet2;
- Atribuie obiectului cutie de editare coef_c valoarea de tip text culeas din celula coefc
din foaia Sheet2;
- Atribuie obiectului cutie de editare x_in valoarea de tip text culeas din celula xin din
foaia Sheet2;
- Atribuie obiectului cutie de editare x_fin valoarea de tip text culeas din celula xfin din
foaia Sheet2;
- Atribuie obiectului cutie de editare x_start valoarea de tip text culeas din celula x0 din
foaia Sheet2.
Private Sub Aplic_coef_Click()
ca = coef_a.Text
cb = coef_b.Text
cc = coef_c.Text
cd = coef_d.Text
If Not (IsNumeric(ca) And IsNumeric(cb) And IsNumeric(cc) And IsNumeric(cd)) Then
MsgBox "Coeficienti gresiti!", vbExclamation, "Eroare"
Exit Sub
End If
Range("coefa").Value = Val(ca)
Range("coefb").Value = Val(cb)
Range("coefc").Value = Val(cc)
Range("coefd").Value = Val(cd)
End Sub
Aceast subrutin trateaz evenimentul produs prin clic pe butonul cu inscripia Aplicare
Coeficienti i efectueaz urmtoarele aciuni:
- Atribuie variabilelor de tip Variant ca, cb, cc i cd valorile de tip text extrase din cutiile
de editare coef_a, coef_b, coef_c i coef_d;
- Testeaz dac nu toate textele preluate au semnificaie numeric i n acest caz afieaz
un mesaj de eroare i foreaz ieirea din subrutin fr alte efecte;
- Dac toate textele preluate au semnificaie numeric ele sunt convertite n valori numerice
271
(prin funcia Val) i sunt introduse n celulele coefa, coefb, coefc i coefd din foaia Sheet2.
Private Sub Aplic_lim_Click()
xi = x_in.Text
xf = x_fin.Text
If Not (IsNumeric(xi) And IsNumeric(xf)) Then
MsgBox "Limite gresite!", vbExclamation, "Eroare"
Exit Sub
Else
xi=Val(xi)
xf=Val(xf)
If (xi > xf) Or (xi = xf) Then
MsgBox "Limite gresite!", vbExclamation, "Eroare"
Exit Sub
End If
End If
Range("xin").Value = xi
Range("xfin").Value = xf
Range("x0").Value = 0.5 * (xi + xf)
x_start.Text = CStr(Range("x0").Value)
End Sub
Aceast subrutin trateaz evenimentul produs prin clic pe butonul cu inscripia Aplicare
Limite i efectueaz urmtoarele aciuni:
- Atribuie variabilelor de tip Variant xi i xf valorile de tip text preluate din cutiile de
editare x_in i x_fin;
- Testeaz dac nu toate textele preluate au semnificaie numeric i n acest caz afieaz
un mesaj de eroare i foreaz ieirea din subrutin fr alte efecte;
- Dac toate textele preluate au semnificaie numeric, ele sunt convertite la valoare
numeric i se testeaz dac nu cumva, din greeal, s-a introdus xi > xf, situaie n care este
afiat un mesaj de eroare i se foreaz ieirea din subrutin fr alte efecte;
- Dac nu s-a detectat nici una dintre erorile de mai sus, valorile preluate sunt introduse n
celulele xin, i xfin din foaia Sheet2;
- Se calculeaz media valorilor introduse ca limite i rezultatul este introdus n celula x0
din foaia Sheet2;
- Valoarea din celula x0 din foaia Sheet2 este atribuit prin convertire la forma text cutiei
de editare x_start.
Private Sub Rezolvare_Click()
If Not (IsNumeric(x_start.Text)) Then
MsgBox "Valoare gresita!", vbExclamation, "Eroare"
x_start.Text = CStr(Range("x0").Value)
Exit Sub
End If
sol_anter = Range("x0").Value
preciz = Application.MaxChange
Range("x0").Value = Val(x_start.Text)
Range("fx0").GoalSeek Goal:=0, ChangingCell:=Range("x0")
rezult = Abs(Range("fx0").Value)
If (rezult > preciz) Then
MsgBox "Nu s-a gasit solutia!", vbExclamation, "Atentie!"
Else
MsgBox ("Solutia gasita este x=" & Range("x0")), vbOKOnly, "Raport"
272
If retine_nu.Value = True Then

Range("x0").Value = sol_anter
Else
x_start.Text = Range("x0").Value
End If
End If
End Sub
Aceast subrutin trateaz evenimentul clic pe butonul cu inscripia Rezolvare i

efectueaz urmtoarele aciuni:
- Se testeaz dac textul din cutia de editare x_start este lipsit de semnificaie numeric i,
n acest caz, este afiat o cutie de dialog cu un mesaj de eroare, textul scris de utilizator este
nlocuit cu valoarea numeric din celula x0 a foii Sheet2 convertit la forma text i se foreaz
ieirea din subrutin fr alte efecte;
Dac textul din cutia de editare are semnificaie numeric urmeaz urmtoarele aciuni:
- Variabila sol_anter preia valoarea din celula x0 a foii Sheet2;
- Variabila preciz ia valoarea setrii Maximum Change din cutia de dialog Options,
pagina Calculation a programului EXCEL, stabilit ca nivel de precizie a calculelor;
- Celula x0 a foii Sheet2 primete valoarea de conversie la forma numeric a textului
extras din cutia de editare x_start;
- Se declaneaz procedura Goal Seek descris mai nainte, prin instruciunea
corespunztoare;
- Variabila rezult primete valoarea absolut din celula fx0 a foii Sheet2, rezultat din
procedura Goal Seek;
- Rezultatul obinut se compar cu precizia impus. Dac el este mai mare se afieaz o
utie de mesaj care avertizeaz c nu a fost gsit soluia;
- Dac rezultatul obinut este mai mic dect precizia impus, se afieaz o cutie cu un
mesaj care anun gsirea soluiei i valoarea ei;
- Dac valoarea butonului de opiune pentru nereinerea soluiei (retine_nu) este 1 (a fost
bifat), atunci celula x0 din foaia Sheet2 i recapt coninutul dinaintea rezolvrii, altfel l
primete pe cel provenit din rezolvare.
Private Sub Iesire_Click()
Unload UserForm1
End Sub
Aceast subrutin produce numai nchiderea cutiei de dialog.

n foaia de module generale Module1 se scrie subrutina necesar afirii cutiei de dialog:
Load UserForm1
UserForm1.Show
End Sub
11.7.4. Asamblarea aplicaiei

n sfrit, n foaia Sheet1 se creaz butonul Rezolvare folosind cutia cu instrumente
Forms i se asociaz cu subrutina Afisare_Dialog.
11.7.5. Protecia aplicaiei
Pentru protejarea datelor i formulelor din foaia Sheet2, aceasta se va ascunde (Hide), iar
pentru protejarea formulelor de referire din foaia Sheet1 aceasta se va proteja (Protect Sheet).
Aplicaia este acum gata de utilizare.
273
Fig.11.7.4.
11.7.6. Observaii finale
Aa cum a fost definit funcia ca una analitic sub forma unui polinom de gradul al
treilea, funcia aproximat prin facilitatea Trend Line coincide cu cea original i, ca urmare,
curba funciei aproximate trece prin punctele funciei original.
ntr-un caz oarecare, cnd funcia original este definit printr-un set de puncte luate la
ntmplare, sau provenite din msurtori efectuate asupra unei mrimi fizice care, fie nu este
modelabil printr-un polinom de gradul trei, fie este marcat de erori de msurare, curba
funciei aproximate trece printre punctele funciei originale aa cum se vede din figura 11.7.4.
11.8. Aplicaie la integrarea ecuaiilor difereniale prin metode Euler

11.8.1. Obiectivul lucrrii
n cele ce urmeaz vom exemplifica metodele Euler simpl i Euler predictor-corector.
Pentru a putea compara cele dou metode se va crea o diagram comun pentru cele dou
rezultate.
De asemenea, pentru o i mai bun comparaie, pe diagram se va reprezenta i ecuaia
analitic a funciei integrale.
S presupunem funcia: y = x 3 4 x avnd soluiile x =-2, x =0 i x =2. Derivata
1
funciei este:
y = f ( x, y ) = 3 x 2 4
Pentru nceput s presupunem c nu se cunoate y i se dorete determinarea lui folosind o
metod de integrare aproximativ pe un interval dat. Aceast metod va determina un set de
valori aproximative y asupra crora vom aplica o metod de aproximare pentru a determina
expresia funciei integrate i a o putea compara cu funcia analitic.
Se reamintesc formulele de integrare:
- Formula Euler simpl: yi = yi 1 + h f ( xi 1, yi 1 ) , h = xi xi 1
274
j
j 1
- Formula Euler predictor-corector: y i = y i 1 + 0.5 h f ( xi 1 , y i 1 ) + f xi , y i
unde i este indicele punctului curent iar j este indicele iteraiei curente.
Deoarece funcia dat f nu depinde de y, procedeul iterativ se rezum la un singur pas iar
formulele de integrare devin:
- Formula Euler simpl: yi = yi 1 + h yi 1 , h = xi xi 1
j
- Formula Euler predictor-corector: yi = yi 1 + 0.5 h[ yi 1 + yi ] , h = xi xi 1
Mersul lucrrii este dat mai jos.
11.8.2. Crearea aplicaiei
n foaia de calcul Sheet1 se creaz tabelul din figura 11.8.1.
Fig.11.8.1.
11.8.2.1. Completarea tabelului
- Se completeaz inscripiile tabelului;
- n domeniul C3:K3 se scriu valorile de discretizare a intervalului de definiie adoptat
(ntre -2 i 2);
- n celula C4 se introduce formula =3*C3^2-4 care, apoi, se extinde prin tragere peste
domeniul C4:K4;
- n celula C5 se introduce valoarea dat de condiia iniial Cauchy, adic 0;
- n celula D5 se introduce formula de intgrare Euler simpl =C5+(D3-C3)*D4 i apoi se
extinde prin tragere peste tot domeniul D5:K5;
- n celula C6 se introduce valoarea dat de condiia iniial Cauchy, adic 0;
- n celula D6 se introduce formula de integrare Euler predictor-corector =C6+0.5*(D3C3)*(C4+D4) care se extinde apoi prin tragere peste tot domeniul D6:K6;
- n celula C7 se introduce formula pentru y analitic, adic =C3^3-4*C3, care se extinde
apoi prin tragere peste tot domeniul C7:K7;
- n celula L7 se introduce formula =ABS(MAX(C7:K7)) pentru extragerea celei mai mari
valori din interval a funciei analitice, n valoare absolut;
- Folosind comanda Insert>Name>Define se atribuie celulei L7 numele maxy;
- n celula C8 se introduce formula =ABS(C5-C7)/maxy i se extinde apoi peste tot
domeniul C8:K8;
- n celula L8 se introduce formula =MAX(C8:K8);
- n celula C9 se introduce formula =ABS(C6-C7)/maxy i apoi se extinde peste tot
domeniul C9:K9;
275
- n celula L9 se introduce formula =MAX(C9:K9);

- n celula M8 se introduce formula =L8/L7. Se denumete aceast celul ereul0;
- n celula M9 se introduce formula =L9/L7. Se denumete aceast celul ereul1;
- Se selecteaz celulele M8 i M9. De pe bara de instrumente Formatting se acioneaz
butonul Percent Style i apoi se apas de dou ori butonul Increase Decimal pentru a se
produce afiarea sub forma procentual cu dou zecimale:
Fig.11.8.2.
Fig.11.8.3.
11.8.2.2. Crearea diagramei

Diagrama se creaz cu comanda Insert>Chart,
folosind ca serii de date domeniile C3:K3 pentru x,
C5:K5 pentru y obinut prin Euler simplu, C6:K6
pentru y obinut prin Euler predictor-corector i
C7:K7 pentru y analitic.
Tipul folosit este Scatter cu subtipul Compares
pairs of values.
Dup crearea diagramei, se folosete comanda Add
Trendline pentru a se crea aproximri polinomiale de
ordinul trei ale funciilor din diagram, cu opiunea de
afiare a ecuaiilor pe diagram.
Cu aceti parametri se creaz diagrama din figura
11.8.2, ca foaie de diagram distinct, cu numele Chart1.
11.8.3. Crearea unui instrument de informare

Pentru a se obine o posibilitate de selectare a informaiilor afiate de diagram se
procedeaz n urmtoarele etape:
11.8.3.1. Crearea unei cutii de dialog
- n editorul de Visual Basic se creaz obiectul UserForm1 cu inscripia Afisare ecuatii, care conine:
276
= un chenar de grup (Frame) cu inscripia Ecuatii;

= un buton de opiune (OptionButton) cu inscripia Euler simplu;
= un buton de opiune (OptionButton) cu inscripia Euler predictor-corector;
= o etichet (Label) n care se va afia ecuaia curbei de integralei de aproximare selectate;
= o etichet (Label) n care se va afia eroarea integralei de aproximare selectate;
= un buton (CommandButton) cu inscripia Terminare, pentru nchiderea cutiei de dialog.
Dup creare, aspectul cutie de dialog n rulare poate fi, la un moment dat, cel din figura 11.8.3.
Proprietile componentelor cutiei de dialog sunt prezentate n tabelul urmtor.
Tip de obiect
Cutia de dialog (Userform)

Cadru de grup (Frame)
Buton de opiune
(OptionButton)
Buton de opiune
(OptionButton)
Etichete
(Label)
n
grupul Ecuatii:
- prima
- a doua
Buton de comand
(CommandButton)
Denumire
(Name)
(Proprietile nemenionate rmn la valorile
prestabilite)
UserForm1 Caption=Afisare ecuatii, Height=194, Width=221
Frame1
Caption=Ecuatii, Height=133, Width=206
Euler_simp Caption=Euler simplu, Accelerator=s, Height=17,
Width=62
Euler_predcor Caption=Euler predictor-corector, Accelerator=p,
Height=17, Width=108
Ecuatie
Eroare
Terminare
Caption=ir vid (se terge coninutul iniial),

Font=Tahoma,
Regular,
12,
Height=24,
Width=188
Caption= Terminare, Accelerator= T, Height=27,
Width=92
11.8.4. Crearea subrutinelor obiectelor de interaciune

Prin metoda de selectare a obiectului de interaciune vizat i de acionare a comenzii
View>Code, se creaz intrrile pentru subrutinele private de tratare a evenimentelor i apoi se
completeaz prin scrierea aciunilor, conform listei de mai jos (excepie face subrutina de
initializare care se scrie complet manual):
Private Sub UserForm_Initialize()
Euler_simp.Value = True
With Application.Charts("Chart1")
.SeriesCollection(1).Trendlines(1).Border.Weight = xlThick
.SeriesCollection(2).Trendlines(1).Border.Weight = xlThin
.SeriesCollection(1).Trendlines(1).DataLabel.Font.Bold = True
.SeriesCollection(2).Trendlines(1).DataLabel.Font.Bold = False
End With
Ecuatie.Caption = _
Application.Charts("Chart1").SeriesCollection(1).Trendlines(1).DataLabel.Text
Eroare.Caption = "Eroare=" & Application.Worksheets("Sheet1").Range("ereul0").Text
End Sub
Aceast subrutin pregtete cutia de dialog n vederea afirii i efectueaz urmtoarele

aciuni:
- Activeaz n starea bifat butonul de opiune Euler_simp;
- Afieaz cu linie groas curba de aproximare prin metoda Euler simpl din diagrama
Chart1;
- Afieaz cu linie subire curba de aproximare prin metoda Euler predictor-corector din
diagrama Chart1;
277
- Afieaz cu caractere ngroate ecuaia curbei de aproximare prin metoda Euler simpl;
- Afieaz cu caractere obinuite ecuaia curbei de aproximare prin metoda Euler predictorcorector;
- Atribuie irul de text al ecuaiei curbei Euler simpl din diagrama Chart1 ca valoare a
proprietii inscripie (Caption) a etichetei Ecuatie;
- Atribuie irul de text al celulei ereul0 din foaia Sheet1 ca valoare a proprietii inscripie
(Caption) a etichetei Eroare;
Observaie: numele de obiect ale curbelor pot fi aflate n dou moduri:
- prin clic pe curba vizat n foaia de diagram i inspectarea coninutului cmpului de
afiare Name Box din stnga sus a ferestrei diagramei;
- efectund o nregistrare de macrocomand n care se aplic un clic de selecie pe curba
vizat i, eventual, se opereaz modificri de atribute de afiare, dup care se inspecteaz
textul surs al macrocomenzii n editorul de Visual Basic.
Private Sub Euler_simp_Click()
End With
Ecuatie.Caption = _
End Sub
Aceast subrutin trateaz evenimentul clic pe butonul de opiune Euler_simp efecund

aciunile urmtoare:
- Afieaz cu linie groas curba de aproximare prin metoda Euler simpl din diagrama
Chart1;
diagrama Chart1;
- Afieaz cu caractere ngroate ecuaia curbei de aproximare prin metoda Euler simpl;
- Atribuie irul de text al ecuaiei curbei Euler simpl din diagrama Chart1 ca valoare a
proprietii inscripie (Caption) a etichetei Ecuatie;
Private Sub Euler_predcor_Click()
End With
Ecuatie.Caption = _
End Sub
Aceast subrutin trateaz evenimentul clic pe butonul de opiune Euler_predcor

efecund aciunile urmtoare:
278
- Afieaz cu linie subire curba de aproximare prin metoda Euler simpl din diagrama
Chart1;
- Afieaz cu linie groas curba de aproximare prin metoda Euler predictor-corector din
diagrama Chart1;
- Afieaz cu caractere obinuite ecuaia curbei de aproximare prin metoda Euler simpl;
- Afieaz cu caractere ngroate ecuaia curbei de aproximare prin metoda Euler predictorcorector;
- Atribuie irul de text al ecuaiei curbei Euler predictor-corecctor din diagrama Chart1 ca
valoare a proprietii inscripie (Caption) a etichetei Ecuatie;
Private Sub Terminare_Click()
End With
Unload UserForm1
End Sub
Aceast subrutin trateaz evenimentul clic pe butonul de comand Terminare efecund

aciunile urmtoare:
- Afieaz cu linie subire curba de aproximare prin metoda Euler simpl din diagrama Chart1;
diagrama Chart1;
- Afieaz cu caractere obinuite ecuaia curbei de aproximare prin metoda Euler simpl;
- nchide cutia de dialog.
De asemenea, n vederea integrrii aplicaiei, n foaia de module Module1 se scriu
subrutina de apel a cutiei de dialog, i cele de comutare dintr-o foaie n alta (acestea din urm
pot fi i nregistrate):
Load UserForm1
UserForm1.Show
End Sub
Sub Selectare_Foaie()
End Sub
Sub Selectare_Diagrama()
End Sub
11.8.5. Integrarea aplicaiei

Pentru integrarea aplicaiei, cu ajutorul cutiei cu instrumente Forms se creaz butoanele
Afisare ecuatii (care se asociaz cu subrutina Afisare_Dialog), Comutare la diagram
(asociat cu Selectare_Foaie) i Comutare la tabel (asociat cu Selectare_Foaie).
Dac se dorete protecia datelor, se va renuna la butoanele de comutare, i se va crea un
singur buton Afisare ecuatii n foaia de diagram Chart1, iar foaia Sheet1 se va ascunde.
279
Cap.12. Aplicaii n FORTRAN

12.1. Calculul unei plutiri drepte folosind FORTRAN
Fig.12.1.1.
Fig.12.1.2
O plutire dreapt este linia de intersecie dintre un plan orizontal i carena navei. Mrimile
de calculat sunt:
Aria suprafeei plutirii:
Momentele de inerie:
2
= 2 ydx ; Centrul de greutate al plutirii: x =
xydx
F A
L
L
w
2 3
2
I x = y dx i I = 2 x ydx
y
3L
L
A
Metoda de calcul a unei integrale prin nsumare succesiv se bazeaz pe formula:

x i +1
i 1
x1
j =1
f (x )dx = A j + A i
12.1.2. Etape de lucru

1. Se va folosi mediul FORTRAN Salford PLATO n care se scrie urmtorul program n
format liber (free format) f95:
PROGRAM PLUTIRI
IMPLICIT NONE
INTEGER n, i
REAL, DIMENSION(100) :: x, y, f
CHARACTER(LEN=16) :: s1="Punctul: ", s2=" Abscisa x(", &
s3=" Semilatimea y(", s4=")="
REAL aw, xf, ix, iy, INTEGRARE
WRITE(*,"(A)",ADVANCE="NO") "Introduceti numarul de puncte al plutirii "
READ(*,*) n
WRITE(*,*) "Introduceti abscisele si semilatimile"
DO i=1,n
WRITE(*,100,ADVANCE="NO") s1, i, s2, i, s4
READ(*,*) x(i)
READ(*,*) y(i)
END DO
DO i=1,n
f(i)=y(i)
END DO
aw=2*INTEGRARE(n,x,f)
280
DO i=1,n;
f(i)=y(i)*x(i); END DO
xf=2*INTEGRARE(n,x,f)/aw
DO i=1,n;
f(i)=y(i)*y(i)*y(i); END DO
ix=2*INTEGRARE(n,x,f)/3
DO i=1,n;
f(i)=y(i)*x(i)*x(i); END DO
iy=2*INTEGRARE(n,x,f)
WRITE(*,*)"Aria plutirii
A=",
WRITE(*,*)"Abscisa centrului plutirii Xf=",
WRITE(*,*)"Momentul de inertie
Ix=",
Iy=",
100 FORMAT(A9,I3,A16,I3,A2)
END PROGRAM PLUTIRI
aw
xf
ix
iy
REAL FUNCTION INTEGRARE(n, x, f)

INTEGER n
REAL, DIMENSION(n) :: x,f
INTEGRARE=0
DO i=2,n
INTEGRARE=INTEGRARE+(x(i)-x(i-1))*(f(i)+f(i-1))/2
END DO
END FUNCTION INTEGRARE
Dup cum se observ, programul este scris integral ntr-un singur fiier. Vom salva acest
fiier sub numele de Plutiri.f95
Dup comenzile de compilare (Compile) i construcie (Build) se aplic comanda de rulare
(Start Run) i se obine afiarea de mai jos (unde sunt cuprinse i rspunsurile operatorului):
Introduceti numarul de puncte al plutirii 7
Introduceti abscisele si semilatimile
Punctul:
1 Abscisa x(
1)=0
Punctul:
1 Semilatimea y( 1)=0
Punctul:
2 Abscisa x(
2)=10
Punctul:
Punctul:
3 Abscisa x(
3)=20
Punctul:
Punctul:
4 Abscisa x(
4)=30
Punctul:
Punctul:
5 Abscisa x(
5)=40
Punctul:
Punctul:
6 Abscisa x(
6)=50
Punctul:
Punctul:
7 Abscisa x(
7)=60
Punctul:
Aria plutirii
A=
1000.00
Abscisa centrului plutirii Xf=
30.0000
Momentul de inertie
Ix=
33333.3
Momentul de inertie
Iy=
1.100000E+06
Press RETURN to close window ...
2. n a doua parte a lucrrii rescriem programul astfel nct s folosim i o procedur

SUBROUTINE, astfel:
PROGRAM PLUTIRI
IMPLICIT NONE
281
INTEGER n, i
REAL, DIMENSION(100) :: x, y
REAL aw, xf, ix, iy
READ(*,*) n
DO i=1,n
READ(*,*) x(i)
READ(*,*) y(i)
END DO
CALL CALCUL(n,x,y,aw,xf,ix,iy)
A=", aw
WRITE(*,*)"Abscisa centrului plutirii Xf=", xf
Ix=", ix
Iy=", iy
END PROGRAM PLUTIRI
SUBROUTINE CALCUL(n,x,y,aw,xf,ix,iy)
INTEGER n
REAL, DIMENSION(n) :: x, y, f
REAL aw, xf, ix, iy, INTEGRARE
DO i=1,n
f(i)=y(i)
END DO
DO i=1,n;
DO i=1,n;
DO i=1,n;
END SUBROUTINE CALCUL
INTEGER n
INTEGRARE=0
DO i=2,n
END DO
Acest fiier l vom salva sub numele de Plutiri_1.f95

3. n a treia parte a lucrrii vom transforma prima aplicaie Plutiri.f95, restructurnd-o ca un
proiect. Rostul acestei modificri este de a face disponibil modulul de calcul de integrare i pentru
alte aplicaii. Acest proiect numit Calc_Plut.ftn95p va conine dou fiiere:
Fiierul program principal Plutiri_2.f95, cu componena de mai jos:
PROGRAM PLUTIRI
USE CALCUL
282
IMPLICIT NONE
INTEGER n, i
REAL, DIMENSION(100) :: x, y, f
REAL aw, xf, ix, iy
READ(*,*) n
DO i=1,n
READ(*,*) x(i)
READ(*,*) y(i)
END DO
DO i=1,n
f(i)=y(i)
END DO
DO i=1,n;
DO i=1,n;
DO i=1,n;
A=", aw
Ix=", ix
Iy=", iy
END PROGRAM PLUTIRI
i fiierul de modul Calc_intg.f95, cu componena urmtoare:

MODULE CALCUL
IMPLICIT NONE
CONTAINS
INTEGER n
INTEGRARE=0
DO i=2,n
END DO
END MODULE CALCUL
4. O alt mbuntire posibil a proiectului este includerea datelor de intrare ntr-un fiier
de includere care s poat fi modificat separat de restul aplicaiei. Aceasta nu exclude fazele
de recompilare i reconstrucie. Proiectul va conine acum urmtoarele componente:
Fiierul program principal Plutiri_3.f95 care conine:
PROGRAM PLUTIRI
USE CALCUL
INCLUDE 'DATE_XY.inc'
283
INTEGER i
REAL, DIMENSION(100) :: f
REAL aw, xf, ix, iy
WRITE(*,*) "Numarul de puncte al plutirii este n=",n
WRITE(*,*) "Abscisele si semilatimile sunt:"
DO i=1,n
WRITE(*,100) s1, i, s2, i, s4, x(i)
WRITE(*,100) s1, i, s3, i, s4, y(i)
END DO
DO i=1,n
f(i)=y(i)
END DO
DO i=1,n;
DO i=1,n;
DO i=1,n;
A=", aw
Ix=", ix
Iy=", iy
100 FORMAT(A9,I3,A16,I3,A2,F10.3)
END PROGRAM PLUTIRI
Fiierul Calc_intg.f95 nemodificat.

Fiierul de includere DATE_XY.INC:
IMPLICIT NONE
INTEGER :: n=7
REAL, DIMENSION(7):: x
DATA x /0.0,10.0,20.0,30.0,40.0,50.0,60.0/
REAL, DIMENSION(7):: y
DATA y /0.0,10.0,10.0,10.0,10.0,10.0,0.0/
12.2. Lucrul cu fiiere n FORTRAN

Se cere preluarea valorilor numerice scrise ntr-un fiier, ordonarea lor n sens cresctor i
scrierea lor ntr-un alt fiier. Se va folosi mediul FORTRAN Salford PLATO.
1. Folosind Notepad se va scrie un fiier denumit Numere.txt al crui coninut este
urmtoarea succesiune de valori numerice reale:
11.2
253.45
3.456
5.021
0.12
2. n mediul Plato se creaz programul Ordon_fis.f95 cu urmtorul coninut:
284
PROGRAM ORDONARE
INTEGER :: nunit=1,NRECR,STARE,I
REAL VALOARE
LOGICAL :: CITIRE=.TRUE.
REAL, ALLOCATABLE :: V(:)
OPEN(UNIT=nunit,FILE='Numere.txt',ACTION='READ')
NRECR=0
DO WHILE (CITIRE)
READ(UNIT=nunit,FMT='(F20.6)',IOSTAT=STARE)VALOARE
IF(STARE==-1) THEN
CITIRE=.FALSE.
ELSE
NRECR=NRECR+1
END IF
END DO
ALLOCATE (V(NRECR))
REWIND(UNIT=nunit)
DO I=1,NRECR
READ(UNIT=nunit,FMT='(F20.6)')V(I)
END DO
CALL ORD_NUM(NRECR,V)
OPEN(UNIT=nunit,FILE='Num_ord.txt',ACTION='WRITE')
REWIND(UNIT=nunit)
DO I=1,NRECR
WRITE(UNIT=nunit,FMT='(F20.6)') V(I)
END DO
CLOSE(UNIT=nunit)
DEALLOCATE(V)
END PROGRAM ORDONARE
SUBROUTINE ORD_NUM(N,V)
DIMENSION :: V(N)
REAL A
INTEGER I,J
DO I=1,N-1
DO J=I+1,N
IF(V(I)>V(J)) THEN
A=V(I)
V(I)=V(J)
V(J)=A
END IF
END DO
END DO
END SUBROUTINE ORD_NUM
Semnificaiile notaiilor folosite n program sunt urmtoarele:

n programul principal:
nunit numr de unitate, este un numr atribuit fiierului cu care se lucreaz (1...99)
NRECR numr de nregistrri citite
STARE variabil care preia valoarea indicatorului de intrare/ieire IOSTAT i care la
citirea dintr-un fiier are valoarea 1 dac s-a atins sfritul fiierului
I indice de contorizare a ciclurilor DO sau indice de tablou
VALOARE variabil care stocheaz valoarea numeric citit din fiier
CITIRE variabil logic creia i se va atribui valoarea .FALSE. n momentul atingerii
285
sfritului de fiier
V vector (tablou unidimensional) destinat s stocheze valorile reale citite din fiier.
Iniial dimensiunea lui este neprecizat i este declarat alocabil. Dup contorizarea numrului
de nregistrri citite tabloului i se aloc spaiul necesar
n subrutin:
N dimensiunea tabloului V
A variabil real auxiliar necesar interschimbului de valori ntre valoarea anterioar i
cea curent atunci cnd se constat c V(I) este mai mare dect V(J)
I, J indici de contorizare a ciclurilor DO sau indici de tablou
Aciunile efectuate de program sunt urmtoarele:
- se deschide fiierul Numere.txt i este citit cte o nregistrare. De cte ori acest lucru
poate avea loc se incrementeaz variabila NRECR
- se redeschide fiierul Numere.txt i este citit cte o nregistrare, de data aceasta valorile
citite fiind pe rnd memorate n vectorul V
- se nchide fiierul Numere.txt
- se apeleaz subrutina de reordonare a vectorului V
- se deschide fiierul Num_ord.txt
- se scriu una cte una valorile vectorului V n acest fiier
- se nchide fiierul
3. Verificarea rezultatului obinut
Folosind Notepad se deschide fiierul Num_ord.txt
Dac programul a funcionat corect trebuie s vedei urmtorul coninut:
0.120000
3.456000
5.021000
11.200000
253.449997
Observaie: s-a luat precauia de a indica drept format de citire formatul F20.6 care este
acoperitor pentru valorile scrise n fiierul de date de intrare. Altfel citirea ar fi fost
defectuoas.
Observaie: Fortran nu folosete mecanismul de copiere a argumentelor procedurilor
(funcii i subrutine) ci lucreaz direct cu adresele de memorie ale argumentelor. Aceasta
nseamn c orice modificare a valorilor argumentelor transmise se reflect n programul
principal dup revenirea din procedur. n aplicaia de fa acest lucru a fost favorabil
deoarece ne-a permis s reordonm valorile vectorului V i ele s rmn reordonate la
revenirea din subrutina Ord_num fr alte eforturi suplimentare. n mod normal ns aceast
nsuire este considerat o nclcare a principiului ncapsulrii datelor statuat de principiile
ingineriei programrii i trebuie tratat cu precauii suplimentare dac acest efect de
vizibilitate n exterior nu este dorit. n acest scop se va proceda la efectuarea explicit de copii
ale argumentelor n interiorul procedurii.
12.3. Conversia datelor ntre fiiere n FORTRAN

n lucrarea anterioar fiierul de date din care se citea avea o structur foarte simpl,
fiecare nregistrare coninnd numai o singura valoare scris n formatul F, iar citirea din fiier
se realiza cu un format acoperitor.
286
Din nefericire lucrurile sunt mai complicate, n practic existnd posibilitatea citirii din
fiiere cu mai multe date numerice n cadrul aceleiai nregistrri, iar tipurile datelor numerice
pot diferi ntre ele. Mai mult, separaia datelor n cadrul unei nregistrri poate avea loc printrun numr oarecare de spaii (blank-uri).
Pentru a nu complica prea mult lucrurile vom restrnge aplicaia la cazul preluarii de date
dintr-un fiier n care sunt scrise date n format F (real) i I (integer), i care poate avea i
rnduri libere. Datele preluate vor fi scrise ntr-un nou fiier care va realiza separaia datelor
printr-un singur spaiu i va elimina rndurile goale. Se va folosi mediul FORTRAN Salford
PLATO.
1. Folosind Notepad se va scrie un fiier denumit Num_div.txt al crui coninut este cel de
mai jos. Acolo unde apar caracterele b se va tasta cte un spaiu pentru fiecare caracter.
bbbbbbbb11bbb-235.2346bb1
1.23b253.45
bbbb3.456bbbbb0.12b0.0
-5.021
bbb0.12bb1.0
2. n mediul Plato se creaz proiectul IOFile.ftn95p cu urmtoarea componen:

Fiierul program principal Citire_din_fis.f95 care conine instruciunile urmtoare:
PROGRAM CONVERSIE
USE EVALUARE
IMPLICIT NONE
INTEGER :: nunit1=1,nunit2=2,stare,i,nval,ncr
CHARACTER(LEN=100) rand,sir_frm,frm_rand,CNUM
LOGICAL :: CIT_FIS=.TRUE.
REAL, ALLOCATABLE :: vector(:)
OPEN(UNIT=nunit1,FILE='Num_div.txt',ACTION='READ')
OPEN(UNIT=nunit2,FILE='Num_div.tmp',ACTION='READWRITE')
REWIND(UNIT=nunit2)
DO WHILE (CIT_FIS)
READ(UNIT=nunit1,FMT='(A)',IOSTAT=stare)rand
IF(STARE==-1) THEN
CIT_FIS=.FALSE.
ELSE
IF (LEN_TRIM(rand)==0) THEN
CONTINUE
ELSE
CALL EVAL_RAND(rand,nval,sir_frm)
frm_rand="(A"//CNUM(LEN_TRIM(rand(2:)))
ncr=LEN_TRIM(frm_rand)
frm_rand(ncr+1:)=')'
WRITE(UNIT=nunit2,FMT=frm_rand)rand(2:)
END IF
END IF
END DO
CLOSE(UNIT=nunit1)
CLOSE(UNIT=nunit2)
OPEN(UNIT=nunit1,FILE='Num_div.tmp',ACTION='READ')
OPEN(UNIT=nunit2,FILE='Num_noi.txt',ACTION='WRITE')
!Obs.1
!Obs.2
!Obs.3
!Obs.4
!Obs.5
!Obs.6
!Obs.7
!Obs.8
!Obs.9
!Obs.10
287
CIT_FIS=.TRUE.
!Obs.11
DO WHILE (CIT_FIS)
READ(UNIT=nunit1,FMT='(A)',IOSTAT=stare)rand
!Obs.12
IF(STARE==-1) THEN
CIT_FIS=.FALSE.
!Obs.13
ELSE
CALL EVAL_RAND(rand,nval,sir_frm)
!Obs.14
BACKSPACE(UNIT=nunit1)
!Obs.15
ALLOCATE(vector(nval))
!Obs.16
READ(UNIT=nunit1,FMT=sir_frm,IOSTAT=stare)(vector(i),i=1,nval)
WRITE(UNIT=6,FMT=sir_frm)(vector(i),i=1,nval)
!Obs.17
WRITE(UNIT=nunit2,FMT=sir_frm)(vector(i),i=1,nval)
DEALLOCATE(vector(nval))
!Obs.18
NULLIFY(vector)
END IF
END DO
CLOSE(UNIT=nunit1)
!Obs.19
CLOSE(UNIT=nunit2)
END PROGRAM CONVERSIE
Fiierul modul Evaluare.f95 care conine instruciunile urmtoare:

MODULE EVALUARE
IMPLICIT NONE
CONTAINS
SUBROUTINE EVAL_RAND(rand,nval,sir_frm)
CHARACTER(LEN=100) TRIM@,TRIM,rand,rezerva,sir,sir_frm
CHARACTER(LEN=10) frm
CHARACTER c
CHARACTER(LEN=2) CNUM
LOGICAL prim
INTEGER i,ip,lsir,nval,ncar,nct,ncarrand
sir_frm="("
rand=TRIM@(rand)
rand=TRIM(rand)
lsir=LEN_TRIM(rand)
rand(lsir+1:)=' '
sir=""
ncarrand=LEN_TRIM(rand)+1
i=0
nval=0
DO WHILE (ncarrand>0)
i=i+1
c=rand(1:1)
IF(c==' ') THEN
nval=nval+1
rand=TRIM@(rand)
ncarrand=LEN_TRIM(rand)
ELSE
sir(1:i+1)=sir(1:i)//c
rand(1:)=rand(2:)
END IF
END DO
rand=sir
!Obs.20
!Obs.21
!Obs.22
!Obs.23
!Obs.24
!Obs.25
288
rezerva=sir
rand=TRIM@(rand)
sir=""
ncar=0
i=0
prim=.TRUE.
DO WHILE (ncarrand>0)
i=i+1
c=rand(1:1)
IF(c==' ') THEN
ip=SCAN(sir,'.')
IF(ip==0) THEN
lsir=LEN_TRIM(sir)
ip=lsir+1
sir(1:lsir+1)=sir(1:lsir)//'.'
ncar=ncar+1
END IF
IF(prim) THEN
nct=ncar
ELSE
nct=ncar+1
END IF
frm='F'//CNUM(nct)//'.'//CNUM(ncar-ip+1)
lsir=LEN_TRIM(sir_frm)
sir_frm(lsir+1:)=frm//','
prim=.FALSE.
sir=""
i=0
ncar=0
rand=TRIM(rand)
ELSE
ncar=ncar+1
sir(1:i+1)=sir(1:i)//c
rand(1:)=rand(2:)
END IF
END DO
lsir=LEN_TRIM(sir_frm)
sir_frm(lsir:)=')'
rand=rezerva
END SUBROUTINE EVAL_RAND
END MODULE EVALUARE
!Obs.26
!Obs.27
!Obs.28
!Obs.29
!Obs.30
!Obs.31
!Obs.32
!Obs.33
!Obs.34
!Obs.35
!Obs.36
!Obs.37

nunit1 numr de unitate atribuit fiierului din care se extrag date (nunit=1, pentru
Num_div.txt);
nunit2 numr de unitate atribuit unui fiier intermediar n care se scriu datele filtrate
(nunit=2, pentru Num_div.tmp);
stare variabil care preia valoarea indicatorului de intrare/ieire IOSTAT i care la citirea
dintr-un fiier are valoarea 1 dac s-a atins sfritul fiierului;
289
i indice de contorizare;
nval variabil reprezentnd numrul de valori cuprinse ntr-o nregistrare citit;
ncr numr de caractere folosit pentru a defini formatul de scriere a unui rnd n fiierul
intermediar (scrierea se face n formatul ir de caractere Ann unde nn este numrul de
caractere);
rand variabil ir de caractere cu lungimea maxim de 100 de caractere care memoreaz
o nregistrare (rand) extras din fiierul de citit i care se va scrie n fiierul intermediar;
sir_frm Descriptor de formate colectiv, este irul de caractere care descrie formatul
datelor numerice ale nregistrrii extrase;
frm_rand irul de caractere care descrie formatul n care nregistrarea extras va scris n
fiierul intermediar;
CNUM numele funciei Fortran Salford de conversie a unui numr ntreg n ir de
caractere;
CIT_FIS variabil logic descriind starea de citire din fiier i care poate fi .TRUE. cnd
poate avea loc citirea i .FALSE. cnd s-a atins sfritul de fiier i citirea trebuie s nceteze;
vector variabil tablou unidimensional destinat stocrii valorilor de tip real citite din
fiier. Iniial ea este declarat de lungime nedefinit dar alocabil, dimensiunea precizndu-se
ulterior dup citirea unei nregistrri, analiza ei i determinarea numrului de valori numerice
pe care le cuprinde;
n subrutina EVAL_RAND:
TRIM@ numele funciei Fortran Salford destinat s elimine spaiile goale (blank-uri)
din faa unui ir de caractere;
TRIM numele funciei Fortran Salford destinat s elimine spaiile goale (blank-uri) din
spatele unui ir de caractere;
rand aceeai semnificaie ca n programul principal. Comunicaia n Fortran dintre
programul principal i subrutine fcndu-se prin adrese aceast variabil este i ca zon de
memorie folosit aceeai cu cea folosit de programul principal;
rezerva variabil ir de caractere destinat s pstreze o copie a unui alt ir;
sir variabil de tip ir de caractere n care se preiau unul cte unul caracterele irului rand
extras din fiierul original, mai puin caracterele spaiu excedentare, cu completarea
numerelor ntregi cu caracterul punct, operaie n urma creia toate numerele citite vor deveni
de tip real;
sir_frm aceeai semnificaie ca n programul principal;
frm variabil de tip ir de caractere de cel mult 10 caractere lungime destinat s
memoreze un subir reprezentnd formatul unei valori (dat) din rndul de date extras.
Variabila sir_frm se va compune din concatenarea (alipirea) mai multor asemenea subiruri;
c variabil de tip monocaracter. Este folosit pentru a memora primul caracter extras din
irul rand, dup care irul rand este reconstruit eliminnd primul caracter. Astfel, rand va
conine tot mai puine caractere, pn la epuizare;
CNUM numele funciei Fortran Salford de conversie a unui numr ntreg n ir de
caractere;
prim variabil logic care are valoarea .TRUE. dac caracterul citit este primul din rand
i .FALSE. n caz contrar;
ip indicele de ordine al caracterului punct n irul sir. n a doua parte a subrutinei
EVAL_RAND sir va conine numai subirul corespunztor unei singure date din tot irul rand.
Dac ip=0 nseamn c numrul este scris fr punct zecimal (ca valoare ntreag) i i se va
aduga punctul zecimal. Dac ip este mai mare dect zero valoarea memorat n ip va fi folosit
290
ulterior la construirea irului descriptor de format pentru a se calcula numrul de cifre zecimale;
lsir lungimea subirului sir. Servete la calculul lungimii de scriere a formatului F care va
apare n irul descriptor de format;
nval numrul de valori (date) cuprinse de irul rand;
ncar numrul curent de caractere prelucrate la construirea unui subir;
nct numrul total de caractere coninut de un subir;
ncarrand numrul de caractere al irului rand;
Aciunile efectuate de program sunt urmtoarele (vezi observaiile marcate n textul surs):
Obs.1. Se deschide pentru citire fiierul Num_div.txt i pentru citire/scriere fiierul
Num_div.tmp;
Obs.2. Se redeschide fiierul Num_div.tmp pentru forarea plasrii indicatorului de poziie
la nceputul primei nregistrri;
Obs.3. Se iniiaz un ciclu de citire din fiierul Num_div.txt;
Obs.4. Se citete o nregistrare (rand) din fiierul Num_div.txt;
Obs.5. Dac s-a ntlnit sfritul de fiier se schimb valoarea CIT_FIS pe .FALSE.
Obs.6. Dac rndul este gol sau conine numai spaii goale (blank-uri) se trece la urmtorul
pas al ciclului;
Obs.7. Se apeleaz subrutina de evaluare a rndului extras. Ea primete ca argument
adresele irului nregistrrii extrase (rand) ale variabilei nval (numr de valori pe rnd) i
sir_frm (ir descriptor de formate). La terminarea execuiei subrutinei irul rand este curat
de spaiile excedentare iar nval i sir_frm conin datele rezultate din evaluare;
Obs.8. Se formeaz irul (frm_rand) descriptor de format de scriere de tip caracter a
rndului n fiierul intermediar Num_div.tmp. De exemplu, dac s-a extras nregistrarea:
bbbb3.456bbbbb0.12b0.0
variabila rand va avea, dup prelucrarea cu subrutina EVAL_RAND, forma

3.456b0.12b0.0
deci va conine 14 caractere. Ca urmare irul descriptor de format frm_rand va fi (A14). Cu

acest format va avea loc scrierea n fiierul intermediar. Calculul lungimii irului rand ine
cont de faptul c primul caracter din rnd este un spaiu;
Obs.9. Se nchid fiierele;
Obs.10. Se deschide din nou fiierul Num_div.tmp, de aceast dat numai pentru citire. Se
deschide un nou fiier Num_noi.txt pentru scriere. n acesta vor fi scrise aceleai valori ca i
pe ecran;
Obs.11. Se pune din nou variabila CIT_FIS pe .TRUE. i se iniiaz un nou ciclu de citire
din fiierul Num_div.tmp;
Obs.12. Se citete un rnd din fiierul Num_div.tmp;
Obs.13. Se constat terminarea citirii fiierului;
Obs.14. Se apeleaz subrutina de evaluare a rndului extras. De aceast dat, apelul este
necesar pentru a se extrage numrul de valori de pe rand;
Obs.15. Se revine pe nregistrarea anterioar (dup fiecare operaie de citire indicatorul de
poziie n fiier avanseaz automat la rndul urmtor aa nct este necesar revenirea);
Obs.16. Se aloc spaiul de memorie pentru nval poziii n tabloul unidimensional vector.
Se citete din nou rndul de aceast dat nu n format ir de caractere ci n formatul F
determinat de subrutina EVAL_RAND i stocat n variabila sir_frm;
Obs.17. Se scriu pe ecran (UNIT=6) cele nval valori ale vectorului. La aceast instruciune
s-a folosit UNIT=6 i nu notaia * deoarece aceasta din urm are nelesul de unitate
prestabilit care, n acest caz este unitatea nunit1. Notaia * semnific ecranul sau tastatura
numai la nceputul rulrii unui program care nc nu a fcut uz de operaii de intrare/ieire cu
291
fiiere. Pentru tastatur se folosete UNIT=5. Aceleai valori sunt scrise i n fiierul rezultat
Num_noi.txt;
Obs.18. Se dezaloc spaiile alocate elementelor tabloului vector ca i adresa de pointer a
tabloului vector;
Obs.19. Se nchide fiierul intermediar Num_div.tmp i fiierul rezultant Num_noi.txt;
Aciunile efectuate de subrutina EVAL_RAND sunt urmtoarele:
Obs.20. Se iniiaz irul descriptor de format sir_frm;
Obs.21. Se cur irul rand de spaiile goale de la nceput i de la sfrit i i se adaug un
singur spaiu gol la capt. Acest spaiu gol va semnaliza terminarea unui subir corespunztor
unei valori numerice;
Obs.22. Se iniiaz o variabil sir n care se vor transfera pe rnd caractere din irul rand.
Se determin ncarrand care reprezint numrul de caractere al rndului rand. Se iniiaz i=0
indicele de parcurgere a citirii caracterelor i nval=0 numrul de valori detectate;
Obs.23. Se iniiaz un ciclu care va dura ct timp vor mai fi caractere neparcurse n irul
rand, ciclu n cuprinsul cruia se analizeaz tot timpul primul caracter din irul rand;
Obs.24. Dac a fost ntlnit caracterul spaiu nseamn c s-a terminat un subir de
caractere care reprezint o valoare numeric, deci nval va fi incrementat, apoi se vor elimina
caracterele spaiu de la nceputul lui rand i se redetermin ncarrand. Dac nu, caracterul
ntlnit se va include n sir pe poziia i+1 iar din rand se elimin primul caracter. Dup
aceast etap sir nu va mai conine caractere spaiu excedentare (dou valori numerice vor fi
separate printr-un singur ir) i se va cunoate numrul de valori din ir, nval;
Obs.25. Se transfer irul sir n irul rand i n irul rezerva. Se elimin spaiile goale de la
nceputul lui rand (dac mai exist);
Obs.26. irul sir este iniializat din nou. Se determin numrul de caractere din irul rand.
Se iniializeaz ncar=0 i i=0. Variabila care indic citirea primului numr de pe rand se
iniializeaz la valoarea .TRUE.
Obs.27. Se iniiaz un ciclu de citire a irului rand, citindu-se mereu primul caracter al
rndului pn la epuizarea tuturor caracterelor. Indicele i este destinat s memoreze numrul
caracterului curent la citire. Caracterul c este primul caracter al lui rand;
Obs.28. Dac c este un spaiu nseamn c s-a terminat un subir numeric;
Obs.29. Indicele ip red poziia n care se gsete caracterul punct n subirul numeric;
Obs.30. Dac ip=0 subirul numeric nu conine caracterul punct i el va fi adugat subirului;
Obs.31. Dac are loc citirea primului subir numeric numrul total de caractere nct este cel
citit adic ncar, altefel este cu 1 mai mare. Aceast convenie este destinat s produc un ir
descriptor de formate care s includ spaiul separator n descriptoarele de formate ale
subirurilor numerice cu excepia primului subir;
Obs.32. Instruciune de formare a unui descriptor de format F. CNUM(nct) produce lungimea
cmpului de format iar CNUM(ncar-ip+1) produce lungimea cmpului rezervat zecimalelor;
Obs.33. Descriptorul de formate colectiv sir_frm este completat cu irul descriptor de
format individual i virgula separatoare de formate;
Obs.34. O dat ce aciunea de adugare a unui descriptor de format individual a avut loc, sa depit situaia de citire a primului subir numeric;
Obs.35. Se reiniiaz sir (un nou subir numeric va fi prelucrat), i=0 i ncar=0, din rand se
eleimin spaiul separator i se recalculeaz ncarrand;
Obs.36. Dac caracterul prim extras din rand nu este un spaiu, deci este un caracter
numeric, se incrementeaz numrul de caractere ncar al subirului sir, se adaug caracterul c
la subirul sir, se elimin primul caracter din rand i se recalculeaz numrul ncarrand de
caractere rmase n rand;
292
Obs.37. Se calculeaz lungimea total lsir a irului descriptor colectiv de formate sir_frm,
se adaug paranteza de nchidere a descriptorului colectiv de formate. Deoarece rand a suferit
transformri se readuce la starea de la citirea din fiierul intermediar prin preluarea
coninutului de la irul rezerva.
3. Verificarea rezultatului obinut
Folosind Notepad se deschide fiierul Num_div.tmp
11 -235.2346 1
1.23 253.45
3.456 -0.12 0.0
-5.021
0.12 1.0
Folosind Notepad se deschide fiierul Num_noi.txt

11. -235.2346 1.
1.23 253.45
3.456 -0.12 0.0
-5.021
0.12 1.0
12.4. Aplicaii interactive sub Windows n FORTRAN

Se va folosi mediul FORTRAN Salford PLATO. n acest mediu se afl integrat o bibliotec
de funcii i subrutine numit ClearWin+ destinat pentru a se crea aplicaii rulabile sub
Windows. Ca intenie, ea este destinat s ajute programatorul lipsit de timp n a crea aplicaii
Windows mai uor dect cu instrumentele Windows API oferite de MicroSoft. Dei pn la un
punct ClearWin satisface bine aceast cerin, ca orice instrument destinat s lucreze n condiii
complexe i aceast bibliotec este relativ complex i studierea tehnicilor de lucru i a
resurselor oferite de ea cere un timp apreciabil. Din acest motiv prezentm mai jos o aplicaie
dintre cele mai simple, cu scopul de a facilita un prim contact cu acest instrument.
Aplicaia const n desenarea unei diagrame a unei funcii polinomiale ptratice de forma:
y=ax2+bx+c
pe baza unor parametri constnd din: domeniul variabilei x i coeficienii a, b i c ai
polinomului.
Valorile acestor parametri vor putea fi modificate ntr-o cutie de dialog dup care se va
comanda afiarea diagramei funciei.
1. n mediul Plato se scrie programul cu urmtoarea componen:
WINAPP
PROGRAM GRAFIC
INCLUDE <windows.ins>
EXTERNAL afisare
INTEGER N, i, col, x0, x1, pas, a, b, c
REAL xin, xfin
COMMON /PARAM/ N,x0,x1,a,b,c
pas=1
N=101
xin=0
!Obs.1
xfin=10
x0=int(xin)
x1=int(xfin)
a=1
b=1
c=1
col=RGB@(225,125,0)
i=winio@('%ca[Parametri]%bg&',col)
i=winio@('%mn[&Comenzi[I&esire]]&','EXIT')
i=winio@('%fn[COURIER NEW]&')
i=winio@('%nlx0=%dd%il%10rd&',pas,-32000,x1-1,x0)
i=winio@('%nl%nlx1=%dd%il%10rd&',pas,x0+1,32000,x1)
i=winio@('%nl%nl a=%dd%il%10rd&',pas,-32000,32000,a)
i=winio@('%nl%nl b=%dd%il%10rd&',pas,-32000,32000,b)
i=winio@('%nl%nl c=%dd%il%10rd&',pas,-32000,32000,c)
i=winio@('%nl%cn%^bt[&Afisare]',afisare)
END PROGRAM GRAFIC
INTEGER FUNCTION afisare()
INCLUDE <windows.ins>
INTEGER N, i, col, x0, x1, a, b, c
DOUBLE PRECISION x(N),y(N)
REAL xin, xfin,dx
COMMON /PARAM/ N,x0,x1,a,b,c
xin=real(x0)
xfin=real(x1)
dx=(xfin-xin)/(N-1)
DO i=1,N
x(i)=xin+dx*(i-1)
y(i)=a*x(i)*x(i)+b*x(i)+c
END DO
col=RGB@(0,225,225)
i=winio@('%ca[Grafic polinom patratic]%bg&',col)
i=winio@('%pl[x_array]&',400,250,N,x,y)
i=winio@('%ff%nl%cn%bt[I&esire]')
afisare=1
END FUNCTION afisare
293
!Obs.2
!Obs.3
!Obs.4
!Obs.5
!Obs.6
!Obs.7
!Obs.8
!Obs.9
!Obs.10
!Obs.11
!Obs.12
!Obs.13
!Obs.14
!Obs.15
!Obs.16
!Obs.17

N numr de puncte cu care se va trasa diagrama funciei. A fost stabilit la 101 pentru a se putea
genera o curb din 100 de segmente liniare, numr suficient pentru a asigura o calitate bun imaginii;
i variabil ntreag n care se stocheaz rspunsul returnat de funcie winio@. Acest
rspuns nu este necesar n aceast aplicaie, dar sintaxa de apel a funciei trebuie respectat;
col variabil ntreag n care se stocheaz rspunsul funciei de culoare RGB@;
x0 limita inferioar (ntreag) a domeniului de variaie al variabilei x;
x1 limita superioar (ntreag) a domeniului de variaie al variabilei x;
a, b, c coeficienii polinomului (valori ntregi);
pas pasul (ntreg) de variaie al valorilor x0, x1, a, b i c;
xin limita inferioar (real) a domeniului de variaie al variabilei x;
xfin limita superioar (real) a domeniului de variaie al variabilei x;
RGB@ funcia din biblioteca ClearWin+ care genereaz codul de culoare din
294
componentele de culoare RED, GREEN, BLUE variind fiecare n intervalul 0...255;

winio@ funcia din biblioteca ClearWin+ care controleaz o mare parte dintre resursele
grafice Windows;
n funcia afisare:
N, col, x0, x1, a, b, c, xin, xfin aceleai semnificaii ca n programul principal;
x(N), y(N) vectorii valorilor (reale) x i y pentru fiecare punct al diagramei;
dx pasul (real) de generare a valorilor x(i);
col indice de culoere returnat de funcia RGB@.
RGB@ i winio@ aceleai semnificaii ca n programul principal;
Aciunile efectuate de program sunt urmtoarele (vezi observaiile marcate n textul surs):
Obs.1. Se declar blocul de de date comune PARAM;
Obs.2. Se genereaz culoarea de fond col a cutiei de dialog pentru controlul parametrilor;
Obs.3. Se genereaz o cutie de dialog. Codul de control %ca determin titlul Parametri iar
codul %bg determin fondul de culoare dat de variabila col;
Obs.4. Se genereaz un meniu (codul de control %mn) cu numele Comenzi i avnd
articolul Iesire care produce terminarea programului;
Obs.5. Se declar c fontul (codul %fn) va fi Courier New. Acesta a fost ales deoarece
toate caracterele lui au aceeai lime i se aliniaz perfect pe vertical, uurndu-se astfel
alinierea mai uoar a componentelor diferite ale ferestrei;
Obs.6. Se opereaz un salt la linie nou (codul %nl) i se scrie textul x0=. Se ataeaz un
spiner (dispozitiv de incrementare/decrementare codul %dd) ataat unei cutii de editare cu
lungimea de 10 caractere pentru numere ntregi (codul 10rd%) i creia i s-au impus ca limite
valorice inferioar i superioar (codul %il) valorile 32000 i x1-1. Spinerul poate produce
variaia lui x0 cu raia pas;
Obs.7. Se las un rnd gol (dou salturi new line %nl%nl) se scrie textul x1= i se creaz o
cutie de editare cu variator ntre limitele x0+1 i 32000 pentru variabila x1;
Obs.8. Idem pentru a ntre limitele 32000 i 32000;
Obs.9. Idem pentru b ntre limitele 32000 i 32000;
Obs.10. Idem pentru c ntre limitele 32000 i 32000;
Obs.11. Se opereaz saltul la linei nou, se comand centrarea elementelor (codul %cn) i
se creaz un buton standard (codul %^bt) cu inscripia Afisare. Prefixul ^ arat c apsarea
butonului produce apelul unei funcii i anume funcia afisare.
n funcia afisare:
Obs.12. Se declar c funcia vede variabilele din blocul de date comune PARAM;
Obs.13. Se calculeaz xin, xfin, dx x(i) i y(i);
Obs.14. Se genereaz codul de culoare col;
Obs.15. Se creaz cutia de dialog cu titlul Grafic polinom patratic cu culoarea de fond col;
Obs.16. Se genereaz o diagram de tip x_array (cu variaia dup axa x) cu 400 pixeli
lungime i 200 pixeli nlime, cu N puncte avnd coordonatele coninute n vectorii x i y;
Obs.17. Codul %ff (form feed) produce plasarea urmtorului element sub aria diagramei.
Codul %nl produce saltul la o linie nou pentru a lsa un rnd liber. Se centreaz (%cn) i se
genereaz un buton cu inscripia Ieire care, dat fiind c nu mai au loc i alte aciuni, la
apsare poduce nchiderea ferestrei;
Fig.12.4.1.
295
Fig.12.4.2.
2. Testarea funcionrii aplicaiei

Dup etapele de compilare i legare se lanseaz programul.
Dac s-a lucrat corect rularea lui decurge astfel:
La lansare se deschide cutia de dialog Parametri din figura 12.4.1.
Se pot ajusta valorile din cmpurile (cutiile) de editare manual sau folosind variatorul de
incrementare/decrementare. Cmpurile de editare trebuie s nu permit ieirea din limitele de
variaie impuse prin program.
La apsarea butonului Afiare se deschide fereastra Grafic polinom patratic din figura
12.4.2 care se nchide cu butonul Iesire, revenindu-se n cutia de dialog Parametri.
Din cutia de dialog Parametri se iese (i aplicaia ia sfrit) accesnd meniul Comenzi i
apoi submeniul Iesire.
Cap.13. Aplicaii n AutoLISP
296

Limbajul AutoLISP este implementat n AutoCAD cu scopul de a permite utilizatorului s
i creeze instrumente de lucru proprii. De aceea n continuare vom descrie cteva asemenea
utilitare simple.
13.1. Desenarea unor drapele folosind AutoLISP

13.1.1. Scrierea programului AutoLISP
Programul const n definirea unei funcii care va fi recunoscut ca o comand nou.
ncepnd de la AutoCAD 2000, mediul de lucru conine un mediu de editare n care se
intr cu comanda de meniu Tools/AutoLISP/Visual Lisp Editor.
Programul se va salva sub numele Drapele.Lsp i componena lui este dat mai jos:
(defun c:drapel (/ oldfill ok)
(command "ERASE" "ALL" "")
(setq lstnat (list "ROM" "FRA" "ITA")
rom (list "BLUE" "YELLOW" "RED")
fra (list "BLUE" "WHITE" "RED")
ita (list "GREEN" "WHITE" "RED")
drapele (list rom fra ita)
)
(command "LIMITS" '(0 0) '(8 5)) (command "ZOOM" "A")
(command "COLOR" "WHITE")
(setq sband (ssadd))
(command "SOLID" '(1 1) '(1 4) '(3 1) '(3 4)) (ssadd (entlast) sband)
(command '(5 1) '(5 4)) (ssadd (entlast) sband)
(command '(7 1) '(7 4) "") (ssadd (entlast) sband)
(setq oldfill (getvar "FILLMODE") ok nil)
(setvar "FILLMODE" 1)
(while (not ok)
(setq natiune (strcase (getstring "\nNatiunea ROMana/FRAnceza/ITAliana:")))
(if (setq ltrunc (member natiune (reverse lstnat))) (setq ok t))
)
(setq drapel (nth (1- (length ltrunc)) drapele) i 0)
(while (< i 3)
(command "CHANGE" (ssname sband i) "" "p" "c" (nth i drapel) "")
(setq i (1+ i))
)
(setvar "FILLMODE" oldfill)
(setq sband nil)
(terpri)
)
; Obs.1
; Obs.2
; Obs.3
; Obs.4
; Obs.5
; Obs.6
; Obs.7
; Obs.8
; Obs.9
; Obs.10
; Obs.11
; Obs.12
; Obs.13
; Obs.14
; Obs.15
; Obs.16
13.1.2. Explicaii privind funcionarea programului

Entitile folosite n program sunt urmtoarele:
lstnat este o list de iruri de caractere reprezentnd prescurtrile denumirilor naiunilor ale
cror drapele vor fi desenate;
rom, fra i ita sunt liste de iruri de caractere recunoscute de AutoCAD ca denumiri de
culori standard;
drapele este o list ale crei elemente sunt listele de culori pentru drapele;
sband este un set de selecie coninnd benzile (solidele) ale cror culori se modific;
297
oldfill este un atom care memoreaz starea variabilei de sistem FILLMODE;

ok este un indicator de stare cu valoare iniial nil care indic corectitudinea rspunsului
utilizatorului la cererea de specificare a numelui naiunii;

natiune este raspunsul operatorului la cererea de specificare a numelui naiunii;
Operaiile efectuate de program sunt cele menionate n observaiile nsoitoare:
Obs.1. tergerea tuturor entitilor din desen;
Obs.2. Se creaz listele lstnat, rom, fra, ita i drapele;
Obs.3. Se declar limitele desenului i ncadrarea n fereastr a cmpului definit de aceste limite;
Obs.4. Se declar culoarea curent de desenare;
Obs.5. Se iniiaz setul de selecie nou sband;
Obs.6. Se deseneaz benzile de culoare ale drapelelor, toate avnd culoarea alb;
Obs.7. Se memoreaz vechea stare a variabilei de umplere FILLMODE i se iniiaz ok la
valoarea nil;
Obs.8. Se schimb valoarea variabilei FILLMODE la 1 (afiarea umplerii este activat);
Obs.9. Se ruleaz un ciclu de cerere din partea utilizatorului a specificrii numelui naiunii;
Obs.10. Funcia getstring preia de la utilizator rspunsul la cerere. Funcia strcase
convertete rspunsul n litere mari. Atomul natiune memoreaz rspunsul;
Obs.11. Funcia reverse inverseaz lista lstnat. Funcia member returneaz lista inversat
lstnat ncepnd cu prima apariie a unui element identic cu rspunsul natiune. Lista ltrunc
memoreaz lista trunchiat. Dac lista ltrunc nu este vid ok ia valoarea t i ciclul se ncheie;
Obs.12. Funcia (1- (length ltrunc)) produce indicele de ordine al lui natiune n lista lstnat.
Ca urmare, funcia nth extrage din lista drapele sublista cu culorile drapelului corespunztor
i o atribuie simbolului drapel;
Obs.13. Se ruleaz un ciclu de schimbare a culorilor benzilor de culoare;
Obs.14. Se atribuie variabilei FILLMODE valoarea avut nainte de schimbare;
Obs.15. Se anuleaz setul de selecie sband;
Obs.16. Se efectueaz o ieire tcut, funcia terpri returnnd valoarea nil are ca efect
evitarea scrierii n ultima linie de comand a efectului ultimei evaluri.
13.1.3. ncrcarea i utilizarea programului
Pentru a se folosi programul acesta trebuie mai nti ncrcat. ncrcarea se face cu
comanda de meniu Tools/Load Application.
Dup ncrcare, n linia de comand AutoCAD se poart urmtorul dialog:
Command: drapel
Command:
Natiunea ROMana/FRAnceza/ITAliana: fra
Dup aceasta drapelul francez este desenat.
13.2. Calculul aproximativ al soluiilor unei ecuaii

i aici vom genera o funcie de comand. n acest caz se cere gsirea soluiilor ecuaiei:
y=sin x e-x cos x = 0
Se cunoate faptul c aceast ecuaie are o infinitate de soluii i c rezolvarea ei analitic
nu este posibil. De aceea, tiind c o putem rescrie sub forma:
sin x = e-x cos x
vom face uz de procedee grafice de determinare a punctelor de intersecie a graficelor
funciilor:
f(x)=sin x i
g(x)=e-x cos x
298
Programul AutoLISP necesar este urmtorul:

(defun fx (x /) (sin x))
(defun gx (x /) (* (exp (* -1 x))(cos x)))
(defun det_solutii (ns / pa1 pa2 pb1 pb2 pint oldcol lsol)
(setq oldcol (getvar "COLOR" )) (command "COLOR" "RED")
(setq lsol nil x1 0 dx 0.1 x2 dx)
(while (< (length lsol) ns)
(setq pa1 (list x1 (fx x1)) pa2 (list x2 (fx x2))
pb1 (list x1 (gx x1)) pb2 (list x2 (gx x2))
x1 (+ x1 dx) x2 (+ x2 dx)
)
(command "LINE" pa1 pa2 "") (command "LINE" pb1 pb2 "")
(if (setq pint (inters pa1 pa2 pb1 pb2))
(setq lsol (adent (car pint) lsol))
)
)
lsol
)
(defun adent (nou lst /) (reverse (append (list nou) (reverse lst))))
(defun c:solutii (/ nsol lsol i)
(command "ERASE" "ALL" "")
(initget 7)
(setq nsol (getint "\nCate solutii doriti:"))
(setq lsol (det_solutii nsol) i 0)
(write-line "\n")
(while (< i (length lsol))
(write-line (strcat "Solutia " (itoa (1+ i)) "=" (rtos (nth i lsol) 2 4 )))
(setq i (1+ i))
)
(terpri)
)
; Obs.1
; Obs.2
; Obs.3
; Obs.4
; Obs.5
; Obs.6
; Obs.7
; Obs.8
; Obs.9
; Obs.10
; Obs.11
; Obs.12
; Obs.13
; Obs.14
; Obs.15
; Obs.16
; Obs.17
; Obs.18
; Obs.19

Principiul de funcionare al programului este simplu: considernd dou valori ale variabilei
x, i anume x1 i x2, se calculeaz valorile funciilor f(x) i g(x) n aceste puncte i se
genereaz cte un segment de dreapt ca aproximare geometric pentru fiecare dintre cele
dou funcii. Punctele pa1 i pa2 delimiteaz segmentul de aproximare a funciei f(x) iar
punctele pb1 i pb2 pe cel al funciei g(x). Funcia AutoLISP inters returneaz punctul de
intersecie al celor dou segmente sau nil dac segmentele nu se intersecteaz.
Derularea programului are loc conform observaiilor nsoitoare, comentate mai jos.
Obs.1. Definirea funciei f(x)=sin x;
Obs.2. Definirea funciei g(x)=e-x cos x;
Obs.3. Definirea funciei de determinare a soluiilor. Parametrul primit de funcie este
numrul de soluii cerut ns;
Obs.4. Salvarea strii variabilei de sistem COLOR (culoarea curent de desenare) i
schimbarea valorii ei pe RED;
Obs.5. Iniializare: lista de soluii este vid, x1=0, dx=0.1 i x2=dx;
Obs.6. Se ruleaz un ciclu de determinare a soluiilor. Dac se va ncerca determinarea
soluiilor cu unei ecuaii cu numr de soluii finit i ns cerut va fi mai mare dect numrul
maxim de soluii pe intervalul x=0 ... x=infinit, programul va intra n bucl infinit;
Obs.7. Se creaz listele de coordonate pentru punctele pa1, pa2, pb1 i pb2, se
299
incrementeaz x1 i x2 cu dx;
Obs.8. Se traseaz segmentele funciilor;
Obs.9, 10. Se determin punctul de intersecie al segmentelor cu funcia inters i dac
aceasta a detectat un asemenea punct, valoarea coordonatei x a punctului este stocat
(adugat) n coada listei de soluii lsol folosind funcia adent;
Obs.11. Se foreaz evaluarea simbolului lsol pentru ca funcia det_solutii s returneze ca
rezultat lista soluiilor (aceasta fiind ultima evaluare din corpul funciei);
Obs.12. Se creaz o funcie de adugare a unui nou element la coada unei liste;
Obs.13. Se genereaz funcia de comand a calculului interactiv al soluiilor;
Obs.14. Se terge tot desenul;
Obs.15. Se limiteaz posibilitile de rspuns la urmtoarea funcie de tip get la
interzicerea rspunsului vid (apsarea numai a tastei Enter), interzicerea valorii zero i
interzicerea rspunsului printr-o valoare negativ;
Obs.16. Cerere de rspuns printr-o valoare ntreag (se cere numrul de soluii de determinat;
Obs.17. Se apeleaz funcia det_solutii i i se memoreaz rezultatul prin asociere cu
simbolul lsol, apoi se iniializeaz indicele de contor i la zero;
Obs.18. Se face o tiprire vid (rnd gol);
Obs.19. Se ruleaz un ciclu de tiprire a soluiilor;
Fig.13.2.1.
13.2.3. Exploatarea programului
Pentru a putea fi folosit programul trebuie mai nti salvat cu numele solec.lsp.
Se ncarc programul folosind comanda Tools/Load Application.
n linia de comand AutoCAD ar putea avea loc urmtorul dialog:
Command: solutii
Command:
Cate solutii doriti: 4
Command:
Solutia 1=0.5321
Solutia 2=3.183
Solutia 3=6.285
Solutia 4=9.4249
nil
Soluiile sunt cele tiprite de program (ca mai sus) iar desenul realizat de program este cel
din figura 13.2.1.
13.3. Desenul seciunii printr-un arbore cu canal de pan

Se va genera o funcie de comand care va permite desenarea seciunii prin arbore pe baza
unor parametri cerui de la utilizator, ntre parametrii cerui aflndu-se i poziia n care va fi
plasat seciunea n cmpul desenului. Programul AutoLISP este cel de mai jos:
300
(defun c:sectarb () (desensect (defarb) (pozsect)))

(defun defarb ()
(initget 7)
(list (getreal "\nDiametrul arborelui:")
(getreal "\nLatimea penei:")
(getreal "\nInaltimea penei:")
)
)
(defun pozsect ()
(initget 1)
(getpoint "\nIndicati centrul sectiunii:")
)
(defun desensect (lp cn / p1 p2 p3 p4 p5 p6 p7 p8 rp hp bp tp xc yc)
(setq rp (/ (nth 0 lp) 2) bp (nth 1 lp) hp (nth 2 lp)
tp (/ hp 2) xc (car cn) yc (cadr cn)
p7 (list xc (+ yc rp)) p8 (list xc (- yc rp))
p1 (list xc (+ yc rp (- hp tp)))
p2 (list (- xc (/ bp 2)) (cadr p1))
p3 (list (car p2) (- (cadr p1) hp))
p4 (list xc (cadr p3))
p5 (list (+ xc (/ bp 2)) (cadr p3))
p6 (list (car p5) (cadr p2))
)
(command "CIRCLE" cn rp)
(command "PLINE" p1 p2 p3 p5 p6 "C")
(command "TRIM" p7 "" p2 p6 "")
(command "TRIM" p4 "" p7 "")
(command "HATCH" "LINE" "" 45 p8 p4 "")
)
; Obs.1
; Obs.2
; Obs.3
; Obs.4
; Obs.5
; Obs.6
; Obs.7
; Obs.8
; Obs.9
; Obs.10
; Obs.11
; Obs.12
Fig.13.3.1.
Fig.13.3.2.
Programul funcioneaz conform observaiilor nsoitoare comentate mai jos:

Obs.1. Se definete funcia de comand. Aceasta apeleaz funcia de desenare a seciunii
prin arbore care primete ca argumente rezultatele returnate de funcia de definire a
parametrilor dimensionali ai seciunii prin arbore i pe cea de precizare a poziiei de
amplasare;
301
Obs.2. Se definesc parametrii dimensionali generali: diametrul arborelui, limea i

nlimea penei prin funcii de cerere de valori reale getreal care, conform funciei initget nu
accept rspuns vid (Enter), valoare zero sau negativ;
Obs.3. Se definete poziia de amplasare a centrului seciunii. Funcia getpoint returneaz ca
rezultat punctul indicat de utilizator, conform funciei initget nefiind acceptat un rspuns vid;
Obs.4. Funcia de desenare a seciunii primete ca parametri lista de parametri
dimensionali lp care va fi returnat de funcia defarb i lista cn a coordonatelor centrului
arborelui care va fi returnat de funcia pozsect;
Obs.5. Se definete raza arborelui rp=d/2, limea penei bp i nlimea penei hp, prin
extragere din lista de parametri dimensionali lp;
Obs.6. Se definete adncimea canalului de pan tp=hp/2, iar xc i yc, coordonatele
centrului arborelui sunt extrase din lista cn;
Obs.7. Se definesc punctele p1...p6 (vezi figura 11.3.1);
Obs.8. Se deseneaz cercul de raz rp cu centrul n punctul cn;
Obs.9. Se deseneaz conturul penei;
Obs.10. Se decupeaz partea din conturul penei care depete conturul cercului;
Obs.11. Se decupeaz partea din conturul cercului cuprins n interiorul conturului penei;
Obs.12. Se haureaz interiorul seciunii.
13.3.3. Utilizarea programului
Salvarea programului se va face sub numele sectarb.Lsp.
Dup ncrcarea n AutoCAD, n linia de comand a acestuia s-ar putea desfura dialogul urmtor:
Command: sectarb
Diametrul arborelui: 40
Latimea penei: 15
Inaltimea penei: 10
Indicati centrul sectiunii: se aplic un punct n cmpul de lucru
Ca rezultat va fi desenat seciunea din figura 13.3.2.
13.4. Generarea unui fiier de date

Se va genera o funcie de comand care va permite scrierea pe disc a unui fiier de date
coninnd coordonatele graficului funciei y=e-x sin x.
Programul AutoLISP necesar este dat mai jos:
(defun y (x /) (* (exp (* -1 x)) (sin x)))
(defun scriexy (x fis /)
(write-line (strcat "X=" (rtos x 1 6) " Y=" (rtos (y x) 1 6)) fis)
)
(defun c:scriefis (/ np dx ip x df)
(setq np 100 dx (/ (* 2 pi) (1- np)) ip 0 x 0)
(setq df (open "c:\\temp\\SINAMO.DAT" "W"))
(while (< ip np)
(scriexy x df)
(setq x (+ x dx) ip (1+ ip))
)
(close df)
)

Conform observaiilor nsoitoare programul funcioneaz n modul urmtor:
; Obs.1
; Obs. 2
; Obs.3
; Obs.4
; Obs.5
; Obs.6
; Obs.7
302
Obs.1. Funcie de calcul a valorii funciei y;

Obs.2. Funcie de scriere a unui rnd n fiier. Funciile rtos convertesc o valoare real n
ir de caractere. Parametrul 1 determin scrierea n format tiinific (cu exponent zecimal) iar
parametrul 6 reprezint precizia de scriere (cu 6 zecimale). Funcia strcat concateneaz iruri
de caractere iar funcia write-line execut scrierea n fiierul care are ca descriptor de fiier
parametrul fis;
Obs.3. Funcie comand de scriere a fiierului;
Obs.4. Se definesc: np numrul de puncte de scris n fiier (100), dx pasul de calcul, ip
contorul de ciclu, x=0 valoarea de start;
Obs.5. Se deschide pentru scriere fiierul SINAMO.DAT. Funcia open returneaz ca
rezultat o dat de tip special numit descriptor de fiier;
Obs.6. Se ruleaz un ciclu de scriere n fiier afiecrui rnd de date;
Obs.7. Se nchide fiierul.
Dup salvarea programului ntr-un fiier cu numele Wrsin.Lsp, se ncarc n AutoCAD cu
comanda Tools/Load Application i se scrie comanda scriefis.
Fiierul SINAMO.DAT va avea structura urmtoare:
X=0.000000E+00 Y=0.000000E+00
X=6.346652E-02 Y=5.952370E-02
X=1.269330E-01 Y=1.115017E-01
...
X=6.219719E+00 Y=-1.262012E-04
X=6.283185E+00 Y=-3.774621E-18
13.5. Desenarea unei diagrame cu date citite din fiier

Se va genera o funcie de comand care va permite citirea datelor dintr-un fiier i
reprezentarea lor sub form de diagram.
Programul AutoLISP necesar este dat mai jos:
(defun citeste_punct (fis / rnd)
(if (setq rnd (read-line fis))
(extpct rnd)
)
)
(defun extpct (rnd / drnd)
(setq drnd rnd cauta t contor 0)
(while cauta
(setq contor (1+ contor))
(if (equal (substr drnd 1 3) " Y=")
(setq cauta nil)
(setq drnd (substr drnd 2))
)
)
(list (atof (substr rnd 3 (- contor 2)))
(atof (substr rnd (+ contor 3)))
)
)
(defun c:diagrama (/ df pt)
(setq df (open "c:\\temp\\SINAMO.DAT" "R"))
(command "PLINE")
; Obs.1
; Obs.2
; Obs.3
; Obs.4
; Obs.5
; Obs.6
; Obs.7
; Obs.8
; Obs.9
; Obs.10
; Obs.11
; Obs.12
303
(while (setq pt (citeste_punct df)) (command pt))

(command "")
; Obs.13
; Obs.14

Conform observaiilor nsoitoare programul funcioneaz n modul urmtor:
Obs.1. Funcie de citire a unui punct din fiier. Parametrul de intrare n funcie este un
descriptor de fiier;
Obs.2. Este citit o linie (rnd) din fiier;
Obs.3. Funcia extpct extrage lista punctului din rndul citit;
Obs.4. Funcie de extragere a unui punct (creare de list de punct) dintr-un rnd de text citit
din fiierul de date;
Obs.5. Se creaz o copie (dublur) a rndului de date citit. Dublura are numele drnd i pe
ea se vor opera o serie de prelucrri ulterioare. Se iniializeaz variabila logic cauta la
valoarea t i contorul de explorare a rndului la valoarea 0;
Obs.6. Se ruleaz un ciclu de prelucrare a rndului;
Obs.7. Se avanseaz contorul de caracter cu o unitate;
Obs.8. Dac rezultatul extragerii primelor trei caractere ale rndului este irul " Y=" atunci
cutarea a luat sfrit i simbolul cauta devine nil. Altfel, din irul drnd este eliminat primul
caracter i se va continua cutarea. Valoarea simbolului contor va fi indicele din ir a
caracterului spaiu care separ textele descriptoare ale coordonatelor X i Y;
Obs.9. Se creaz lista de punct extrgndu-se din irul rnd numai prile cu semnificaie
numeric i, cu ajutorul funciei atof, convertindu-le n valori numerice reale. Funcia extpct
va returna ca rezultat lista de punct deoarece ea este ultima evaluare din corpul funciei;
Obs.10. Funcie de desenare a diagramei;
Obs.11. Se deschide fiierul de date;
Obs.12. Se iniiaz comanda Polyline;
Obs.13. Se ruleaz un ciclu de citire din fiier a datelor i conversie a lor n liste de puncte
care sunt furnizate ca date comenzii de trasare a polininiei aflat n derulare;
Obs.14. Se ncheie comanda Polyline.
Dup salvarea programului ntr-un fiier cu numele Rdfunc.Lsp, se ncarc n AutoCAD cu
comanda Tools/Load Application i se scrie comanda diagrama. Rezultatul obinut va fi cel
din figura 13.5.1.
Fig.13.5.1.
Bibliografie
304
Bibliografie
[1].
[2].
[3].
[4].
[5].
[6].
[7].
[8].
[9].
[10].
[11].
[12].
[13].
[14].
[15].
[16].
[17].
Cris H. Pappas & William H. Murray, III, "Borland C++ Handbook, Second Edition,
Osborne Mc Graw-Hill, Berkeley, California, USA, 1992.
Dan
Manolea,
Programare
n
AutoLISP
sub
AutoCAD,
Grupul
MicroINFORMATICA, Cluj-Napoca, 1996.
Dan Roman, Ingineria programrii obiectuale, Grupul MicroINFORMATICA, ClujNapoca, 1996.
Dumitru Dragomir, ndrumar de lucrri practice pentru proiectare asistat de
calculator, Editura Evrika, Brila, 1999.
Dumitru Dragomir, Ovidiu Iona, Leonard Domnioru, Ionel Gavrilescu, Lucrri de
tehnici de calcul numeric n ingineria asistat de calculator, Editura Evrika, Brila,
1999.
Dumitru Dragomir, Proiectare asistat de calculator pentru inginerie mecanic, Editura
Teora, Bucureti, 1996.
Gheorghe Curelet-Blan, "Visual BASIC, introducere n programarea uzua a
aplicaiilor Windows", Editura DONE, Bucureti, 1994.
Ioan Salomie, Tehnici orientate pe obiecte, Grupul MicroINFORMATICA, ClujNapoca, 1995.
Michael Metcalf, John Reid, Fortran 90/95 Explained, Second Edition, Oxford
University Press Inc., New York, 1999.
Mihai Anton Cerghizan, "EXCEL 7.0 pentru Windows 95", Editura TEHNIC,
Bucureti, 1996.
Namir C. Shammas, "Curs rapid de Borland C++", Teora, Bucureti, 1996.
Octavian Catrina, Iuliana Cojocaru, Turbo C++, Editura Teora, Bucureti, 1993.
Ovidiu Iona, Leonard Domnioru, Ionel Gavrilescu, Dumitru Dragomir, Tehnici de
calcul n construcii navale, Editura Evrika, Brila, 1999.
Teodor Tiuca, Tudor Precup, Tiberiu Antal, Dezvoltarea Aplicaiilor cu AutoCAD i
AutoLISP, Editura ProMedia Plus, Cluj Napoca, 1995.
Tom Swan, "nvm C... pas cu pas", Editura Tehnic, Bucureti, 1996.
Valentin C., Cristian G., Eugenia K., Alexandru P., "Limbajul C Standard", Teora,
Bucureti, 1992.
Vasile Petrovici, Florin Goicea, Programarea n Limbajul C, Editura Tehnic,
Bucureti, 1993.

Programarea Calculatoarelor Si Limbaje de Programare PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programarea Calculatoarelor Si Limbaje de Programare PDF

Uploaded by

Copyright:

Available Formats

Dumitru Dragomir

Editura Fundaiei Universitare Dunrea de Jos

Editura Fundaiei Universitare Dunrea de Jos

UNIVERSITATEA DUNREA DE JOS DIN GALAI

Editura Fundaiei Universitare

ISBN : 973 - 627 - 260 5

Programarea calculatoarelor i limbaje de programare

2.3. Tipuri de date standard ...........................................................................................50

Programarea calculatoarelor i limbaje de programare

3.5. Conceptul de clas..................................................................................................73

6.3. Tipuri de date........................................................................................................123

Programarea calculatoarelor i limbaje de programare

8.11.2.2. Instruciunea WRITE ............................................................................170

Programarea calculatoarelor i limbaje de programare

11.2.7.3. Crearea unei cutii de dialog pentru comutarea de la tabel la

Programarea calculatoarelor i limbaje de programare

11.8.4. Crearea subrutinelor obiectelor de interaciune.................................................276

Programarea calculatoarelor i limbaje de programare

Evident c, prin aceast alegere, lucrarea nu epuizeaz domeniul de opiuni ale

Programarea calculatoarelor i limbaje de programare

Capitolul 1. Elemente de baz n informatic

.1.2. Sisteme de numeraie

Capitolul 1. Elemente de baz n informatic

Sistemul zecimal, folosete alfabetul 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, baza fiind q=10.

Programarea calculatoarelor i limbaje de programare

.1.3. Reprezentarea informaiei n calculator

.1.4. Codificarea informaiei n calculator

Capitolul 1. Elemente de baz n informatic

08H BS caracterul Back Space tergerea caracterului anterior;

.1. 5. Reprezentarea datelor

Programarea calculatoarelor i limbaje de programare

De exemplu, fie numrul 10 i numrul 3. Ele se reprezint astfel:

Capitolul 1. Elemente de baz n informatic

folosete o singur operaie de adunare direct, att la adunare ct i la scdere.

C. Reprezentarea numerelor reale n virgul mobil.

Aadar, mrimea numrului reprezentat n virgul mobil i precizia reprezentrii lui

Programarea calculatoarelor i limbaje de programare

reprezentare creaz complicaii constructive, modelul de reprezentare variind la diferite

.1. 6. Structura fizic (hardware) a unui calculator

Capitolul 1. Elemente de baz n informatic

- Memoria calculatorului, este de dou tipuri:

Programarea calculatoarelor i limbaje de programare

Capitolul 1. Elemente de baz n informatic

Programarea calculatoarelor i limbaje de programare

Memoria virtual a calculatorului

.1.7. Structura operaional a unui sistem de calcul

Capitolul 1. Elemente de baz n informatic

Relaie extern (conectare la reea)

Programarea calculatoarelor i limbaje de programare

.1.8. Organizarea funcional a unui sistem de calcul

Capitolul 1. Elemente de baz n informatic

Programarea calculatoarelor i limbaje de programare

.1.9. Dispozitive periferice

Capitolul 1. Elemente de baz n informatic

- tastele Home i End pentru deplasarea cursorului la nceputul i la sfritul textului

Programarea calculatoarelor i limbaje de programare

1.9.2. Dispozitive de ieire

Imaginea poate fi afiat n dou moduri:

Capitolul 1. Elemente de baz n informatic

Programarea calculatoarelor i limbaje de programare

Mvt = cr2 octei

Capitolul 1. Elemente de baz n informatic

unde b = 1, 2, 4, 8, 16, 32 este numrul de bii folosii la codificare