Класс Matrix c конструктором от файла

#include <algorithm>
#include <cstddef>
#include <iomanip>
#include <iostream>
#include <fstream>
#include <iterator>
#include <vector>
#include <map>
 
void swap(std::vector<double>& rhs, std::vector<double>& lhs);
 
class Matrix {
private:
    std::size_t m_row{3};
    std::size_t m_col{3};
    std::vector<std::vector<double>> m_table{}; 
 
public:
    Matrix() {
        m_table.clear(); 
        m_table.reserve(m_row * m_col);
        for (std::size_t i = 0; i < m_row; ++i) {
            m_table.emplace_back(std::vector<double>(m_col, 0));
        }
    }
 
    Matrix(std::size_t row, std::size_t col) : m_row(row), m_col(col) {
        m_table.clear(); 
        m_table.reserve(m_row * m_col);
        for (std::size_t i = 0; i < m_row; ++i) {
            m_table.emplace_back(std::vector<double>(m_col, 0));
        }
    }
 
    Matrix(const char* file_name) : Matrix() {
        std::ifstream fin{file_name};
        if(!fin) {
            std::cerr << "Cann't open the file\n";
        }
 
        fin >> m_row;
        fin >> m_col;
        m_table.reserve(m_row * m_col);
        for (std::size_t i = 0; i < m_row; ++i) {
            for (std::size_t j = 0; i < m_col; ++j) {
                fin >> m_table[i][j];
            }
        }
    }
 
    std::vector<double>& operator[](std::size_t index) {
        return m_table[index];
    }
 
    const std::vector<double>& operator[](std::size_t index) const {
        return m_table[index];
    }
 
    std::vector<double> getm_row(std::size_t index) const {
        return m_table[index];
    }
 
    std::vector<double> getm_column(std::size_t index) const {
        std::vector<double> m_column;
        for (std::size_t i = 0; i < m_row; ++i) {
            m_column.push_back(m_table[i][index]);
        }
 
        return m_column;
    }
 
    void countChange() {
        std::map<std::size_t, std::size_t> index_array{};
        for(std::size_t i{0}; i < m_row; ++i) {
            auto change = std::count_if(std::cbegin(m_table[i]),
                                          std::cend(m_table[i]),
                                          [](int number) {
                                               return number < 0;
                                          }
            );
 
            if(change) {
                index_array.emplace(change, i);
            }
        }
 
        // TODO
        auto min_index = index_array.begin()->second; 
        auto max_index = (--(index_array.end()))->second;
 
        swap(m_table[min_index], m_table[max_index]);
    }
 
    friend std::istream& operator>>(std::istream& in, Matrix& matrix);
    friend std::ostream& operator<<(std::ostream& out, const Matrix& matrix);
};
 
std::istream& operator>>(std::istream& in, Matrix& matrix) {
    in >> matrix.m_row;
    in >> matrix.m_col;
    for (std::size_t i = 0; i < matrix.m_row; ++i) {
        for (std::size_t j = 0; j < matrix.m_col; ++j) {
            in >> matrix[i][j];
        }
    }
 
    return in;
}
 
std::ostream& operator<<(std::ostream& out, const std::vector<double>& vector) {
    for (const auto& element : vector) {
        out << element << " ";
    }
 
    return out;
}
 
std::ostream& operator<<(std::ostream& out, const Matrix& matrix) {
    for (std::size_t i = 0; i < matrix.m_row; ++i) {
        for (std::size_t j = 0; j < matrix.m_col; ++j) {
            out << std::setw(4) << std::internal << std::fixed
                << std::setprecision(1) << matrix[i][j] << " ";
        }
 
        out << '\n';
    }
 
    return out;
}
 
void swap(std::vector<double>& rhs, std::vector<double>& lhs) {
    std::vector<double> tmp{};
    std::move(std::begin(rhs), std::end(rhs), std::back_inserter(tmp));
    rhs.clear();
    std::move(std::begin(lhs), std::end(lhs), std::back_inserter(rhs));
    lhs.clear();
    std::move(std::begin(tmp), std::end(tmp), std::back_inserter(lhs));
}
 
void inputMatrix(Matrix& matrix, const char* file_name) {
    std::ifstream fin(file_name);
    if(!fin) {
        std::cerr << "Cann't open the file\n";
    }
 
    fin >> matrix;
}
 
 
int main() {
    Matrix matrix;
    inputMatrix(matrix, "matrix.txt");
    std::cout << matrix << '\n';
    matrix.countChange();
    std::ofstream fout("matrix_out.txt");
    fout << "Matrix is after exchange: \n" << matrix;
}

    Matrix matrix("matrix.txt");
    std::cout << matrix << '\n';
    matrix.countChange();
    std::ofstream fout("matrix_out.txt");
    fout << "Matrix is after exchange: \n" << matrix;