Przeciążenia operatorów dla klas

class TablicaD  // klasa z tablica liczb typu DOUBLE
{
private:
	int licznik;       // deklaracja licznika elementow tablicy
	int rozmiar;	   // deklaracja zmiennej uzywana jako rozmiar tablicy dynamicznej
	double *wtab;         // deklaracja wskaznika do utworzenia tablcy dynamicznej
	
	
	
public:
	TablicaD(int n);				  // deklaracja konstruktora
	~TablicaD();					  // deklaracja destruktora
	static int liczba_tablic;     // zmienna statyczna, zawierajaca informacje o ilosci utworzonych obiektow klasy Tablica

//==================================================================================================
//                   FUNKCJE SKLADOWE
	int size();
	int ile_tablic();
	void wypelnij();
	void wyswietl();																			 
	void zeruj();									 											  
	void zapis_do_pliku();	

		//funkcje sortujace
	void sortuj_m();																			  
	void sortuj_r();

		//funkcje zmienajace notacje
	void szesnastkowo();
	void naukowo();
	void osemkowo();

	//funkcja kontrolujaca prezycje
	void precyzja(int pr);
//==================================================================================================
	
	
};

#include "TablicaD.h"
#include "naglowek.h"

int TablicaD::liczba_tablic;   // definicja zmiennej statycznej (domyslnie inicjalizowana zerem)

TablicaD::TablicaD(int n)       // definicja funkcji konstruktora
{
	
	rozmiar = n;
	wtab = new double[rozmiar];		// dynamiczna alokacja tablicy
	cout << "Zostala utworzona tablica elementow double o rozmiarze: " << rozmiar << endl;
	liczba_tablic++;
}


TablicaD::~TablicaD(void)		 // definicja funkcji destruktora
{
	cout << "Destruktor usuwa obiekt /n";
	delete wtab;
	liczba_tablic--;
	
}

////////////////////////////////////////////////////////////////////////////////////////////////
//                          DEFINICJE FUNKCJI SKLADOWYCH
void TablicaD::wypelnij()      // funkcja wypelniajaca elementy tablicy
{
	for(int i=0; i<rozmiar; i++)
	{
		cout << "Podaj element nr " << i+1 << ": ";
		cin >> wtab[i];   // wypelnianie tablicy z kontrola precyzji wprowadzania do 3 miejsc po przecinku
		cout << endl;
		licznik++;
	}
}

void TablicaD::wyswietl()	   // funkcja wyswietlajaca zawartosc tablicy
{
	cout << "Aktualna zawartosc tablicy: " << endl;
	for(int i=0; i<rozmiar; i++)
	{
		cout << "Element " << i+1 << ". : "  << wtab[i] << endl;
	}
}

int TablicaD::size()		// funkcja zwracajaca jako wartosc liczbe elementow tablicy
{
	return rozmiar;
}

int TablicaD::ile_tablic()		// funkcja zwracajaca jako wartosc zmienna statyczna bedaca iloscia utworzonych obiektow
{
	return liczba_tablic;
}


void TablicaD::zeruj()		// funkcja zerujaca elementy tablicy
{
	cout << "\nTeraz nastapi zerowanie tablicy.\n";
	for(int i=0; i<rozmiar; i++)
	{
		wtab[i]=0;
	}

	wyswietl();
}

void TablicaD::zapis_do_pliku()		// funkcja zapisujaca strumieniowo zawartosc tablicy do pliku tablica.txt
{
	//zapis zawartosci tablicy do pliku
	ofstream plik;	
	plik.open("tablica.txt");
	plik << "Zawartosc tablicy: \n";
	for(int i=0; i<rozmiar; i++)
	{
		plik << wtab[i] << " ";
		
	}
	plik.close();
	
}

void TablicaD::sortuj_m()		// sortowanie elementow tablicy malejaco metoda babelkowa
{
	for(int j=0; j<rozmiar; j++)
	for(int i=0; i<rozmiar-1; i++)
	{
		if(wtab[i] < wtab[i+1]) 
		{
			int temp = wtab[i]; wtab[i] = wtab[i+1]; wtab[i+1] = temp;
		}
	}
		cout << "\n Po sortowaniu.\n";
		wyswietl();
}

void TablicaD::sortuj_r()		// sortowanie elementow tablicy rosnaco metoda babelkowa
{
	for(int j=0; j<rozmiar-1; j++)
	for(int i=0; i<rozmiar-1; i++)
	{
		if(wtab[i] > wtab[i+1]) 
		{
			int temp = wtab[i]; wtab[i] = wtab[i+1]; wtab[i+1] = temp;
		}
	}
	cout << "\n Po sortowaniu.\n";
	wyswietl();
		
}

void TablicaD::szesnastkowo()
{
	for(int i=0; i<rozmiar; i++)
	{
		cout << "Element " << i+1 << ". : " << hex << wtab[i] << endl;
	}
}

void TablicaD::naukowo()
{
	for(int i=0; i<rozmiar; i++)
	{
		cout << "Element " << i+1 << ". : " << scientific << wtab[i] << endl;
	}
}

void TablicaD::osemkowo()
{
	
	for(int i=0; i<rozmiar; i++)
	{
		cout << "Element " << i+1 << ". : " << oct << wtab[i] << endl;

	}
}

void TablicaD::precyzja(int pr)
{
	cout << "Aktualna zawartosc tablicy po kontroli precyzji: " << endl;
	for(int i=0; i<rozmiar; i++)
	{
		cout << "Element " << i+1 << ". : " << setprecision(pr+1) << wtab[i] << endl;
	}

}
/////////////////////////////////////////////////////////////////////////////////////////////

class TablicaD  // klasa z tablica liczb typu DOUBLE
{
   ....
   // operator wykonujący działanie typu TablicaD = TablicaD+TablicaD
   TablicaD operator+(const TablicaD &other) const;
};

TablicaD TablicaD::operator+(const TablicaD &other) const
{
   // dodać 'this' i 'other' wg. zadanego algorytmu i zwrócić wynik
}

TablicaD obiekt2(5);
	TablicaD suma(5);
	suma = obiekt + obiekt2;
	cout << "\n\nSuma wynosi: \n";
	suma.wyswietl();

TablicaD TablicaD::operator+(const TablicaD &other) const
{
	double *t = new double[rozmiar];

	for(int i=0; i<rozmiar; i++)
	{
		t[i] = this->wtab[i] + other.wtab[i];
	}
	
              TablicaD *nowy_obiekt = new TablicaD();
              nowy_obiekt->wtab = t;
              return nowy_obiekt;
}

No instance of constructor "TablicaD::TablicaD" matches the argument list.
No suitable constructor exists to convert from "TablicaD *" to "TablicaD" 

TablicaD* TablicaD::operator+(const TablicaD &other) const
{
        double *t = new double[rozmiar];
 
        for(int i=0; i<rozmiar; i++)
        {
                t[i] = this->wtab[i] + other.wtab[i];
        }
 
              TablicaD *nowy_obiekt = new TablicaD(0);
              nowy_obiekt->wtab = t;
              return nowy_obiekt;
}

TablicaD suma(5);
suma = obiekt + obiekt2;
suma.wyswietl();

#include <cstddef>
 
class Array
{
public:
    Array(): size(0), data(NULL) { ; }
    Array(size_t s): size(s), data(new double[s]) { ; }
    Array& operator=(const Array& a)
    {
        delete[] this->data;
        this->data = new double[a.size];
        for(size_t i = 0; i < a.size; ++i)
            this->data[i] = a.data[i];
        this->size = a.size;
        return *this;
    }
    
    Array operator+(const Array& a)
    {
        Array tmp(this->size + a.size);
        size_t i;
        for(i = 0; i < this->size; ++i)
            tmp.data[i] = this->data[i];
        for(size_t j = 0; j < a.size; ++i, ++j)
            tmp.data[i] = a.data[j];
        
        return tmp;
    }
private:
    size_t size;
    double* data;
};
 
int main()
{
    Array a(5);
    Array b(3);
    Array c;
    c = a + b;
    
    return 0;
}