pr5/pr5.cpp

#include <iostream>
#include <fstream>
#include <typeinfo>
#include <cstring>
#include <utility>
using namespace std;

class Exception: public exception
{
protected:
    // Сообщение об ошибке
    char* str;
public:
    Exception(const char* s)
    {
        str = new char[strlen(s) + 1];
        strcpy(str, s);
    }
    Exception(const Exception& e)
    {
        str = new char[strlen(e.str) + 1];
        strcpy(str, e.str);
    }
    ~Exception()
    {
        delete[] str;
    }
    // Функцию вывода можно будет переопределить в производных
    // классах, когда будет ясна конкретика
    virtual void print()
    {
        cout << "Exception: " << str;
    }
};

class BaseMatrix
{
protected:
    double** ptr;
    int height;
    int width;

public:
    BaseMatrix(int Height = 2, int Width = 2)
    {
        if (Height <= 0 || Width <= 0)
            throw Exception("Non-positive size of matrix");
        height = Height;
        width = Width;
        ptr = new double*[height];
        for (int i = 0; i < height; i++)
            ptr[i] = new double[width];
    }

    BaseMatrix(const BaseMatrix& M) : height(M.height), width(M.width)
    {
        ptr = new double*[height];
        for (int i = 0; i < height; i++)
        {
            ptr[i] = new double[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)
    {
        ptr = new double*[height];
        for (int i = 0; i < height; i++)
        {
            ptr[i] = new double[width];
            for (int j = 0; j < width; j++)
                ptr[i][j] = arr[i][j];
        }
    }

    ~BaseMatrix()
    {
        if (ptr != NULL)
        {
            for (int i = 0; i < height; i++)
                delete[] ptr[i];
            delete[] ptr;
            ptr = NULL;
        }
    }

    void print()
    {
        for (int i = 0; i < height; i++)
        {
            for (int j = 0; j < width; j++)
                cout << ptr[i][j] << " ";
            cout << "\n";
        }
    }

    double& operator()(int row, int column)
    {
        if (row < 0 || column < 0 || row >= height || column >= width)
            throw Exception("Index is out of bounds");
        return ptr[row][column];
    }

    BaseMatrix& operator=(const BaseMatrix& other)
    {
        if (this != &other)
        {
            for (int i = 0; i < height; i++)
                delete[] ptr[i];
            delete[] ptr;

            height = other.height;
            width = other.width;

            ptr = new double*[height];
            for (int i = 0; i < height; i++)
            {
                ptr[i] = new double[width];
                for (int j = 0; j < width; j++)
                    ptr[i][j] = other.ptr[i][j];
            }
        }
        return *this;
    }

    friend ostream& operator<<(ostream& ustream, BaseMatrix obj);
    friend istream& operator>>(istream& ustream, BaseMatrix& obj);
};

ostream& operator<<(ostream& ustream, BaseMatrix obj)
{
    if (typeid(ustream).name() == typeid(ofstream).name())
    {
        ustream << obj.height << " " << obj.width << "\n";
        for (int i = 0; i < obj.height; i++)
        {
            for (int j = 0; j < obj.width; j++)
                ustream << obj.ptr[i][j] << "\n";
        }
        return ustream;
    }
    for (int i = 0; i < obj.height; i++)
    {
        for (int j = 0; j < obj.width; j++)
            ustream << obj.ptr[i][j] << " ";
        ustream << "\n";
    }
    return ustream;
}

istream& operator>>(istream& ustream, BaseMatrix& obj)
{
    if (typeid(ustream) == typeid(ifstream))
        ustream >> obj.height >> obj.width;
    for (int i = 0; i < obj.height; i++)
        for (int j = 0; j < obj.width; j++)
            ustream >> obj.ptr[i][j];
    return ustream;
}

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()
    {
        double totalMass = 0.0;
        double weightedSumX = 0.0;
        double weightedSumY = 0.0;

        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");
    MultidimensionalArray M1;
    if (fin)
    {
        fin >> M1;
        fin.close();
    }

    cout << M1;

    char c1;
    cin >> c1;

    return 0;
}