Матрица. Поиск максимума и минимума в колонках

#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <vector>
using namespace std;
struct Сonstraints {
    Сonstraints() :
        min_size_rows(1U),
        max_size_rows(100U),
        min_size_columns(1U),
        max_size_columns(100U),
        min_value(-1000),
        max_value(1000) {
    }
    size_t min_size_rows;
    size_t max_size_rows;
    size_t min_size_columns;
    size_t max_size_columns;
    int min_value;
    int max_value;
};
struct Error {
    bool error;
    string message;
};
class Matrix {
public:
    Matrix() : n_(0), m_(0) {}
    Error load(const string& path, const Сonstraints& con) {
        matrix_.clear();
        ifstream file(path);
        Error info{false, "Good"};
        if (file.is_open()) {
            size_t n, m;
            file >> n >> m;
            int value;
            if (n < con.min_size_rows) {
                info.error = true;
                info.message = "the number of rows is insufficient";
            } else if (m < con.min_size_columns) {
                info.error = true;
                info.message = "the number of columns is insufficient";
            } else if (n > con.max_size_rows) {
                info.error = true;
                info.message = "the number of rows is redundant";
            } else if (m > con.max_size_columns) {
                info.error = true;
                info.message = "the number of columns is redundant";
            }
            if (info.error) return info;
            n_ = n;
            m_ = m;
            for (size_t i = 0; i < n; ++i) {
                vector<int> row;
                for (size_t j = 0; j < m; ++j) {
                    file >> value;
                    if (value < con.min_value || value > con.max_value) {
                        info.error = true;
                        info.message = "file contains invalid values";
                        matrix_.clear();
                        return info;
                    }
                    row.push_back(value);
                }
                matrix_.emplace_back(row);
            }
            file.close();
        }
        return info;
    }
    size_t rows()const { return n_; }
    size_t columns()const { return m_; }
    pair<int, int> min_max(const size_t column) {
        auto min = numeric_limits<int>::max();
        auto max = numeric_limits<int>::min();
        for (size_t i = 0; i < n_; ++i) {
            if (min > matrix_[i][column]) min = matrix_[i][column];
            if (max < matrix_[i][column]) max = matrix_[i][column];
        }
        return { min, max };
    }
private:
    vector<vector<int>> matrix_;
    size_t n_;
    size_t m_;
};
int main() {
    const auto path = "file.txt"s;
    const Сonstraints con;
    Matrix matrix;
    const auto status = matrix.load(path, con);
    if (status.error) cout << "Error: " << status.message << '\n';
    else {
        for (size_t i = 0; i < matrix.columns(); ++i) {
            auto [min, max] = matrix.min_max(i);
            cout << max << ' ' << min << '\n';
        }
        cout.put('\n');
    }
    system("pause");
}