В каждой строке матрицы найти разницу между максимальным и минимальным элементом

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <string>
#include <random>
#include <stdexcept>
 
template<typename T>
class Matrix {
public:
    Matrix(size_t width, size_t height) : width(width), height(height), data(nullptr) {
        initData();
    }
    template<typename Generator>
    Matrix(size_t width, size_t height, Generator g) : width(width), height(height), data(nullptr) {
        initData();
        generateData(g);
    }
    virtual ~Matrix() {
        deleteData();
    }
    Matrix &operator=(const Matrix<T> &other) {
        if (this != &other) {
            deleteData();
            width = other.width;
            height = other.height;
            copy(other.data);
        }
        return *this;
    }
    Matrix(const Matrix<T> &other) : width(other.width), height(other.height), data(nullptr) {
        initData();
        copy(other.data);
    }
    Matrix(Matrix &&other) noexcept : width(other.width), height(other.height), data(std::exchange(other.data, nullptr)) {
    }
    Matrix &operator=(Matrix<T> &&other) noexcept {
        if (this != &other) {
            deleteData();
            height = other.height;
            width = other.width;
            data = std::exchange(other.data, nullptr);
        }
        return *this;
    }
    size_t getWidth() const { return width; }
    size_t getHeight() const { return height; }
    T& operator()(int row, int col) { return data[row][col]; }
    const T& operator()(int row, int col) const { return data[row][col]; }
    const T* operator[](int row) const { return data[row]; }
private:
    void copy(int **other) {
        for (size_t i = 0; i < height; ++i) {
            for (size_t j = 0; j < width; ++j) {
                data[i][j] = std::move(other[i][j]);
            }
        }
    }
    void deleteData() {
        if (data != nullptr) {
            for (size_t i = 0; i < height; ++i) {
                delete[] data[i];
            }
            delete[] data;
        }
    }
    void initData() {
        deleteData();
        data = new T*[height];
        for (size_t i = 0; i < height; ++i) {
            data[i] = new T[width]{ 0 };
        }
    }
    template<typename Generator>
    void generateData(Generator g) {
        for (size_t i = 0; i < height; ++i) {
            for (size_t j = 0; j < width; ++j) {
                data[i][j] = g();
            }
        }
    }
    size_t width;
    size_t height;
    T **data;
};
 
template<typename T>
std::ostream &operator<<(std::ostream &out, Matrix<T> &m) {
    for (size_t i = 0; i < m.getHeight(); ++i) {
        for (size_t j = 0; j < m.getWidth(); ++j) {
            out << std::setw(3) << m(i, j) << " ";
        }
        out << std::endl;
    }
    return out;
}
 
int main(int argc, char **argv) {
 
    std::random_device rd;
    std::uniform_int_distribution<int> uid(-25, 25);
    auto generator = [&]() { return uid(rd); };
 
 
    Matrix<int> a(5, 5, generator);
    std::cout << a << std::endl;
 
    for (size_t i = 0; i < a.getHeight(); ++i) {
        int min = *std::min_element(a[i], a[i] + a.getWidth());
        int max = *std::max_element(a[i], a[i] + a.getWidth());
        std::cout << "Row " << i << ": max-min=" << max << "-(" << min << ")=" << (max-min) << std::endl;
    }
 
    return 0;
}