Destruktor a potęgowanie macierzy

[dry_ice]

Chodzi o funkcję potega. Nie jestem pewien, ale problem leży chyba w destruktorze, gdyż usuwa on obiekty od razu po wyjściu za zakres ważności tegoż obiektu. Jak temu zaradzić?

PLIK macierz.h

Kod: Zaznacz cały

#ifndef MACIERZ_H_
#define MACIERZ_H_

using namespace std;
class MACIERZ
{
	friend MACIERZ operator*(MACIERZ, MACIERZ);
	friend MACIERZ operator*(int, MACIERZ);
	friend MACIERZ operator*(MACIERZ, int );
	friend ostream &operator<<(ostream&, MACIERZ);
	friend MACIERZ potega(MACIERZ, unsigned int);
	unsigned int rozmiar;
	unsigned int **tablica;
public:
	MACIERZ(int);
	MACIERZ ();
	~MACIERZ();
	void wypelnij();

};

#endif /* MACIERZ_H_ */

PROGRAM GŁÓWNY

Kod: Zaznacz cały

#include<iostream>
#include "macierz.h"
using namespace std;


MACIERZ::MACIERZ()
{
		rozmiar=2;
		tablica=new unsigned int*[rozmiar];
		for (unsigned int i=0; i<rozmiar; i++)
			tablica[i]=new unsigned int[rozmiar];

		for (unsigned int i=0; i<rozmiar; i++)
				{
					for (unsigned int j=0; j<rozmiar; j++)
					{
						tablica[i][j]=1;
					}
				}
}

MACIERZ::~MACIERZ()
{
		for (unsigned int i=0; i<rozmiar; i++)
			delete [] tablica[i];
		delete [] tablica;

		cout << "
 usunieto" ;
}

MACIERZ::MACIERZ (int wielkosc)
	{
	rozmiar=wielkosc;
	tablica=new unsigned int*[wielkosc];
	for (int i=0; i<wielkosc; i++)
		tablica[i]=new unsigned int[wielkosc];
	}

void MACIERZ::wypelnij()
{
	for (unsigned int i=0; i<rozmiar; i++)
			{
				for (unsigned int j=0; j<rozmiar; j++)
				{
					cin >> tablica[i][j];
				}
			}

}

ostream &operator<<(ostream& wyjscie, MACIERZ m)
{
	for (unsigned int i=0; i<m.rozmiar; i++)
		{
			for (unsigned int j=0; j<m.rozmiar; j++ )
				wyjscie << m.tablica[i][j]<< " ";
		wyjscie << "
" ;
		};

	return wyjscie;
}

MACIERZ operator*(MACIERZ m1, MACIERZ m2)
{
	MACIERZ nowa=MACIERZ();

	nowa.rozmiar=m1.rozmiar;
	for(unsigned int i=0; i<m1.rozmiar; i++)
	 {
	   for(unsigned int j=0; j<m1.rozmiar; j++)
	     {
	       nowa.tablica[i][j]=0;
	         for(unsigned int k=0; k<m1.rozmiar; k++)
	          {
	           nowa.tablica[i][j] += m1.tablica[i][k] * m2.tablica[k][j];
	         }
	     }
	 }
	return nowa;
}

MACIERZ operator*(MACIERZ m1, int x)
{
	MACIERZ nowa;
	nowa.rozmiar=m1.rozmiar;
	for(unsigned int i=0; i<m1.rozmiar; i++)
	 {
	   for(unsigned int j=0; j<m1.rozmiar; j++)
	     {
		   	   nowa.tablica[i][j]=0;
		   	   nowa.tablica[i][j] = m1.tablica[i][j] * x;
	     }
	 }
	return nowa;
}


MACIERZ operator*(int x, MACIERZ m1)
{
	MACIERZ nowa;
	nowa.rozmiar=m1.rozmiar;
	for(unsigned int i=0; i<m1.rozmiar; i++)
	 {
	   for(unsigned int j=0; j<m1.rozmiar; j++)
	     {
		   	   nowa.tablica[i][j]=0;
		   	   nowa.tablica[i][j] = m1.tablica[i][j] * x;
	     }
	 }
	return nowa;
}

MACIERZ a, a2;
MACIERZ potega(MACIERZ m1, unsigned int n)
	{
		MACIERZ a2;
		if (n==0) return a2;
		else if (n%2 != 0 )
			{
			cout << "
 UWAGAn " << n <<" "; // pomoc do petli
			return m1*potega(m1,n-1);
			}
		else
			{
			cout << "
 UWAGAp " << n << " ";  // pomoc do petli
			a=potega(m1, n/2);
			}
		cout << "KONIEC";
		return potega(a,2);
	}



int main()
{

	MACIERZ macierz;
	cout << potega(macierz,17);
	cout << "xxx";

	int x;
	cin >> x;
	return 0;

}

[PMichalak]

Ogólnie masz trochę bałaganu.. Na pewno błędem jest nie przeciążanie konstruktora kopiującego macierzy. Standardowy kopiuje jedynie wskaźnik, w efekcie możesz mieć dwie instancje operujące na jednej tablicy.