Învăţământul profesional şi tehnic în domeniul TIC

Proiect cofinanţat din Fondul Social European în cadrul POS DRU 2007-2013
Beneficiar – Centrul Naţional de Dezvoltare a Învăţământului Profesional şi Tehnic
str. Spiru Haret nr. 10-12, sector 1, Bucureşti-010176, tel. 021-3111162, fax. 021-
3125498, vet@tvet.ro

Limbaje de programare
Material de predare

Domeniul: Informatică
Calificarea: Analist programator

Nivel 3 avansat

2009
 AUTOR:
CLAUDIA DANIELA MOLNAR – profesor, grad didactic II

COORDONATOR:

MARIANA VIOLETA CIOBANU – profesor, grad didactic I

CONSULTANŢĂ:

IOANA CÎRSTEA – expert CNDIPT

ZOICA VLĂDUŢ – expert CNDIPT
ANGELA POPESCU – expert CNDIPT
DANA STROIE – expert CNDIPT

Acest material a fost elaborat în cadrul proiectului Învăţământul profesional şi tehnic în

domeniul TIC, proiect cofinanţat din Fondul Social European în cadrul POS DRU 2007-
2013

2
 Cuprins

I. Introducere ................................................................................................................................... 4
II. Documente necesare pentru activitatea de predare..................................................................... 5
III. Resurse ...................................................................................................................................... 6
Tema 1. Elemente de interfaţă ale unui mediu de dezvoltare integrat ........................................ 6
Fişa suport 1 Meniuri, bare de instrumente, ferestre, bare de navigare ...................................... 6
Tema 2. Tipuri de fişiere cu care lucrează mediul de dezvoltare integrat utilizat ...................... 7
Fişa suport 2 - Tipuri de fişiere ................................................................................................... 7
Tema 3. Opţiuni de instalare ale mediului de dezvoltare integrat utilizat ................................... 9
Fişa suport 3 - Inserare/eliminare biblioteci de clase/componente ............................................. 9
Tema 4. Limbaje de programare ............................................................................................... 11
Fişa suport 3 – Limbaje de programare ..................................................................................... 11
Tema 5: Noţiuni de bază ale limbajului de programare studiat ................................................ 12
Fişa suport 5.1 - Vocabularul limbajului de programare .......................................................... 12
Fişa suport 5.2 - Tipuri simple de date ...................................................................................... 14
Tema 5: Noţiuni de bază ale limbajului de programare studiat ................................................ 16
Fişa suport 5.3 – Variabile ........................................................................................................ 16
Tema 6: Operatori, Expresii ...................................................................................................... 19
Fişa suport 6 - Operatori, Expresii ............................................................................................ 19
Tema 7: Programarea structurata. Structuri fundamentale de control ...................................... 20
Fişa suport - Programarea structurata. Structuri fundamentale de control ................................ 20
Tema 8: Programarea structurata. Structuri fundamentale de control ...................................... 23
Fişa suport 8 - Corectitudinea programelor............................................................................... 23
Tema 9: Tablouri unidimensionale (Vectori) ............................................................................ 26
Fişa suport 9 - Tablouri unidimensionale .................................................................................. 26
Tema 10: Tablou bidimensional (Matrice) ................................................................................ 33
Fişa suport 10 - Tablou bidimensional ...................................................................................... 33
Tema 11: Şiruri de caractere .................................................................................................... 37
Fişa suport 11 - Şiruri de caractere........................................................................................... 37
Tema 12: Tipul înregistrare (articol) ......................................................................................... 39
Fişa suport 12 - Tipul înregistrare ............................................................................................. 39
Tema 13: Fişiere ........................................................................................................................ 42
Fişa suport 13 – Fișiere ............................................................................................................. 42
Tema 14: Utilizarea tipurilor structurate de date în aplicaţii practice ....................................... 44
Fişa suport 14 – Tipuri structurate de date. Aplicatii ................................................................ 44
IV. Fişa rezumat ............................................................................................................................ 45
V. Bibliografie ............................................................................................................................... 46
I. Introducere

Materialele de predare reprezintă o resursă – suport pentru activitatea de predare,

instrumente auxiliare care includ un mesaj sau o informaţie didactică.
Prezentul material de predare, se adresează cadrelor didactice care predau în cadrul
şcolilor postliceale, domeniul Informatică, calificarea Analist programator.
El a fost elaborat pentru modulul VII, ce se desfăşoară în 72 ore, din care 36 ore
laborator tehnologic.

Competenţe Teme Fise suport

Se familiarizează  Tema 1: Elemente de interfaţă  Fişa suport 1
cu elementele de ale unui mediu de dezvoltare
interfaţă ale unui integrat
mediu de  Tema 2: Tipuri de fişiere cu care  Fişa suport 2
dezvoltare lucrează mediul de dezvoltare
integrat integrat utilizat
 Tema 3: Opţiuni de instalare ale  Fişa suport 3
mediului de dezvoltare integrat
utilizat
Lucrează cu  Tema 4: Limbaje de programare  Fişa suport 4
elementele de
bază ale  Tema 5: Noţiuni de bază ale  Fişa suport 5.1
limbajului de limbajului de programare studiat  Fişa suport 5.2
programare  Fişa suport 5.3
 Tema 6: Operatori, Expresii  Fişa suport 6

Foloseşte  Tema 7: Programarea  Fişa suport 7

structurile de structurata. Structuri
bază ale fundamentale de control
limbajului de  Tema 8: Corectitudinea  Fişa suport 8
programare programelor
Implementează  Tema 9: Tablouri  Fişa suport 9
tipurile unidimensionale (Vectori)
structurate de  Tema 10: Tablou bidimensional  Fişa suport 10
date în (Matrice)
rezolvarea  Tema 11: Şiruri de caractere  Fişa suport 11
problemelor  Tema 12: Tipul înregistrare  Fişa suport 12
(articol)
 Tema 13: Fişiere  Fişa suport 13
 Tema 14: Utilizarea tipurilor  Fişa suport 14
structurate de date în aplicaţii
practice

Absolvenţii nivelului 3 avansat, şcoală postliceală, calificarea Analist programator, vor fi

capabili să descrie elementele de interfaţă şi tipurile de fişiere, să utilizeze opţiunile de
instalare ale mediului utilizat, să utilizeze datele şi operatorii în scrierea expresiilor, să
utilizeze structuri de decizie, selecţie şi repetitive şi să identifice şi să rezolve erorile/bug
– urile din program.
II. Documente necesare pentru activitatea de predare
Pentru predarea conţinuturilor abordate în cadrul materialului de predare cadrul
didactic are obligaţia de a studia următoarele documente:
 Standardul de Pregătire Profesională pentru calificarea Analist programator,
nivelul 3 avansat – www.tvet.ro, secţiunea SPP sau www.edu.ro , secţiunea
învăţământ preuniversitar
 Curriculum pentru calificarea Analist programator, nivelul 3 avansat –
www.tvet.ro, secţiunea Curriculum sau www.edu.ro , secţiunea învăţământ
preuniversitar

5
III. Resurse

Tema 1. Elemente de interfaţă ale unui mediu de dezvoltare integrat

Fişa suport 1 Meniuri, bare de instrumente, ferestre, bare de navigare

Lansare în execuţie: prezentarea modului de lansare în execuţie, explicarea

locaţiile în care vor fi salvate fişierele aplicaţie.

Meniuri – prezentarea meniurile principale ale mediului de dezvoltare integrat şi

eventualele combinaţii de taste rapide.
Meniurile File şi Edit sunt comune tuturor mediilor de dezvoltare, celelalte meniuri
urmând a fi prezentate în funcţie de mediul de dezvoltare integrat ales.

Fereastra principală a aplicaţiei – cuprinde: meniurile principale, zona de lucru,

linia de referinţe rapide (tastele funcţionale cele mai utilizate şi semnificaţia lor) sau bare
de instrumente (funcţie de mediul de dezvoltare integrat utilizat).

Sugestii metodologice
UNDE PREDĂM?
Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă care are video-proiector
CUM PREDĂM?
Metode:
- Expunere
- Conversaţie
Profesorul prezintă meniurile principale şi fereastra principală a aplicaţiei. Elevii
urmăresc activitatea profesorului şi primesc explicaţii.
- Practic: se creează comanda rapidă a aplicaţiei pe ecran
Se recomandă utilizarea calculatoarelor pentru activităţile de fixare a noilor cunoştinţe.

Ca materiale de evaluare se pot folosi:

o Probe orale şi scrise
Tema 2. Tipuri de fişiere cu care lucrează mediul de dezvoltare integrat utilizat
Fişa suport 2 - Tipuri de fişiere

Tipuri de fişiere cu care lucrează mediului de dezvoltare integrat utilizat: pentru cod
sursa, obiect, executabile, pentru descrierea datelor, pentru descrierea formularelor,
pentru module de cod, rapoarte, pentru memorarea proiectelor

Mediul de dezvoltare integrat de nivel înalt nu este înţeles de calculator deoarece

acesta nu înţelege decât instrucţiunile binare ale limbajului maşina. Instrucţiunile din
mediul de dezvoltare integrat de nivel înalt trebuie traduse. Aceasta operaţie se
realizează cu ajutorul unor programe. Pentru a obţine un program executabil se parcurg
etapele:
I. Scrierea (editarea) codului sursă.
Codul sursă reprezintă un fişier text care conţine instrucţiuni (cu sintactica şi semantica
proprie limbajului utilizat). Codul (fişierul) sursă este creat cu ajutorul unui editor de
texte şi va fi salvat pe disc .

II. Compilarea
Procesul de compilare este realizat cu ajutorul compilatorului, care translatează codul
sursă în cod obiect (cod maşină), pentru ca programul să poată fi înţeles de calculator.
Apoi codul sursă este translatat în cod de asamblare, iar în final, în cod maşină, binar,
propriu calculatorului. Acest cod binar este numit cod obiect şi de obicei este memorat
într-un alt fişier, numit fişier obiect.

III. Editarea legăturilor

După ce fişierul sursă a fost translatat în fişier obiect, el este va fi supus operaţiei de
editarea legăturilor. Scopul fazei de editare a legăturilor este acela de a obţine o formă
finală a programului, în vederea execuţiei acestuia. Editorul de legături “leagă”
modulele obiect, rezolvă referinţele către funcţiile externe şi rutinele din biblioteci şi
produce cod executabil, memorat într-un alt fişier, numit fişier executabil.

IV. Execuţia
Lansarea în execuţie constă în încărcarea programului executabil în memorie şi
începerea execuţiei sale.

Formulare
Obiecte proiectate pentru introducerea datelor în tabele sau pentru afişarea
personalizată a datelor din tabele

Rapoarte
Obiecte proiectate pentru a extrage datele din tabele şi a le afişa în vederea tipăririi.

Module: obiecte ce conţin proceduri personalizate şi oferă posibilitatea controlării mai

fine a acţiunilor şi corectarea erorilor.

Proiecte
Pentru memorarea proiectelor se folosesc fişierele cu extensia .prg şi conţin informaţii
despre date, formulare, rapoarte

7
Proiectele mediului de dezvoltare integrat constau din diferite tipuri de fişiere. Mediul
de dezvoltare integrat creează automat anumite fişiere; când se începe un nou proiect
sau când noii itemi sunt adăugaţi la un proiect existent.
Există fişiere care sunt create când aplicaţia este compilată. Fişierele proiectului pot fi:
fişiere principale şi fişierele formularului.

Fişierele principale: la crearea unui proiect, trei fişiere principale sunt automat create –
fişierul proiectului, fişierul sursă şi fişierul resursă. Fişierul proiectului este un fişier text
care conţine setările şi regulile de construire a proiectului. Fişierul sursă conţine codul
sursă. Fişierul resursă conţine pictograma aplicaţiei, numărul versiunii aplicaţiei şi alte
informaţii. Nu toate tipurile de aplicaţii au un fişier resursă.

Fişierele formularului: pentru fiecare formular se creează fişierele – fişierul machetă

care conţine valorile ce reprezintă partea grafică a formularului, fişierul sursă şi fişierul
header, care sunt create cu fişierul machetă de fiecare dată când se creează un nou
formular.

Sugestii metodologice
UNDE PREDĂM?
Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă
CUM PREDĂM?
Metode:
- Expunere
- Conversaţia
Profesorul discută cu elevii şi le prezintă principalele tipuri de fişiere pe care le vor
întâlni în utilizarea mediu de dezvoltare integrat.

Ca materiale de evaluare se pot folosi:

o Probe orale şi scrise

8
Tema 3. Opţiuni de instalare ale mediului de dezvoltare integrat utilizat
Fişa suport 3 - Inserare/eliminare biblioteci de clase/componente

Instalare software suplimentar (compilatoare, interpretoare, instrumente pentru

vizualizare, generatoare de documentaţii, instrumente pentru arhive)
Interfeţe pentru acces la baze de date
Organizare resurse

Bibliotecile de clase: oferă o interfaţă comună şi consistentă de dezvoltare

pentru toate mediile de dezvoltare integrate.
O biblioteca este o colecţie de rutine stocate într-un singur fişier (module, programe,
texte etc.), rutine care sunt obţinute prin compilări sau asamblări separate. Fiecare set
de instrucţiuni dintr-o biblioteca are un nume şi execută o anumită sarcină specifică.
Rutina de bibliotecă este o procedură memorată într-o biblioteca a sistemului, putând fi
apelată din programe scrise în limbaje de nivel înalt, de exemplu: funcţiile aritmetice
standard, trigonometrice, grafice, ale programatorului.
Astfel de rutine simplifică munca şi împiedică multiplicarea efortului atunci când este
nevoie să se execute de mai multe ori o aceeaşi sarcină. Programatorul poate identifica
biblioteca programului (fişier care poartă un nume), apoi se poate referi la rutina dorită
iar programul va îngloba în execuţie toate instrucţiunile pe care le conţine rutina prin
simpla apelare a numelui acesteia.
Principalele avantaje pe care le prezintă un astfel de utilitar:
- siguranţa în lucru, oferită prin gestionarea automată a tuturor modificărilor asupra
fişierelor pe care le conţine o bibliotecă;
- simplificarea activităţii de programare, prin apelarea din biblioteca a rutinei de care
este nevoie;
- utilizare simplă, cu ajutorul unei linii de comanda, în mod conversaţional sau utilizând
un fişier de răspunsuri;
- creşterea gradului de portabilitate.

Software suplimentar
Un mediu de dezvoltare integrat combină toţi paşii necesari creării unui program (ex.:
editarea codului sursă, compilarea, depanarea, testarea, generarea de documentaţie)
într-un singur soft, care, de regulă, oferă o interfaţă cu utilizatorul grafică, prietenoasă.
Mediile de dezvoltare integrate apelează compilatoare, sau interpretoare, care pot veni
în acelaşi pachet cu mediul însuşi, sau pot fi instalate separat de către programator.

Interfeţe pentru acces la baze de date

Baza de date reprezintă o modalitate de stocare a unor informaţii (date) pe un suport
extern, cu posibilitatea regăsirii acestora. Uzual, o bază de date este memorată într-
unul sau mai multe fişiere. Modelul clasic de bază de date este cel relaţional, în care
datele sunt memorate în tabele.
Crearea unei baze de date: se face cu aplicaţii specializate oferite de producătorul
tipului respectiv de bază de date.
Accesul la o bază de date se face prin intermediul unui driver specific tipului respectiv
de bază de date. Acesta este responsabil cu accesul efectiv la datele stocate, fiind
legătura între aplicaţie şi baza de date.
- Exemplu: JDBC (Java Database Connectivity) este o interfaţă standard SQL de acces
la baze de date. Cu alte cuvinte, nu este necesară scrierea un program pentru a accesa
o bază de date Oracle, alt program pentru a accesa o bază de date Sybase. Este de
ajuns scrierea un singur program folosind JDBC şi acesta va fi capabil să trimită

9
secvenţe SQL bazei de date dorite. Bineînţeles, scriind codul sursa în Java, ne este
asigurată portabilitatea programului.

Sugestii metodologice
UNDE PREDĂM?
Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă dotată cu video-proiector
CUM PREDĂM?
- Expunere
- Exemplificare
Profesorul defineşte noţiuni legate de biblioteci de date şi apoi exemplifică o interfaţă
pentru acces la bazele de date.
- Învăţare prin descoperire
- Practic: profesorul propune elevilor instalarea unui compilator.

Ca materiale de evaluare se pot folosi:

o Probe orale şi practice

10
Tema 4. Limbaje de programare
Fişa suport 3 – Limbaje de programare

Program. Proiect. Pachete de programe. Categorii de limbaje de programare

- algoritm: o metodă de soluţionare a unei clase de probleme, reprezentată de o
succesiune finită de operaţii bine definite, numite instrucţiuni
- program: soluţia unei probleme, din punct de vedere informatic, este dată printr-o
mulţime de comenzi (instrucţiuni) explicite şi neambigue, exprimate într-un limbaj
de programare. Aceasta mulţime de instrucţiuni prezentată conform anumitor
reguli sintactice formează un program.
- proiect: programe ale căror surse sunt împărţite în mai multe fişiere şi permite
deschiderea unui proiect existent sau crearea unuia nou, închiderea proiectului
curent, adăugarea unor fişiere la proiectul curent şi înlăturarea unor fişiere din
componenta proiectului curent.
- pachet de programe: un pachet conţine, în general, programul în forma sa binară
plus informaţii despre locul în care va fi instalat pe sistem. În plus mai poate
conţine informaţii despre alte pachete care trebuie instalate. Pentru a instala
pachete, este nevoie de un manager de pachete. Acest program facilitează
instalarea şi dezinstalarea pachetelor precum şi alte operaţii mult mai complexe
care decurg din aceste acţiuni.
- limbaje de programare: un limbaj artificial care prin exprimări simbolice descrie
operaţiile de prelucrare automata a datelor, necesare pentru rezolvarea unei
anumite probleme a utilizatorului.
- categorii de limbaje de programare: limbajele de nivel înalt sunt de obicei
procedurale şi neprocedurale sunt de nivel foarte înalt şi definesc scopul, fără a
da detalii asupra modului în care acesta se atinge.
Categorii de limbaje de programare: Pascal, C++, Java

Sugestii metodologice
UNDE PREDĂM?
Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă
CUM PREDĂM?
Metode:
- Expunere
- Comunicare
- Conversaţie
Profesorul discută cu elevii şi definesc noţiunile teoretice ale limbajelor de programare.

Ca materiale de evaluare se pot folosi:

o Probe orale şi practice

11
Tema 5: Noţiuni de bază ale limbajului de programare studiat
Fişa suport 5.1 - Vocabularul limbajului de programare

Identificatori: nume folosit pentru un element din program, fie el o variabilă, un

tip, o metodă, o clasă. Un identificator este format dintr-un şir de caractere care începe
cu o literă şi poate conţine litere, cifre şi caracterul "_". Identificatorul nu poate conţine
spatii sau apostrof, virgulă, ghilimele şi pot coincide cu cuvintele cheie.
- Exemplu:
 a, b, c, , x1, x2, delta ar putea identifica coeficienţii reali din ecuaţia de gradul 2,
soluţiile şi discriminantul acesteia.
 x2_ab, a1__xc sunt de asemenea identificatori corecţi însă nu sugerează nimic.

Separatori şi comentarii:
Separatorul este un caracter care delimitează formele sintactice sau le separa între ele.
Comentariile sunt texte care pot fi introduse în programul sursă, dar nu sunt luate în
consideraţie de compilator şi deci nu au efect în timpul executării programului.
Comentariile sunt utile pentru o mai bună înţelegere a programului.

- Exemple în Turbo Pascal de: - Exemple în C++ şi Java de:

 separatori: spaţiul şi caracterele  comentarii: /* … */ sau //
Tab şi Enter (sfârşitul de linie)
 comentarii: { şi } sau (* şi *)

Cuvinte cheie (rezervate) sunt identificatori cu semnificaţie fixată care nu pot fi

folosiţi în alt context decât cel precizat de semantica limbajului.

- Exemple de cuvinte - Exemple de cuvinte - Exemple de cuvinte

rezervate în Turbo Pascal:
and, array, begin, const,
do, end, file, for, if, label,
not, of, or, procedure,
record, repeat, set, string,
then, type, unit, until, var,
while
rezervate în C++:
if, while, for, break, class
rezervate în Java:
abstract, class, default,
double, float, for, public,
static, private, super, this,
while

Caractere speciale
Vocabularul limbajului reprezintă totalitatea cuvintelor care pot apărea în cadrul unui
program. Aceste cuvinte sunt entităţi formate din caractere.

- Exemple de caractere în Turbo Pascal:

 litere mari şi mici, cifrele 0- 9, caractere speciale (+ - * / () [ ] { } . , # @ $)

Sugestii metodologice
UNDE PREDĂM? Conţinutul poate fi predat în:
- laboratorul de informatică

12
- sală de clasă dotată cu video-proiector
CUM PREDĂM?
- Conversaţia
- Expunerea
Profesorul discută cu elevii şi identifică principalele elemente ale unui limbaj. Profesorul
defineşte, apoi, elementele de bază ale limbajului: identificatori, separatori, comentarii,
cuvinte rezervate
Se recomandă utilizarea calculatoarelor pentru activităţile de fixare a noilor cunoştinţe.

Ca materiale de evaluare se pot folosi:

o Probe orale şi scrise

13
Tema 5: Noţiuni de bază ale limbajului de programare studiat
Fişa suport 5.2 - Tipuri simple de date

Prin tip de dată se înţelege o mulţime de valori şi o mulţime de operaţii ce pot fi

efectuate cu aceste valori. Acestea sunt: tipurile reale, tipurile întregi, tipul caracter şi
tipurile logice.
Tipul real este reprezentat de o submulţime a mulţimii numerelor reale, care poate fi
reprezentată în calculator.

- Exemple în Turbo Pascal: - Exemple în C++ şi Java

Tip Valoare Valoare Tip Valoare Valoare

minima maxima minima maxima
Single 1.5E-45 3.4E38
Real 2.9E-39 1.7E38 Float 3.4E-38 3.4E38
Double 5.0E-324 1.7E308
Double 1.7E-308 1.7E308
Extended 3.4E-4932 1.1E4932
Comp -263+1 263-1

Tipul întreg: există mai multe tipuri întregi predefinite, iar fiecare tip desemnează o
submulţime a mulţimii numerelor întregi.
- Exemple în Turbo Pascal: - Exemple in Java

Valoare Valoare Valoare Valoare

Tip Tip
minimă maximă minimă maximă
Shortint -128 127 Byte -128 +127
Byte 0 255 short -32768 32767
Integer -32768 32767 int -2147483648 2147483648
Word 0 65535 Long -2exp(63) 2exp(63)-1
Longint -2147483648 2147483647

Tipul caracter este reprezentat de mulţimea caracterelor, adică a tuturor cifrelor, a

literelor mici şi mari şi a caracterelor speciale.
Tipurile logice mai sunt numite şi booleene (denumirea venind de la numele
matematicianului englez Boole). Valorile booleene sunt reprezentate de identificatorii de
constante predefiniţi Adevărat şi Fals.

Sugestii metodologice
UNDE PREDĂM? Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă dotată cu video-proiector
CUM PREDĂM?

14
Metode:
- Expunere
- Conversaţie
După prezentarea tipurile de date şi înţelegerea noţiunilor, elevii utilizează noţiunile în
exemple concrete.
Se recomandă utilizarea calculatoarelor pentru activităţile de fixare a noilor cunoştinţe.

Ca materiale de evaluare se pot folosi:

o Probe orale şi scrise

15
Tema 5: Noţiuni de bază ale limbajului de programare studiat
Fişa suport 5.3 – Variabile

Definiţie: prin variabilă se înţelege o informaţie (o dată) a cărei valoare se poate

modifica pe parcursul execuţiei unui program. Ea are un nume şi poate primi o valoare
dintr-un domeniu bine precizat de valori.
Declarare: Tip nume_variabilă

- Exemple în Turbo Pascal: - Exemple în C++:

Var i, j, k, l, m, n: integer;
a, b, x, y, z: real;
- se declară şase variabile de tip întreg
având numele i, j, k, l, m, n
- cinci variabile de tip real cu numele a, b,
x, y, z
Int i, j;
Char c;
- variabilele i şi j sunt variabile de tip int
- variabila c este o variabila de tip char

Constante

Definiţie: o constantă este o informaţie (o dată) a cărei valoare nu poate fi

modificată pe parcursul rulării unui program. Orice constantă este precizată prin sintaxa
ei şi are o valoare bine definită.
Declarare: nume_constantă = valoare

- Exemple în Turbo Pascal:

Const Pi = 3.141592653
e = 2.718281828

Operaţii de intrare / ieşire (citire / scriere)

Acestea se realizează cu conversie între reprezentarea internă a datelor (binară:

virgulă fixă, virgulă mobilă etc.) şi cea externă (ASCII). Operaţia de ieşire / scrierea pe
ecran se desfăşoară în doi paşi: datele din memoria principală sunt convertite în
formatul extern de reprezentare (ASCII) şi transferate într-o zonă tampon (pasul 1). De
aici sunt preluate şi afişate pe ecran (pasul 2). La operaţia de intrare / citire datele
sunt preluate de la tastatură şi depuse într-o zona tampon în format ASCII (pasul 1). De
aici se preiau datele necesare, se convertesc în formatul intern şi se depun în memoria
principală, în zonele corespunzătoare parametrilor funcţiilor de citire.

- Exemple în Turbo Pascal: - Exemple în C++:

Operaţia de citire se realizează cu ReadLn Limbajul nu dispune de instrucţiuni de
sau Read, iar cea de scriere cu WriteLn intrare / ieşire. Aceste operaţii se
sau Write realizează prin intermediul unor funcţii din
Program CalculArie; biblioteca standard.
const pi=3.1415926 Implicit, unui program i se ataşează
var raza, aria: real; fişierele stdin (intrare standard), stdout
begin (ieşire standard), stderr (ieşire standard
ReadLn (raza); pentru erori), stprn (ieşire pentru
aria:=pi*sqr (raza); imprimantă), stdoux (intrare/ieşire serială).
WriteLn (aria)
end.

16
Structura generala a unui program

Părţile principale ale unui program sunt: antetul (header-ul) programului,

declaraţiile în care se descriu obiectele asupra cărora vor avea loc prelucrările şi partea
principală a programului în care se scriu instrucţiunile (ansamblul operaţiilor ce urmează
a fi executate).
Exemplu în Turbo Pascal
program <nume_program>;
uses <biblioteci cu funcţii şi proceduri folosite în program>
type <tipuri de date definite de utilizator>
const <constante folosite în program>
var <variabile globale folosite în program>
<aici se pot scrie funcţii şi proceduri folosite în program>
begin
<aici se scrie programul principal>
end.

Includeri de fişiere (header, biblioteci de funcţii, directive de compilare/

interpretare)

Includeri de fişiere
Toate funcţiile folosite în program trebuie descrise în fişierele sursă (cele scrise de către
programator), în fişiere header (funcţiile predefinite, existente în limbaj), sau în biblioteci
de funcţii.
Un fişier header este un fişier aflat în sistem sau creat de către programator, care
conţine declaraţii şi definiţii de funcţii şi variabile.

- Exemplu in Turbo Pascal: - Exemplu in C++:

Fişiere incluse în fişierele sursă
Fişiere compilate cu extensia TPU
Fişiere executabile cu extensia EXE
Linia
#include <iostream.h>
determină includerea în fişierul sursă a
fişierului header cu numele iostream.h.
Acest header permite realizarea afişării pe
monitor

Sugestii metodologice
UNDE PREDĂM? Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă dotată cu video-proiector
CUM PREDĂM?
Metode:
- Expunerea
- Conversaţie
- Învăţare prin descoperire
Profesorul discută cu elevii şi identifică principalele noţiuni de bază ale limbajului de
programare. Profesorul defineşte elementele limbajului: variabile, constante, operaţii de
citire/scriere şi propune ca exemplu un program care calculează aria.

Se recomandă utilizarea calculatoarelor pentru activităţile de fixare a noilor cunoştinţe.

17
Ca materiale de evaluare se pot folosi:
o Probe orale şi scrise

18
Tema 6: Operatori, Expresii
Fişa suport 6 - Operatori, Expresii

O expresie este formată din operanzi şi operatori având forma: a1 o1 a2 o2 …an on

an+1 unde ai, i= 1,2,…n+1 sunt operanzi iar oi, i=1,2,…n sunt operatori. În funcţie de
tipurile de operatori expresiile pot fi aritmetice, relaţionale, logice.

Operatorii aritmetici sunt binari (acţionează asupra a doi operanzi). Operatorii

aritmetici se pot aplica numai operanzilor numerici. Rezultatul evaluării unei expresii
aritmetice este numeric (întreg sau real, în funcţie de operanzi şi operatori). Operatori
relaţionali descriu relaţia de ordine sau de egalitate dintre cei doi operanzi : < (mai
mic), > (mai mare), <= (mai mic sau egal), >= (mai mare sau egal), = (egal), (diferit).
Operatorii relaţionali sunt operatori binari şi se pot aplica numai operanzilor numerici,
logici (fals <adevărat) şi caractere.
Valoarea unei expresii relaţionale este întotdeauna de tip logic (deci poate fi adevărat
sau fals).

Operatori logici definesc o operaţie logică : negaţie logică, conjuncţie logică – şi;
disjuncţie logică – sau. Operatorii logici se pot aplica operanzilor logici. Valoarea unei
expresii logice este de tip logic.

Operatori pe biţi: utilizează reprezentarea binară a tipurilor de date numerice la

operaţiuni pe succesiunile de biţi a datelor.

Sugestii metodologice
UNDE PREDĂM? Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă
CUM PREDĂM?
Metode:
- Expunere
- Conversaţie
Profesorul defineşte operatorii aritmetici şi expresiile
Se recomandă utilizarea calculatoarelor pentru activităţile de fixare a noilor cunoştinţe.

Ca materiale de evaluare se pot folosi:

o Probe orale şi scrise

19
Tema 7: Programarea structurata. Structuri fundamentale de control
Fişa suport - Programarea structurata. Structuri fundamentale de control

Programare structurata. Structuri fundamentale de control:

- instrucţiuni simple ale limbajului
- structuri de decizie/alternative:cu o singură ramură, cu două ramuri, selecţie
multiplă (case / switch)
- structuri repetitive: cu test iniţial, cu test final, cu număr cunoscut de paşi,
scrierea de programe echivalente

Definiţie:
Programarea reprezintă întreaga activitate depusă pentru obţinerea unui program, deci
atât proiectarea algoritmului cât şi traducerea acestuia în limbajul de programare ales.
Principiul programării structurate, formulat de Bohm şi Jacopini, afirmă că orice algoritm
poate fi compus din numai trei structuri de calcul:
- instrucţiuni simple;
- structură alternativă;
- structură repetitivă.

Instrucţiunile simple sunt: de atribuire, de apel şi de salt

Instrucţiunea de atribuire specifică faptul ca unei variabile îi este atribuită o valoare.

- Exemplu în Turbo Pascal - Exemplu în C++

var i: integer; Int x;
i:=7 …
variabilei „i” i se atribuie valoarea 7 x=10
variabilei „x” i se atribuie valoarea 10

Instrucţiunea de apel specifică activarea (apelul) unei funcţii al cărei nume apare în
instrucţiune.

- Exemplu în Turbo Pascal - Exemplu în C++

var r: integer; putch (c-’a’+’A’);
procedure calcul (x, y:integer; var
rez:integer); este apelată funcţia putch
begin
rez:=x*x+y*y*y+5;
end;
{…}
calcul (2, 3, r);

Instrucţiunea de salt indică faptul că execuţia se întrerupe şi se continuă în alte parte a

programului, la locul specificat.

- Exemplu în Turbo Pascal - Exemplu în C++

instrucţiunea goto instrucţiunea return, break, continue, goto

Structură alternativă
- cu o singură ramură
Sintaxa instrucţiunii este:

20
În Turbo Pascal: În C++ şi Java
if Condiţie then if Condiţie
instrucţiune 1 instrucţiune 1

Interpretare: După evaluarea expresiei booleene Condiţie, dacă valoarea rezultată este
adevărată atunci se execută instrucţiune 1, iar în caz contrar se trece direct la
următoarea structură.
- cu două ramuri

Sintaxa instrucţiunii este:

În Turbo Pascal: În C++ şi Java
if Condiţie then if Condiţie
instrucţiune 1 instrucţiune 1
else else
instrucţiune 2 instrucţiune 2

Interpretare: După evaluarea expresiei booleene Condiţie, dacă rezultatul evaluării este
fals, instrucţiune 1 este sărită şi va fi executată ramura else, adică se va executa
instrucţiune 2.
- selecţie multiplă (case / switch)

Sintaxa instrucţiunii
În Turbo Pascal: În C++ şi Java
case expresie of switch (expresie)
caz 1: instrucţiune 1; [case ValoareIndividuală: instrucţiuni]
………………… [default: InstrucţiuniImplicite]
caz n: instrucţiune n;
else instrucţiune n+1
end;

Interpretare: se evaluează expresie. Dacă valoarea ei este egală cu una din constantele
cazurilor, se alege secvenţa de prelucrare corespunzătoare, după care se continuă cu
secvenţele de prelucrare ale cazurilor următoare. Daca valoarea expresiei nu este
egală cu nici una din constantele cazurilor, se execută instrucţiunea situată după else /
se alege secvenţa corespunzătoare etichetei default.

Structuri repetitive
- cu test iniţial
Sintaxa instrucţiunii
În Turbo Pascal: În C++ şi Java
While expresie do While expresie
instrucţiune instrucţiune

Interpretare: se evaluează expresie; dacă are valoare adevărată, atunci se execută

instrucţiune. Apoi se revine la punctul în care se evaluează din nou valoarea expresiei.
În felul acesta, corpul ciclului se execută cât timp expresia este adevărată. Dacă
expresia este falsă, instrucţiune nu se execută şi se trece la instrucţiunea următoare
instrucţiunii while.
- cu test final

Sintaxa instrucţiunii

21
În Turbo Pascal: În C++ şi Java
Repeat instrucţiune Do instrucţiune
Until expresie_logică while (expresie)

Interpretare: se execută instrucţiune şi apoi se evaluează expresie. Când aceasta este

falsă se revine la executarea instrucţiunii, iar când devine adevărata se trece la
instrucţiunea următoare.
- cu număr cunoscut de paşi

Sintaxa instrucţiunii
În Turbo Pascal: În C++ şi Java
For variabila:= For(exp1, exp2, exp3)
valoare_iniţială (to/downto) instrucţiune
valoare_finală do instrucţiune unde: exp1, exp2, exp3 sunt expresii

Sugestii metodologice
UNDE PREDĂM? Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă dotată cu video-proiector
CUM PREDĂM?
Metode:
- Expunere
- Conversaţie
Profesorul defineşte structurile fundamentale de control, prezintă interpretarea fiecărui
tip de structură.
- Exemplificare
- Practic
Propune rezolvarea unor programe astfel:
Pentru structura alternativa: să se scrie un program care citeşte valorile variabilelor
neîntregi a şi b, calculează rădăcina ecuaţiei ax+b=0 şi afişează rezultatul.
Pentru structura repetitivă cu test iniţial: să se scrie un program care citeşte un întreg n,
calculează şi afişează pe n!.
Pentru structura repetitivă cu test final: Să se calculeze suma: S=1+1/2+1/3+…+1/n
Pentru structura repetitivă cu număr cunoscut de paşi: Să se calculeze suma
S=1+3+5+…+(2n-1)
Se recomandă utilizarea calculatoarelor pentru activităţile de fixare a noilor cunoştinţe.

Ca materiale de evaluare se pot folosi:

o Probe scrise şi practice

22
Tema 8: Programarea structurata. Structuri fundamentale de control
Fişa suport 8 - Corectitudinea programelor

- corectarea greşelilor de sintaxă şi de semantică

- corectitudinea datelor (declaraţiilor)
- corectitudinea atribuirilor
- corectitudinea ciclurilor repetitive
- declararea tuturor variabilelor utilizate
- identificarea şi corectarea bug – urilor

Corectarea greşelilor de sintaxă şi de semantică

Programul obţinut în limbaj maşină se numeşte cod obiect. În această etapă
compilatorul poate determina erori de sintaxă ale programului.
O eroare de sintaxă este o greşeală în gramatica limbajului. Astfel se repetă compilarea
până la eliminarea tuturor erorilor de sintaxă.
Urmează apoi rularea programului compilat. Astfel se vor pune în evidenţă erorile de
logică ale programului. Erorile de logică sunt erori care sunt produse de metoda de
rezolvare a problemei. Astfel, deşi programul este scris corect din punct de vedere al
sintaxei acesta poate executa ceva ce este incorect în contextul aplicaţiei. Poate fi
ceva simplu, de exemplu realizarea unei operaţii de scădere în loc de adunare. O formă
particulară a erorilor de logică este apariţia erorilor de rulare (run-time error). O eroare
de rulare va produce o oprire a programului în timpul execuţiei pentru că anumite
instrucţiuni nu pot fi realizate. De exemplu o împărţire la zero.
Astfel se impune ca în această etapă programul să fie reverificat şi apoi erorile să fie re-
corectate.
Exemplu: C++ necesită ca fiecare linie să se termine cu ;.
Dacă se uită plasarea ; atunci compilatorul va semnala eroarea de sintaxă.

Corectitudinea datelor (declaraţiilor)

O dată se consideră corectă dacă respectă o serie de condiţii aritmetice sau logice
prestabilite. Corectitudinea datelor presupune precizarea următoarelor elemente:
- Condiţiile de verificare
- Acţiunile care trebuie executate când data este corectă sau incorectă
- Modul de semnalare a erorilor şi structura mesajelor
- Modul de corecţie a erorilor
- Modul de reintroducere a articolelor după corecţia acestora
Verificarea corectitudinii se poate face la nivel de câmp (un câmp respectă propriile
sale condiţii), la nivel de articol (respectarea unor relaţii între câmpurile aceluiaşi
articol), la nivelul mai multor articole (respectarea unor relaţii între câmpurile unor
articole diferite, completitudinea pe pachete de documente, corectitudinea unor totaluri
pe pachete) sau la nivel de fişier (completitudine, corectitudinea unor totaluri pe fişier).
Cele mai importante verificări la nivel de câmpuri şi la nivel de articol se referă la:
- Existenţa
- Natura
- Lungime
- Semn
- Apartenenţa la o mulţime sau lista de valori
- Respectarea unor corelaţii aritmetice sau logice între câmpuri

23
Dacă o dată nu îndeplineşte toate condiţiile stabilite, se consideră eroare şi se solicită
reintroducerea ei. Introducerea se poate repeta, fie până se obţine o dată corectă, fie
până când se depăşeşte un număr prestabilit de reintroduceri.

Corectitudinea atribuirilor
Forma generală a unei atribuiri este
v = expresie
unde v este o variabilă simplă, referenţiază un element de tablou (variabila cu indici)
sau de structură, iar expresie este fie o expresie aritmetică, relaţională sau logică.
Atribuirea are ca efect atribuirea valorii expresiei aflată în dreapta semnului de atribuire,
variabilei v.
Dacă tipul identificatorului v nu este compatibil cu tipul expresiei, la compilare se
afişează o eroare de sintaxă.
Dacă valoarea expresiei din dreapta semnului de atribuire nu este de acelaşi tip sau un
tip compatibil cu tipul variabilei v, trebuie făcuta o conversie a rezultatului la care se
evaluează expresie spre tipul variabilei din stânga semnului de atribuire.
O construcţie de forma
v1 = (v = expresie) este corectă şi reprezintă tot o expresie de atribuire: lui v1 i se
atribuie valoarea atribuită în prealabil lui v, făcându-se şi conversie dacă e necesar.

Corectitudinea ciclurilor repetitive

Un ciclu repetă execuţia unei anumite secvenţe de instrucţiuni şi este necesar ca
repetarea să nu aibă loc la infinit.
Exemplu:
În limbajul Pascal, instrucţiunea while are forma:
while c do B.
Instrucţiunea B este executată în mod repetat, atâta timp cât condiţia c este adevărată.
O executare a instrucţiunii B se numeşte iteraţie. După ultima iteraţie condiţia c devine
falsă. Dacă c este falsă de la început, atunci există zero iteraţii. Dacă c este totdeauna
adevărată, numărul de iteraţii este infinit şi instrucţiunea while nu se termină.

Declararea tuturor variabilelor utilizate

O variabilă este o locaţie de memorie căreia i s-a atribuit un nume şi care poate conţine
diferite valori. Toate variabilele trebuie declarate înainte de utilizarea lor, în scopul de a
pregăti compilatorul în ceea ce priveşte tipul variabilei ce va fi utilizată.
Exemplu: Limbajul C suporta cinci tipuri de date, împreună cu cuvintele cheie care le
reprezintă.

Identificarea şi corectarea bug – urilor

Respectarea următoarelor reguli poate conduce la evitarea introducerii unor bug-uri în
aplicaţie.
- Aplicaţia se proiectează cu atenţie prin notarea evenimentelor importante şi a
modului în care codul va răspunde la fiecare eveniment. Fiecare procedură
generală, ca şi fiecare procedură eveniment trebuie să aibă un scop specific,
bine definit.

24
 - Se vor include cât mai multe comentarii. La întoarcerea în cod şi analiza
comportării aplicaţiei, comentariile privind scopul fiecărei rutine sunt de un real
ajutor.
- Se va dezvolta sau adapta o schemă consistentă de construcţie a denumirilor
pentru variabilele şi obiectele din aplicaţie.

Sugestii metodologice
UNDE PREDĂM? Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă
CUM PREDĂM?
Metode:
- Expunere
- Conversaţie
Profesorul defineşte noţiunile legate de corectitudinea programelor, corectarea erorilor.
- Exemplificare

Ca materiale de evaluare se pot folosi:

o Probe orale, scrise şi practice

25
Tema 9: Tablouri unidimensionale (Vectori)
Fişa suport 9 - Tablouri unidimensionale

Definiţie:
Un şir de elemente de acelaşi tip, în care contează ordinea elementelor, se numeşte
vector sau tablou unidimensional.
Un tablou (array) constă dintr-o succesiune de elemente, aflate într-o anumită ordine,
având toate acelaşi tip. Elementele pot fi identificate prin indici care sunt obligatoriu
tipuri ordinale.

Acces la componentele vectorului – referirea la elementele unui vector se face

printr-o variabila cu indici. O variabila cu indici se compune din numele vectorului urmat
de valorile indicelui, fiecare indice fiind reprezentat printr-o expresie inclusa intre
paranteze pătrate.

Sintaxa declarării tipului tablou este

- în Turbo Pascal - în Java
type_nume = array tip dată [ ] nume_array
[tip_ordinal1,......tip_ordinal n] of Exemplu
tip_oarecare ad [0]=99.99; //accesarea primului element
unde: ad [4]=0.001; // accesarea elementului 4
n - reprezintă dimensiunea tabloului for (int=0; i<ad.length; i++) ad [i] = i+4 //
tip_ordinal 1,... tip_ordinal n atribuirea de valori elementelor unui array
reprezintă tipul indicilor tabloului prin intermediul buclei for
tip_oarecare reprezintă tipul
componentelor tabloului
Exemplu:
type vector=array[1..100] of integer;
var v:vector;
variabila v este un tablou de dimensiune 1
cu 100 componente întregi identificate
prin indici din subdomeniul 1..100

Operaţii specifice
- citirea unui vector
Aceasta înseamnă citirea numărului n de componente, într-un ciclu for, de pildă. De
fapt avem de citit componenta numărului i, cu i de la 1 la n. Deci putem scrie:
- Exemplu în Turbo Pascal - Exemplu în C++
for i:= 1 to n do double a[5];
begin int i;
write('daţi x[',x,']='); for (i=0; i<5; i++)
readln(x[i]); { cout<<”a["<<i<<”]=”;
end; //afişarea unui mesaj prealabil citirii
fiecărui element
cin>>a[i];
//citirea valorii elementului de indice I }

26
- Scrierea unui vector
Când trebuie sa afişăm vectorul, adică toate componentele sale efective numărul
acestora este cunoscut. Afişarea se realizează ciclic şi poate fi astfel:
- fiecare element pe un rând (folosită mai ales când avem vectori şi şiruri de
caractere)
Exemplu în Turbo Pascal
for i:=1 to n do
writeln(x[i]);
- Parcurgerea unui vector presupune "vizualizarea" tuturor elementelor pe rând şi
prelucrare acestora. Parcurgerea într-un ciclu a poziţiilor elementelor din vector
i=1,2,3,...,n şi pentru fiecare valoare a lui i, "vizităm" şi prelucrăm elementul v[i], adică
elementul aflat pe poziţia i.
- Numărarea elementelor negative şi a celor pozitive dintr-un vector de numere.
Exemplu în Turbo Pascal
Fie NN Si NP cele două numere. Acestea se comportă ca două contoare, iniţial nule.
De fiecare dată când găsim în şirul de numere un element negativ se incrementează
NN.
NN:=NN+1,altfel NP
NN=0;NP=0;
for i:=1to n do
if x[i]<0 then inc(NN)
else inc(NP);
writeln('Exista',NN,'elemente negative');
writeln('Exista,'NP',elemente pozitive');
- afişarea elementelor pare dintr-un vector de numere întregi
- Exemplu în Turbo Pascal - Exemplu în C++
Se consideră var x: array [1..20] of integer Afişarea elementelor unui vector:
şi var n,i: integer. cout<<”Vectorul introdus este:\n”;
Vom parcurge vectorul şi vom afişa doar for (i=0; i<n i++)
numerele pare: cout<<a[i]<<’ ’;
for i:=1to n do if not odd (x[i]) then
WrileLn (x[i])

Utilitate
Sortare
- prin selecţie
Algoritmul presupune ca la fiecare pas “i “ să se găsească elementul minim dintre
a[i+1], a[i+2]…a[n] şi se interschimbă cu a[i].
Algoritmul este următorul:
Selecţie (a[nmax+1])
Pentru i 1 pana la n-1
{min a[i]
Pentru j i+1 pana la n
Daca (a[j] < min) min a[j]}
Daca (a[i]>min) interschimbă (a[i],a[j])
}
}
- prin inserţie
Algoritmul de sortare prin inserţie construieşte pas cu pas lista de elemente sortate,
adăugând la ea câte un element la un moment dat. La fiecare pas un element este
extras din lista iniţială şi este introdus în lista de elemente sortate. Elementul este

27
inserat în poziţia corectă în lista sortată, astfel încât ea să rămână sortată în continuare.
Algoritmul este următorul:
pentru i := 1 până la N-1
aux := a[i];
j := i-1;
cât timp (j>=0) si (a[j]>aux)
a[j+1] := a[j];
j := j-1;
sfârşit cât timp;
a[j+1] := aux;
sfârşit pentru;
- prin numărare :
Algoritmul sortează un vector A astfel: pentru fiecare element din vector se număra câte
elemente mai mici decât el exista în vector. Se va folosi un vector suplimentar K, iar
rezultatul se depune in vectorul B.
Algoritmul este următorul:
Pentru i:= 1 până la n
K[i]:=0;
Sfârşit pentru;
Pentru i:=1 până la n-1
Pentru j:= i+1 până la n
Daca a [i] < a[j]
atunci
K[j]:= k [j] +1;
Altfel
k[i]:= k[i] +1;
sfârşit pentru;
sfârşit pentru;
pentru i:=1 până la n
B [k [i] +1] := A[i]
sfârşit pentru;
- prin interschimbare
Acesta metoda se rezumă la a compara fiecare element cu celelalte, făcându-se
interschimbarea daca elementul mai mare are indexul mai mic. Este cea mai simplă
metode de sortare.
Algoritmul este următorul:
simple-sort (a[Nmax+ 1])
pentru i 1 până la n
pentru j i+1 până la n
dacă a[i]>a[j]
interschimbă (a[i], a[j])
}

Căutare
- secvenţială
Această operaţie necesită o parcurgere a vectorului, de la prima poziţie până la sfârşit
sau până s-a găsit elementul căutat. Găsirea elementului căutat este marcat de o
variabilă logică găsit, poziţionată iniţial pe fals. Fie x vectorul, iar a elementul căutat.
găsit:= fals;
i:= 1;
while (i<=n) and (not găsit) do
if x[i]=y then

28
găsit:=true
else
Inc(i)
- binară: se compară elementul căutat cu elementul din mijloc şi dacă ele nu coincide se
va trece la căutarea doar în acea jumătate a vectorului în care în mod logic elementul
căutat s-ar putea găsi: în stânga sau în dreapta, după cum elementul din mijloc este
mai mare sau mai mic decât elementul căutat, până când domeniul în care trebuie să
se mai caute s-a terminat.
s:=1; d:=N;
dacă (x<=a[d]) şi (x>=a[s]) atunci
repetă
m:=(s+d) div 2;
dacă x>a[m] atunci s:=m+1 altfel d:=m-1
sfârşit dacă;
până când (a[m]=x) sau (s>d);
sfârşit repetă;
sfârşit dacă;
dacă a[m]=x atunci { elementul căutat se află pe poziţia m }
altfel { nu exista elementul căutat }
sfârşit dacă;

Operaţiile aritmetice cu vectori

- adunarea a doi vectori
Fiind daţi doi vectori, A cu M cifre si B cu N cifre, adunarea lor se face în mod obişnuit,
ca la aritmetică. Pentru a evita testele de depăşire, se recomandă să se completeze
mai întâi vectorul cu mai puţine cifre cu zerouri până la dimensiunea vectorului mai
mare. La sfârşit, vectorul sumă va avea dimensiunea vectorului mai mare dintre A si B,
sau cu 1 mai mult dacă apare transport de la cifra cea mai semnificativă.
Exemplu în C++:
Procedura de mai jos adăuga numărul B la numărul A.
void Add(Huge A, Huge B)
/* A <- A+B */
{ int i,T=0;
if (B[0]>A[0])
{ for (i=A[0]+1;i<=B[0];) A[i++]=0;
A[0]=B[0];
}
else for (i=B[0]+1;i<=A[0];) B[i++]=0;
for (i=1;i<=A[0];i++)
{ A[i]+=B[i]+T;
T=A[i]/10;
A[i]%=10;
}
if (T) A[++A[0]]=T;
}

- Scăderea a doi vectori

Fie doi vectori A si B. Pentru a calcula diferenţa A – B se presupune B ≤ A. Pentru
aceasta, se porneşte de la cifra unităţilor şi se memorează la fiecare pas "împrumutul"
care trebuie efectuat de la cifra de ordin imediat superior (împrumutul poate fi doar 0

29
sau 1). Deoarece B ≤ A, avem garanţia că pentru a scădea cifra cea mai semnificativă a
lui B din cifra cea mai semnificativă a lui A nu e nevoie de împrumut.

Exemplu în C++:
void Subtract(Huge A, Huge B)
A <- A-B */
{ int i, T=0;
for (i=B[0]+1;i<=A[0];) B[i++]=0;
for (i=1;i<=A[0];i++)
A[i]+= (T=(A[i]-=B[i]+T)<0) ? 10 : 0;
/* Adică A[i]=A[i]-(B[i]+T);
if (A[i]<0) T=1; else T=0;
if (T) A[i]+=10; */
while (!A[A[0]]) A[0]--;
}

Înmulţirea unui vector cu un scalar

Această operaţie este o simplă implementare a modului manual de efectuare a
calculului. La înmulţirea "de mână" a unui număr mare cu unul de o singură cifră, noi
parcurgem deînmulţitul de la sfârşit la început, şi pentru fiecare cifră efectuăm
următoarele operaţii:
Înmulţim cifra respectivă cu înmulţitorul;
Adăugam "transportul" de la înmulţirea precedentă;
Separăm ultima cifră a rezultatului şi o trecem la produs;
Celelalte cifre are rezultatului constituie transportul pentru următoarea înmulţire;
La sfârşitul înmulţirii, dacă există transport, acesta are o singură cifră, care se scrie
înaintea rezultatului.
Exact acelaşi procedeu se poate aplica şi dacă înmulţitorul are mai mult de o cifră.
Singura deosebire este că transportul poate avea mai multe cifre (poate fi mai mare ca
9). Din această cauză, la sfârşitul înmulţirii, poate rămâne un transport de mai multe
cifre, care se vor scrie înaintea rezultatului.
Exemplu în C++:
void Mult(Huge H, unsigned long X)
/* H <- H*X */
{ int i;
unsigned long T=0;
for (i=1;i<=H[0];i++)
{ H[i]=H[i]*X+T;
T=H[i]/10;
H[i]=H[i]%10;
}
while (T) /* Cat timp exista transport */
{ H[++H[0]]=T%10;
T/=10;
}

Înmulţirea a doi vectori

Dacă ambele numere au dimensiuni mari, produsul lor se calculează înmulţind fiecare
cifră a deînmulţitului cu fiecare cifră a înmulţitorului şi trecând rezultatul la ordinul de
mărime (exponentul lui 10) cuvenit.
Exemplu în C++:
void MultHuge(Huge A, Huge B, Huge C)

30
/* C <- A x B */
{ int i,j,T=0;
C[0]=A[0]+B[0]-1;
for (i=1;i<=A[0]+B[0];) C[i++]=0;
for (i=1;i<=A[0];i++)
for (j=1;j<=B[0];j++)
C[i+j-1]+=A[i]*B[j];
for (i=1;i<=C[0];i++)
{ T=(C[i]+=T)/10;
C[i]%=10;
}
if (T) C[++C[0]]=T;
}

Împărţirea unui vector la un scalar

Ne propunem să scriem o funcţie care să împartă numărul A la scalarul B, să reţină
valoarea câtului tot în numărul A şi să întoarcă restul (care este o variabilă scalară).
Exemplu în C++:
unsigned long Divide(Huge A, unsigned long X)
/* A <- A/X si intoarce A%X */
{ int i;
unsigned long R=0;

for (i=A[0];i;i--)
{ A[i]=(R=10*R+A[i])/X;
R%=X;
}
while (!A[A[0]] && A[0]>1) A[0]--;
return R;
}
Împărţirea a doi vectori
Dacă se dau doi vectori A si B şi se cere să se afle câtul C şi restul R. Etapele de
parcurs sunt aceleaşi ca la punctul precedent. Cu alte cuvinte, după ce "coborâm" la
fiecare pas următoarea cifră de la deîmpărţit, trebuie să aflăm cea mai mare cifră X
astfel încât împărţitorul să se cuprindă de X ori în restul de la momentul respectiv. Acest
lucru se face cel mai comod prin adunări repetate: pornim cu cifra X=0 şi o
incrementăm, micşorând concomitent restul, până când restul care rămâne este prea
mic.
Exemplu în C++:
void DivideHuge(Huge A, Huge B, Huge C, Huge R)
/* A/B = C rest R */
{ int i;
R[0]=0;C[0]=A[0];
for (i=A[0];i;i--)
{ Shl(R,1);R[1]=A[i];
C[i]=0;
while (Sgn(B,R)!=1)
{ C[i]++;
Subtract(R,B);
}
}
while (!C[C[0]] && C[0]>1) C[0]--;

31
}

Sugestii metodologice
UNDE PREDĂM? Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă dotată cu video-proiector
CUM PREDĂM?
Metode:
- Expunere
- Conversaţie
- Învăţare prin descoperire
Profesorul defineşte vectorii, prezintă operaţiile cu vectori, algoritmii de sortare şi
căutare şi operaţiile aritmetice.
Se recomandă utilizarea calculatoarelor pentru activităţile de fixare a noilor cunoştinţe.

Ca materiale de evaluare se pot folosi:

o Probe orale, scrise şi practice

32
Tema 10: Tablou bidimensional (Matrice)
Fişa suport 10 - Tablou bidimensional

Definiţie:
Tablou bidimensional (matrice) = succesiune de locaţii de memorie recunoscute prin
acelaşi identificator şi prin poziţia fiecăruia în cadrul şirului. Poziţia este dată printr-o
suită de două numere pozitive, care reprezintă cele două dimensiuni (linie şi coloană).
Valorile atribuite elementelor tabloului trebuie să fie de acelaşi tip.

Declararea variabilelor de tip matrice

tip_data nume matrice[nr1] [nr2]

Unde
- tip data este tipul elementelor matricei
- nume matrice este identificatorul matricei
- nr1 este numărul de linii
- nr2 este numărul de coloane

Exemplu:

int a[4] [5];

Matricea a are elemente de tip int, 4 linii şi 5 coloane.

Acces la componentele tabloului

Pentru a folosi componentele individuale scriem numele tabloului urmat de o expresie
indice între []. Expresia specifică numărul componentei accesate şi poate fi atât
constantă cât şi variabilă ori o expresie mai complicată. Oricare ar fi, însă, forma
indicelui, acesta trebuie să fie o valoare întreagă.
Matrice pătratica = matricea care are numărul de linii egal cu numărul de coloane.
Exemplu:
m=3 n=3
100
356
201

Diagonala principală într-o matrice pătratică:

100
356
201

Diagonala secundară într-o matrice pătratică:

100
356
201

33
- Exemplu în Turbo Pascal - Exemplu în C++

type id_tip_tablou_bidimensional =
array [id_tip_sc_1, id_tip_sc_2] double q[3][2];
unde: id_tip_tablou_bidimensional este un // declararea matricei q, cu maxim3 linii şi
tip de dată definit ca tablou bidimensional, 2 coloane, tip double
iar id_tip_sc_1 şi id_tip_sc_2 sunt indici în
domenii scalare

Ca şi variabile simple, variabilele tablou trebuie declarate înainte de utilizare.

Operaţii specifice
- Citirea tablourilor bidimensionale (matricelor)
Citirea elementelor unui tablou nu este posibilă decât prin citirea fiecărui element. De
aceea, la fel ca şi în cazul vectorilor operaţia de citire a matricelor impune folosirea a
două secvenţe ciclice suprapuse. Acestea corespund indicilor liniei (i), respectiv
coloanei (j).
Pentru a citi elementele unei matrice avem nevoie de un indice pentru linii i şi unul
pentru coloane j. Trebuie specificat că m reprezintă numărul de linii al matricei, iar n
numărul de coloane.
Astfel citirea se realizează în trei etape:
a. se citeşte numărul de linii;
b. se citeşte numărul de coloane;
c. se citesc pe rând toate componentele.

Exemplu în Turbo Pascal:

var a: array[1..5][1..5] of integer;
m,n, i, j: integer;
Write (’Numărul de linii’);
readln(n);
write(’Numărul de coloane’);
readln(m);
for i := 1 to n do
for j:=1 to m do
begin
write(’Componenta=’);
readln(a[i,j]);
end;
- Afişarea matricelor se face componentă cu componentă.
For i:= 1 to n do
For j:=1 to m do
Write(a[i,j], ’ ’);

Operaţii aritmetice
- Adunare, scădere
Pentru a aduna/ scădea două matrice condiţia care trebuie respectată este că
dimensiunea celor doua matrice să fie aceeaşi. Prin dimensiunea unei matrice
înţelegem numărul de linii şi de coloane pe care aceasta le are. În aceste condiţii
adunarea/scăderea matricelor se face termen cu termen.

34
Pentru i:=1 pana la n
Pentru j:= 1 pana la n
Sfârşit pentru
Sfârşit pentru
C[i,j]:= 0
Pentru i:=1 pana la n
Pentru j:= 1 pana la n
C[i,j]:= A[i,j] + B[i,j]
Sfârşit pentru
Sfârşit pentru
- înmulţire
Înmulţirea matricelor cu un scalar real se realizează pe acelaşi principiu de calcul ca şi
adunarea matricilor: Se înmulţeşte primul element al matricei cu scalarul real dorit.
Pentru i:=1 până la n
Pentru j:= 1 până la n
C[i,j]:= 0;
Sfârşit pentru
Sfârşit pentru
Pentru i:=1 până la n
Pentru j:= 1 până la n
C[i,j]:= nr*A[i,j]
Sfârşit pentru
Sfârşit pentru
Înmulţirea matricilor
După cum se cunoaşte din algebra elementară operaţia de înmulţire a doua matrice se
realizează prin procedeul “linii prin coloane”. Există o singură restricţie asupra celor
doua matrice ce se înmulţesc, legată de numărul de linii şi coloane pe care le au cele
două matrice: adică numărul de coloane a primei matrice să fie egal cu numărul de linii
a celei de a doua matrice.
- Calculul determinantului unei matrice pătratice
Determinantul unei matrice pătratice (matrice cu număr egal de linii şi coloane) este un
număr ce se asociază matricei A, de dimensiune n.
- Inversarea matricilor
Operaţiunea de inversare a matricilor se poate aplica doar matricilor pătratice
nesingulare, adică cu determinantul diferit de zero.

Utilitate
Cu ajutorul matricei (de adiacenţă) se pot reprezenta grafurile. Grafurile sunt
reprezentări sub forma unor scheme a unor obiecte abstracte cu ajutorul cărora se pot
modela diferite realităţi concrete.
Matricea de adiacenţă este o matrice pătratică, linia şi coloana i corespunzând vârfului i
al grafului.
Elementele matricei de adiacenţă se definesc astfel:
1 dacă există muchie între i şi j
a ij  
0 în rest
2
3

1 graful reprezentat mai sus, matricea de adiacenţă este:

Pentru
4 5
35
  0 1 0 1 0
 
1 0 1 0 0
A  0 1 0 1 1
 
1 0 1 0 0
 0 0 1 0 0
 
Sisteme de ecuaţii
Prin sistem de ecuaţii înţelegem un sistem de ecuaţii polinomiale liniare cu număr egal
de necunoscute şi ecuaţii în care determinantul asociat sistemului este diferit de zero.
Un astfel de sistem de ecuaţii poate privit şi sub forma lui matriceală:
AX=B
unde
A este matricea sistemului formată din coeficienţii necunoscutelor
X reprezintă vectorul necunoscutelor
B este coloana termenilor liberi
Cu aceste notaţii, soluţia sistemului se poate exprima matriceal:
X = A-1 B prin înmulţirea ecuaţiei la stânga cu inversa matricei A.
Vectorul necunoscutelor se obţine astfel prin înmulţirea inversei matricei sistemului cu
coloana termenilor liberi, în această ordine. Ordinea acestor operaţii este esenţială
întrucât înmulţirea matricilor nu este comutativa.

Sugestii metodologice
UNDE PREDĂM? Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă dotată cu video-proiector
CUM PREDĂM?
Metode:
- Expunere
- Conversaţie
Profesorul defineşte noţiunile legate de tablou bidimensional: definirea, sintaxa,
operaţiile specifice.
- Exemplificare
Profesorul propune ca exemplu un program care citeşte elementele unei matrice.
Se recomandă utilizarea calculatoarelor pentru activităţile de fixare a noilor cunoştinţe.

Ca materiale de evaluare se pot folosi:

o Probe orale, scrise şi practice

36
Tema 11: Şiruri de caractere
Fişa suport 11 - Şiruri de caractere

Definire:
Şirul de caractere, după cum îi spune şi numele, reuneşte mai multe caractere sub "un
nume comun". Putem înţelege şirul de caractere ca fiind un cuvânt, o propoziţie sau o
frază, adică orice formulare scrisă ce conţine semne (litere, cifre, semne de punctuaţie,
semne speciale). Un şir de caractere se păstrează într-o zonă de memorie organizată
ca tablou unidimensional.

Declarare:
- Exemplu în Turbo Pascal - Exemplu în C++
Type char tab [ ] = „Acesta este un şir ”
SirMare = STRING; {implicit 255
poziţii}
SirMediu = STRING[120];{numai 120
poziţii}

Funcţii /clase definite pe şiruri

- Exemplu în Turbo Pascal - Exemplu în C++

CONCAT(sau+)– realizează concatenarea
şirurilor de caractere;
COPY – extrage din şirul de caractere, de
la o poziţie dată, un număr specificat de
caractere ;
LENGTH – întoarce lungimea unui şir de
caractere ;
POS – întoarce poziţia pe care un subşir îl
ocupă într-un şir de caractere ;
UPCASE – transformă toate literele mici în
majuscule ;
DELETE – şterge din şirul de caractere, de
la poziţia specificată, un număr de
caractere ;
INSERT – inserează un subşir într-un şir,
începând cu o anumită poziţie ;
STR – transformă o valoare numerică într-
un şir de caractere;
VAL – transformă un şir de caractere într-o
valoare numerică, dacă transformarea se
face fără eroare ;
Pentru a utiliza funcţiile care lucrează cu
şirurile de caractere trebuie inclusă
directiva
#include<string.h>
Funcţia strlen.
Are rolul de a returna lungimea unui şir
(fără a lua în considerare caracterul nul).
Forma generala : strlen(nume sir);
Funcţia strcpy.
Forma generala: strcpy (destinaţie, sursă)
Funcţia are rolul de a copia şirul de la
adresa sursa la adresa destinaţie
Funcţia strcat.
Forma generala: strcat (destinaţie, sursă)
Funcţia are rolul de a adăuga şirului de la
adresa destinaţie, şirul de la adresa
sursă;

37
 Sugestii metodologice
UNDE PREDĂM? Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă dotată cu video-proiector
CUM PREDĂM?
Metode:
- Expunere
- Conversaţie
Profesorul prezintă noţiunile teoretice (definire, declarare), apoi funcţiile folosite de
şirurile de caractere.

Ca materiale de evaluare se pot folosi:

Probe orale, scrise şi practice

38
Tema 12: Tipul înregistrare (articol)
Fişa suport 12 - Tipul înregistrare

Definire:
Tipul înregistrare permite gruparea datelor de tipuri diferite. O astfel de data numita
înregistrare putem spune că este alcătuita din mai multe câmpuri, nu neapărat de
acelaşi tip. Un câmp poate la rândul lui să fie alcătuit din mai multe câmpuri şi aşa mai
departe. Sunt şi situaţii în care nu toate înregistrările conţin aceleaşi informaţii, ceea ce
înseamnă că avem nevoie de o structură variabilă (diferite câmpuri) în funcţie de
anumite valori ale unor câmpuri fixe. În acest sens putem spune că o înregistrare are o
parte fixă formată din mai multe câmpuri de diverse tipuri, urmată eventual de o parte
variabilă.

Declarare:
- în Turbo Pascal - în C++
Record struct [nume structură]
type <identificator> = <tip record>; unde {
<tip record> ::= record <listă de câmpuri> [;] [<tip> <nume variabilă>];
end [<tip> <nume variabilă>];
<listă de câmpuri> ::= <parte fixă> [; <parte ...
variante>] | <parte variante> } [listă de variabile];
<parte fixă> ::= <secţiune record> {; Exemplu:
<secţiune record> } Este necesar să dăm un nume
<secţiune record> ::= <identificator>{, structurii. O să-i spunem: elev.
<identificator>}: <tip> struct elev
<parte variante> ::= case[ <identificator>:] {
<tip> of <variantă> {; <variantă>} char nume[200];
<variantă> ::= <constantă> {, <constantă>} float media;
:[<listă de câmpuri>] [;]) int absente;
adică un element de tip record este în };
general format dintr-o parte fixă şi una elev x[30];
variabilă, fiecare dintre acestea fiind alcătuită //am declarat un vector în care fiecare
din câmpuri. componentă este de tip elev.

Exemplu:
Type Data = record
ziua: 1..31;
luna: 1..12;
anul: 1..9999
end;

Acces la componentele variabilei

Un câmp al unei variabile de tip înregistrare se accesează prin:
nume_variabilă. câmp

Exemplu:
Fie următoarea declaraţie de variabilă:
x:data; {declarat la exemplul de mai sus}

39
 Accesul la câmpurile variabilei se face: x. ziua :=3; x. luna :=6; x. anul :=2009;

Operaţii specifice
Citirea unei variabile de tip înregistrare se face citind informaţiile corespunzătoare
fiecărui câmp al acesteia: readln (x. ziua); readln (x. luna); readln (x. anul);
Scrierea unei variabile de tip înregistrare se face scriind informaţiile corespunzătoare
fiecărui câmp al acesteia: writeln (x. ziua); writeln (x. luna); writeln (x. anul);

Utilitate
- Lista
Exemple de liste se întâlnesc destul de des în practica prelucrării datelor pe calculator.
Iată câteva: lista studenţilor dintr-o grupa şi a notelor primite la un examen, lista cărţilor
dintr-o biblioteca, lista clienţilor unei bănci, lista cadrelor didactice dintr-o catedra etc.
Putem defini lista ca o colecţie omogenă, secvenţială de date.

- Stiva
Stiva este un caz special de listă liniară în care intrările şi ieşirile se fac la un singur
capăt al ei.
Exemple de stive de obiecte sunt oarecum evidente: stive de lemne, de lăzi, de baloţi
de paie, de farfurii, de dosare etc. Structura de stivă presupune, conform definiţiei, o
anumită disciplină: totdeauna se adăugă un obiect "deasupra" ultimului depus si se
extrage totdeauna ultimul obiect adăugat. Se spune ca accesul la o stivă este de tip
LIFO (Last In - First Out). Două operaţii sunt esenţiale în lucrul cu stiva: adăugarea unui
element şi extragerea unui element din stiva.

- Cozi
Coada este lista liniară în care adăugarea de noi elemente se face la un capăt, iar
extragerea unui element se poate face numai prin celălalt capăt al listei.
Din definiţie rezulta că, întotdeauna, dintr-o coadă se extrage elementul cel mai vechi.
Se spune ca accesul la o coadă este de tip FIFO (First In First Out).
Ca şi în cazul stivei, operaţiile de bază asupra unei cozi sunt două: adăugarea unui
element în coada şi extragerea unui element din coadă.

- Arbori
Listele reprezintă mijloace simple şi practice de a reprezenta organizarea liniara a
obiectelor.
Realitatea complexă pe care o modelăm ne arată însa legături între obiecte care
depăşesc modelul liniar. Grafurile şi ca un caz particular al acestora - arborii - reprezintă
structuri capabile să surprindă complexitatea legăturilor dintre obiecte.
Cu ajutorul arborilor se pot descrie foarte fidel structurile de tip ierarhic (piramidal). Iată
câteva exemple: structura de conducere a unei firme, organizarea administrativ
teritoriala dintr-o tara, organizarea unei armate, structura unei cărţi.

Sugestii metodologice
UNDE PREDĂM? ? Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă dotată cu video-proiector
CUM PREDĂM?

40
Metode:
- Expunere
- Conversaţie
După prezentarea noţiunilor teoretice (definire, declarare, operaţii specifice) profesorul
propune exemple din viaţa cotidiană legate de utilitatea tipului înregistrare

Ca materiale de evaluare se pot folosi:

o Probe orale, scrise şi practice

41
Tema 13: Fişiere
Fişa suport 13 – Fișiere

Definire:
Fişierul este o colecţie organizată de informaţii (date, rezultate, programe sursă,
programe direct executabile etc.), dispuse pe unul sau mai multe suporturi externe.
Fişierul, în contextul limbajelor de programare, este o structură de date omogenă,
formată din componente de acelaşi tip.
Transferul informaţiilor între memoria internă şi cea externă se realizează la nivel de
articol. Pentru aceasta, în memoria internă va trebui să declarăm o variabilă având
acelaşi tip cu tipul înregistrărilor fişierului iar prin operaţiile de intrare / ieşire se va
realiza citirea, respective scrierea, în fişier.

Moduri de deschidere a fişierelor (citire, scriere, adăugare)

Orice fişier, înainte de a fi prelucrat trebuie deschis. Deschiderea se face în două etape:
în primul rând se precizează ce fişier se deschide şi apoi urmează deschiderea propriu-
zisă prin apelul unor proceduri/funcţii.

- Exemplu în Turbo Pascal - Exemplu în C++

Deschiderea unui fişier se face folosind Deschiderea se realizează cu funcţia open
procedura Assign(f, nume): se realizează care se apelează printr-o expresie de
asocierea numelui fişierului extern(nume) forma df= open (…) unde df este o
variabilei fişier(f) şi apoi procedura variabilă de tip int
Rewrite(f): pregăteşte pentru re(scriere)
fişierul f, înlocuindu-l cu un fişier vid(nu
conţine nici o componentă) şi stabilind
poziţia iniţială de scriere sau Reset(f):
pregăteşte fişierul f pentru citire, mutând
poziţia de citire la începutul fişierului

Citirea dintr-un fişier deschis se realizează folosind funcţia read.

- Exemplu în Turbo Pascal - Exemplu în C++
Citirea se face prin apelul procedurii La fiecare apel al funcţiei read se citeşte
Read(f, x): copiază următoarea înregistrarea curentă. Astfel, la primul apel
componentă a fişierului f în variabila x şi se citeşte prima înregistrare din fişier, la al
apoi avansează poziţia de citire dincolo de doilea apel a doua înregistrare şi aşa mai
această componentă sau Readln(f): trece departe.
la începutul următoarei lini a fişierului f.

Scrierea într-un fişier se face folosind funcţia write. Este asemănătoare cu funcţia read
şi are acelaşi prototip. Diferenţa constă în aceea că realizează transferul datelor în sens
invers, adică din zona de memorie, în fişier.
- Exemplu în Turbo Pascal - Exemplu în C++
Scrierea se face prin apelul procedurii Scrierea se face folosind funcţia write.
Write(f, x): adaugă în fişierul f o Utilizarea funcţiei implica includerea
componentă a cărei valoare este dată de fişierului io.h
expresia x şi deplasează poziţia de scriere
în dreptul noului sfârşit de fişier sau
Writeln(f): încheie linia curentă a fişierului

42
f.
Adăugarea se face prin apelul procedurii
Append(f): adăugă informaţii într-un fişier
deschis;

După terminarea prelucrări unui fişier acesta trebuie închis. Acest lucru se realizează
folosind funcţia close.
O funcţie utilă în programele care lucrează cu fişiere este funcţia Eof care spune dacă
s-a ajuns la sfârşitul fişierului.

Accesul la datele din fişier (secvenţial, direct)

Din punctul de vedere al accesului la componente, fişierele se împart în:
- fişiere cu acces secvenţial : componentele pot fi prelucrate(accesate) succesiv (unul
după altul) începând cu primul până la ultimul, în ordinea în care sunt înregistrate în
fişier;
- fişiere cu acces direct: componentele fişierului pot fi prelucrate în orice ordine prin
precizarea numărului de ordine din cadrul fişierului.

Operaţii de intrare/ieşire
- Exemplu în Turbo Pascal
Operaţiile de intrare / ieşire sunt Read (f,
art) respectiv Write (f, art) unde art este
variabila din memoria internă (declarată în
program) în, sau din care se face
transferul din / în fişier.
- Exemplu în C++
Intrări / ieşiri de şiruri de caractere:
biblioteca standard a limbajului conţine
funcţiile fgets şi fputs care permit citirea,
respectiv scrierea înregistrărilor care sunt
şiruri de caractere.
Intrări / ieşiri cu format: biblioteca standard
a limbajului conţine funcţiile fscanf şi fprintf
care permit citirea datelor dintr-un fişier,
respectiv scrierea.

Sugestii metodologice
UNDE PREDĂM? Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă dotată cu video-proiector
CUM PREDĂM?
Metode:
- Expunere
- Conversaţie
Profesorul prezintă funcţiile/procedurile necesare lucrului cu fişiere.
Se recomandă utilizarea calculatoarelor pentru activităţile de fixare a noilor cunoştinţe.

Ca materiale de evaluare se pot folosi:

o Probe orale, scrise şi practice

43
Tema 14: Utilizarea tipurilor structurate de date în aplicaţii practice

Fişa suport 14 – Tipuri structurate de date. Aplicatii

Folosirea tipurilor structurate de date duce la creşterea flexibilităţii programelor.

Tipul tablou grupează datele de acelaşi tip. Tablourile pot fi unidimensionale (vectori),
bidimensionale (matrice) sau cu mai multe dimensiuni.
Tipul şir de caractere oferă posibilităţi de lucru cu şiruri de caractere superioare
tablourilor cu tipul de bază caracter. Acestea se realizează cu funcţii şi proceduri. Multe
probleme trebuie să lucreze cu şiruri (de o lungime necunoscută) de variabile de acelaşi
tip. De exemplu, pentru a memora numele unor elevi, avem nevoie de un sir de date de
tip şir de caractere. Astfel de probleme pot fi soluţionate apelând la tipurile tablou.

Se recomandă ca aplicaţii practice pentru tipurile structurate de date, următoarele:

 pentru tablourile unidimensionale: un program care citeşte un vector şi îl afişează
în ordine inversă
 pentru tablourile bidimensionale: un program care tipăreşte calendarul, un orar
pentru elevi sau un program care transformă o matrice cu elemente reale, de m
linii şi n coloane, prin interschimbări de linii astfel încât pe coloana k (dată)
elementele să fie în ordine crescătoare şi apoi să se tipărească matricea în
forma ei finală.
 Pentru şiruri de caractere: un program care transformă un şir scris cu litere mici
în acelaşi şir cu litere mari şi invers, despărţirea unei propoziţii în cuvinte şi
numărarea lor.
 Pentru tipul înregistrare: se citesc informaţiile referitoare la elevii unei şcoli
(nume, clasa, nota 1..nota n) şi apoi se ordonează elevii descrescător după
medii şi se listează elevii în ordinea mediilor.
 Pentru fişiere: program care citeşte şiruri de numere de dimensiuni variabile
dintr-un fişier şi le afişează, un program care citeşte o matrice dintr-un fişier sau
un program care realizează o agendă telefonică care să permită gestionarea
unor persoane, a adreselor lor şi a numerelor de telefon.

Sugestii metodologice
UNDE PREDĂM? Conţinutul poate fi predat în:
- laboratorul de informatică
- sală de clasă dotată cu video-proiector
CUM PREDĂM?
Metode:
- Conversaţie
- Problematizare
Profesorul propune probleme pentru fiecare tip structurat de dată.

Ca materiale de evaluare se pot folosi:

Probe orale şi scrise

44
IV. Fişa rezumat

Unitatea de învăţământ __________________

Fişa rezumat

Clasa ________________ Profesor_____________________

Nume şi Competenţa 1 Competenţa 2 Competenţa 3
Nr.
prenume Observaţii
Crt. A1 A2 AX A1 A2 A3 A1 A2 A3
elev
1 zz.ll.aaaa1
2
3
4
...
Y

1
zz.ll.aaaa – reprezintă data la care elevul a demonstrat că a dobândit cunoştinţele, abilităţile şi atitudinile vizate prin activitatea respectivă
V. Bibliografie

1. Prejmerean, Vasile. (1999). Algoritmică şi programare, Cluj - Napoca: Litografia

Universităţii “Babeş - Bolyai”
2. Pătruţ, Bogdan. Miloşescu, Mariana (1999). Informatică – Manual pentru clasa a
IX-a, Bucureşti: Editura Teora
3. Kovacs, Sandor. (1993). Turbo pascal 6.0 – Ghid de utilizare, Cluj - Napoca:
Editura Microinformatica
4. Negrescu, Liviu. (1994). Limbajele C şi C++ pentru începători, Cluj - Napoca:
Editura Microinformatica
5. Haipl, Reinhold. (2003). Java pentru ingineri, Timişoara: Editura Mirton
6. ***. La http://facultate.regielive.ro 5.05.2009
7. ***. La http://infoscience.3x.ro 5.05.2009
8. ***. La http://www.upg-ploiesti.ro 14.05.2009