Szablony specjalizacja operator+

0

Witam.
Mam szablonową klasę Matrix. Podstawowy szablon to

template<typename T,int Roz>
class Matrix  

Pierwszy argument to typ danych przechowywanych w macierzy, druga to rozmiar macierzy. Jest jedna bo macierz jest Roz x Roz czyli kwadratowa.
Specjalizacja tej macierzy to:

template<class T>
class Matrix<T,0>

Tworzy macierz 0 na 0 ale specjalizacja posiada konstruktor, w którym definiujemy wielkość macierzy.
Wywołanie wygląda tak:

Matrix<int, 0> Z(3);
 

Mój kłopot polega na tym, że chciałbym napisać operator+ i operator* działający w taki sposób aby

 
Matrix<int,3> A;
Matrix<int, 0> Z(3);

Tak stworzone macierze A i Z mające takie same wymiary, można było dodać:

 
Z + A;

Jednak jak ja napisałem ten operator+ to mam taki error z kompilatora: error: no match for 'operator+' in 'Z + A'.
Nie wiem jak go napisać poniżej podaje cały kod:

 
#include <iostream>
#include <vector>

using namespace std;

template<typename T,int Roz>
class Matrix
{
public:
    T tab[Roz][Roz];
    int z=Roz;
    Matrix()
    {
        for(int i=0;i<Roz;++i)
                for(int j=0;j<Roz;++j)
                    tab[i][j]=0;
    }
    T& operator()(int x,int y){
        return tab[x-1][y-1];
    }

    Matrix& operator+(Matrix<T,Roz> b)
    {
            Matrix<T,Roz> tmp;
            for(int i=0;i<Roz;++i)
                for(int j=0;j<Roz;++j)
                    tmp.tab[i][j]=this->tab[i][j]+b.tab[i][j];

    }

    Matrix& operator*(Matrix<T,Roz> b)
    {
            Matrix<T,Roz> tmp;
            for(int i=0;i<Roz;++i)
                for(int j=0;j<Roz;++j)
                    tmp.tab[i][j]=this->tab[i][j]+b.tab[i][j];

    }

    friend ostream& operator<<(ostream& out, Matrix<T,Roz> &v)
    {

    	for(int i=0;i<v.z;++i)
                {
                    for(int j=0;j<v.z;++j)
                        out<<v.tab[i][j]<<" ";

                    out<<endl;
                }
    	return out;
    }
};


template<class T>
class Matrix<T,0>
{
private:
     Matrix()
    {

    }
public:
    vector<vector<T> > tab;
    int z=0;

    Matrix(int z)
    {
        for(int i=0;i<z;++i)
            tab.push_back(vector<T>(z));
        this->z = z;
        for(int i=0;i<z;++i)
                for(int j=0;j<z;++j)
                    tab[i][j]=0;
    }
    T& operator()(int x,int y){
        return tab[x-1][y-1];
    }

    Matrix& operator+(Matrix<T,0> b)
    {
            Matrix<T,0> tmp(b.z);
            for(int i=0;i<z;++i)
                for(int j=0;j<z;++j)
                    tmp.tab[i][j]=this->tab[i][j]+b.tab[i][j];


    }
     Matrix& operator+(Matrix<T,0> &b)
    {
            Matrix<T,0> tmp(b.z);
            for(int i=0;i<z;++i)
                for(int j=0;j<z;++j)
                    tmp.tab[i][j]=this->tab[i][j]+b.tab[i][j];

    }



    friend ostream& operator<<(ostream& out, Matrix<T,0> &v)
    {

    	for(int i=0;i<v.z;++i)
                {
                    for(int j=0;j<v.z;++j)
                        out<<v.tab[i][j]<<" ";

                    out<<endl;
                }
    	return out;
    }
};



int main()
{
    Matrix<int,3> A;
    Matrix<int, 0> Z(3);
    A(1,1)=1;
    Z(1,1)=1;

    A + Z;


    return 0;
}

0

Tworzy macierz 0 na 0 ale specjalizacja posiada konstruktor, w którym definiujemy wielkość macierzy.
IMHO tym pomysłem sobie wszystko skomplikowałeś…

0

Jak bym sobie sam wymyślał zadania to bym problemów nie miał:] Wiem, że ta specjalizacja robi problemy ale musi być tak a nie inaczej.

0

Pisałem na szybko i nie sprawdziłem, czy na pewno zadziała. Daj ten kod w definicji szablonu klasy Matrix.

 
template <typename T2, int W>
Matrix operator+(const Matrix<T2,W>& b)
{
     assert(b.z == Roz && this->z == Roz);
     Matrix<T2,Roz> tmp;
     for(int i=0;i<Roz;++i)
        for(int j=0;j<Roz;++j)
	   tmp.tab[i][j]=this->tab[i][j]+b.tab[i][j];
      return tmp;
}
 
template <typename T2, int W>
Matrix& operator=(const Matrix<T2,W>& b)
{
     if(&b != this) {
        assert(Roz == W);
				
	for(int i=0;i<Roz;++i)
	   for(int j=0;j<Roz;++j)
	      this->tab[i][j] = b.tab[i][j];
     }
     return *this;
}

Btw. nie możesz zdefiniować składowej klasy (nie-const i nie-static) -> int z = Roz; Musisz to przenieść do konstruktora.

http://ideone.com/d7rEBN

1 użytkowników online, w tym zalogowanych: 0, gości: 1