Функции и динамические двумерные массивы

Здравствуйте, любители C++, как я вам и обещал, сегодня мы с вами разберем динамические массивы и напишем свои собственные функции. За основу мы возьмем задание из статьи №3, где мы работали с двумерным массивом размерностью 8×8.

Вспомним то задание(оригинал в статье №3) и запишем его немножко в другом виде:
Для заданной матрицы размером n на m найти такие k, что k-ая строка матрицы совпадает с k-ым столбцом.
Найти сумму элементов в тех строках, которые содержат хотя бы один отрицательный элемент.

Начнем:
Ну во первых я должен вас поздравить: мы переходим к функциональному программированию, и это уже можно считать достижением.

#include <conio.h>
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int** sozdanie(int n, int m);
void initialize( int** A, int n, int m); // будем передавать динамический массив и размерность в качестве параметра
void compare(int** A, int n, int m);
void summa (int** A, int n, int m);

Для начала нам следует подключить стандартные библиотеки, пространство имен, и, самое главное, объявить наши функции.
Объявляют функцию в C++ следующим образом:

1) Тип возвращаемых данных
То есть если написать в самом начале int, то это значит что функция вернет какое то целочисленное значение, как видите, функция sozdanie возвращает динамический двумерный массив целых чисел(да именно так он обозначается int**), если же написать в начале объявления тип void(как во всех остальных функциях), то это означает, что функция ничего не возвращает(но не путайте, она все же что то делает с нашими данными).

2) Имя функции
Здесь все просто: мы просто придумываем имя нашим функциям(желательно, чтобы имя отражало суть функции).

3) Список параметров
Чтобы наши функции что то делали, им нужно передать какие то данные. Например функция sozdanie, она принимает 2 параметра: число строк n и число столбцов m, и на основе этих данных создает двумерный массив.

Только не путайте: мы пока что только объявили эти функции, после этого нам следует описать их, то есть написать, что каждая из них делает.

int** sozdanie(int n, int m)
{
    int **A;// Создаем матрицу введенной размерности
    A = new int *[n]; // через массив указателей
    for (int i = 0; i < n; i++) {
       A[i] = new int [m];
    }
    return A;
}

void initialize(int** A, int n, int m)// Функция заполнения
{
    srand(time(0));
    for(int i = 0; i < n; i++ )
        {
            for(int j = 0;  j < m;  j++ )
                {
                    A[i][j] = rand()%11 - 5 ;
                    cout << A[i][j] << "     ";
                }
    cout << endl;
        }
}

Таким образом описываются функции в C++, следует отметить, что описывать их можно как до main, так и после него.
Разберем функцию создания динамического массива:

Для начала нам следует создать одномерный массив указателей, затем в цикле в каждый указатель мы записываем еще одномерный массив, таким образом у нас выходит массив массивов, или, двумерный массив в котором n строк и m столбцов.

Так как мы работаем с динамическим массивом, то следует выделять память под него, это делается с помощью ключевого слова new.

Вторая функция, как и в статье №3, заполняет массив рандомными числами и выводит на экран. Заметьте, что в качестве параметра этой функции передается и сам массив.

void compare(int** A, int n, int m) // Функция сравнения
{
        int count(0), k(0);
        for(int i = 0; i < n; i++ )
        {
                for(int j = 0;  j < m;  j++ )
                {
                        if(A[i][j] == A[j][i])
                        {
                                count++;
                        }
                        if (count == n)
                        {
                                cout << " \n " << i + 1 << " строка совпадает с " << i + 1 << " столбцом " << endl;
                                k ++;
                        }
                        
                }
                count = 0;
        }
        if(k == 0)
                cout << "\n\n Нет совпадающих строк и столбцов" << endl;
}

void summa (int** A, int n, int m) // Функция суммы
{
        int result(0);
        for(int i = 0; i < n; i++ )
        {
                for(int j = 0;  j < m;  j++ )
                {
                        if(A[i][j] < 0)
                        {
                                for(int count = 0; count < m; count ++)
                                {
                                         result += A[i][count];
                                }
                                cout << "\n Сумма элементов на " << i + 1  << " строке равна "<< result << endl;
                                j = m;
                                result = 0;
                        }
                }
        }
}

Здесь подробно останавливаться не будем, так как рабочие моменты уже были пояснены в той самой насущной статье №3, поэтому сразу перейдем к main:

int main()
{
        setlocale(LC_ALL, "Russian");
     
        int n(0), m(0);
        cout << " Введите кол-во строк в массиве" << endl;
        cin >> n;
        cout << " \nВведите кол-во столбцов в массиве" << endl;
        cin >> m;
        cout << endl;
        int **A;

        A = sozdanie(n,m); // Создаем через функцию
        initialize(A, n, m); // заполняем матрицу
        compare(A, n, m); // сравниваем столбцы и строки
        summa(A, n, m); // считаем сумму элементов на строке с отрицательным элементом


        for ( int i = 0; i < n; i++ )
        {
                delete [] A[ i ];
        }
        delete [] A; // Освобождение памяти
        _getch();
        return 0;
}

Создаем переменные строки и столбцы, далее просим пользователя ввести вручную значения для этих переменных(именно поэтому массив называется динамическим). После, вызываем наши функции: вызов осуществляется как имя функции + параметры в ()

И не лишним было бы освободить память по окончанию работы с динамическим массивом в C++

Скачать исходники

На этом сегодня все. Пишите свои комментарии, ваше мнение очень важно для нас!