Aspecte teoretice:

Prin matrice vom înţelege structura de date care este compusă dintr-un set finit
de elemente de unul şi acelaşi tip, alocate astfel ca poziţia fiecărui din elementele
matricei se determină univoc printr-un set aranjat de numere întregi (indici).
Indicii asigură posibilitatea accesului direct la fiecare element al matricei.

Vectorul reprezintă un set finit de elemente de unul şi acelaşi tip, alocate fizic în
memoria calculatorului, consecutiv unul după altul fără spaţii.

În memoria calculatorului matricele, aproape întotdeauna, sunt reflectate în vectori.

Matricele dreptunghiulare de dimensiuni mai mari de 1, de obicei se reflectă în vectori prin una
din următoarele două metode:
1. Mai repede se schimbă ultimul indice (aşa-numită metodă “pe linii”, denumirea provine de la
matricea de dimensiune 2);
2. Mai repede se schimbă primul indice (aşa-numită metodă “pe coloane”, denumirea provine de
la matricea de dimensiune 2).

Vector definitor este un vector “special ”, in care se salveaza niste marimi , care defines
matricea . Acest vector este folosit pentru a micsora numarul de operatii de + si x , la accesarea
elementelor matricei .

Într-un vector definitor se înscriu următoarele mărimi:

a) dimensiunea matricei (n);
b) marginile inferioare şi superioare pentru fiecare indice (lj, hj, j=1,2,...,n);
c) numărul de elemente în matrice;
d) mărimile Dj pentru j=1,2,...,n etc.

Amintim că numerele Dj depind de dimensiunea matricei, de intervalele de reprezentare a

indicilor şi de metoda de aranjare a elementelor în memoria operativă (“pe linii” sau “pe
coloane”).
În cazul în care sunt mai multe matrice de una şi aceeaşi dimensiune şi cu unele şi aceleaşi
interval de valori ale indicilor, aceste matrice pot folosi unul şi acelaşi vector definitor.

Vector Iliffe
Pentru a accesa elementele matricei prin accesul direct sau cu ajutorul vectorului definitor, este
necesar a efectua un şir de adunări şi înmulţiri, numărul cărora este proporţional cu dimensiunea
matricei. Informaticianul John K. Iliffe [16] a elaborat metoda care exclude înmulţirile şi reduce
la minim adunările la accesarea elementelor matricelor de orice dimensiune n, drept vorbind se
foloseşte mai multă memorie.
Esenţa constă în aceea că împreună cu fiecare matrice se păstrează şi o ierarhie de vectori,
care au căpătat denumirea vectori Iliffe.

Cu numele matricei se asociază un pointer cu adresa primului vector Iliffe deplasată în

corespondenţa cu valoarea de jos a primului indice în cazul aranjării “pe linii”, sau cu valoarea de
jos a ultimului indice în cazul aranjării “pe coloane”.
Listingul programului:
#include <iostream>
#include <fstream>
#include <string>
#include "windows.h"

using namespace std;

class caracter
{
public:
unsigned char c;
public:
caracter()
{
c='\0';
}

caracter(unsigned char ch)

{
c=ch;
}

void introducere(ifstream& f);

int operator == (caracter &e2) {

return (this->c==e2.c); }

};

std::istream& operator >> (std::istream& in, caracter& m){

in >> m.c;
return in;
}

std::ostream& operator << (std::ostream& out, const caracter& m)

{
out << m.c ;
return out;
}

void caracter::introducere(ifstream& f)
{
f >> *this;
}

//pe linii

template <class T>

class matrice_l
{
protected:
T *v;
int l1, h1;
int l2, h2;
int l3, h3;
int l4, h4;

public:
matrice_l<T>(int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
{

2
 this->l1=l1;
this->h1=h1;
this->l2=l2;
this->h2=h2;
this->l3=l3;
this->h3=h3;
this->l4=l4;
this->h4=h4;

int nr_elem=(this->h1-this->l1+1)*(this->h2-this->l2+1)*(this->h3-this->l3+1)*(this-
>h4-this->l4+1);

v=new T[nr_elem];

matrice_l<T>(string f,int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
{
this->l1=l1;
this->h1=h1;
this->l2=l2;
this->h2=h2;
this->l3=l3;
this->h3=h3;
this->l4=l4;
this->h4=h4;

int nr_elem=(this->h1-this->l1+1)*(this->h2-this->l2+1)*(this->h3-this->l3+1)*(this-
>h4-this->l4+1);
v=new T[nr_elem];

ifstream fin(f);

for(int i=0; i<nr_elem; i++)

v[i].introducere(fin);
fin.close();

virtual T& elem(int i1, int i2, int i3, int i4)
{
int D1, D2, D3, D4;
D4=1;
D3=(h4-l4+1)*D4;
D2=(h3-l3+1)*D3;
D1=(h2-l2+1)*D2;
return v[(i1-l1)*D1+(i2-l2)*D2+(i3-l3)*D3+(i4-l4)*D4];
}

virtual void afisare()

{
cout<< "Afisare matrice"<<endl<<endl;
int i1,i2,i3,i4;

for( i1=l1; i1<=h1; i1++)

{

cout<<"i1= "<<i1<<endl;
for(i2=l2; i2<=h2; i2++)
{

cout<<"i2= "<<i2<<endl;
for(i3=l3; i3<=h3; i3++)
{

3
 cout<<endl;
for(i4=l4; i4<=h4; i4++)
cout << elem(i1,i2,i3,i4)<<" ";
}
cout<<endl<<"=============="<<endl;
}
cout<<endl;
}
}

virtual void afisare_vector()

{
cout<< "Afisare vector"<<endl<<endl;
int nr_elem=(h1-l1+1)*(h2-l2+1)*(h3-l3+1)*(h4-l4+1);

for(int i=0; i<nr_elem; i++)

{
cout << i <<". ";
cout << v[i] <<endl;
}
}

virtual int cautare(T e)

{
int position = -1;
int nr_el=(h1-l1+1)*(h2-l2+1)*(h3-l3+1)*(h4-l4+1);
for(int i=0; (position==-1) && i<nr_el ; i++)
if(e==this->v[i])
position=i;
return position;
}

virtual int cautare(T e,int &i1, int &i2, int &i3,int &i4)
{
int found = 0;
for(int i1t=l1; i1t<=h1 && !found; i1t++)
for(int i2t=l2; i2t<=h2 && !found; i2t++)
for(int i3t=l3; i3t<=h3 && !found; i3t++)
for(int i4t=l4; i4t<=h4 && !found; i4t++)
if(e==elem(i1t, i2t, i3t, i4t))
found=1, i1=i1t, i2=i2t, i3=i3t, i4=i4t;
return found;
}

};
//vector definitor pe linii

template <class T>

class matrice_l_vd: public matrice_l<T>
{
protected:
int *d;
public:
matrice_l_vd<T>(int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
:matrice_l<T>(l1,h1,l2,h2,l3,h3,l4,h4)
{
d=new int[15];

d[0]=3; // dimension
d[1]=l1;
d[2]=h1;
d[3]=l2;
d[4]=h2;
d[5]=l3;
d[6]=h3;

4
 d[7]=l4;
d[8]=h4;
d[9]=(h1-l1+1)*(h2-l2+1)*(h3-l3+1)*(h4-l4+1); //nr de elemente
d[10]=1; // D4
d[11]=(h4-l4+1)*d[10]; // D3
d[12]=(h3-l3+1)*d[11]; //D2
d[13]=(h2-l2+1)*d[12]; //D1
d[14]=l1*d[10]+l2*d[11]+l3*d[12]+l4*d[13]; // suma (ljxDj)
}

matrice_l_vd<T>(string f,int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
:matrice_l<T>(f,l1,h1,l2,h2,l3,h3,l4,h4)
{
d=new int[15];

d[0]=3; // dimension
d[1]=l1;
d[2]=h1;
d[3]=l2;
d[4]=h2;
d[5]=l3;
d[6]=h3;
d[7]=l4;
d[8]=h4;
d[9]=(h1-l1+1)*(h2-l2+1)*(h3-l3+1)*(h4-l4+1); //nr de elemente
d[10]=1; // D4
d[11]=(h4-l4+1)*d[10]; // D3
d[12]=(h3-l3+1)*d[11]; //D2
d[13]=(h2-l2+1)*d[12]; //D1
d[14]=l1*d[10]+l2*d[11]+l3*d[12]+l4*d[13]; // suma (ljxDj)
}
/*
virtual T& elem(int i1, int i2, int i3, int i4)
{
return matrice_l<T>::v[d[14]];
}
*/
} ;

//vectoe ILIFFE pe linii

template <class T>

class matrice_l_Illife:public matrice_l<T>
{
protected:
T**** va;
public:
matrice_l_Illife<T>(int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
:matrice_l<T>(l1,h1,l2,h2,l3,h3,l4,h4)
{
int i1, i2 ,i3 , d, step;
d=-l4;
step=h4-l4+1;
va = new T***[h1-l1+1] - l1;
for(i1=l1; i1<=h1; i1++)
{
*(va+i1) = new T**[h2-l2+1] - l2;
for(i2=l2; i2<=h2; i2++)
{
*(*(va+i1)+i2)=new T*[h3-l3+1] - l3;
for(i3=l3; i3<=h3; i3++, d+=step)
*(*(*(va+i1)+i2)+i3)=matrice_l<T>::v+d;
}
}
}

5
 matrice_l_Illife<T>(string f,int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
:matrice_l<T>(f,l1,h1,l2,h2,l3,h3,l4,h4)
{
int i1, i2 ,i3 , d, step;
d=-l4;
step=h4-l4+1;
va = new T***[h1-l1+1] - l1;
for(i1=l1; i1<=h1; i1++)
{
*(va+i1) = new T**[h2-l2+1] - l2;
for(i2=l2; i2<=h2; i2++)
{
*(*(va+i1)+i2)=new T*[h3-l3+1] - l3;
for(i3=l3; i3<=h3; i3++, d+=step)
*(*(*(va+i1)+i2)+i3)=matrice_l<T>::v+d;
}
}
}

T& elem(int i1, int i2, int i3, int i4)

{
return *(*(*(*(va+i1)+i2)+i3)+i4);
}
};

////// pe coloane

template <class T>

class matrice_c
{
protected:
T *v;
int l1, h1;
int l2, h2;
int l3, h3;
int l4, h4;

public:
matrice_c<T>(int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
{
this->l1=l1;
this->h1=h1;
this->l2=l2;
this->h2=h2;
this->l3=l3;
this->h3=h3;
this->l4=l4;
this->h4=h4;

int nr_elem=(this->h1-this->l1+1)*(this->h2-this->l2+1)*(this->h3-this->l3+1)*(this-
>h4-this->l4+1);

v=new T[nr_elem];

matrice_c<T>(string f,int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
{
this->l1=l1;
this->h1=h1;
this->l2=l2;
this->h2=h2;

6
 this->l3=l3;
this->h3=h3;
this->l4=l4;
this->h4=h4;

int nr_elem=(this->h1-this->l1+1)*(this->h2-this->l2+1)*(this->h3-this->l3+1)*(this-
>h4-this->l4+1);
v=new T[nr_elem];

ifstream fin(f);

for(int i=0; i<nr_elem; i++)

v[i].introducere(fin);
fin.close();

virtual T& elem(int i1, int i2, int i3, int i4)
{
int D1, D2, D3, D4;
D1=1;
D2=(h1-l1+1)*D1;
D3=(h2-l2+1)*D2;
D4=(h3-l3+1)*D3;
return v[(i1-l1)*D1+(i2-l2)*D2+(i3-l3)*D3+(i4-l4)*D4];
}

virtual void afisare()

{
cout<< "Afisare matrice"<<endl<<endl;
int i1,i2,i3,i4;

for( i4=l4; i4<=h4; i4++)

{

cout<<"i4= "<<i4<<endl;
for(i3=l3; i3<=h3; i3++)
{

cout<<"i3= "<<i3<<endl;
for(i1=l1; i1<=h1; i1++)
{
cout<<endl;
for(i2=l2; i2<=h2; i2++)
cout << elem(i1,i2,i3,i4)<<" ";
}
cout<<endl<<"=============="<<endl;
}
cout<<endl;
}
}

virtual void afisare_vector()

{
cout<< "Afisare vector"<<endl<<endl;
int nr_elem=(h1-l1+1)*(h2-l2+1)*(h3-l3+1)*(h4-l4+1);

for(int i=0; i<nr_elem; i++)

{
cout << i <<". ";
cout << v[i] <<endl;
}
}

virtual int cautare(T e)

7
{
int position = -1;
int nr_el=(h1-l1+1)*(h2-l2+1)*(h3-l3+1)*(h4-l4+1);
for(int i=0; (position==-1) && i<nr_el ; i++)
if(e==this->v[i])
position=i;
return position;
}

virtual int cautare(T e,int &i1, int &i2, int &i3,int &i4)
{
int found = 0;
for(int i1t=l1; i1t<=h1 && !found; i1t++)
for(int i2t=l2; i2t<=h2 && !found; i2t++)
for(int i3t=l3; i3t<=h3 && !found; i3t++)
for(int i4t=l4; i4t<=h4 && !found; i4t++)
if(e==elem(i1t, i2t, i3t, i4t))
found=1, i1=i1t, i2=i2t, i3=i3t, i4=i4t;
return found;
}

};

// vector definitor pe coloane

template <class T>

class matrice_c_vd: public matrice_c<T>
{
protected:
int *d;
public:
matrice_c_vd<T>(int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
:matrice_c<T>(l1,h1,l2,h2,l3,h3,l4,h4)
{
d=new int[15];

d[0]=3; // dimension
d[1]=l1;
d[2]=h1;
d[3]=l2;
d[4]=h2;
d[5]=l3;
d[6]=h3;
d[7]=l4;
d[8]=h4;
d[9]=(h1-l1+1)*(h2-l2+1)*(h3-l3+1)*(h4-l4+1); //nr de elemente
d[10]=1; // D1
d[11]=(h1-l1+1)*d[10]; // D2
d[12]=(h2-l2+1)*d[11]; //D3
d[13]=(h3-l3+1)*d[12]; //D4
d[14]=l1*d[10]+l2*d[11]+l3*d[12]+l4*d[13]; // suma (ljxDj)
}

matrice_c_vd<T>(string f,int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
:matrice_c<T>(f,l1,h1,l2,h2,l3,h3,l4,h4)
{
d=new int[15];

d[0]=3; // dimension
d[1]=l1;
d[2]=h1;
d[3]=l2;
d[4]=h2;
d[5]=l3;
d[6]=h3;

8
 d[7]=l4;
d[8]=h4;
d[9]=(h1-l1+1)*(h2-l2+1)*(h3-l3+1)*(h4-l4+1); //nr de elemente
d[10]=1; // D1
d[11]=(h1-l1+1)*d[10]; // D2
d[12]=(h2-l2+1)*d[11]; //D3
d[13]=(h3-l3+1)*d[12]; //D4
d[14]=l1*d[10]+l2*d[11]+l3*d[12]+l4*d[13]; // suma (ljxDj)
}
/*
virtual T& elem(int i1, int i2, int i3, int i4)
{
return matrice_l<T>::v[d[14]];
}
*/
} ;

//vector ILLIFE pe coloane

template <class T>

class matrice_c_Illife:public matrice_c<T>
{
protected:
T**** va;
public:
matrice_c_Illife<T>(int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
:matrice_c<T>(l1,h1,l2,h2,l3,h3,l4,h4)
{
int i4, i2 ,i3 , d, step;
d=-l1;
step=h1-l1+1;
va = new T***[h4-l4+1] - l4;
for(i4=l4; i4<=h4; i4++)
{
*(va+i4) = new T**[h3-l3+1] - l3;
for(i3=l3; i3<=h3; i3++)
{
*(*(va+i4)+i3)=new T*[h2-l2+1] - l2;
for(i2=l2; i2<=h2; i2++, d+=step)
*(*(*(va+i4)+i3)+i2)=matrice_c<T>::v+d;
}
}
}

matrice_c_Illife<T>(string f,int l1,int h1,int l2,int h2,int l3,int h3,int l4,int h4)
:matrice_c<T>(f,l1,h1,l2,h2,l3,h3,l4,h4)
{
int i4, i2 ,i3 , d, step;
d=-l1;
step=h1-l1+1;
va = new T***[h4-l4+1] - l4;
for(i4=l4; i4<=h4; i4++)
{
*(va+i4) = new T**[h3-l3+1] - l3;
for(i3=l3; i3<=h3; i3++)
{
*(*(va+i4)+i3)=new T*[h2-l2+1] - l2;
for(i2=l2; i2<=h2; i2++, d+=step)
*(*(*(va+i4)+i3)+i2)=matrice_c<T>::v+d;
}
}
}

T& elem(int i1, int i2, int i3, int i4)

9
{
return *(*(*(*(va+i4)+i3)+i2)+i1);
}
};

int main()
{
int r;
l1:
cout << "Alegeti :"<<endl;
cout << "1. Metoda directa (pe linii)"<<endl;
cout << "2. Metoda directa (pe coloane)"<<endl;
cout << "3. Metoda vectorului definitor (pe linii)"<<endl;
cout << "4. Metoda vectorului definitor (pe coloane)"<<endl;
cout << "5. Metoda vectorului Iliffe (pe linii)"<<endl;
cout << "6. Metoda vectorului Iliffe (pe coloane)"<<endl;
cout << "0. Iesire"<<endl;
cout << "Ati ales ==> ";

cin >> r;
cout << endl;

switch(r)
{
case 1:
{
matrice_l<caracter> A("char.txt", -7, -5, -1, 0, 4, 7, 0, 3);
A.afisare();

cout<< "Introduceti caracterul cautat: ";

char ch;
int i1,i2,i3,i4;
cin>>ch;
cout<<endl;

int pozitia=A.cautare(ch);
if(pozitia<0)
{
cout<< "Nu exista asemenea caracter !!!! "<<endl;
}
else
{
A.cautare(ch,i1,i2,i3,i4);
cout<< "Caracterul ==> "<<ch<<" se afla pe pozitia ==> "<<pozitia<<" ,";
cout << "cu indicii ("<<i1<<","<<i2<<","<<i3<<","<<i4<<")"<<endl;
}

A.elem(-7,-1,4,0)='a';
A.afisare_vector();

system("pause");system("cls");
goto l1;
}

case 2:
{
matrice_c<caracter> A("char.txt", -7, -5, -1, 0, 4, 7, 0, 3);
A.afisare();

cout<< "Introduceti caracterul cautat: ";

char ch;

10
 int i1,i2,i3,i4;
cin>>ch;
cout<<endl;

int pozitia=A.cautare(ch);
if(pozitia<0)
{
cout<< "Nu exista asemenea caracter !!!! "<<endl;
}
else
{
A.cautare(ch,i1,i2,i3,i4);
cout<< "Caracterul ==> "<<ch<<" se afla pe pozitia ==> "<<pozitia<<" ,";
cout << "cu indicii ("<<i1<<","<<i2<<","<<i3<<","<<i4<<")"<<endl;
}

A.elem(-7,-1,4,0)='a';
A.afisare_vector();

system("pause");system("cls");
goto l1;
}

case 3:
{
matrice_l_vd<caracter> A("char.txt", -7, -5, -1, 0, 4, 7, 0, 3);
A.afisare();

cout<< "Introduceti caracterul cautat: ";

char ch;
int i1,i2,i3,i4;
cin>>ch;
cout<<endl;

int pozitia=A.cautare(ch);
if(pozitia<0)
{
cout<< "Nu exista asemenea caracter !!!! "<<endl;
}
else
{
A.cautare(ch,i1,i2,i3,i4);
cout<< "Caracterul ==> "<<ch<<" se afla pe pozitia ==> "<<pozitia<<" ,";
cout << "cu indicii ("<<i1<<","<<i2<<","<<i3<<","<<i4<<")"<<endl;
}

A.elem(-7,-1,4,0)='a';
A.afisare_vector();

system("pause");system("cls");
goto l1;
}

case 4:
{
matrice_c_vd<caracter> A("char.txt", -7, -5, -1, 0, 4, 7, 0, 3);
A.afisare();

cout<< "Introduceti caracterul cautat: ";

char ch;

11
 int i1,i2,i3,i4;
cin>>ch;
cout<<endl;

int pozitia=A.cautare(ch);
if(pozitia<0)
{
cout<< "Nu exista asemenea caracter !!!! "<<endl;
}
else
{
A.cautare(ch,i1,i2,i3,i4);
cout<< "Caracterul ==> "<<ch<<" se afla pe pozitia ==> "<<pozitia<<" ,";
cout << "cu indicii ("<<i1<<","<<i2<<","<<i3<<","<<i4<<")"<<endl;
}

A.elem(-7,-1,4,0)='a';
A.afisare_vector();

system("pause");system("cls");
goto l1;
}

case 5:
{
matrice_l_Illife<caracter> A("char.txt", -7, -5, -1, 0, 4, 7, 0, 3);
A.afisare();

cout<< "Introduceti caracterul cautat: ";

char ch;
int i1,i2,i3,i4;
cin>>ch;
cout<<endl;

int pozitia=A.cautare(ch);
if(pozitia<0)
{
cout<< "Nu exista asemenea caracter !!!! "<<endl;
}
else
{
A.cautare(ch,i1,i2,i3,i4);
cout<< "Caracterul ==> "<<ch<<" se afla pe pozitia ==> "<<pozitia<<" ,";
cout << "cu indicii ("<<i1<<","<<i2<<","<<i3<<","<<i4<<")"<<endl;
}

A.elem(-7,-1,4,0)='a';
A.afisare_vector();

system("pause");system("cls");
goto l1;
}

case 6:
{
matrice_c_Illife<caracter> A("char.txt", -7, -5, -1, 0, 4, 7, 0, 3);
A.afisare();

cout<< "Introduceti caracterul cautat: ";

char ch;
int i1,i2,i3,i4;
cin>>ch;
cout<<endl;

12
 int pozitia=A.cautare(ch);
if(pozitia<0)
{
cout<< "Nu exista asemenea caracter !!!! "<<endl;
}
else
{
A.cautare(ch,i1,i2,i3,i4);
cout<< "Caracterul ==> "<<ch<<" se afla pe pozitia ==> "<<pozitia<<" ,";
cout << "cu indicii ("<<i1<<","<<i2<<","<<i3<<","<<i4<<")"<<endl;
}

A.elem(-7,-1,4,0)='a';
A.afisare_vector();

system("pause");system("cls");
goto l1;
}

case 7:
{
system("pause");system("cls");
goto l2;
}

default:
{
cout<< "gresit!!!"<<endl; system("pause");system("cls"); goto l1;
}

l2: return 0;
}

Afisarea rezultatelor:

13
Concluzie:
La accesarea directa a elementelor masivului se utilizeaza cel mai mic volum de meorie operativa
dar din cauza volumului mare de operatii, timpul de accesare este cel mai mare. In cazul accesarii
prin vector definitoriu numarul de operatii este redus dar volumul de memorie ocupat este ceva
mai mare ca in cazul accesarii directe in functie marimea matricei se cer celule de memorie de
numere intregi suplimentare si un pointer.
In cazul vectorulor Iliffe timpul de accesare este cel mai mic deoarece se reduce la minin numarul
de adunari la accesarea elementelor, dar volumul de memorie este cel mai mare deoarece
împreună cu fiecare matrice se păstrează şi o ierarhie de vectori, care au căpătat de denumirea
vectori Iliffe.
Cu numele matricei se asociază un pointer cu adresa primului vector Iliffe deplasată în
corespondenţa cu valoarea de jos a primului indice în cazul aranjării “pe linii”, sau cu valoarea de
jos a ultimului indice în cazul aranjării “pe coloane”.

14