Pre-end version

pr5.cpp

@@ -1,77 +1,170 @@
-#include <iostream>
+#include <iostream>
 #include <fstream>
-#include <typeinfo>
+#include<string.h>
-#include <cstring>
+#include <cstdlib>
-#include <utility>
+#include <ctime>
+#include <tuple>
 using namespace std;
 
-class Exception: public exception
+/*class Exception: public exception
 {
 protected:
-    // Сообщение об ошибке
+	//????????? ?? ??????
 	char* str;
 public:
 	Exception(const char* s)
 	{
 		str = new char[strlen(s) + 1];
-        strcpy(str, s);
+		strcpy_s(str, strlen(s) + 1, s);
 	}
 	Exception(const Exception& e)
 	{
 		str = new char[strlen(e.str) + 1];
-        strcpy(str, e.str);
+		strcpy_s(str, strlen(e.str) + 1, e.str);
 	}
 	~Exception()
 	{
 		delete[] str;
 	}
-    // Функцию вывода можно будет переопределить в производных
+
-    // классах, когда будет ясна конкретика
 	virtual void print()
 	{
-        cout << "Exception: " << str;
+		cout << "Exception: " << str<< "; "<<what();
+	}
+};*/
+
+class Exception : public exception
+{
+protected:
+	char* str;
+public:
+	Exception(const char* s)
+	{
+		str = new char[strlen(s) + 1];
+		strcpy_s(str, strlen(s) + 1, s);
+	}
+	Exception(const Exception& e)
+	{
+		str = new char[strlen(e.str) + 1];
+		strcpy_s(str, strlen(e.str) + 1, e.str);
+	}
+	~Exception()
+	{
+		delete[] str;
+	}
+
+	virtual void print()
+	{
+		cout << "Exception: " << str << "; " << what();
+	}
+};
+class InvalidOperationException : public Exception {
+public:
+	InvalidOperationException(const char* s) : Exception(s) {}
+	virtual void print()
+	{
+		cout << "InvalidOperationException: " << str << "; " << what();
 	}
 };
 
+
+class WrongSizeException : public Exception
+{
+protected:
+	int Row1, Col1, Row2, Col2;
+public:
+	WrongSizeException(const char* s, int row1, int col1, int row2, int col2) : Exception(s) { Row1 = row1; Col1 = col1; Row2 = row2; Col2 = col2; }
+	virtual void print()
+	{
+		cout << "WrongSizeException: " << str << "; " << Row1 << ", " << Col1 << ", " << Row2 << ", " << Col2 << "; " << what();
+	}
+};
+
+class IndexOutOfBoundsException : public Exception
+{
+protected:
+	int Row, Col;
+public:
+	IndexOutOfBoundsException(const char* s, int row, int col) : Exception(s) { Row = row; Col = col; }
+	virtual void print()
+	{
+		cout << "IndexOutOfBoundsException: " << str << "; " << Row << ", " << Col << "; " << what();
+	}
+};
+class NonPositiveSizeException : public WrongSizeException {
+public:
+	NonPositiveSizeException(const char* s, int row1, int col1, int row2, int col2) : WrongSizeException(s, row1, col1, row2, col2) {}
+
+	virtual void print()
+	{
+		cout << "NonPositiveSizeException: " << str << "; " << Row1 << ", " << Col1 << ", " << Row2 << ", " << Col2 << "; " << what();
+	}
+};
+
+class TooLargeSizeException : public WrongSizeException {
+public:
+	TooLargeSizeException(const char* s, int row1, int col1, int row2, int col2) : WrongSizeException(s, row1, col1, row2, col2) {}
+
+	virtual void print()
+	{
+		cout << "TooLargeSizeException: " << str << "; " << Row1 << ", " << Col1 << ", " << Row2 << ", " << Col2 << "; " << what();
+	}
+};
+
+template<class T>
 class BaseMatrix
 {
 protected:
-    double** ptr;
+	T** ptr;
 	int height;
 	int width;
-
 public:
 	BaseMatrix(int Height = 2, int Width = 2)
 	{
-        if (Height <= 0 || Width <= 0)
+		if (Height <= 0 || Width <= 0) {
-            throw Exception("Non-positive size of matrix");
+			throw NonPositiveSizeException("Attempt to create a matrix of negative or zero size", Height, Width, -1, -1);
+		}
 		height = Height;
 		width = Width;
-        ptr = new double*[height];
+		ptr = new T* [height];
 		for (int i = 0; i < height; i++)
-            ptr[i] = new double[width];
+			ptr[i] = new T[width];
 	}
 
-    BaseMatrix(const BaseMatrix& M) : height(M.height), width(M.width)
+	BaseMatrix(const BaseMatrix& M)
 	{
-        ptr = new double*[height];
+		height = M.height;
+		width = M.width;
+		ptr = new T* [height];
 		for (int i = 0; i < height; i++)
 		{
-            ptr[i] = new double[width];
+			ptr[i] = new T[width];
 			for (int j = 0; j < width; j++)
 				ptr[i][j] = M.ptr[i][j];
 		}
 	}
 
-    BaseMatrix(double** arr, int Height, int Width) : height(Height), width(Width)
+	BaseMatrix operator=(BaseMatrix& V)
+	{
+		if (height != V.height && width != V.width)
+		{
+			if (ptr != NULL)
 			{
-        ptr = new double*[height];
 				for (int i = 0; i < height; i++)
-        {
+					delete[] ptr[i];
-            ptr[i] = new double[width];
+				delete[] ptr;
-            for (int j = 0; j < width; j++)
+				ptr = NULL;
-                ptr[i][j] = arr[i][j];
 			}
+			height = V.height;
+			width = V.width;
+			ptr = new double* [height];
+			for (int i = 0; i < height; i++)
+				ptr[i] = new double[width];
+		}
+		for (int i = 0; i < height; i++)
+			for (int j = 0; j < width; j++)
+				ptr[i][j] = V.ptr[i][j];
+		return *this;
 	}
 
 	~BaseMatrix()
@@ -95,150 +188,211 @@ public:
 		}
 	}
 
-    double& operator()(int row, int column)
+	double& operator()(int row, int col)
 	{
-        if (row < 0 || column < 0 || row >= height || column >= width)
+		if (row < 0 || col < 0 || row >= height || col >= width)
-            throw Exception("Index is out of bounds");
+			throw IndexOutOfBoundsException("IndexOutOfBoundsException in operator()", row, col);
-        return ptr[row][column];
+		return ptr[row][col];
+	}
+};
+template <class T>
+class Matrix : public BaseMatrix<T>
+{
+public:
+	using BaseMatrix<T>::ptr;
+	using BaseMatrix<T>::height;
+	using BaseMatrix<T>::width;
+	Matrix(int Height = 2, int Width = 2) : BaseMatrix<T>(Height, Width) { cout << "\nMatrix constructor\n"; }
+	~Matrix() { cout << "\nMatrix destructor\n"; }
+	Matrix(T** array, int Height, int Width) : BaseMatrix<T>(Height, Width) {
+		ptr = new T* [height];
+		for (int i = 0; i < height; ++i) {
+			ptr[i] = new T[width];
+			for (int j = 0; j < width; ++j) {
+				ptr[i][j] = array[i][j];
+			}
+		}
+	}
+	// Filling a matrix element by the sum of its indices
+	void fillRandom(int a) {
+		// Initialization of random number generator with current time
+		srand(time(nullptr));
+
+		for (int i = 0; i < height; ++i) {
+			for (int j = 0; j < width; ++j) {
+				// Random number generation
+				ptr[i][j] = (rand() * (a + 1))%100;
+			}
+		}
 	}
 
-    BaseMatrix& operator=(const BaseMatrix& other)
+
-    {
+	pair<double, double> calculateCenterOfMass() {
-        if (this != &other)
+		double totalMass = 0;
+		double centerX = 0;
+		double centerY = 0;
+
+		for (int i = 0; i < this->height; ++i) {
+			for (int j = 0; j < this->width; ++j) {
+				totalMass += this->ptr[i][j];
+				centerX += i * this->ptr[i][j]; 
+				centerY += j * this->ptr[i][j]; 
+			}
+		}
+		if (totalMass != 0) {
+			centerX /= totalMass;
+			centerY /= totalMass;
+		}
+		return make_pair(centerX, centerY);
+	}
+
+
+	double Trace()
 	{
+		if (height != width) {
+			throw InvalidOperationException("The operation of finding the trace is not defined for a non-square matrix");
+		}
+		double summ = 0;
 		for (int i = 0; i < height; i++)
-                delete[] ptr[i];
+			summ += ptr[i][i];
-            delete[] ptr;
+		return summ;
+	}
+
+	Matrix operator+(Matrix M)
+	{
+		if (height != M.height || width != M.width)
+			throw WrongSizeException("Unequal size of matrices to add in operator+()", height, width, M.height, M.width);
+		Matrix res(height, width);
+		for (int i = 0; i < height; i++)
+			for (int j = 0; j < width; j++)
+				res(i, j) = ptr[i][j] + M.ptr[i][j];
+		return res;
+	}
+	// Перегрузка оператора присваивания
+	Matrix& operator=(const Matrix& other) {
+		if (this != &other) {
+			this->~Matrix();
 
 			height = other.height;
 			width = other.width;
 
-            ptr = new double*[height];
+			ptr = new double* [height];
-            for (int i = 0; i < height; i++)
+			for (int i = 0; i < height; ++i) {
-            {
 				ptr[i] = new double[width];
-                for (int j = 0; j < width; j++)
+				for (int j = 0; j < width; ++j) {
 					ptr[i][j] = other.ptr[i][j];
 				}
 			}
+		}
 		return *this;
 	}
-
+	template<class T>
-    friend ostream& operator<<(ostream& ustream, BaseMatrix obj);
+	friend ostream& operator<<(ostream& s, Matrix<T> M);
-    friend istream& operator>>(istream& ustream, BaseMatrix& obj);
+	template<class T>
+	friend istream& operator>>(istream& s, Matrix<T>& M);
 };
-
+template<class T>
-ostream& operator<<(ostream& ustream, BaseMatrix obj)
+ostream& operator<<(ostream& s, Matrix<T> M)
 {
-    if (typeid(ustream).name() == typeid(ofstream).name())
+	if (typeid(s) == typeid(ofstream))
 	{
-        ustream << obj.height << " " << obj.width << "\n";
+		s << M.height << " " << M.width << " ";
-        for (int i = 0; i < obj.height; i++)
+		for (int i = 0; i < M.height; i++)
+			for (int j = 0; j < M.width; j++)
+				s << M.ptr[i][j] << " ";
+		return s;
+	}
+	for (int i = 0; i < M.height; i++)
 	{
-            for (int j = 0; j < obj.width; j++)
+		for (int j = 0; j < M.width; j++)
-                ustream << obj.ptr[i][j] << "\n";
+			s << M.ptr[i][j] << " ";
+		s << "\n";
 	}
-        return ustream;
+	return s;
-    }
+}
-    for (int i = 0; i < obj.height; i++)
+template<class T>
+istream& operator>>(istream& s, Matrix<T>& M)
+{
+	if (typeid(s) == typeid(ifstream))
 	{
-        for (int j = 0; j < obj.width; j++)
+		int w, h; s >> h >> w;
-            ustream << obj.ptr[i][j] << " ";
+		if (h != M.height || w != M.width)
-        ustream << "\n";
+		{
+			throw InvalidOperationException("The dimensions of the read matrix are different from those of the original matrix.");
 		}
-    return ustream;
+	}
+	for (int i = 0; i < M.height; i++)
+		for (int j = 0; j < M.width; j++)
+			s >> M.ptr[i][j];
+	return s;
 }
 
-istream& operator>>(istream& ustream, BaseMatrix& obj)
+int main() {
-{
+	try {
-    if (typeid(ustream) == typeid(ifstream))
+		Matrix<double> M[10];
-        ustream >> obj.height >> obj.width;
+		// Matrix filling and output
-    for (int i = 0; i < obj.height; i++)
+		for (int i = 0; i < 3; i++) {
-        for (int j = 0; j < obj.width; j++)
+			cout << "Matrix " << i + 1 << ":" << endl;
-            ustream >> obj.ptr[i][j];
+			M[i].fillRandom(i);
-    return ustream;
+			cout << M[i] << endl;
-}
-
-class MultidimensionalArray : public BaseMatrix
-{
-public:
-    MultidimensionalArray(int Height = 2, int Width = 2) : BaseMatrix(Height, Width) {}
-
-    MultidimensionalArray(const MultidimensionalArray& M) : BaseMatrix(M) {}
-
-    MultidimensionalArray(double** arr, int Height, int Width) : BaseMatrix(arr, Height, Width) {}
-
-    MultidimensionalArray& operator=(const MultidimensionalArray& other)
-    {
-        BaseMatrix::operator=(other);
-        return *this;
 		}
 
-    pair<double, double> calculateCenterOfMass()
+		// Saving a matrix array to a file
-    {
+		ofstream fout("1.txt");
-        double totalMass = 0.0;
+		if (fout) {
-        double weightedSumX = 0.0;
+			fout << "3\n";
-        double weightedSumY = 0.0;
+			for (int i = 0; i < 3; i++)
-
+				fout << M[i] << "\n";
-        for (int i = 0; i < height; ++i)
-        {
-            for (int j = 0; j < width; ++j)
-            {
-                double mass = ptr[i][j];
-                totalMass += mass;
-                weightedSumX += j * mass; // умножаем координату на массу
-                weightedSumY += i * mass; // умножаем координату на массу
-            }
-        }
-
-        if (totalMass == 0.0)
-        {
-            return make_pair(-1.0, -1.0); // Или другое значение по умолчанию
-        }
-
-        double centerX = weightedSumX / totalMass;
-        double centerY = weightedSumY / totalMass;
-
-        return make_pair(centerX, centerY);
-    }
-};
-
-int main()
-{
-    try
-    {
-        MultidimensionalArray Wrong(-2, 0);
-    }
-    catch (Exception e)
-    {
-        cout << "\nException has been caught: ";
-        e.print();
-    }
-
-    cout << "\n";
-
-    MultidimensionalArray M;
-    cin >> M;
-
-    ofstream fout("out.txt");
-    if (fout.is_open())
-    {
-        fout << M;
 			fout.close();
 		}
 
-    ifstream fin("out.txt");
+		// reading a matrix array from a file
-    MultidimensionalArray M1;
+		Matrix<double>* M1;
-    if (fin)
+		ifstream fin("1.txt");
-    {
+		if (fin) {
-        fin >> M1;
+			int n;
-        fin.close();
+			fin >> n;
+			M1 = new Matrix<double>[n];
+			for (int i = 0; i < 3; i++) {
+				fin >> M1[i];
+				cout << "Matrix from file " << i + 1 << ":" << endl;
+				cout << M1[i] << endl;
+			}
+			delete[] M1;
+		}
+		Matrix<double> A(2, 2);
+		A.fillRandom(4);
+		A.print();
+		Matrix<double> B(2, 2);
+		B.fillRandom(3);
+		B.print();
+		Matrix<double> C = A + B; // matrix1+matrix2
+		cout << "A + B:" << endl << C << endl;
+
+		Matrix<double> D;
+		D = A; //Assignment of matrix
+		cout << "D (assigned from A):" << endl << D << endl;
+		double a, b;
+		A.print();
+		tie(a,b)=A.calculateCenterOfMass(); //calculate Center Of Mass
+		cout << "Center of Mass of A:" << endl;
+		cout << a << ", " << b << "\n";
+		double traceA = A.Trace(); // calculate trace
+		cout << "Trace of A: " << traceA << endl;
+	}
+	catch (IndexOutOfBoundsException& ex) {
+		cout << "IndexOutOfBoundsException has been caught: ";
+		ex.print();
+	}
+	catch (Exception& ex) {
+		cout << "Exception has been caught: ";
+		ex.print();
+	}
+	catch (exception& ex) {
+		cout << "Standard exception has been caught: " << ex.what();
 	}
 
-    cout << M1;
+	// char c;
-
+	// cin >> c;
-    char c1;
-    cin >> c1;
-
 	return 0;
 }