Funkcja zwracająca obiekt klasy

Witam,
Zastanwiam się jak napisać funkcję która zwraca obiekt klasy.

void macierz::trans(const macierz& m1)
{
    macierz m(m1.k, m1.w);//towrzymy nową macierz o wymiarach macierzy m1.
           for ( int i = 0; i < m1.k; ++i)
	{
		for ( int j = 0; j < m1.w; ++j)// do nowej macierzy przepisujemy starą "od tyłu" transpozycja
		m.tab[i][j]=m1.tab[j][i];
	}
	return m; //zwracamy nową macierz
};

taki error się pojawia:

135 9 C:\Users\M\Desktop\AiR\C++\macierz.cpp [Error] return-statement with a value, in function returning 'void' [-fpermissive]
Wiem, że na pewno funcja nie może być void, bo w końcu zwraca macierz, czyli obiekt klasy. Jak to ugryźć?

dodanie znacznika <code> - fp

Nie powinna to być funkcja zaprzyjaźniona.

macierz macierz::trans(const macierz& m1)

W tym przypadku musi być przez wartość.

Może miałeś na myśli:

macierz macierz::trans()const
  {
   macierz m(k,w);//towrzymy nową macierz o wymiarach TEJ macierzy.
   for(size_t x=0;x<k;++x) for(size_t y=0;y<w;++y) m.tab[x][y]=tab[y][x];
   return m; //zwracamy nową macierz przez wartość
  };
//uzycie:
macierz M(Y,X);
macierz W=M.trans();

Dokładnie o to mi chodziło. Wielkie dzięki za pomoc.
Tylko nie rozumiem jednej linijki:

 macierz M(Y,X);

bez niej program się kompiluje i działą tak jak powinien. Więc po co ona jest?
Druga sprawa to czy w C++, w aplikacji konsolowej można odtwarzać pliki . wav? Nie mam na myśli jakiś skomplikowanych utworów, tylko 3 sekunowy dźwięk?

Biblioteka bass

Już rozumiem. Program mi działał tak jak należy, bo wcześniej miałem utworzone obiekty kalsy macierz.

Witam, jeszcze nie rozumiem dwóch rzeczy z C++, może to się wyda dla was banalne, chodzi o enkapsulacje, i destruktor.

 
#include<iostream>

using namespace std;

class figura
{
	public:
		int a, b;
	public:
		figura(int wysokosc, int szerokosc)
		{
			a=wysokosc;
			b=szerokosc;
		}
		int pole()
		{
			return a*b;
		}
};
int main()
{
	int p;
	figura f1(5, 6);
	p=f1.pole();
	cout<<p<<endl;
	if(f1.a!=f1.b)
	{
		f1.a=f1.a+2;
		f1.b=f1.b-1;
	}
	p=f1.pole();
	cout<<p;
}

Mamy taki przykładowy programik. W mainie chcę używać zmiennych a, b z klasy, żeby mieć do nich dostęp muszą być publiczne. Zmienne prywatne stosujemy tylko wtedy gdy z poza klasy nie chcemy na nich operować? Mam rację.
Druga sprawa to destruktor, kiedy go używać?, Na studiach mówili, że w destruktorze, zwalnia się pamięć, przydziloną do obiektu. Jeżeli w destruktorze, umieszczę

delete[] tab;

to zaraz po utworzeniu obiektu zwolni mi pamięć, a ja tego obiektu chcę używać, przez cały czas aż do zamknięcia programu. Więc co powinienm umieścić w destruktorze, kiedy zwalniać pamięć?

1. Nie muszą być publiczne, możesz dorobić gettery i settery: int A()const { return a; } void A(int v) { a=v; }
2. Nie masz racji, prywatne robimy wtedy kiedy niekontrolowana zmiana jednej może doprowadzić do powstania "niepoprawnego" obiektu.
3. Jak coś przydzielasz w konstruktorach lub metodach i zachowujesz to w polach obiektu to tworzysz destruktor
4. destruktor odpala się po zakończeniu życia obiektu, nie "zaraz po utworzeniu"

Na studiach mówili, że w destruktorze, zwalnia się pamięć, przydziloną do obiektu.
Tak Ci powiedzieli? ; D To znaczy niby nic błędnego w tym nie ma, niby przeważnie się tak robi... ale naucz człowieka jednego schematu myslowego to z innym nie bedzie mogl sobie poradzić.

U mnie w programie to wygląda tak:

macierz m1, m2, m3;
m1.wprowadz();
m2.wprowadz();
m3=m1+m2;
cout<<m3;

Podaj liczbe kolumn:1
Podaj liczbe wierszy:2
Podaj wartosc A11
1
Podaj wartosc A21
2
Podaj liczbe kolumn:1
Podaj liczbe wierszy:2
Podaj wartosc A11
3
Podaj wartosc A21
4
destruktor

| 1.79245e-317 |
| 1.79259e-317 |

Jak widać destrukor uruchamia się raz(na rzecz którego obiektu to nie wiem) i zwalnia pamięć, Wydaje mi się, że uruchamia się za wcześnie, bo przed wykonaniem operacji m1+m2.? Mam pytanie jak powinieniem zwalniać pamięć? Przykładowo nie chcę już w programie używać obiektu m2 i m3, tylko chce aby został m1?

Możesz tworzyc sztuczne bloki, po wyjsciu z nich zmiennej zdefiniowane w tych blokach przestają istniec. Mozesz też tworzyc obiekty za pomocą operatora new i new[] (to są dwa ROŻNE operatory, a nie dwa warianty jednego operatora).

Dzięki, jutro się douczę z tego. Jak coś nie będę wiedział to zapytam.

int main()
{
  int a;
  {
     int b;
     // tu istnieje a i b
  }
  // tutaj istnieje tylko a
  return 0;
}

pingwindyktator napisał(a):

int main()
{
  int a;
  {
     int b;
     // tu istnieje a i b
  }
  // tutaj istnieje tylko a
  return 0;
}

To wiem.
Może załączę fragment tego programu z którym mam kłopot. Najlepiej skompilować i uruchomić, wtedy wszysko widać co jest nie tak.

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<conio.h>

using namespace std;

class macierz
{	
	public:
		int k, w;
		double **tab;
	public:
		macierz();
		macierz(int kolumny, int wiersze)
		{
			k=kolumny;
			w=wiersze;
			tab = new double *[w]; 
			for ( int i = 0; i < w; ++i )
			{
			tab[i] = new double [k];
			}  
		}
		~macierz();
		void wprowadz();
		void wpisz();
		friend ostream& operator<<(ostream& out, macierz& m);
		friend macierz operator+(const macierz& m1, const macierz& m2);
};
macierz::macierz()
{
	k=w=0;
}
macierz::~macierz()
{
	delete[] tab;
}
void macierz::wprowadz()
{
	double tmp;
	cout<<"Podaj liczbe kolumn:" ; cin>>k;
	cout<<"Podaj liczbe wierszy:" ; cin>>w;
	tab = new double *[w]; //alokacja pamieci
	for ( int i = 0; i < w; ++i )
	{
		tab[i] = new double [k]; //alokacja pamieci
		for ( int j = 0; j < k; ++j) //wpisanie wartosci do tablicy
		{
			cout<<"Podaj wartosc A" <<i+1<<j+1<<endl;
			cin>>tmp;
			tab[i][j]=tmp;
		}
	}
};
ostream& operator<<(ostream& out, macierz& m)
{
	for ( int i = 0; i < m.w; ++i)
	{
		cout<<endl;
		cout<<"| ";
		for ( int j = 0; j < m.k; ++j)
		cout<<m.tab[i][j]<<" | ";;
	}
	cout<<endl;
};
macierz operator+(const macierz& m1, const macierz& m2)
{
	macierz m3(m1.k, m1.w);
	for ( int i = 0; i < m1.w; ++i)
	{
		for ( int j = 0; j < m1.k; ++j)
		{
			m3.tab[i][j]=m1.tab[i][j]+m2.tab[i][j];
		}	
	}
	return m3;
};
int main()
{
	macierz m1, m2, m3;
	m1.wprowadz();
	m2.wprowadz();
	m3=m1+m2;//Tutaj powinny istnieć wszystkie obiekty;
	cout<<m1; //wypisuje tylko m1 i m2
	cout<<m2;
	cout<<m3;//Tutaj wypisuje"smiecie"
	return 0;
} 

Z góry dzięki za pomoc.

Brakuje:

1. Zwolnienia wierszy w destruktorze
2. Zwolnienia całości w metodzie wprowadź (przed nowym przydziałem)
3. Przeciążenia operatora macierz &operator=(const macierz &m)

Może to ci pomoże:

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
 
class matrix
  {
   private:	
   size_t X,Y;
   double *Tb;
   public:
   matrix(istream &s) // bardzo brzydkie rozwiązanie lecz bardzo szybkie
     {
      if(&s==&cin) cout<<"Podaj liczbe kolumn: ";
      s>>Y;
      if(&s==&cin) cout<<"Podaj liczbe wierszy: ";
      s>>X;
      Tb=new double[Y*X]; //alokacja pamieci
      s>>*this;
     }
   matrix(size_t X=0,size_t Y=1):X(X),Y(Y),Tb(new double[Y*X]) {}
   matrix(const matrix &m):X(m.X),Y(m.Y),Tb(new double[Y*X])
     {
      memcpy(Tb,m.Tb,Y*X*sizeof(double));
     }
   ~matrix() { delete[] Tb; }
   void swap(matrix &m)
     {
      std::swap(X,m.X);
      std::swap(Y,m.Y);
      std::swap(Tb,m.Tb);
     }
   matrix &operator=(const matrix &m)
     {
      matrix tmp(m);
      swap(tmp);
      return *this;
     }
   double *operator[](size_t y) { return Tb+y*X; }
   const double *operator[](size_t y)const { return Tb+y*X; }
   friend matrix operator+(const matrix &a,const matrix &b)
     {
      if((a.Y!=b.Y)||(a.X!=b.X)) return matrix();
      matrix m(a.X,b.Y);
      size_t S=m.Y*m.X;
      for(size_t s=0;s<S;++s) m.Tb[s]=a.Tb[s]+b.Tb[s];
      return m;
     }
   friend istream &operator>>(istream &s,matrix &m)
     {
      for(size_t y=0,i=0;y<m.Y;++y)
        {
         for(size_t x=0;x<m.X;++x,++i)
           {
            if(&s==&cin) cout<<"Podaj wartosc A["<<(y+1)<<"]["<<(x+1)<<": ";
            cin>>m.Tb[i];
           }
        }
      return s;
     }
   friend ostream &operator<<(ostream &s,const matrix &m)
     {
      for(size_t y=0,i=0;y<m.Y;++y,s<<endl)
        {
         s<<"|";
         for(size_t x=0;x<m.X;++x,++i) s<<' '<<m.Tb[i]<<" |";
        }
      return s;
     }
  };
  
int main()
  {
   matrix m1(cin),m2(m1); //m2 ma ten sam rozmiar co m1
   cin>>m2;
   matrix m3(m1+m2);
   cout<<endl;
   cout<<"m1:"<<endl<<m1<<endl;
   cout<<"m2:"<<endl<<m2<<endl;
   cout<<"m3:"<<endl<<m3<<endl;
   return 0;
  } 

_13th_Dragon napisał(a):

Brakuje:
3. Przeciążenia operatora macierz &operator=(const macierz &m)

Czy na pewno musi być przeciążenie operatora=?
Gdy w destrukorze nie zwalniam żadnej pamięci, to dodawanie
m3=m1+m2; działa bez problemu?
tak samo wypisywanie
cout<<m3;
Gdy tylko dałem zwalnianie pamięci w destruktorze wszystko zaczęło się psuć.

Jak nie przeciazysz operatora= to kompilator zrobi to za Ciebie.

... kontynuacja do powyższego ...
ale zrobi to mało inteligentnie - bo bez głębokiego kopiowania.

Nie wiem czy o to chodziło, ale
przeciążyem operator =
dodałem poprawne(chyba) zwalnaie pamięci w destrktorze
i zwalnianie pamięci w metodzie wprowadz(); chodź, tego nie rozumiem, po co tam zwalniać pamięć.
Tak teraz wygląda kod:

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<conio.h>

using namespace std;

class macierz
{	
	public:
		int k, w;
		double **tab;
	public:
		macierz();
		macierz(int kolumny, int wiersze)
		{
			k=kolumny;
			w=wiersze;
			tab = new double *[w]; 
			for ( int i = 0; i < w; ++i )
			{
			tab[i] = new double [k];
			}  
		}
		~macierz();
		void wprowadz();
		void wpisz();
		friend ostream& operator<<(ostream& out, macierz& m);
		friend macierz operator+(const macierz& m1, const macierz& m2);
		macierz& operator = (const macierz& m1);
};
macierz::macierz()
{
	k=w=0;
}
macierz::~macierz()
{
	for ( int i=0; i < w; ++i )
	{
		delete [] tab[i]; 
	}
	delete [] tab; 
}
void macierz::wprowadz()
{
    for ( int i=0; i < w; ++i )
	{
		delete [] tab[i]; 
	}
	delete [] tab; 	
	double tmp;
	cout<<"Podaj liczbe kolumn:" ; cin>>k;
	cout<<"Podaj liczbe wierszy:" ; cin>>w;
	tab = new double *[w]; //alokacja pamieci
	for ( int i = 0; i < w; ++i )
	{
		tab[i] = new double [k]; //alokacja pamieci
		for ( int j = 0; j < k; ++j) //wpisanie wartosci do tablicy
		{
			cout<<"Podaj wartosc A" <<i+1<<j+1<<endl;
			cin>>tmp;
			tab[i][j]=tmp;
		}
	}
};
ostream& operator<<(ostream& out, macierz& m)
{
	for ( int i = 0; i < m.w; ++i)
	{
		cout<<endl;
		cout<<"| ";
		for ( int j = 0; j < m.k; ++j)
		cout<<m.tab[i][j]<<" | ";;
	}
	cout<<endl;
};
macierz operator+(const macierz& m1, const macierz& m2)
{
	macierz m3(m1.k, m1.w);
	for ( int i = 0; i < m1.w; ++i)
	{
		for ( int j = 0; j < m1.k; ++j)
		{
			m3.tab[i][j]=m1.tab[i][j]+m2.tab[i][j];
		}	
	}
	return m3;
	
};
macierz& macierz::operator = (const macierz& m1)
{
	for(int i=0;i<m1.w;i++)
	{
         for(int j=0;j<m1.k;j++)
         {
          	this->tab[i][j]=m1.tab[i][j];
         }
    }
    return *this;
};
int main()
{
	macierz m1, m2, m3;
	m1.wprowadz();
	m2.wprowadz();
	m3=m1+m2;
	cout<<m1; 
	cout<<m2;
	cout<<m3;
	return 0;
} 

Kompiluje się, ale zaraz po uruchominiu przestaje działać "Program macierz.exe przestał działać". Co jeszcze jest nie tak?

Problem w tym że w konstruktorze zapomniałeś o wyzerowaniu tab, więc destruktor oraz wprowadz() próbują zwolnić coś co nie przydzielone.
W operatorze przepisania zapomniałeś o zwolnieniu tego co masz obecnie, przypisaniu nowych rozmiarów, przydzieleniu odpowiedniej pamięci.

Coś takiego? ale program i tak nie działa?

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<conio.h>

using namespace std;

class macierz
{	
	public:
		int k, w;
		double **tab;
	public:
		macierz();
		macierz(int kolumny, int wiersze)
		{
			k=kolumny;
			w=wiersze;
			for ( int i=0; i < w; ++i )
			{
				delete [] tab[i]; 
			}
			delete [] tab; 
			tab = new double *[w]; 
			for ( int i = 0; i < w; ++i )
			{
			tab[i] = new double [k];
			}  
		}
		~macierz();
		void wprowadz();
		void wpisz();
		friend ostream& operator<<(ostream& out, macierz& m);
		friend macierz operator+(const macierz& m1, const macierz& m2);
		macierz& operator = (const macierz& m1);
};
macierz::macierz()
{
	k=w=0;
}
macierz::~macierz()
{
	for ( int i=0; i < w; ++i )
	{
		delete [] tab[i]; 
	}
	delete [] tab; 
}
void macierz::wprowadz()
{
    for ( int i=0; i < w; ++i )
	{
		delete [] tab[i]; 
	}
	delete [] tab; 	
	double tmp;
	cout<<"Podaj liczbe kolumn:" ; cin>>k;
	cout<<"Podaj liczbe wierszy:" ; cin>>w;
	tab = new double *[w]; //alokacja pamieci
	for ( int i = 0; i < w; ++i )
	{
		tab[i] = new double [k]; //alokacja pamieci
		for ( int j = 0; j < k; ++j) //wpisanie wartosci do tablicy
		{
			cout<<"Podaj wartosc A" <<i+1<<j+1<<endl;
			cin>>tmp;
			tab[i][j]=tmp;
		}
	}
};
ostream& operator<<(ostream& out, macierz& m)
{
	for ( int i = 0; i < m.w; ++i)
	{
		cout<<endl;
		cout<<"| ";
		for ( int j = 0; j < m.k; ++j)
		cout<<m.tab[i][j]<<" | ";;
	}
	cout<<endl;
};
macierz operator+(const macierz& m1, const macierz& m2)
{
	macierz m3(m1.k, m1.w);
	for ( int i = 0; i < m1.w; ++i)
	{
		for ( int j = 0; j < m1.k; ++j)
		{
			m3.tab[i][j]=m1.tab[i][j]+m2.tab[i][j];
		}	
	}
	return m3;
	
};
macierz& macierz::operator = (const macierz& m1)
{
	for ( int i=0; i < w; ++i )
	{
		delete [] tab[i]; 
	}
	delete [] tab;
	macierz m3(m1.k, m1.w);
	for(int i=0;i<m1.w;i++)
	{
         for(int j=0;j<m1.k;j++)
         {
          	m3.tab[i][j]=m1.tab[i][j];
         }
    }
    return *this;
};
int main()
{
	macierz m1, m2;
	macierz m3;
	m1.wprowadz();
	m2.wprowadz();
	m3=m1+m2;
	cout<<m1; 
	cout<<m2;
	cout<<m3;
	return 0;
} 

"Problem w tym że w konstruktorze zapomniałeś o wyzerowaniu tab" - którego słowa nie rozumiesz?

Dla mnie wyzerowanie tab, to przypisanie wszystkim elementom tablicy wartosc 0.
Ale chyba coś jeszcze brakuje.

macierz::macierz()
{
    k=w=0;
    tab=0;
}

Jeszcze nie działa.

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<conio.h>

using namespace std;

class macierz
{	
	public:
		int k, w;
		double **tab;
	public:
		macierz();
		macierz(int kolumny, int wiersze)
		{
			k=kolumny;
			w=wiersze;
			tab = new double *[w]; 
			for ( int i = 0; i < w; ++i )
			{
			tab[i] = new double [k];
			} 
		}
		~macierz();
		void wprowadz();
		void wpisz();
		friend ostream& operator<<(ostream& out, macierz& m);
		friend macierz operator+(const macierz& m1, const macierz& m2);
		macierz& operator = (const macierz& m1);
};
macierz::macierz()
{
	k=w=0;
	tab=0;
}
macierz::~macierz()
{
	for ( int i=0; i < w; ++i )
	{
		delete [] tab[i]; 
	}
	delete [] tab; 
}
void macierz::wprowadz()
{
    for ( int i=0; i < w; ++i )
	{
		delete [] tab[i]; 
	}
	delete [] tab;
	double tmp;
	cout<<"Podaj liczbe kolumn:" ; cin>>k;
	cout<<"Podaj liczbe wierszy:" ; cin>>w;
	tab = new double *[w]; //alokacja pamieci
	for ( int i = 0; i < w; ++i )
	{
		tab[i] = new double [k]; //alokacja pamieci
		for ( int j = 0; j < k; ++j) //wpisanie wartosci do tablicy
		{
			cout<<"Podaj wartosc A" <<i+1<<j+1<<endl;
			cin>>tmp;
			tab[i][j]=tmp;
		}
	}
};
ostream& operator<<(ostream& out, macierz& m)
{
	for ( int i = 0; i < m.w; ++i)
	{
		cout<<endl;
		cout<<"| ";
		for ( int j = 0; j < m.k; ++j)
		cout<<m.tab[i][j]<<" | ";;
	}
	cout<<endl;
};
macierz operator+(const macierz& m1, const macierz& m2)
{
	macierz m3(m1.k, m1.w);
	for ( int i = 0; i < m1.w; ++i)
	{
		for ( int j = 0; j < m1.k; ++j)
		{
			m3.tab[i][j]=m1.tab[i][j]+m2.tab[i][j];
		}	
	}
	return m3;
	
};
macierz &macierz::operator = (const macierz& m1)
{
	for ( int i=0; i < w; ++i )
    {
        delete [] tab[i]; 
    }
    delete [] tab;
    macierz m3(m1.k, m1.w);
    for(int i=0;i<m1.w;i++)
    {
         for(int j=0;j<m1.k;j++)
         {
              m3.tab[i][j]=m1.tab[i][j];
         }
    }
    return *this;
};
int main()
{
	macierz m1, m2;
	macierz m3;
	m1.wprowadz();
	m2.wprowadz();
	m3=m1+m2;
	cout<<m1; 
	cout<<m2;
	cout<<m3;
	return 0;
}

wypisuje m1, m2, ale nie wypisuje m3. Podejrzewam, że jest źle przeciążony operator =?

dodanie znacznika <code class="cpp"> - fp

_13th_Dragon napisał(a):

Problem w tym że w konstruktorze zapomniałeś o wyzerowaniu tab, więc destruktor oraz wprowadz() próbują zwolnić coś co nie przydzielone.
W operatorze przepisania zapomniałeś o zwolnieniu tego co masz obecnie, przypisaniu nowych rozmiarów, przydzieleniu odpowiedniej pamięci.

Mów którego słowa nie rozumiesz?

_13th_Dragon napisał(a):

_13th_Dragon napisał(a):

W operatorze przepisania zapomniałeś o zwolnieniu tego co masz obecnie, przypisaniu nowych rozmiarów, przydzieleniu odpowiedniej pamięci.

Mów którego słowa nie rozumiesz?

Problem w tym że w konstruktorze zapomniałeś o wyzerowaniu tab to chyba jest?
W operatorze przepisania zapomniałeś o zwolnieniu tego co masz obecnie- tego nie rozumiem
przypisaniu nowych rozmiarów, przydzieleniu odpowiedniej pamięci to też chyba jest

_13th_Dragon napisał(a):

przypisaniu nowych rozmiarów, przydzieleniu odpowiedniej pamięci

 macierz m3(m1.k, m1.w);

a ta linijka nie przydziela mi pamięci? przecież tworzę nowy obiekt m3 klasy macierz. i konstruktor i przydziela pamięc, tworzy tablice dwuwymiarową o wymiarach m1.k i m1.w? Nie o to chodzi?

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<conio.h>
#include<algorithm>
using namespace std;

class macierz
{	
	public:
		int k, w;
		double **tab;
	public:
		macierz();
		macierz(int kolumny, int wiersze)
		{
			k=kolumny;
			w=wiersze;
			tab = new double *[w]; 
			for ( int i = 0; i < w; ++i )
			{
			tab[i] = new double [k];
			} 
		}
		~macierz();
		void wprowadz();
		void wpisz();
		friend ostream& operator<<(ostream& out, macierz& m);
		friend macierz operator+(const macierz& m1, const macierz& m2);
		macierz& operator = (const macierz& m1);
		
};
macierz::macierz()
{
	k=w=0;
	tab=0;
}
macierz::~macierz()
{
	for ( int i=0; i < w; ++i )
	{
		delete [] tab[i]; 
	}
	delete [] tab; 
}
void macierz::wprowadz()
{
    for ( int i=0; i < w; ++i )
	{
		delete [] tab[i]; 
	}
	delete [] tab;
	double tmp;
	cout<<"Podaj liczbe kolumn:" ; cin>>k;
	cout<<"Podaj liczbe wierszy:" ; cin>>w;
	tab = new double *[w]; //alokacja pamieci
	for ( int i = 0; i < w; ++i )
	{
		tab[i] = new double [k]; //alokacja pamieci
		for ( int j = 0; j < k; ++j) //wpisanie wartosci do tablicy
		{
			cout<<"Podaj wartosc A" <<i+1<<j+1<<endl;
			cin>>tmp;
			tab[i][j]=tmp;
		}
	}
};
ostream& operator<<(ostream& out, macierz& m)
{
	for ( int i = 0; i < m.w; ++i)
	{
		cout<<endl;
		cout<<"| ";
		for ( int j = 0; j < m.k; ++j)
		cout<<m.tab[i][j]<<" | ";;
	}
	cout<<endl;
};
macierz operator+(const macierz& m1, const macierz& m2)
{
	macierz m3(m1.k, m1.w);
	for ( int i = 0; i < m1.w; ++i)
	{
		for ( int j = 0; j < m1.k; ++j)
		{
			m3.tab[i][j]=m1.tab[i][j]+m2.tab[i][j];
		}	
	}
	return m3;
	
};
macierz &macierz::operator = (const macierz& m1)
{
	for ( int i=0; i < w; ++i )
    {
        delete [] tab[i]; 
    }
    delete [] tab;
    this->tab = new double *[m1.w]; 
	for ( int i = 0; i < m1.w; ++i )
	{
		this->tab[i] = new double [m1.k];
	}
    for(int i=0;i<m1.w;i++)
    {
         for(int j=0;j<m1.k;j++)
         {
              this->tab[i][j]=m1.tab[i][j];
         }
    }
    return *this;
};
int main()
{
	macierz m1, m2;
	macierz m3;
	m1.wprowadz();
	m2.wprowadz();
	m3=m1+m2;
	cout<<m1; 
	cout<<m2;
	cout<<m3;
	return 0;
}

Tak ma wyglądać?
Program już prawie działa, bo się nie zawiesza, tylko nie wypisuje m3.

No to po raz trzeci wklejam to samo:

Problem w tym że w konstruktorze zapomniałeś o wyzerowaniu tab, więc destruktor oraz wprowadz() próbują zwolnić coś co nie przydzielone.
W operatorze przepisania zapomniałeś o zwolnieniu tego co masz obecnie, przypisaniu nowych rozmiarów, przydzieleniu odpowiedniej pamięci.

nie musisz odwoływać się przez this-> do składowych o ile nie ma konfliktu nazw.