Matrix

#include <iostream>
#include <vector>

using namespace std;

class Matrix
{
public:
    Matrix(int n = 2, int val = 0) : n(n)
    {
        elements = new int*[n];
        for (int i = 0; i < n; i++)
        {
            elements[i] = new int[n];
            for (int j = 0; j < n; j++)
                elements[i][j] = val;
        }
    }

    // конструктор копирования. Особый конструктор для случаем такого типа:
    // Matrix a(5, 2);
    // Matrix b(a); - будет вызван конструктор копирования
    // Конструктор копирования всегда принимает константную ссылку на объект
    Matrix(const Matrix & other) : n(other.n)
    {
        elements = new int*[n];
        for (int i = 0; i < n; i++)
        {
            elements[i] = new int[n];
            for (int j = 0; j < n; j++)
                elements[i][j] = other.elements[i][j];
        }
    }

    ~Matrix()
    {
        for (int i = 0; i < n; i++)
            delete [] elements[i];
        delete [] elements;
    }

    int getN() const
    {
        return n;
    }

    int & at(int i, int j)
    {
        return elements[i][j];
    }

    int at(int i, int j) const
    {
        return elements[i][j];
    }

    // Оператор = возвращает ссылку на сам объект. Это нужно для обработки выражений вида
    // a = b = c;
    // Сначала будет обработан вызов b.operator=(c), который вернёт при этом новое значение b,
    // Которое послужит аргументом в вызове a.operator=( b.operator=(c) );
    Matrix & operator =(const Matrix & right)
    {
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                elements[i][j] = right.elements[i][j];
        return *this;
    }

    Matrix operator +(const Matrix & a) const
    {
        Matrix res(a.n);
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                res.elements[i][j] = a.elements[i][j] + elements[i][j];
        return res; // в этот момент будет использован оператор = для Matrix
    }

    Matrix operator *(const Matrix & a) const
    {
        Matrix res(a.n);
        for (int i = 0; i < n; i++) // строки
            for (int j = 0; j < n; j++) //столбцы
                for (int k = 0; k < n; k++) //элементы
                    res.elements[i][j] += elements[i][k] * a.elements[k][j];
        return res; // в этот момент будет использован оператор = для Matrix
    }

    vector<int> operator *(const vector<int> v) const
    {
        vector<int> res(n);
        for (int i = 0; i < n; i++) // строки
            for (int k = 0; k < n; k++) //элементы
                res[i] += elements[i][k] * v[k];
        return res;
    }

    friend Matrix pow(const Matrix & a, int p);

private:
    int n;
    int **elements;
};


Matrix pow(const Matrix & a, int p)
{
    Matrix res(a.n);
    for (int i = 0; i < a.n; i++)
        res.elements[i][i] = 1;

    Matrix current(a); // будет вызван конструктор копирования

    while (p)
    {
        if (p & 1)
        {
            res = res * current;
        }

        current = current * current;

        p >>= 1;
    }

    return res; // в этот момент будет использован оператор = для Matrix
}


int main()
{
    Matrix a(2);
    a.at(0, 0) = 1;
    a.at(0, 1) = 1;
    a.at(1, 0) = 1;

    for (int i = 0; i <= 20; i++)
    {
        Matrix b = pow(a, i);

        vector <int> fib(2, 1);
        fib = b * fib;

        cout << "F[" << i << "] = " << fib[1] << endl;

        // в этот момент вызывается деструктор матрицы b
    }

    return 0;
}