Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Supraincarcarea operatorului paranteze patrate de 2 ori in C++ creind o matrice.
/**
Titlu: Supraincarcarea operatorului [][] in C++ creind o matrice.
Autor: Luca Andrei
Ideone: http://ideone.com/y8Km37
Descriere: De fapt operatorul [][] nu poate fi supraincarcat,
deoarece el nu este operator )), ma contrazic pe mine ce am scris in titlu ).
De fapt aici sunt doi operatori []. Pentru a "supraincarca" [][], avem nevoie
sa cream 2 clase, si pentru fiecare in parte sa supraincarcam [].
Urmariti exemplul de mai jos pentru lamurire.
/**/
#include <iostream>
using namespace std;
/**
Mai intii vom crea clasa Vector care este doar o singura linie dintr-o matrice
/**/
class Vector {
private:
// in m tinem numarul de elemente intr-o linie
int m;
// columns este un pointer la int
// pe care la construirea unui Vector vom aloca m elemente pentru columns
int* columns;
public:
// Definim constructorul implicit, este nevoie de el obligatoriu
// mai jos voi lamuri pentru ce
Vector(): m(0), columns(NULL) {}
// Definim constructorul general, anume el va aloca memorie pentru columns
Vector(int m): m(m)
{
// alocam un array de m elemente
columns = new int[m];
}
// Aici este supraincarcat unul din operatorii []
// el va returna o referinta a unui element din tabloul columns
int& operator [] (int j)
{
return columns[j];
}
};
/**
Acum vom crea a doua clasa Matrice. De fapt aceasta este prima clasa
iarasi ma contrazic. )
/**/
class Matrice {
private:
// in n tinem numarul liniilor matricei
int n;
// lines este un pointer la Vector
// daca tineti minte Vector este o singura linie din matrice
// pe care la construirea unei matrici vom aloca n Vectori pentru lines
Vector* lines;
public:
// Constructorul general cu 2 parametri, linii si coloane
Matrice(int n, int m): n(n)
{
// alocam pentru lines n Vectori
// utilizind new fiecare Vector este creat cu ajutorul constructorului
// implicit. Am mentionat mai sus ca in clasa Vector constructorul implicit
// este obligatoriu, in caz contrar compilatorul va arunca o eroare
lines = new Vector[n];
// mergem prin array-ul de linii creat
// si initializam fiecare Vector cu m elemente
for (int i = 0; i < n; ++i)
{
// aici folosim constructorul general pentru a crea m elemente
// pentru fiecare linie Vector
lines[i] = Vector(m);
}
}
// Supraincarcarea operatorului al doilea []
// el va returna referinta la Vectorul i din lines
Vector& operator [] (int i)
{
return lines[i];
}
};
int main(int argc, char const *argv[])
{
// cream o matrice 5 pe 5
Matrice m(5,5);
// numeroatarea se incepe de la 0
// m[3] va returna referinta la Vectorul 4 din m
// m[3][3] va returna o referinta la elementul 4 din
// vectorul m[3], deoarece m[3] returneaza referinta la Vector
for (int i = 0; i < 5; ++i)
{
for (int j = 0; j < 5; ++j)
{
m[i][j] = i + j;
}
}
for (int i = 0; i < 5; ++i)
{
for (int j = 0; j < 5; ++j)
{
cout << m[i][j] << " ";
}
cout << endl;
}
cout << endl << "That's all folks!" << endl;
return 0;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.