\n/*
* Створити клас Matrix3F (матриця цілих чисел), використовуючи клас Vector3F. Розробити такі елементи класу:    Поля (захищені):  Vector3F  * PointArray; // масив  int n; //  розмір матриці (к-ть векторів)  int codeError; // код помилки  static int num_matrix; // кількість матриць (загально доступних)  У змінну стану встановлювати код помилки, коли не вистачає пам'яті, виходить за межі матриці. У класі визначити:  конструктори:   конструктор без параметрів(PointArray = nullptr, n  = codeError = 0);  конструктор з одним параметрів типу int size( створює матрицю n=size на 3, інінціалізує поля в нуль );  конструктор із двома параметрами - розмір матриці (виділяє місце та ініціалізує значенням другого параметру);  конструктор із чотирма параметрами - розмір матриці, значення ініціалізації полів вектора;  копіювання;  функції доступу до полів : n та codeError.  деструктор (деструктор звільняє пам'ять);   перевантаження операцій (операції перевантажувати через функції класу або дружні функції, якщо не вказано яким чином це робити):   унарних префіксних та постфіксних ++ та --: одночасно збільшує (зменшує) значення елементів масиву на 1;   унарної логічної ! (заперечення): повертає значення true, якщо елементи якщо n не дорівнює – нулю, інакше false;   унарний арифметичний - (мінус) : повертає всі елементи масиву класу матриця з протилежним знаком;    присвоєння =: копіює матрицю (перевантажити через функцію класу);  арифметичних бінарні:
* a. + додавання: i. для двох матриць; ii. для матриці та скаляра типу int; iii. для матриці та скаляра типу double; iv. для матриці та скаляра типу float; b. - (віднімання):  i. для двох матриць ii. для матриці та скаляра типу int; iii. для матриці та скаляра типу double; iv. для матриці та скаляра типу float; c. *(множення)  i. для двох матриць, ii. для матриці та вектора Vector3F; iii. для матриці та скаляра типу double; iv. для матриці та скаляра типу float; d. /(ділення)  i. векторне множення елементів масивів PointArray; ii. для матриці та скаляра типу int; iii. для матриці та скаляра типу float; e. %(остача від ділення)  i. для матриці та скаляра типу int; f. += присвоєння з додаванням: i. для двох матриць ii. для матриці та скаляра типу double; iii. для матриці та скаляра типу float; g. -= присвоєння з відніманням:  i. для двох матриць; ii. для матриці та скаляра типу double; iii. для матриці та скаляра типу float; h. *= присвоєння з множенням  i. для двох матриць, ii. для матриці та вектора Vector3F; iii. для матриці та скаляра типу double; iv. для матриці та скаляра типу float; i. /= присвоєння з діленням  i. для матриці та скаляра типу int; ii. для матриці та скаляра типу double; iii. для матриці та скаляра типу float; j. %= присвоєння з остачею від ділення  i. для матриці та скаляра типу int;  операцій == (рівності) та != (нерівності), функція-операція виконує певні дії над кожною парою елементів матриці за індексом;  порівняння (функція-операція виконує певні дії над кожною парою елементів матриць за індексом) a. > (більше) для двох матриць;  b. >= (більше рівне) для двох матриць; c. < (менше) для двох матриць; d. <= (менше рівне) для двох матриць.
* операцію індексації [] – функцію, яка звертається до елементу  Vector3F, якщо індекс невірний вказує на останній елемент масиву та встановлює код помилки у змінну CodeError.   розподілу пам’яті new та delete;  виклику функції ();  побітові операції зсувів, як дружні операції введення та виведення вектора у потік (перевантажувати через дружні функції) a. введення  >> (побітовий зсув право) ; b. введення << (побітовий зсув ліво);  Передбачити можливість підрахунку числа об'єктів даного типу. Перевірити роботу цього класу.
*/
#include 
#include 
#include 

using namespace std;


 int matrix_count=0;
 int vectors_count=0;
class vector
{
private:
    int *x;
    int size_vector;

public:
    vector()
    {
        const int size=5;
        size_vector=size;
        x=new int[size_vector];
        for(int i=0; i         {
            x[i]=0;
        }
        vectors_count++;
    }

    vector(const int _n)
    {
        size_vector=_n;
        x=new int[size_vector];
        for(int i=0; i         {
            x[i]=5;
        }
        ++vectors_count;
    }

    vector(const int _n, int _value):size_vector(_n)
    {
        x=new int[size_vector];
        for(int i=0; i         {
            x[i]=_value;
        }
        ++vectors_count;
    }

    vector(const vector &other)
    {
        this->x=new int[other.size_vector];
        for(int i=0; i         {
            this->x[i]=other.x[i];
        }
        ++vectors_count;
    }

    void operator = (const vector &other)
    {
        this->size_vector=other.size_vector;
        if(this->x != nullptr )
        {
            delete[] this->x;
        }
        this->x=new int[other.size_vector];
        for(int i=0; i         {
            this->x[i]=other.x[i];
        }
    }

    vector &operator ~()
    {
        for(int i=0; isize_vector; i++)
        {
            this->x[i]=~(this->x[i]);
        }
        return *this;
    }

    bool operator!=(const vector &other)
    {
        for(int i=0; isize_vector; i++)
        {
            if(this->x[i]!=other.x[i]) return true;
            else return false;
        }
    }

     vector& operator -()
     {
        for(int i=0; isize_vector; i++)
        {
            this->x[i]=-(this->x[i]);
        }
        return *this;
     }
/*


     vector operator+(const vector &other)
    {
        for(int i=0; isize_vector; i++)
        {
            this->x[i] = this->x[i]+other.x[i];
        }
        return *this;
    } */

    void print()
    {
        for (int i=0; isize_vector; i++)
        {
            cout<         }
        cout<<"n";
    }
    friend ostream& operator<< (ostream &out, const vector &other);
    friend class matrix;
    ~vector(){--vectors_count;delete[] x;}

};

ostream &operator<< (ostream &out, const vector &other)
{
    for(int i=0; i     {
      out << other.x[i]<< " ";
    }
    return out;

}

class matrix
{
private:
    vector *arr;
    int vector_count;
public:
    matrix()
    {
        const int size=5;
        vector_count=size;
        arr=new vector[vector_count];
        for(int i=0; i         {
            arr[i]=5;
        }
    }

    matrix(int _n)
    {
        arr=new vector[vector_count];
        for(int i=0; i         {
            arr[i]=5;
        }
        ++matrix_count;
    }

    matrix(const int _n, const int _value):vector_count(_n)
    {
        arr=new vector[vector_count];
        for(int i=0; i         {
            arr[i]=_value;
        }
        ++matrix_count;
    }

    matrix(const matrix &other)
    {
        this->arr=new vector[other.vector_count];
        for(int i=0; i         {
            this->arr[i]=other.arr[i];
        }
        ++matrix_count;
    }

    void operator = (const matrix &other)
    {
           this->vector_count=other.vector_count;
            if(this->arr != nullptr)
            {
                delete[] this->arr;
            }
        this->arr=new vector[other.vector_count];
        for(int i=0; i         {
            this->arr[i]=other.arr[i];
        }
    }

    matrix &operator ++()
    {
        vector *temp=new vector[this->vector_count];
        for(int i=0; ivector_count; i++)
        {
            temp[i]=arr[i];
        }
        delete[] this->arr;
        ++vector_count;
        arr=new vector[vector_count];
        for(int i=0; i<(this->vector_count)-1; i++)
        {
            arr[i]=temp[i];
        }
        delete[] temp;
        return *this;
    }
    matrix &operator --()
    {
        vector *temp=new vector[this->vector_count];
        for(int i=0; ivector_count; i++)
        {
            temp[i]=arr[i];
        }
        delete[] this->arr;
        --vector_count;
        arr=new vector[vector_count];
        for(int i=0; i<(this->vector_count)-1; i++)
        {
            arr[i]=temp[i];
        }
        delete[] temp;
        return *this;
    }

    bool operator !() const
    {
        if(this->vector_count != 0) return true;
        else return false;
    }

    matrix &operator~()
    {
        for(int i=0; ivector_count; i++)
        {
            this->arr[i]=~(this->arr[i]);
        }
        return *this;
    }

    matrix &operator-()
    {
        for(int i=0; ivector_count; i++)
        {
            this->arr[i]=-(this->arr[i]);
        }
        return (-arr[i]);
        }

*this;
    }
    /*
    matrix& operator+(const matrix &other)
    {
        for(int i=0; ivector_count; i++)
        {
            this->arr[i] = this->arr[i]+other.arr[i];
        }
    return *this;
    } */

    int getSize()
    {
        return vector_count;
    }
    friend ostream& operator<<(ostream &out, const matrix &other);
    ~matrix(){--matrix_count; delete[] arr;}
};

ostream &operator<<(ostream &outs, const matrix &other)
{
    for(int i=0; i     {
      outs << "n"<     }
    return outs;

}

int main(int argc, char *argv[])
{
 vector obj1(4,4);
 matrix obj2(4,5);
 cout<  cout<<"n"<<~obj1;
 cout<<"n"<  cout<<"n"<<(obj2);
 cout<<"n"<<++obj2;
 cout<<"n"<<(--obj2);
 /*cout<<"n"<  cout<<"n"<<++obj2;
 cout<<"n"<<--obj2;
 cout<<"nn"<   */

 return 0;
}