Przeciążenie operatora [] a przeciążenie [][], jak zrobić, czym zastąpić.

Question

Dobry wieczór. 
Ćwiczę przeładowanie operatorów w C++ ale mam problem z jednym.
Jeśli chcę przeładować operator indeksowania [], nie ma problemu, ale jeśli mam klasę, która ma określać macierz, ustaliłem sobie, że polami będą: ilość wierszy macierzy, ilość kolumn oraz tablica dwuwymiarowa tworzona dynamicznie. 
Chciałbym teraz znaleźć sposób, abym mógł pobrać dany element macierzy tak jak pobiera się element z tablicy dwuwymiarowej.
jeśli klasa to Matrix to:

Matrix Obj;
cout << Obj[2][2];

Pobiera element z 2 wiersza i 2 kolumny (indeksowanie od 1 ale to nie problem)
Mógłby ktoś mnie nakierować w jaki sposób to zrobić?

Answer 1

Mam wrażenie, że użycie operatora [] powinno zwracać obiekt do którego znowu będzie się dało użyć tego operatora

Comments

Tzn. klasa Matrix ma w sobie wskaźnik na obiekt tej klasy i zwraca go, a w nim są kolejne itd. itd.

Nie wiem czy to tak zadziała, wymyśliłem to przed chwilą.
EDIT: Każdy obiekt klasy matrix, powinien mieć w sobie tablicę wskaźników.

---

Nie bardzo rozumiem jak by to mogło działać.
Może jakaś rekurencja przy tym? 
Ale to się nie spisze, bo muszę według polecenia zrobić to w taki sposób, abym w kodzie mógł wywołać to w sposób jak przy tablicy 2W:
 

obj[][];

więc gdybym spróbował to jakoś zrobić w taki sposób, żeby operator [] rekurencyjnie wywoływał sam siebie (jeśli się tak da) to i tak przekazywał bym jedną wartość tylko do tego operatora. 

Chodziło Ci o coś takiego?
 

obj[obj[]]

 

 

---

Chodziło mi o to:
 

class Matrix{
    Matrix *tab;
    Operator[](int indeks) zwracający obiekt o podanym indeksie;
        return tab[indeks];
}

 

---

Nadal ciężko mi to pojąć.
Klasa która ma za zmienną obiekt samej siebie i indeks tego obiektu jest zwracany.
Może napiszę jak wygląda klasa:
 

class Matrix{
     double **macierz;
     int wiersze, kolumny;
   public:
     double operator [](int index)
     {
        // i tu ma nastapic przeladowanie ale w taki sposob,
        // zeby mozna bylo wywolac obiekt matrix z [][]
     }
}

int main()
{ 
  Matrix obj;
  obj[i][j];
}

 

Answer 2

Mając do dyspozycji tylko standardowe przeładowanie operatora indeksowania [], wywołując obiekt klasy Matrix np.:

Matrix obj;
cout << obj[0];   // Wypisuje element 0,0
cout << obj[1];   // Wypisuje element 1,0
cout << obj[2];   // Wypisuje element 2,0
// itd...

Ale napisałem coś takiego:

class helpM
{
private:
    double *macierzH;
public:
    helpM(int k, double* t)
    {
        macierzH = new double[k];
        for (int i = 0; i < k; i++)
            macierzH[i] = t[i];
    }
    ~helpM()
    {//Zwalnianie pamieci
 
    }
    double operator[](const int index2)
    {
        return macierzH[index2];
    }
};
 
double Matrix::operator [](const int index)
{
    helpM oH(kolumny, macierz[index]);
    return oH[index];
}

Czyli napisałem druga klasę, gdzie również zrobiłem przeładowanie, działa to tak:
Mamy przeładowanie operatora [] dla klasy Matrix,
 - w tym przeładowaniu tworzymy obiekt klasy helpM, w którym zostaje utworzona tablica      ale już 1W składająca się z wiersza (numer z indexu) tablicy z klasy Matrix
 - w drugiej klasie helpM również przeładowuje operator w którym zwracam element              index2 tej tablicy 1W, 
Niestety nie działa tak jakbym chciał, nadal nie mogę wywołać obiektu klasy Matrix z dwoma operatorami indeksowania. Ale przy wywołaniu jednego nie bierze już kolejno 0,0; 1,0 itd elementu tablicy 2W ale 0,0; 1,1; 2,2 itd.. 
Czyli chyba jest progres. Ktoś ma jakieś pomysły w jaki sposób to jeszcze mogę rozegrać? Jak poprawić mój kod, czy jest w ogóle sens poprawiania tego kodu czy nie ma on zupełnie sensu. 

Answer 3

Zrobiłem to tak:

#include <iostream>
#include <vector>

class Matrix
{
	class Row
	{
		std::vector<double>numbers;
	public:
		Row(unsigned x)
		{
			numbers.resize(x);
		}

		double& operator[](const unsigned index)
		{
			return numbers.at(index);
		}

		void show()
		{
			for (int i = 0; i != numbers.size(); i++)
				std::cout << numbers.at(i) << " ";
		}
	};

	std::vector<Row> rows;

public:
	Matrix(unsigned x, unsigned y)
	{
		for (int i = 0; i != y; ++i)
			rows.push_back(Row(y));
	}

	Row& operator[](const unsigned index)
	{
		return rows.at(index);
	}

	void show()
	{
		for (int i = 0; i != rows.size(); i++)
		{
			rows.at(i).show();
			std::cout << std::endl;
		}
	}

};


int main()
{
	Matrix mat(2, 2);

	mat[0][0] = 8;
	mat[1][0] = 2;
	mat[0][1] = 3;
	mat[1][1] = 11;

	mat.show();


	std::cin.get();
    return 0;
}

 

Comments

Okej, dzięki wielkie, posiedze jeszcze nad tym spróbując zrobić to bez wektorów

---

wystarczą tablice

---

No dobrze, to może jakaś podpowiedź?

---

#include <iostream>

class Matrix
{
	class Row
	{
		double*numbers;
		unsigned size;
	public:
		void init(unsigned x)	
		{
			size = x;
			numbers = new double[x];
		}

		~Row()
		{
			delete[] numbers;
		}

		double& operator[](const unsigned index) const
		{
			return numbers[index];
		}

		void show()
		{
			for (int i = 0; i != size; i++)
				std::cout << numbers[i] << " ";
		}
	};

	Row*rows;
	unsigned size;

public:
	Matrix(unsigned x, unsigned y)
		:size(y)
	{
		rows = new Row[y];
		for (int i = 0; i != size; i++)
			rows[i].init(x);
	}

	Row& operator[](const unsigned index) const
	{
		return rows[index];
	}

	void show()
	{
		for (int i = 0; i != size; i++)
		{
			rows[i].show();
			std::cout << std::endl;
		}
	}

	~Matrix()
	{
		delete [] rows;
	}

};


int main()
{
	Matrix mat(2, 2);

	mat[0][0] = 8;
	mat[1][0] = 2;
	mat[0][1] = 3;
	mat[1][1] = 11;

	mat.show();


	std::cin.get();
    return 0;
}

 

---

Dziękuję wszystkim za podpowiedzi, zrobiłem to zwracając w przeładowaniu wskaźnik.
Takie proste a tyle czasu zajęło. Czeka mnie długa praca :D
Pozdrawiam

class A
{
  double **t;
  //...
  double* operator [](int _el)
  {
     return t[el];
  }
};

int main()
{
  A obj(...);
  // ... 
  cout<<obj[w][k];
}