Массив: Разделить элементы каждого столбца заданной матрицы на последний элемент столбца.

#include <iostream>
#include <string>
#include <iomanip>
#include <algorithm>
using namespace std;
 
//выделяет память по данному указателю
template <typename T>
void createMatrix(T **&mtx, int lines, int columns)
{
    //также кидает исключение, если кто-то передаст указатель, в котором
    //уже есть адрес на выделенную память. Конечно, такое легко обойти 
    //присвоив в коде указателю на матрицу nullptr и тем самым создать
    //прекрасную ошибку утечки памяти, однако это уже проблемы 
    //программиста, сделавшего это, а не функции.
    if(mtx != nullptr) 
        throw (string)"Pointer != nullptr => already initialized! Can't assign new memmory!";
    mtx = new T*[lines];
    for(int i = 0; i < lines; i++)
        mtx[i] = new T[columns];
}
 
//удаляет память матрицы по переданному указателю на неё
template <typename T>
void deleteMatrix(T **mtx, int lines)
{
    for(int i = 0; i < lines; i++)
        delete[] mtx[i];
    delete[] mtx;
}
 
//выдает "рандомное" значение в диапазоне [from; to]
int random(int from, int to)
{
    if(from > to) swap(from, to);
    return rand() % (to - from + 1) + from;
}
 
//заполняет матрицу случайными значениями
template <typename T>
void fillMatrix(T **mtx, int lines, int columns, int from, int to)
{
    for(int i = 0; i < lines; i++)
        for(int j = 0; j < columns; j++)
            mtx[i][j] = random(from, to);
}
 
//ввод матрицы с клавиатуры
template <typename T>
void inputMatrix(T **mtx, int lines, int columns)
{
    for(int i = 0; i < lines; i++)
            for(int j = 0; j < columns; j++)
                cin >> mtx[i][j];
}
 
//простой вывод матрицы
template <typename T>
void displayMatrix(T **mtx, int lines, int columns)
{
    for(int i = 0; i < lines; i++)
    {
        for(int j = 0; j < columns; j++)
            cout << mtx[i][j] << ' ';
        cout << endl;
    }
}
 
//для вывода матрицы с излишествами
int lengthOfNum(int num)
{//вычисляет длину числа (кол-во цифр)
    int length = 1;
    while(num /= 10) length++;
    return length;
}
 
int lengthOfNum(double num)
{//вычисляет длину числа (кол-во цифр) + точность вывода 
//чисел с плавающей запятой
    int length = lengthOfNum(int(num)) + 1;
    int temp = cout.precision(1); cout.precision(temp);
    length += temp;
    return length;
}
 
//выводим матрицы с излишествами
//(лучше использовать только с целыми числами)
template <typename T>
void displayPrettyMatrix(T **mtx, int lines, int columns, T maxNum)
{
    int linesLength = lengthOfNum(lines) + 1;
    int maxLength = max(lengthOfNum(maxNum), lengthOfNum(columns)) + 1;
    
    //выводим номера столбцы
    cout << setw(linesLength + 1) << ' ';
    for(int i = 0; i < columns; i++) cout << setw(maxLength) << i;
    //выводим разграничивающую линию
    cout << endl << setw(linesLength + 1) << char(218);
    for(int i = 0; i < maxLength * columns; i++) cout << char(196);
    cout << endl;
 
    //выводим саму матрицу и номера строк
    for(int i = 0; i < lines; i++)
    {
        //выводим номер строки и символ между матрицей.
        cout << setw(linesLength) << i << char(179);
        //выводим саму матрицу со сдвигом на maxLength шобы
        //красЫво было
        for(int j = 0; j < columns; j++)
            cout << setw(maxLength) << mtx[i][j];
        cout << endl;
    }
 
}
 
//дефы, которые определяют как работает программа 
//по желанию разработчика.
//При объявлении первого будет красивый вывод матрицы, 
//без - обычный. Второе объявление запросит у пользователя
//с клавиатуры размер матрицы, без - будут использоваться 
//заданные в значения. Третье объявление запросит у 
//пользователя всю матрицу, без - заполнит её самостоятельно
#define Pretty_output
//#define Manual_size
//#define Manual_input
int main()
{
    //ставим точность
    cout.precision(4);
    //объявляем и обнуляем указатель
    double **mtx = nullptr;
    int lines, columns;
    typedef remove_reference<decltype(**mtx)>::type usedType;
 
#ifdef Manual_size
    cout << "Enter matrix size (lines X columns): ";
    cin >> lines >> columns;
#else
    lines = 5;
    columns = 10;
#endif
    
    //блок try-catch для поимки исключения при 
    //попытке выделить память на имеющийся уже
    //участок памяти, однако так же срабатывает на
    //не инициализированный указатель, т.к.
    //в нем лежит мусор.
    try
    {
        createMatrix<usedType>(mtx, lines, columns);
    }
    catch(string str){
        cout << "Error: " << str;
        system("pause>nul");
        return 0;
    }
#ifdef Manual_input
    cout << "Enter elemnt of matrix: ";
    inputMatrix<usedType>(mtx, lines, columns);
#else
    fillMatrix<usedType>(mtx, lines, columns, 700, 2000);
#endif
 
#ifdef Pretty_output
    //поиск максимального элемента, нужен лишь
    //для красивого вывода матрицы
    usedType maxNum = 0;
    for(int i = 0; i < lines; i++) 
        for(int j = 0; j < columns; j++) 
            if(maxNum < mtx[i][j]) maxNum = mtx[i][j];
 
    displayPrettyMatrix<usedType>(mtx, lines, columns, maxNum);
#else
    displayMatrix<usedType>(mtx, lines, columns);
#endif
    cout << endl << endl;
 
    //делим каждый эл. каждого столбика 
    //на последний
    for(int j = 0; j < columns; j++)
        for(int i = 0; i < lines; i++)
            mtx[i][j] /= mtx[lines - 1][j];
    maxNum = 0.0;
 
    //создание массива, в котором будут храниться
    //минимальные значения каждой строки
    usedType *minInLine = new usedType[lines];
    //ищем минимальное значение для каждой строки
    for(int i = 0; i < lines; i++)
    {
        minInLine[i] = mtx[i][0];
        for(int j = 1; j < columns; j++)
        {
            if(minInLine[i] > mtx[i][j])
                minInLine[i] = mtx[i][j];
#ifdef Pretty_output
            //т.к. матрица поменялась, то придется опять
            //искать максимальный элемент
            if(mtx[i][j] > maxNum)
                maxNum = mtx[i][j];
#endif
        }
    }
 
#ifdef Pretty_output
    displayPrettyMatrix<usedType>(mtx, lines, columns, maxNum);
#else
    displayMatrix<usedType>(mtx, lines, columns);
#endif
 
    //выводим их
    cout << "Min elements in lines of the matrix[" << lines << "]: " << endl;
    for(int i = 0; i < lines; i++)
        cout << minInLine[i] << ' ';
    cout << endl;
 
    //считаем ср. арифметическое
    int sum = 0;
    for(int i = 0; i < lines; i++)
        sum += minInLine[i];
    cout << "Arithmetic mean of min elemnts: " << (double)sum / lines;
 
    //удаляем массив мин. значений
    delete[] minInLine;
    //удаляем матрицу
    deleteMatrix<usedType>(mtx, lines);
    //стопим консоль
    system("pause>nul");
    return 0;
}