+

Algoritmi și tehnici de
programare

Cursul 2
+
Cuprins

◼ Tipul Struct

◼ Organizarea externă a datelor în fișiere

◼ Fişiere text şi binare

+
Typedef

◼ Limbajul C/C++ dă posibilitatea programatorului

să introducă denumiri personalizate pentru
tipurile limbajului, cu ajutorul cuvântului cheie
typedef.

◼ typedef int Intreg; ▪ typedef int vector[10];

◼ typedef int varsta; ▪ typedef vector matrice[10];
◼ typedef int matrice [10][10];
▪ vector x;
▪ matrice y;
◼ Intreg a1,a2;
◼ varsta v1, v2;
◼ matrice m1, m2;
+
Tipul Struct

◼ Articolul:
◼ Structură statică
◼ Structură compusă, ierarhică
◼ Membri = câmpuri

◼ Nume și tip

◼ Structură neomogenă
◼ Câmpurile/membrii de tipuri diferite de date
◼ Access direct la membri
+
Tipul Struct

struct StructureName
{
dataType field1;
dataType field2;
.
.
.
dataType fieldn;
};
+
Tipul Struct

struct Student

{
int id;
char nume[20];
char prenume[20];
int grupa;
int note[10];

};
+
Tipul Struct

id nume prenume grupa nota

bytes 4 20 20 4 4*10
+
Tipul Struct
Există două posibilități de declarare a variabilelor care alcătuiesc
structura:

1) Declarând variabilele de tipul definit:

struct Student

{
int id;
char nume[20];
char prenume[20];
int grupa;
int note[10];

};

O variabilă de acest tip se declară astfel:

◼ Student s;

◼ s este o variabila de tipul Student care are 5 membrii.

+
Tipul Struct
#include <stdio.h>
struct complex
{
float im;
float re;
};
void main()
{
complex nr;
nr.re = 3;
nr.im = 4;
printf("nr=%.2f+%.2f * i",nr.re, nr.im);
}
+
Tipul Struct
2) Folosind typedef se poate redenumi orice tip structură:

typedef struct {
int id;
char nume[20];
char prenume[20];
int grupa;
int note[10];

} stud;
O variabilă de acest tip se declară astfel:

◼ stud s;

◼ //typedef struct student stud;

+
Tipul Struct

#include <stdio.h>
typedef struct {
float im;
float re;
} complex1;
void main()
{
complex1 nr1;
nr1.re = 3;
nr1.im = 4;
printf("nr=%.2f+%.2f * i",nr1.re, nr1.im);
}
+
Tipul Struct
#include <stdio.h>
struct complex
{
float im;
float re;
};
void main()
{
complex nr;
nr.re = 3;
nr.im = 4;
printf("nr=%.2f+%.2f * i",nr.re, nr.im);
}

// typedef struct complex comp2;

//comp2 nr2;
+
Tipul Struct

Pentru accesul la câmpurile unei variabile de tip

struct se foloseşte operatorul de selecţie directă, notat
cu ‘.’, operator cu prioritate maximă.
+
Tipul Struct

◼ Dacă s este o variabilă de tipul Student.

◼ Atunci:
◼ s.nume – reprezintă şirul nume al variabilei s;
◼ s.nume[0] - reprezintă primul caracter al şirului nume;
◼ s.nota[0] – reprezintă prima nota a variabilei s.
+
Tipul Struct
◼ Definirea variabilelor
◼ Student s1, studenti[20];

◼ Inițializare
◼ La definire
◼ Student s2 = {2120, "Ionut", "Popa", 1043, {10, 8, 9}};

◼ Referirea cîmpurilor
◼ strcpy(s1.nume, “Ionut");
◼ s1.id = 2121;
◼ studenti[0].nota[2] = 10;
+
Tipul Struct

◼ Între două variabile de acelaşi tip struct se poate folosi

atribuirea.

◼ Dacă s1, s2 sunt două variabile de tip Student, prin atribuirea

s1=s2, variabila s1 ia aceeaşi valoare ca variabila s2.
+
Tipul Struct
Putem avea un tip structurat ce conține în
interiorul său un alt tip structurat.
struct data

{
int an, luna, zi;

typedef struct persoana

◼ pers.datan.an=2022

{
char nume[20];
char adresa[30];
data datan;
int cod;

} pers;
+
Tipul Struct
typedef struct persoana

{
char nume[20];
char adresa[30];

typedef struct data{

int an, luna, zi;
◼ pers.datan.an=2022
} datan;
int cod;

} pers;
+
Tipuri de fişiere în C/C++
◼ Fișiere utilizator
◼ Text
◼ Binare

◼ Fișiere standard
◼ stdout
◼ stdin
◼ stderr
+
Fişiere text şi binare

◼ Există două tipuri de fişiere cu care se poate opera

într-un program:

◼ Fişierele text:
◼ stochează datele ca o secvenţă de caractere alfanumerice şi
conţinutul acestor fişiere poate fi vizualizat şi poate fi editat direct
cu ajutorul unui editor de texte.

◼ Fişierele binare:
◼ stochează informația fără prelucrări exact așa cum apare ea în
memorie
+
Organizarea externă a datelor în fișiere

◼ Structură de date externe

◼ Colecție omogenă din punct de vedere al:

◼ Conținutului: articole/înregistrări
◼ Prelucrărilor

◼ Caracteristici:
◼ Externe: nume, extensie, atribute
◼ Interne

◼ Abordare:
◼ Nivel logic
◼ Nivel fizic
+
Organizarea externă a datelor în fișiere

A1 A2 … Ak … An eof

marcator sfârşit
de fişier
început de fişier separatori de articole

Separatorii şi marcatorul sfârşit de

fişier pot fi fizici sau logici.

+ Fisiere: Abordare la nivel logic

Înregistrare logică

C1 C2 ... Cm

separatori de câmpuri
Ak
• Articole cu lungime:
• fixă
• variabilă Lk Ak
+
Fişiere: Abordare la nivel fizic
Zona tampon
(buffer)
• Blocul (înregistrare fizică)
Ai+1 Ai+2 ... Ai+k
I/

Ai+j
MP
/O

Zona articol
+
Moduri de acces la articole

◼ Acces secvențial

◼ Acces direct

◼ Acces dinamic
+
Moduri de acces la articole

Acces  determinarea adresei

Adresă articol = Adresă fişier + Deplasare

A1 A2 … Ak-1 Ak … An eof

D(Ak)

Pointer
(poziția curentă în fișier)
+
Moduri de acces la articole

Acces secvenţial

A1 A2 … Ak-1 Ak … An eof

D(Ak)
• Pentru articole cu lungime fixă:
D(A1) = 0
D(Ak) = D(Ak-1) + Lart; k=2,3,…,n
+
Moduri de acces la articole

Acces secvenţial (cont.)

• Pentru articole cu lungime variabilă:
D(A1) = 0
D(Ak) = f(D(Ak-1)) = D(Ak-1) + Lartk-1; k=2,3,…,n
+
Moduri de acces la articole

Acces direct după numărul relativ

0 1 … k-1 … n-1
( 1 2 … k … n )
A1 A2 … Ak … An eof

P(Ak)

Numărul relativ: P(Ak) = k-1 sau P*(Ak) = k

Deplasamentul: D(Ak) = P(Ak) x Lart sau
D(Ak) = P*(Ak) x Lart
+
Moduri de acces la articole

Acces direct după cheie

C1 C2 Ck Cn
eof

A1 A2 … Ak … An

Deplasamentul: D(Ak) = f(cheiek)

Cheia cu valori unice cheie primară
Cheia cu valori duplicate cheie secundară
+
Metode de organizare a fişierelor

◼ Principiile și regulile după care se memorează

articolele unui fișier pe suportul de memorie
extern
◼ se asigură protecția și regăsirea acestora
+
Metode de organizare a fişierelor

◼ Organizare Secvenţială

◼ Organizare Relativă

◼ Organizare Indexată
+
Operaţii de intrare/ieşire
la nivel de fişier

◼ Procesarea conținutului unui fișier presupune:

◼ Deschiderea fișierului
◼ fişier nou
◼ fişier existent
◼ Prelucrarea conținutului acestuia (citiri, scrieri)
◼ Închiderea fișierului
+
Nivelul superior de prelucrare a fişierelor

◼ Fişierul se descrie ca pointer către o structură

predefinită (FIB - File Information Block)

◼ FILE* fis;
◼ FILE * - un tip structură definită în stdio.h
+
Moduri de deschidere a fişierelor

Mod Scop

• Deschide un fişier existent pentru adăugare la sfârşit (extindere) sau

• Îl creează dacă nu există.
a
• Este permisă numai scrierea.
• Numai pentru fişiere text.
r • Deschide un fişier existent numai pentru citire
• Suprascrie un fişier existent sau creează unul nou,
w
• Permite numai operaţia de scriere
• Deschide un fişier existent pentru adăugare la sfârşit (extindere) sau îl creează dacă nu
există.
a+
• Sunt permise citiri şi scrieri.
• Numai pentru fişiere text.
r+ • Deschide un fişier existent pentru citire şi scriere
• Suprascrie un fişier existent sau creează unul nou.
w+
• Permite atât citiri cât şi scrieri.

Se poate adăuga: b – fişiere binare sau t – fişiere text

+
Moduri uzuale de deschidere a fişierelor

Operaţia de gestiune Fişiere text Fişiere binare

Creare w wb
Consultare r rb
Actualizare r+b
Creare şi actualizare w+ rwb, w+b
Extindere a
+
Operaţii la nivel de fişier

◼ Deschiderea fişierelor

◼ FILE* fopen(const char* nume_extern, const char* mod);

◼ Asignarea fişierelor

◼ FILE *fis = fopen(nume_extern, mod);

exemplu:
1. FILE* f;
f= fopen(“lista.txt”,"r");

2. FILE* f;
fopen_s(&f, nume,"r");
+
Operaţii la nivel de fişier

◼ Închiderea fişierelor

◼ int fclose(FILE* f);

+
Exemplu

char *numeFisier = "test.dat"; char *numeFisier = "test.dat";

FILE *fis = fopen(numeFisier, “rb"); FILE *fis;

if (fopen(numeFisier, “rb") !=
if (fis != NULL) NULL)

{ {
//… //…
fclose(fis);
fclose(fis);
}
}
+
Operaţii la nivel de fişier

◼ Redenumirea (mutarea) unui fişier

◼ int rename(const char* nume_vechi, const char* nume_nou);

◼ Ştergerea unui fişier

◼ int remove(const char* cale);
+
Operaţii la nivel de fişier

◼ Revenirea la începutul fişierului

◼ void rewind(FILE *f);

◼ Testarea sfârşitului de fişier

◼ int feof(FILE* f);

◼ Golirea zonei tampon

◼ int fflush(FILE* f);
+
Operaţii de intrare/ieşire
la nivel de articol

◼ Scriere
◼ Citire
◼ Poziţionare
◼ Rescriere
◼ Ştergere
+
Operaţii de citire/scriere cu conversie
◼ Scrierea pe bază de format
◼ int fprintf(FILE *fis, const char *spec, …)

◼ Citirea pe bază de format

◼ int fscanf(FILE *fis, const char *spec, …)

◼ Scrierea unui șir de caractere

◼ int fputs(const char *sir, FILE *fis)

◼ Citirea unui șir de caractere

◼ char * fgets(char *sir, int nrMax, FILE *fis)
◼ nrMax – 1 sau EOL

◼ Scrierea unui caracter

◼ int fputc(int car, FILE *fis)

◼ Citirea unui caracter

◼ int fgetc(FILE *fis)
+
Operaţii de citire/scriere cu conversie

◼ stdin și stdout sînt fișiere text

◼ Citirea de la tastatură
◼ citirea din fișiere text (stdin)
◼ fscanf( stdin, "%d", &x );
◼ sau scanf( "%d", &x );

◼ Scrierea pe ecran
◼ Scrierea în fișiere text (stdout)
◼ fprintf( stdout, "%d", x);
◼ sau printf("%d", x);
+
Fișiere text ca surse de date

◼ Fișierele text sunt utilizate în aplicații ca:

◼ Sursă de date inițiale
◼ Raport final
+
Fișiere text ca surse de date

float a[10];
int i, l = 0;
preluare_vector_1("test.txt", a, &l);
Vectorul preluat are 6 elemente:
1.11 2.22 3.33 4.44 5.55 23.12
if(!l)
printf("\n\nNu s-a putut deschide fisierul sau nu sint elemente");
else
{
printf("\n\nVectorul preluat are %d elemente: \n",l);
for(i=0;i<l;i++)
printf("%5.2f ",a[i]);
}
+
Fișiere text ca surse de date
int preluare_vector_1(float v[], int* n)
{
float x;
int er;
FILE *f ;
f= fopen(“fis1.txt”,"r");
*n=0;
if(f!=NULL)
{
while(fscanf(f, "%f", &x) > 0)
{
v[(*n)++]=x;
}
fclose(f);
er=1;
}
else er=0;
return er;
}
+
Fișiere text ca surse de date
int preluare_vector_2(float v[], int* n)
{
float x;
int er;
FILE* f;
f= fopen(“vector1.txt”,"r");
*n=0;
if(f!=NULL)
{
fscanf_s(f, "%f", &x);
while(!feof(f))
{
v[*n]=x;(*n)++;
fscanf_s(f, "%f", &x);
}
fclose(f);
er=1;
}
else er=0;
return er;
}
+
Fișiere text ca surse de date

void scrie_fis(float* v, int n)

{
FILE* f;
int i;
f = fopen("vector2.txt", "w");
for (i = 0; i < n; i++)
{
printf("%5.2f\t", v[i]);
fprintf(f, "%5.2f\t", v[i]);
}
fclose(f);
}
+
Fișiere text ca surse de date
int scrie_fis1()
{
FILE* f,* g;
float x;
int er;
f = fopen(“vector2.txt", "r");
if (f != NULL)
{
g = fopen(“vector3.txt", "w");
fscanf(f,"%f", &x);
while (!feof(f))
{
if (x > 2.0)
{
printf("%f\t",x);
fprintf(g,"%f\t",x);
}
fscanf(f, "%f", &x);
}
fclose(g);
fclose(f);
er = 1;
}
else er = 0;
return er;
}
+
Bibliografie
◼ C. Uscatu, C. Cocianu, M. Mircea, L. Pocatilu, Algoritmi
si tehnici de programare. Aplicații, Editura ASE București
2015
◼ C. Uscatu, M. Popa, L. Bătăgan, C. Silvestru,
Programarea Calculatoarelor. Aplicații, Ed. ASE, 2012
◼ I.Gh. Roşca, B. Ghilic-Micu, C. Cocianu, M. Stoica, C.
Uscatu, M. Mircea, Programarea calculatoarelor.
Algoritmi în programare, Ed. ASE Bucureşti, 2007
◼ I. Gh. Roşca, B. Ghilic-Micu, C. Cocianu, M. Stoica, C.
Uscatu, Programarea calculatoarelor. Ştiinţa învăţării unui
limbaj de programare, Teorie şi aplicaţii, Ed. ASE, 2003