Умные указатели

#include <fstream>
#include <algorithm>
#include <vector>
#include <iostream>
#include <memory>
using namespace std;
 
template<typename real, typename ext = real>
class gaussmethod
{
    vector<shared_ptr<vector<real>>> mat;
    int dim;
public:
    gaussmethod<real, ext> (string filename)
    {
        ifstream in (filename);
 
        in >> dim;
        mat = vector<shared_ptr<vector<real>>> (dim);
        for (int i = 0; i < dim; i++)
        {
            mat[i] = make_shared<vector<real>> (dim + 1);
            for (int j = 0; j < dim + 1; j++)
                in >> (*mat[i])[j];
        }
    }
 
    gaussmethod<real, ext> (vector<vector<real>> &vv, vector<real> &v)
    {
        dim = vv.size ();
        mat = vector<shared_ptr<vector<real>>> (dim);
        for (int i = 0; i < dim; i++)
        {
            mat[i] = make_shared<vector<real>> (dim + 1);
            for (int j = 0; j < dim; j++)
                (*mat[i])[j] = vv[i][j];
        }
 
        for (int i = 0; i < dim; i++)
            (*mat[i])[dim] = v[i];
    }
 
    vector<real, ext> solve ()
    {
        vector<real> solution (dim);
        for (int col = 0; col < dim; col++)
        {
            auto max = make_pair (0, mat[0][col]);
            for (int i = 1; i < dim; i++)
            if (abs ((*mat[i])[col]) > abs (max.second))
                max = make_pair (i, (*mat[i])[col]);
            swap (mat[max.first], mat[col]);
            for (int j = col; j < dim + 1; j++)
                (*mat[i])[j] /= max.second;
            for (int i = col + 1; i < dim; i++)
            {
                real delta = (*mat[i])[col];
                for (int j = col; j < dim + 1; j++)
                    (*mat[i])[j] -= mat[max.first][j] * delta;
            }
        }
        for (int col = dim - 1; col >= 0; col--)
        {
            for (int j = col + 1; j < dim; j++)
                (*mat[i])[dim] -= solution[j] * (*mat[i])[j];
            solution[col] = (*mat[i])[dim] / (*mat[i])[col];
        }
        return solution;
    }
};
 
class generator
{
public:
    template<typename real, typename ext = real>
    static gaussmethod<real, ext> HilbertGauss (int k)
    {
        vector<vector<real>> vv (n, vector<real> (n));
        vector<real> v (n);
 
        for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            v[i] += (vv[i][j] = 1. / (i + j + 1)) * (j + 1);
        return gaussmethod<real, ext> (vv, v);
    }
};
 
int main ()
{
    ifstream in ("input.txt");
    ofstream out ("output.txt");
    out << fixed;
    out.precision (15);
    for (int k = 1; k < 10; k++)
    {
        auto gm = generator::HilbertGauss<double> (k);
        auto v = gm.solve ();
        for (auto a : v)
            out << a << endl;
    }
 
    return 0;
}

#include <fstream>
#include <algorithm>
#include <vector>
#include <memory>
using namespace std;
 
int main ()
{
    ifstream in ("input.txt");
    ofstream out ("output.txt");
    vector<unique_ptr<vector<double>>> vuv(5);
    for (int i = 0; i < 5; i++)
    {
        vuv[i] = make_unique<vector<double>> (5);
        for (int j = 0; j < 5; j++)
        {
            (*vuv[i])[j] = i*j;
            out << (*vuv[i])[j] << " ";
        }
        out << endl;
    }
    out << endl;
    swap (vuv[1], vuv[2]);
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
            out << (*vuv[i])[j] << " ";
    }
 
    return 0;
}