Форум программистов, компьютерный форум CyberForum.ru
Наши страницы

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 10, средняя оценка - 4.80
Ксения love
0 / 0 / 0
Регистрация: 23.12.2012
Сообщений: 21
#1

Сравнение двумерных матриц - разобрать код - C++

19.08.2014, 19:21. Просмотров 1468. Ответов 27
Метки нет (Все метки)

Разобрать суть кода, что в нем описанно, функций

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
int** create_matrix(int n, int m,int tip)
{
    int**variable= NULL; //переменная
    variable = (int**)malloc(sizeof(int*)*n);
    for(int i=0;i<n;i++)
        variable[i]=(int*)malloc(sizeof(int)*m);
    printf("Matrix_successfully_created\n",n,m);//матрицу успешно созданно
    rand_value(variable,n,m); //рандомное значение
    return variable;
}
//----------------------------------------------------------------------------------
void free_memory(int*** matrix,int n)
{
    if((*matrix==NULL) || (matrix == NULL))
    {
        printf("memory_deleted");
    }else
    {
        for(int i=0;i < n;i++)
        {
            free(matrix[i]);
        }
        free(*matrix);
        *matrix=NULL;
    }
}
//----------------------------------------------------------------------------------
int** rand_value(int** matrix, int n, int m)
{
    srand(time(NULL));
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
            matrix[i][j]=rand()%20;
    check (matrix,n,m);
    return matrix;
}
//----------------------------------------------------------------------------------
int* find_max_min(int** matrix,int n,int m)
{
    if((matrix==NULL)||(n==0)||(m==0))
    {
        printf("First_create_a_matrix");// сначала создайте матрицу
        return NULL;
    } else
    {
        int max=matrix[0][0];
        int max_k_n=0,max_k_m=0;
        int min=matrix[0][0];
        int min_k_n=0,min_k_m=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(matrix[i][j] > max)
                {
                    max = matrix[i][j];
                    max_k_n=i;
                    max_k_m=j;
                }
                if(matrix[i][j] < min)
                {
                    min = matrix[i][j];
                    min_k_n=i;
                    min_k_m=j;
                }
            }
        }
        int *return_matrix = (int*)malloc(sizeof(int)*4);
        return_matrix[0]=max_k_n;
        return_matrix[1]=max_k_m;
        return_matrix[2]=min_k_n;
        return_matrix[3]=min_k_m;
        return return_matrix;
    }
}
//----------------------------------------------------------------------------------
void find_value(int** matrix, int n, int m, int value)
{
    if((matrix==NULL)||(n==0)||(m==0))
    {
        printf("First_create_a_matrix");
    } else
    {
        int find=0;
        int index=0;
        int** variable;
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                if(matrix[i][j] == value)
                    find++;
        variable = (int**)malloc(sizeof(int*)*find);
        for(int i=0;i<find;i++)
            variable[i]=(int*)malloc(sizeof(int)*2);
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                if(matrix[i][j] == value)
                {
            variable[index][0]=i;
            variable[index][1]=j;
            index++;
        }
        for(int i=0;i<find;i++)
            printf("n=%d,m=%d\n",variable[i][0],variable[i][1]);
    }
}
//----------------------------------------------------------------------------------
int** compare(int** matrix,int** matrix2,int n,int m)
{
    if((matrix==NULL)||(n==0)||(m==0))
    {
        printf("First_create_a_matrix");
        return NULL;
    } else
    {
        int** matrix3 = create_matrix(n,m,1);
        printf("First_matrix:\n");//первая
        check(matrix,n,m);
        printf("second:\n");//вторая
        check(matrix2,n,m);
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
            {
            if(matrix[i][j] > matrix2[i][j])
            {
                matrix3[i][j]=matrix[i][j];
            }else
            {
                matrix3[i][j]=matrix3[i][j];
            }
        }
        printf("The_compare_is_successful\n"); //Сравнение прошло успешно.
        return matrix3;
    }
}
0
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
19.08.2014, 19:21
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Сравнение двумерных матриц - разобрать код (C++):

Сравнение двух двумерных массивов - C++
Всем привет ) Только начинаю работать с С++. Помогите разобраться с задачей, нужно сравнить два двумерных массива, то есть если в массивах...

Перегрузка сложения для двумерных матриц - C++
Имеется класс для работы с матрицами размера 3 на 3: class Matrix{ private: int aMas ; public: Matrix(){} void...

Сравнение элементов двух двумерных массивов - C++
Нужна очень ваша помощь!!!!не могу разобраться с двумерными массивами!!помогите!!Люди!!помогите с двумерным массивом!!!вообще не могу...

Сравнение элементов двух двумерных массивов - C++
Прошу помощи в написании данной задачи. Написал сам все что мог, выдает ошибку error C2447: '{' : missing function header (old-style formal...

Матрицы: сложения двух матриц (двумерных массивов) - C++
Необходимо написать программу сложения двух матриц (двумерных массивов) на языке СИ++. Даны матрицы A и B. Надо их объявить и заполнить...

Объявить два двумерных массива (матрицы) и подсчитать сумму этих матриц - C++
Объявить два двумерных массива (матрицы) и подсчитать сумму этих матриц.

Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
0x10
2463 / 1635 / 238
Регистрация: 24.11.2012
Сообщений: 4,026
19.08.2014, 19:29 #2
Пока модераторы не поправили пост - в нем еще нет подсветки и форматирования кода. Но даже так я вижу названия функций, которые однозначно дают понять свое назначение. В связи с этим: есть конкретные вопросы по коду или "все непонятно"?
0
Ксения love
0 / 0 / 0
Регистрация: 23.12.2012
Сообщений: 21
19.08.2014, 19:34  [ТС] #3
назначения понятны, а именно что в них происходит

Добавлено через 31 секунду
хотя бы в общем так
0
gru74ik
Модератор
Эксперт CЭксперт С++
4178 / 1806 / 197
Регистрация: 20.02.2013
Сообщений: 4,943
Записей в блоге: 21
19.08.2014, 20:33 #4
Цитата Сообщение от 0x10 Посмотреть сообщение
Пока модераторы не поправили пост - в нем еще нет подсветки и форматирования кода.
А чтобы ,была и подсветка и форматирование кода, надо делать так:
1
Миниатюры
Сравнение двумерных матриц - разобрать код   Сравнение двумерных матриц - разобрать код   Сравнение двумерных матриц - разобрать код  

gru74ik
Модератор
Эксперт CЭксперт С++
4178 / 1806 / 197
Регистрация: 20.02.2013
Сообщений: 4,943
Записей в блоге: 21
19.08.2014, 21:11 #5
Поправил форматирование, чтобы не "вырви глаз" было:

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
//=========================  1  =========================
int** create_matrix(int n, int m, int tip)
{
    int**variable= NULL; //переменная
    variable = (int**)malloc(sizeof(int*)*n);
    
    for (int i=0; i<n; i++)
        variable[i]=(int*)malloc(sizeof(int)*m);
    printf("Matrix_successfully_created\n",n,m);//матрицу успешно созданно
    rand_value(variable,n,m); //рандомное значение
    
    return variable;
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//=========================  2  =========================
void free_memory(int*** matrix, int n)
{
    if ((*matrix==NULL) || (matrix == NULL))
        printf("memory_deleted");
        
    else
    {
        for (int i=0; i<n; i++)
            free(matrix[i]);
        
        free(*matrix);
        *matrix=NULL;
    }
}
C++
1
2
3
4
5
6
7
8
9
10
11
//=========================  3  =========================
int** rand_value(int** matrix, int n, int m)
{
    srand(time(NULL));
    for (int i=0; i<n; i++)
        for (int j=0; j<m; j++)
            matrix[i][j]=rand()%20;
    check (matrix,n,m);
    
    return matrix;
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//=========================  4  =========================
int* find_max_min(int** matrix,int n,int m)
{
    if((matrix==NULL)||(n==0)||(m==0))
    {
        printf("First_create_a_matrix");// сначала создайте матрицу
        return NULL;
    }
    else
    {
        int max=matrix[0][0];
        int max_k_n=0, max_k_m=0;
        int min=matrix[0][0];
        int min_k_n=0, min_k_m=0;
        for (int i=0; i<n; i++)
        {
            for (int j=0; j<m; j++)
            {
                if (matrix[i][j] > max)
                {
                        max = matrix[i][j];
                        max_k_n=i;
                        max_k_m=j;
                }
                if (matrix[i][j] < min)
                {
                    min = matrix[i][j];
                    min_k_n=i;
                    min_k_m=j;
                }
            }
        }
        
        int *return_matrix = (int*)malloc(sizeof(int)*4);
        return_matrix[0]=max_k_n;
        return_matrix[1]=max_k_m;
        return_matrix[2]=min_k_n;
        return_matrix[3]=min_k_m;
        
        return return_matrix;
    }
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//=========================  5  =========================
void find_value(int** matrix, int n, int m, int value)
{
    if ((matrix==NULL)||(n==0)||(m==0))
        printf("First_create_a_matrix");
    else
    {
        int find=0;
        int index=0;
        int** variable;
        for (int i=0; i<n; i++)
            for (int j=0; j<m; j++)
                if (matrix[i][j] == value)
                    find++;
        variable = (int**)malloc(sizeof(int*)*find);
        
        for (int i=0; i<find; i++)
            variable[i] = (int*)malloc(sizeof(int)*2);
            
        for (int i=0; i<n; i++)
            for (int j=0; j<m; j++)
                if (matrix[i][j] == value)
                {
                    variable[index][0] = i;
                    variable[index][1] = j;
                    index++;
                }
                
        for (int i=0; i<find; i++)
            printf("n=%d,m=%d\n",variable[i][0],variable[i][1]);
    }
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//=========================  6  =========================
int** compare(int** matrix,int** matrix2,int n,int m)
{
    if ((matrix==NULL)||(n==0)||(m==0))
    {
        printf("First_create_a_matrix");
        return NULL;
    }
    
    else
    {
        int** matrix3 = create_matrix(n,m,1);
        printf("First_matrix:\n");//первая
        check(matrix,n,m);
        printf("second:\n");//вторая
        check(matrix2,n,m);
        for (int i=0; i<n; i++)
            for (int j=0; j<m; j++)
            {
                if (matrix[i][j] > matrix2[i][j])
                    matrix3[i][j] = matrix[i][j];
                else
                    matrix3[i][j] = matrix3[i][j];
            }
        printf("The_compare_is_successful\n"); //Сравнение прошло успешно.
        
        return matrix3;
    }
}


Добавлено через 3 минуты
Ксения love, Вам прям построчно прокомментировать что там происходит в функциях или и так сойдёт?
  • create_matrix - создаются двумерные массивы (ещё их называют матрицы)
  • rand_value - матрицы наполняются случайными значениями
  • find_value - выполняется поиск значений
  • find_max_min - ищётся максимальное и минимальное значение
  • compare - сравниваются матрицы
0
Ксения love
0 / 0 / 0
Регистрация: 23.12.2012
Сообщений: 21
19.08.2014, 21:37  [ТС] #6
да заголовки тех функций я и сама знаю как переводяться))
да что в них происходит
0
Algoritmer
155 / 95 / 13
Регистрация: 07.03.2013
Сообщений: 480
Записей в блоге: 1
19.08.2014, 21:54 #7
Лучший ответ Сообщение было отмечено автором темы, экспертом или модератором как ответ
Ладно, начнем
Двумерный массив это одномерный массив одномерных массивов. Если рассматривать двумерный массив как таблицу, то можно представить, что сначала мы создаем массив строк, а потом создаем в цикле каждую строку, то есть массив ячеек.
C++
1
2
3
4
5
6
7
8
9
10
int** create_matrix(int n, int m, int tip)
{
  int**variable= NULL; //переменная    --объявляем переменную под наш двумерный массив
  variable = (int**)malloc(sizeof(int*)*n); // динамически выделяем память под массив строк
for (int i=0; i<n; i++) //в этом цикле выделяем память под каждую строку (массив ячеек)
    variable[i]=(int*)malloc(sizeof(int)*m); 
    printf("Matrix_successfully_created\n",n,m);//матрицу успешно созданно
   rand_value(variable,n,m); //рандомное значение
return variable;
}
2
Ксения love
0 / 0 / 0
Регистрация: 23.12.2012
Сообщений: 21
19.08.2014, 21:56  [ТС] #8
я была бы безумно вам благодарна)
0
gru74ik
Модератор
Эксперт CЭксперт С++
4178 / 1806 / 197
Регистрация: 20.02.2013
Сообщений: 4,943
Записей в блоге: 21
20.08.2014, 10:32 #9
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//===================================  1  =====================================
// Определение функции create_matrix(). Функция принимает три аргумента
// целочисленного типа и возвращает указатель на указатель на тип int.
// Переменные int n и int m задают размерность матрицы.
int** create_matrix(int n, int m, int tip)
{
    int**variable = NULL;   // создаётся указатель на указатель на int с именем
                            // variable и ему присваивается значение NULL
                            
// Функция malloc() возвращает указатель на первый байт области памяти размером
// size, которая была выделена из динамически распределяемой области памяти.
// Для определения размера используется sizeof - унарный оператор, возвращающий
// длину в байтах переменной или типа, помещенных в скобки (результат приводится
// к типу указатель на указатель на int). Как написал выше Algoritmer,
// двумерный массив - это одномерный массив одномерных массивов. Если
// рассматривать двумерный массив как таблицу, то можно представить, что сначала
// мы создаем массив строк (рядов) - у нас количество строк это значение переменной
// int n, а потом создаем в цикле массив ячеек (колонок) - за количество колонок 
// у нас отвечает переменная int m:                          
    variable = (int**)malloc(sizeof(int*)*n); // для variable выделяется память
 
// Выделение памяти для всех элементов матрицы пошагово - элемент за элементом
// при помощи цикла for, функции malloc() и унарного оператора sizeof:
    for (int i=0; i<n; i++)
        variable[i]=(int*)malloc(sizeof(int)*m);
        
// Вывод в поток (чаще всего - на экран монитора) строкового литерала
// "Matrix_successfully_created" при помощи функции printf(); в конце строкового
// литерала имеется управляющая последовательность \n - эти два символа
// трактуются как один символ и обозначают перевод строки:
    printf("Matrix_successfully_created\n", n, m);  // матрица успешно создана
    
// Вызов функции rand_value(), генерирующей случайное значение:
    rand_value(variable, n, m);     // рандомное значение
 
// Функция create_matrix() заканчивает все вычисления, возвращая в вызвавшую её
// функцию (например, в функцию main) значение variable при помощи оператора
// return:
    return variable;
}
Добавлено через 39 минут

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//===================================  2  ======================================
// Определение (иногда вместо термина "определение" используют термин
// "реализация") функции free_memory(). Функция принимает два аргумента.
// В качестве первого аргумента - указатель третьего уровня (указатель на
// указатель на указатель) на тип int, в качестве второго - целочисленную
// переменную. Функция не возвращает никаких значений в вызывающую функцию,
// о чём свидетельствует тип возвращаемого значения void (от англ. "void" -
// пустой).
void free_memory(int*** matrix, int n)
{
// Функция выполняет проверку матрицы на предмет занимаемой ею памяти.
    if ((*matrix==NULL) || (matrix == NULL)) // если матрица не занимает памяти
        printf("memory_deleted");   // вывести сообщение "память очищена"
        
    else    // иначе
    {
        for (int i=0; i<n; i++) // элемент за элементом удалить из памяти
            free(matrix[i]);    // вызов функции free(), освобождающей память
            
// Функция free() возвращает память, на которую указывает параметр ptr (в нашем
// случае, в качестве такого параметра выступает указатель matrix[i] записанный в
// нотации массивов - то есть, синтаксис как у массивов, а на самом деле это
// указатель на первый элемент массива), назад в кучу (heap).
// В результате эта память может выделяться снова.
// Обязательным условием использования функции free() является то, что
// освобождаемая память должна была быть предварительно выделена с использованием
// одной из следующих функций: malloc(), realloc() или calloc().
// Прототип функции free() находится в заголовочном файле <stdlib.h>
                    
        free(*matrix);  // освободить память, на которую указывает matrix
        *matrix = NULL; // присвоить указателю matrix значение NULL
    }
}
Добавлено через 1 час 19 минут
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//===================================  3  ======================================
// Определение функции rand_value(). Функция принимает три аргумента - 
// указатель на указатель на тип int и две переменных типа int. Функция
// возвращает указатель на указатель на тип int.
 
// Функция srand выполняет инициализацию генератора случайных чисел rand.
// Генератор псевдо-случайных чисел инициализируется с помощью аргумента seed, 
// который играет роль зерна. В нашем случаем таким аргументом выступает
// значение, возвращаемое функцией time().
// Для того, чтобы генерировать случайные числа, функция srand обычно
// инициализируется некоторыми различными значения, например, такие значения
// генерируются функцией time. Значение, возвращенное функцией time (объявлена
// в заголовке <ctime>) отличается каждую секунду, что дает возможность получать
// совершенно случайные последовательности чисел, при каждом новом вызове
// функции rand.
int** rand_value(int** matrix, int n, int m)
{
    srand(time(NULL));  // запускаем генератор псевдо-случайных чисел
    
// Проходим по всей матрице элемент за элементом при помощи двух вложенных
// циклов for, инициализируя каждый элемент матрицы matrix случайными
// числами в диапазоне от 0 до 20:
    for (int i=0; i<n; i++)
        for (int j=0; j<m; j++)
            matrix[i][j] = rand()%20;   // диапазон значений от 0 до 20
 
    check(matrix, n, m);    // какая-то функция проверки - хз чё за хреновина
    
    return matrix;  // возвращаем matrix
}
1
SatanaXIII
Супер-модератор
Эксперт С++
5616 / 2651 / 246
Регистрация: 01.11.2011
Сообщений: 6,529
Завершенные тесты: 1
20.08.2014, 11:00 #10
Оффтоп

Не по теме:

Цитата Сообщение от gru74ik Посмотреть сообщение
Определение (иногда вместо термина "определение" используют термин "реализация") функции
Если ударяться в казуистику, то обычно, в разговорной речи, под "реализацией"
понимают только потроха, то есть голое тело функции. Говоря "Где реализация?", подразумевают, что "Ну да, вот я вижу интерфейсы, но где реализация-то? Где все остальное?". А "определение" функции это прям как в книжке: начиная с типа возвращаемого параметра и прям до конца тела.

Цитата Сообщение от gru74ik Посмотреть сообщение
Функция free() возвращает память
Уже прям сразу передергивает постановка.
Лучше б было:
Функция free() как входной параметр принимает указатель matrix[i], записанный в
// нотации массивов - то есть, синтаксис как у массивов, а на самом деле это
// указатель на первый элемент массива) и освобождает по этому указателю память, возвращая ее назад в кучу (heap).
Цитата Сообщение от gru74ik Посмотреть сообщение
Функция malloc() возвращает указатель на первый байт области памяти размером
size, которая была выделена из динамически распределяемой области памяти.
Для определения размера используется sizeof - унарный оператор, возвращающий
длину в байтах переменной или типа, помещенных в скобки (результат приводится
к типу указатель на указатель на int). Как написал выше Algoritmer,
двумерный массив - это одномерный массив одномерных массивов. Если
рассматривать двумерный массив как таблицу, то можно представить, что сначала
мы создаем массив строк (рядов) - у нас количество строк это значение переменной
int n, а потом создаем в цикле массив ячеек (колонок) - за количество колонок
у нас отвечает переменная int m:
C++
1
int**variable = (int**)malloc(sizeof(int*)*n);
Я вот почитал и ничего не понял.
variable это указатель на указатель. То есть, по аналогии с одномерным динамическим массивом, это указатель на массив указателей - тип, содержащихся в нем элементов это указатели. Еще раз: указатель на массив, каждый элемент которого есть указатель. Все. Никакой магии.
Когда мы пишем malloc, или в плюсовом варианте new, то мы говорим компилятору: "выдели нам непрерывный кусок памяти вот такого размера". Как он выделяет, где находит - нас не волнует. Главное, что непрерывный кусок памяти это и есть массив. Он выделяет и говорит: "на, пользуйся". С этих пор никто другой не может в выданную нам память залезть, только мы сами.
Мы имеем непрерывный кусок памяти, требуемого нам размера в одном направлении двумерного массива. Теперь надо выделить себе вторую размерность двумерного массива. Для этого мы должны в каждый элемент того одномерного массива повтыкать по одному новому одномерному массиву. Как палки в забор. Для этого мы проходимся циклом по каждому элементу созданного массива и объявляем, что этот каждый элемент это новый массив:
C++
1
2
    for (int i=0; i<n; i++)
        variable[i]=(int*)malloc(sizeof(int)*m);
Здесь мы компилятору говорим, чтобы он нам выделил памяти сколько нам требуется (то есть m раз по sizeof(int) байт) и начало этой области памяти зафиксировал в текущем элементе массива.
В итоге мы имеем кучу одномерных массивов, но только с тем отличием, что их началы располагаются подряд в памяти. А куда там ведут хвосты нам без разницы.

Поскольку я люблю рисовать картинки, то вот:
Сравнение двумерных матриц - разобрать код
Здесь, правда, целевой тип массива не int, а char - это для того, чтобы наглядно видно было разницу в размерах char и указателя на char.


gru74ik, а так круто, вам бы методички писать. ))

1
gru74ik
Модератор
Эксперт CЭксперт С++
4178 / 1806 / 197
Регистрация: 20.02.2013
Сообщений: 4,943
Записей в блоге: 21
20.08.2014, 14:36 #11

Не по теме:

Цитата Сообщение от SatanaXIII Посмотреть сообщение
gru74ik, а так круто, вам бы методички писать. ))
На самом деле мой труд тут достаточно скромен - оформил код в читаемом виде и написал несколько комментариев. Где чего не знал - тупо гуглил и передирал текст с сайтов типа такого и вот такого. За подсказки, поправки и уточнения покорнейше благодарю!



Добавлено через 2 часа 19 минут
Объяснения по 1-й, 2-й и 3-й функции см. на первой странице топика.

Продолжаем:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
//===================================  4  ======================================
// Определение функции find_max_min(). Назначение функции - искать минимальные и
// максимальные значения в матрице. Функция принимает три аргумента - 
// указатель на массив указателей на тип int и две целочисленные переменные,
// задающие размерность матрицы. Возвращаемое значение - указатель на тип int.
int* find_max_min(int** matrix, int n, int m)
{
// Если память под матрицу не выделена или если матрица не заполнена значениями:
    if ((matrix==NULL)||(n==0)||(m==0))
    {   // Вывести на экран сообщение "сначала создайте матрицу":
        printf("First_create_a_matrix");
            
// В завсисмости от реализации компилятора вернуть 0, либо вернуть "мусор":            
        return NULL;    // Плохой стиль программирования! Лучше так не делать!
    }
    
    else    // иначе
    {
        // Присвоить переменной max значение, хранящееся в первом элементе
        // массива matrix:
        int max = matrix[0][0];
        
        // Создать две целочисленные перменные для максимальных значений
        // и пока что присвоить им нулевые значения:
        int max_k_n = 0, max_k_m = 0;
        
        // Присвоить переменной min значение, хранящееся в первом элементе
        // массива matrix:
        int min = matrix[0][0];
        
        // Создать две целочисленные перменные для минимальных значений
        // и пока что присвоить им нулевые значения:
        int min_k_n = 0, min_k_m = 0;
        
        // ЦИкл пошагово проверяет все элементы матрицы:
        for (int i=0; i<n; i++)
            for (int j=0; j<m; j++)
                
// Если значение, хранящееся в текущем элементе массива больше, чем то, которое
// на данный момент хранится в переменной max, то
                if (matrix[i][j]>max) 
                {
                    max = matrix[i][j]; // присвоить переменной max это значение
                    
// "Запомнить" в какой ячейке массива найдено максимальное значение (в отдельные
// переменные сохраняются индексы ячейки):                 
                    max_k_n = i;
                    max_k_m = j;
                }
 
 // Если значение, хранящееся в текущем элементе массива меньше, чем то, которое
// на данный момент хранится в переменной min, то               
                if (matrix[i][j]<min)
                {
                    min = matrix[i][j]; // присвоить переменной min это значение
                    
// "Запомнить" в какой ячейке массива найдено миниимальное значение (в отдельные
// переменные сохраняются индексы ячейки): 
                    min_k_n = i;
                    min_k_m = j;
                }
            }
        }
// Создание массива int return_matrix[4]. Выделение памяти для 4 интов:
        int *return_matrix = (int*)malloc(sizeof(int)*4);
        
// Инициализация элементов массива значениями:
        return_matrix[0] = max_k_n;
        return_matrix[1] = max_k_m;
        return_matrix[2] = min_k_n;
        return_matrix[3] = min_k_m;
 
// Вернуть в вызывающую функцию указатель на массив return_matrix:    
        return return_matrix;
    }
}
P.S. Что такое NULL и почему его не стоит использовать в современных C++ программах.

P.P.S. Поморока с параметром функции в виде указателя на указатель на тип int - это попросту трик (хитрость), с помощью которого функции в качестве параметра можно передать двумерный массив (матрицу). То же самое с возвращаемым значением (указатель на int). В языке программирования C++ нельзя передать в функцию массив или вернуть массив из функции, зато можно передать указатель (ну или, при надобности - вернуть в качестве возращаемого значения указатель).
Так что если массив одномерный, то работаете с указателем первого уровня (с одной звёздочкой который).
Если же массив двумерный (матрица), то работаете с указателем второго уровня (с двумя звёздочками).
0
Ксения love
0 / 0 / 0
Регистрация: 23.12.2012
Сообщений: 21
22.08.2014, 15:20  [ТС] #12
спасибо большое)
0
gru74ik
Модератор
Эксперт CЭксперт С++
4178 / 1806 / 197
Регистрация: 20.02.2013
Сообщений: 4,943
Записей в блоге: 21
22.08.2014, 17:03 #13
Цитата Сообщение от Ксения love Посмотреть сообщение
спасибо большое)
На здоровье.

Два вопроса:
  1. Первые четыре функции всё понятно или ещё остались вопросы?
  2. С последними двумя попробуешь сама разобраться?
0
Ксения love
0 / 0 / 0
Регистрация: 23.12.2012
Сообщений: 21
22.08.2014, 23:37  [ТС] #14
можете пожалуйста дописать значения остальных. мне это очень важно и я вам безумно благодарна

Добавлено через 1 минуту
прошуу))
0
gru74ik
Модератор
Эксперт CЭксперт С++
4178 / 1806 / 197
Регистрация: 20.02.2013
Сообщений: 4,943
Записей в блоге: 21
23.08.2014, 23:27 #15
Цитата Сообщение от Ксения love Посмотреть сообщение
можете пожалуйста дописать значения остальных
Ну раз уж, как говорится, взялся за гуж, и раз уж Вы объявились (а то я в какой-то момент начал уж думать, что Вы к теме потеряли интерес), то вот Вам комментарии к пятой функции:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
//===================================  5  ======================================
// Определение функции find_value(). Назначение функции - искать заданное
// значение в матрице. Функция принимает четыре аргумента -
// указатель на матрицу типа int, две целочисленные переменные,
// задающие размерность матрицы и переменную int value, с помощью которой
// в функцию передаётся значение, которое и будем искать.
// Возвращаемое значение отсутствует.
void find_value(int** matrix, int n, int m, int value)
{
// Если память для матрицы не выделена (матрица не существует) или если
// в матрице нет значений (точнее, если вместо значений - нули), то
    if ((matrix==NULL)||(n==0)||(m==0))
        printf("First_create_a_matrix");    //вывести на экран сообщение
        
    else    // иначе
    {
        int find = 0;   // создаём счётчик "найдёнышей"
        
        int index = 0;  // индекс "рядов" (rows) матрицы variable
        
        int** variable; // создаём матрицу, которая будет хранить индексы
                        // найденных совпадений с нашим "поисковым запросом"
                        
    // Пробегаем по матрице matrix двумя вложенными циклами for:
        for (int i=0; i<n; i++)
            for (int j = 0; j<m; j++)
    // Если какое-то значение совпадает с нашим "поисковым запросом" (то есть
    // с значением переменной value)               
                if (matrix[i][j] == value)
                    find++; // то увеличить счётчик найденных совпадений
 
    // Создадим матрицу, в которую сложим всех найдёнышей. Размер матрицы
    // будет завязан, соответственно, на количество найденных совпадений (то
    // есть, на значение переменной find. Выделяем память под массив variable:
        variable = (int**)malloc(sizeof(int*)*find);
        
    // А раз у нас variable - это массив массивов (матрица), выделяем память
    // под каждый так сказать "субмассив":
        for (int i=0; i<find; i++)
            variable[i] = (int*)malloc(sizeof(int)*2);
            
    // Складываем всех найдёнышей в матрицу variable:
        for (int i=0; i<n; i++)
            for (int j=0; j<m; j++)
                if (matrix[i][j] == value)
                {
                    variable[index][0] = i;
                    variable[index][1] = j;
                    index++;
                }
    // Выводим на экран результаты поиска (всех "найдёнышей"):
        for (int i=0; i<find; i++)
            printf("n=%d,m=%d\n",variable[i][0],variable[i][1]);
    }
}
0
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
23.08.2014, 23:27
Привет! Вот еще темы с ответами:

Сравнение матриц в бинарных файлах - C++
Добрый вечер, хотел бы задать немного вопросов по своей задачке. Сама задачка: Есть 2 файла, в первом - N матриц, во втором - M...

Разобрать код с++ - C++
Всем доброго времени суток. Дело такое нужно разобрать код явных ошибок нету но при компиляции вижуалка вылетает с ошибкой вроде в хидере...

Разобрать код - C++
Помогите разобраться с кодом!Можите рассписать где что находится пожалуйста! #include &quot;stdafx.h&quot; #include&lt;iostream&gt; #include...

Разобрать код - C++
Всем привет помогите разобрать код, программа создана для подсчета что вот это вот означает? double s = 1.0 / 6.0, e, t = 1.0 /...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
Yandex
Объявления
23.08.2014, 23:27
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru