► PROGRAM C++ :
#include <fstream>
using namespace std;
void fill(const unsigned i, const unsigned j, const unsigned culoare_noua, const unsigned culoare_veche, const unsigned n, const unsigned m, int** matrice)
{
const int di[] = { -1, 0, 1, 0 };
const int dj[] = { 0, 1, 0,-1 };
if (i >= 0 && i < n && j >= 0 && j <= m && matrice[i][j] == culoare_veche)
{
matrice[i][j] = culoare_noua;
for (int vecin = 0; vecin < 4; vecin++)
fill(i + di[vecin], j + dj[vecin], culoare_noua, culoare_veche, n, m, matrice);
}
}
//Functie pentru alocarea dinamica a memoriei
int** alocare_mem(int n, int m) {
//Alocare linii
int** A = new int* [n];
//Alocare coloane
for (int col = 0; col < m; col++)
A[col] = new int[m];
//Returnare matrice alocata dinamic
return A;
}
void dealocare(int** A, int n) {
//Dealocare fiecare linie
for (int col = 0; col < n; col++)
delete A[col];
//Dealocare fiecare coloana
delete A;
}
int main()
{
//Deschidere fisiere
ifstream fin("culoare.in");
ofstream fout("culoare.out");
//Citire dimensiuni matrice
int n, m;
fin >> n >> m;
//Alocare memorie matrice
int** matrice;
matrice = alocare_mem(n, m);
//Citire matrice
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
fin >> matrice[i][j];
//Citire coordonate start, culoare
unsigned istart, jstart, culoare;
fin >> istart >> jstart >> culoare;
//Compensare pentru inceperea de la 0
--istart;
--jstart;
//Inchidere fisier citire
fin.close();
//Umplere recursiva
fill(istart, jstart, culoare, matrice[istart][jstart], n, m, matrice);
//Afisare
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
fout << matrice[i][j] << " ";
fout << endl;
}
//Inchidere fisier scriere
fout.close();
//Dealocare matrice
dealocare(matrice, n);
return 0;
}
► Explicatie :
O variabila (fie aceasta o variabila simpla, vector, matrice, ins.tanta a unei clase, s.a.m.d. ) este vizibila doar in functia/scope in care este declarat.
Pentru ca matricea noastra sa fie vizibila in functia fill avem doua optiuni :
- Trimitem matricea ca parametru (adaugam int** matrice la lista de parametrii). Deoarece o matrice este un pointer catre un vector de vectori NU este necesar sa transmitem matricea prin referinta. Putem accesa si modifica elementele matricei direct.
- Declaram matricea global (nerecomandat)
- Ne folosim de avantajele programarii orientate pe obiect (recomandat cu tarie)
Pentru alocarea/eliberearea memoriei in mod dinamic in C++ avem operatorii new si delete.
Pentru alocarea memoriei trebuie sa alocam memorie pentru fiecare linie (liniile sunt vectori de numere intregi, deci int *), iar pentru fiecare astfel de linie trebuie sa alocam memorie pentru m variabile de tip int.
Dealocarea se face in ordine inversa (dealocam fiecare linie apoi dealocam matricea = vectorul de linii).
Gasesti pe net mai multe resurse privind alocarea dinamica in C++.
Sfaturi :
- Incercam sa evitam variabilele declarate global pe cat posibil. In proiecte mari acestea pot cauza probleme greu de diagnosticat, deci e indicat sa ne invatam sa le evitam pe cat putem de acum.
- Incercam sa declaram constant tot ce ar trebui sa fie constant.
- Inchidem fisierele in momentul in care nu mai avem nevoie de ele pentru a putea elibera resurse.
- Nu uitam sa eliberam memoria alocata dinamic.
- In mod normal se evita proiectarea functiilor cu mai mult de 3-4 parametrii, folosind concepte de programare orientata pe obiecte (presupun ca nu ai invatat, din acest motiv nici nu am folosit aici).
- Incercam sa pastram codul cat mai usor de citit, punem nume sugestiv variabilelor.
- Evitam functiile recursive, utilizam stive/cozi pentru a putea rezolva problema iterativ (nu am respectat sfatul asta aici, am vrut sa modific codul tau, dar pe viitor tine minte ca implementarile recursive "costa" mai mult decat implementarile iterative)
Ai test pe exemplu in atasament
