Очень часто возникают задачи обработки массивов данных, размерность которых заранее неизвестна. В этом случае возможно использование одного из двух подходов:
- выделение памяти под статический массив, содержащий максимально возможное число элементов, однако в этом случае память расходуется не рационально;
- динамическое выделение памяти для хранение массива данных.
Для использования функций динамического выделения памяти необходимо описать указатель, представляющий собой начальный адрес хранения элементов массива.
Начальный адрес статического массива определяется компилятором в момент его объявления и не может быть изменен.
Для динамического массива начальный адрес присваивается объявленному указателю на массив в процессе выполнения программы.
Стандартные функции динамического выделения памяти
Функции динамического выделения памяти находят в оперативной памяти непрерывный участок требуемой длины и возвращают начальный адрес этого участка.
Функции динамического распределения памяти:
void* calloc(ЧислоЭлементов, РазмерЭлементаВБайтах);
Для использования функций динамического распределения памяти необходимо подключение библиотеки <malloc.h>:
#include <alloc.h>Поскольку обе представленные функции в качестве возвращаемого значения имеют указатель на пустой тип void, требуется явное приведение типа возвращаемого значения.
Для определения размера массива в байтах, используемого в качестве аргумента функции malloc() требуется количество элементов умножить на размер одного элемента. Поскольку элементами массива могут быть как данные простых типов, так и составных типов (например, структуры), для точного определения размера элемента в общем случае рекомендуется использование функции
которая определяет количество байт, занимаемое элементом указанного типа.
Память, динамически выделенная с использованием функций calloc(), malloc(), может быть освобождена с использованием функции
«Правилом хорошего тона» в программировании является освобождение динамически выделенной памяти в случае отсутствия ее дальнейшего использования. Однако если динамически выделенная память не освобождается явным образом, она будет освобождена по завершении выполнения программы.
Динамическое выделение памяти для одномерных массивов
Форма обращения к элементам массива с помощью указателей имеет следующий вид:
int b;
p = a; // присваиваем указателю начальный адрес массива
… // ввод элементов массива
b = *p; // b = a[0];
b = *(p+i) // b = a[i];
Пример на Си: Организация динамического одномерного массива и ввод его элементов.
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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
int main()
{
int* a; // указатель на массив
int i, n;
system("chcp 1251");
system("cls");
printf("Введите размер массива: ");
scanf("%d", &n);
// Выделение памяти
a = (int*)malloc(n * sizeof(int));
// Ввод элементов массива
for (i = 0; i < n; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
// Вывод элементов массива
for (i = 0; i < n; i++)
printf("%d ", a[i]);
free(a);
getchar(); getchar();
return 0;
}Результат выполнения программы:
Динамическое выделение памяти для двумерных массивов
Пусть требуется разместить в динамической памяти матрицу, содержащую n строк и m столбцов. Двумерная матрица будет располагаться в оперативной памяти в форме ленты, состоящей из элементов строк. При этом индекс любого элемента двумерной матрицы можно получить по формуле
index = i*m+j;
где i — номер текущей строки; j — номер текущего столбца.
Рассмотрим матрицу 3×4 (см. рис.)
Индекс выделенного элемента определится как
index = 1*4+2=6
Объем памяти, требуемый для размещения двумерного массива, определится как
n·m·(размер элемента)
Однако поскольку при таком объявлении компилятору явно не указывается количество элементов в строке и столбце двумерного массива, традиционное обращение к элементу путем указания индекса строки и индекса столбца является некорректным:
a[j] — некорректно.
Правильное обращение к элементу с использованием указателя будет выглядеть как
*(p+i*m+j),
где
- p — указатель на массив,
- m — количество столбцов,
- i — индекс строки,
- j — индекс столбца.
Пример на Си Ввод и вывод значений динамического двумерного массива
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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
int main()
{
int* a; // указатель на массив
int i, j, n, m;
system("chcp 1251");
system("cls");
printf("Введите количество строк: ");
scanf("%d", &n);
printf("Введите количество столбцов: ");
scanf("%d", &m);
// Выделение памяти
a = (int*)malloc(n * m * sizeof(int));
// Ввод элементов массива
for (i = 0; i < n; i++) // цикл по строкам
{
for (j = 0; j < m; j++) // цикл по столбцам
{
printf("a[%d][%d] = ", i, j);
scanf("%d", (a + i * m + j));
}
}
// Вывод элементов массива
for (i = 0; i < n; i++) // цикл по строкам
{
for (j = 0; j < m; j++) // цикл по столбцам
{
printf("%5d ", *(a + i * m + j)); // 5 знакомест под элемент массива
}
printf("\n");
}
free(a);
getchar(); getchar();
return 0;
}Результат выполнения
Возможен также другой способ динамического выделения памяти под двумерный массив — с использованием массива указателей. Для этого необходимо:
- выделить блок оперативной памяти под массив указателей;
- выделить блоки оперативной памяти под одномерные массивы, представляющие собой строки искомой матрицы;
- записать адреса строк в массив указателей.
Графически такой способ выделения памяти можно представить следующим образом.
При таком способе выделения памяти компилятору явно указано количество строк и количество столбцов в массиве.
Пример на Си
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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
int main()
{
int** a; // указатель на указатель на строку элементов
int i, j, n, m;
system("chcp 1251");
system("cls");
printf("Введите количество строк: ");
scanf("%d", &n);
printf("Введите количество столбцов: ");
scanf("%d", &m);
// Выделение памяти под указатели на строки
a = (int**)malloc(n * sizeof(int*));
// Ввод элементов массива
for (i = 0; i < n; i++) // цикл по строкам
{
// Выделение памяти под хранение строк
a[i] = (int*)malloc(m * sizeof(int));
for (j = 0; j < m; j++) // цикл по столбцам
{
printf("a[%d][%d] = ", i, j);
scanf("%d", &a[i][j]);
}
}
// Вывод элементов массива
for (i = 0; i < n; i++) // цикл по строкам
{
for (j = 0; j < m; j++) // цикл по столбцам
{
printf("%5d ", a[i][j]); // 5 знакомест под элемент массива
}
printf("\n");
}
// Очистка памяти
for (i = 0; i < n; i++) // цикл по строкам
free(a[i]); // освобождение памяти под строку
free(a);
getchar(); getchar();
return 0;
}Результат выполнения программы аналогичен предыдущему случаю.
Свободные массивы
С помощью динамического выделения памяти под указатели строк можно размещать свободные массивы.
Свободным называется двухмерный массив (матрица), размер строк которого может быть различным.
Преимущество использования свободного массива заключается в том, что не требуется отводить память компьютера с запасом для размещения строки максимально возможной длины. Фактически свободный массив представляет собой одномерный массив указателей на одномерные массивы данных.
Для размещения в оперативной памяти матрицы со строками разной длины необходимо ввести дополнительный массив m, в котором будут храниться размеры строк.
Пример на Си: Свободный массив
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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int main()
{
int** a;
int i, j, n, * m;
system("chcp 1251");
system("cls");
printf("Введите количество строк: ");
scanf("%d", &n);
a = (int**)malloc(n * sizeof(int*));
m = (int*)malloc(n * sizeof(int)); // массив кол-ва элеменов в строках массива a
// Ввод элементов массива
for (i = 0; i < n; i++)
{
printf("Введите количество столбцов строки %d: ", i);
scanf("%d", &m[i]);
a[i] = (int*)malloc(m[i] * sizeof(int));
for (j = 0; j < m[i]; j++) {
printf("a[%d][%d]= ", i, j);
scanf("%d", &a[i][j]);
}
}
// Вывод элементов массива
for (i = 0; i < n; i++)
{
for (j = 0; j < m[i]; j++)
{
printf("%3d ", a[i][j]);
}
printf("\n");
}
// Освобождение памяти
for (i = 0; i < n; i++)
{
free(a[i]);
}
free(a);
free(m);
getchar(); getchar();
return 0;
}Результат выполнения
Перераспределение памяти
Если размер выделяемой памяти нельзя задать заранее, например при вводе последовательности значений до определенной команды, то для увеличения размера массива при вводе следующего значения необходимо выполнить следующие действия:
- Выделить блок памяти размерности n+1 (на 1 больше текущего размера массива)
- Скопировать все значения, хранящиеся в массиве во вновь выделенную область памяти
- Освободить память, выделенную ранее для хранения массива
- Переместить указатель начала массива на начало вновь выделенной области памяти
- Дополнить массив последним введенным значением
Все перечисленные выше действия (кроме последнего) выполняет функция
- ptr — указатель на блок ранее выделенной памяти функциями malloc(), calloc() или realloc() для перемещения в новое место. Если этот параметр равен NULL, то выделяется новый блок, и функция возвращает на него указатель.
- size — новый размер, в байтах, выделяемого блока памяти. Если size = 0, ранее выделенная память освобождается и функция возвращает нулевой указатель, ptr устанавливается в NULL.
Размер блока памяти, на который ссылается параметр ptr изменяется на size байтов. Блок памяти может уменьшаться или увеличиваться в размере. Содержимое блока памяти сохраняется даже если новый блок имеет меньший размер, чем старый. Но отбрасываются те данные, которые выходят за рамки нового блока. Если новый блок памяти больше старого, то содержимое вновь выделенной памяти будет неопределенным.
Пример на Си Выделить память для ввода массива целых чисел. После ввода каждого значения задавать вопрос о вводе следующего значения.
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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
int main()
{
int* a = NULL, i = 0, elem;
char c;
do {
printf("a[%d]= ", i);
scanf("%d", &elem);
a = (int*)realloc(a, (i + 1) * sizeof(int));
a[i] = elem;
i++;
getchar();
printf("Next (y/n)? ");
c = getchar();
} while (c == 'y');
for (int j = 0; j < i; j++)
printf("%d ", a[j]);
if (i > 2) i -= 2;
printf("\n");
a = (int*)realloc(a, i * sizeof(int)); // уменьшение размера массива на 2
for (int j = 0; j < i; j++)
printf("%d ", a[j]);
getchar(); getchar();
return 0;
}
Елена, отлично написанная статья! Всё разложено по полочкам. Благодарю Вас!
Здравствуйте, подскажите пожалуйста, free() в данном коде не работает, в чем ошибка? и можно ли использовать free() через указатели, без []?
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
#include <cstdlib>
#include <ctime>
#include <clocale>
#include <iostream>
#include <malloc.h>
#define S 5
using namespace std;
void two_dim_input(int** a)
{
srand(time(0));
for (int i = 0; i < S; i++)
{
for (int u = 0; u < S; u++)
{
*((int*)a + i * S + u) = rand() % 99;
}
}
}
int main()
{
int** mas = (int **)calloc(S, sizeof(*mas));
for (int i = 0; i < S; i++)
*(mas + i) = (int *)calloc(S, sizeof(mas));
two_dim_input(mas);
two_dim_output(mas);
two_dim_sum(mas);
printf("\n\n");
two_dim_output(mas);
for (int i = 0; i < S; i++) // цикл по строкам
free(mas[i]); // освобождение памяти под строку
free(mas);
}
2
3
4
5
6
7
8
…
int** mas = (int**)calloc(S, sizeof(int*));
for (int i = 0; i < S; i++)
*(mas + i) = (int*)calloc(S, sizeof(int)); // не sizeof(mas)
…
for (int i = 0; i < S; i++) // цикл по строкам
free(*(mas+i)); // освобождение памяти под строку
Добрый день! У меня есть такой простенький код C++ с ассемблерной вставкой. Скажите, как реализовать такой же алгоритм, но с динамическим выделением память под var. У самого не вышло:
2
3
4
5
6
7
8
9
10
11
12
13
cout << "_asm code started working" << endl;
_asm {
pushf // помещаем регистр флагов в стек
pop var // извлекаем операнд из стека (шта?)
}
cout << "_asm code finished working" << endl;
// Вывод var
cout << var << endl;
2
3
4
5
6
7
8
9
10
11
12
13
var = new short[1];
cout << "_asm code started working" << endl;
_asm {
pushf // помещаем регистр флагов в стек
pop *var[0] // извлекаем операнд из стека (шта?)
}
cout << "_asm code finished working" << endl;
// Вывод var
cout << *var[0] << endl;
Здравствуйте Елена, часто прибегаю к подсказкам из ваших примеров и объяснений, за что вам большое спасибо. Сам являюсь самоучкой, знакомство с Си начал примерно 1,5 года назад. И вот сегодня в первые узнаю, что заголовок <malloc.h> является не стандартным и вместо него рекомендуют использовать <stdlib.h>. Хотя знал, что функция malloc() может использовать любой из этих двух заголовков.
На самом деле, зависит от компилятора. Чаще всего, если подключить "malloc.h", ошибки не будет. Но, например, Visual Studio позволяет подключить malloc.h внутри stdlib.h
Доброго времени суток Вам!
Простите, что буду задавать вам глупые вопросы. Сын попросил помочь написать ему сортировку методом решета Эратосфена 3 с лишним млрд. простых чисел. Если реализовывать алгоритм в "классическом" виде, то время выполнения очень большое. Я предложил ему следующее "ускорение": 1. Заполнять массив только НЕчетными числами (ну кроме 2ки) — это уменьшило размер массива в 2 раза. 2. Попытаться при каждом проходе удалять "Ненужные" элементы массива, для того чтобы при каждом последующем проходе уменьшать количество просматриваемых элементов. НО. Сын мне объяснил, что такие фокусы в Си не проходят. Так вот вопрос: массив ведь не единственный вид данных в Си, может существует вид данных, который позволяет получить данные по индексу и при этом позволяет динамически удалять элементы, без последующей перезаписи всей цепочки элементов?
Существует структура данных "список" с последовательным доступом. В ней удаление элементов проще реализовать.
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
#include <stdlib.h>
#include <time.h>
#include <malloc.h>
int main()
{
system("chcp 1251"); system("cls");
srand(time(NULL));
int* b, n, m;
printf("кол-во строк: "); scanf_s("%d", &n);
printf("кол-во столбцов: "); scanf_s("%d", &m);
b = (int*)malloc(n * m * sizeof(int));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
*(b + i * m + j) = rand() % 100;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%4d", *(b + i * m + j));
}
printf("\n");
}
int max, maxi = 0, maxj = 0;
max = *b;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (*(b + i * m + j) == max) {
continue;
}
else if (*(b + i * m + j) > max) {
max = *(b + i * m + j);
maxi = i;
maxj = j;
}
}
printf("\nMax = %d", max);
printf("\nmaxi = %d", maxi);
printf("\nmaxj = %d", maxj);
if (maxi > 0) {
for (int i = maxi; i < n; i++) {
for (int j = 0; j < m; j++) {
*(b + (i — 1) * m + j) = *(b + i * m + j);
}
}
n—;
printf("\nматрица после удаления строки\n\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%4d", *(b + i * m + j));
}
printf("\n");
}
m++;
for (int i = 0; i < n; i++) {
for (int j = m — 1; j > maxj — 1; j—) {
*(b + i * m + j) = *(b + i * m + (j — 1)); //зміщуємо стовбчики вправо
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
*(b + i * m + maxj) = rand() % 100;
}
}
printf("\nматрица после добавления столбца\n\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%4d", *(b + i * m + j));
}
printf("\n");
}
return 0;
}
else return 0;
}
Не коректно работает удаление столбца и заполнение нового.
Помогите пожалуйста!
Насколько я поняла, нужно удалить строку и столбец, на пересечении которых находится максимум:
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
for (int j = 0; j < m; j++) {
*(b + i * m + j) = *(b + (i+1) * m + j);
}
}
n—;
printf("\nматрица после удаления строки\n\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%4d", *(b + i * m + j));
}
printf("\n");
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < maxj; j++) {
*(b + i * (m-1) + j) = *(b + i * m + j); //сдвигаем столбцы влево
}
for (int j = maxj+1; j < m; j++) {
*(b + i * (m-1) + j-1) = *(b + i * m + j); //сдвигаем столбцы влево
}
}
m—;
printf("\nматрица после удаления столбца\n\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%4d", *(b + i * m + j));
}
printf("\n");
}
извините
там нужно добавить столбец после столбца с максимальным елемнтом и заполнить этот столбец рандомными значениями
Надеюсь, уже справитесь самостоятельно 🙂
Суть в том, что при добавлении или удалении столбца и таком способе выделения памяти смещаются все элементы массива (кроме тех, которые стоят до изменяемого столбца в начальной строчке)
Здравствуйте, есть задание : заданы две одинаковые матрицы, требуется одну из них записать вниз во вторую, используя функцию realloc, я не так давно изучаю программирование, поэтому не понимаю почему мой код не работает, не могли бы вы указать на ошибку ?
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
#include "stdlib.h"
#include "stdio.h"
#include "conio.h"
#include "math.h"
#include <malloc.h>
#include "locale.h"
#include "string.h"
#include "windows.h"
#include "time.h"
int main()
{
int** a; // указатель на указатель на строку элементов
int** b; // указатель на указатель на строку элементов
int i, j, n, m;
int counter = 0;
system("chcp 1251");
system("cls");
printf("Введите количество строк: ");
scanf("%d", &n);
printf("Введите количество столбцов: ");
scanf("%d", &m);
// Выделение памяти под указатели на строки
a = (int**)malloc(n * sizeof(int*));
// Ввод элементов массива
for (i = 0; i < n; i++) // цикл по строкам
{
// Выделение памяти под хранение строк
a[i] = (int*)malloc(m * sizeof(int));
for (j = 0; j < m; j++) // цикл по столбцам
{
printf("a[%d][%d] = ", i, j);
scanf("%d", &a[i][j]);
}
}
// Вывод элементов массива
for (i = 0; i < n; i++) // цикл по строкам
{
for (j = 0; j < m; j++) // цикл по столбцам
{
printf("%5d ", a[i][j]); // 5 знакомест под элемент массива
}
printf("\n");
}
b = (int**)malloc(n * sizeof(int*));
// Ввод элементов массива
for (i = 0; i < n; i++) // цикл по строкам
{
// Выделение памяти под хранение строк
b[i] = (int*)malloc(m * sizeof(int));
for (j = 0; j < m; j++) // цикл по столбцам
{
printf("a[%d][%d] = ", i, j);
scanf("%d", &b[i][j]);
}
}
for (i = 0; i < n; i++) // цикл по строкам
{
for (j = 0; j < m; j++) // цикл по столбцам
{
printf("%5d ", b[i][j]); // 5 знакомест под элемент массива
}
printf("\n");
}
a = (int**)realloc(a, (2*n*m) * sizeof(int));
for (i = n; i < 2*n; i++) // цикл по строкам
{
for (j = 0; j < m; j++) // цикл по столбцам
{
a[i][j] = b[counter][j];
counter++;
}
printf("\n");
}
for (i = 0; i < 2*n; i++) // цикл по строкам
{
for (j = 0; j < m; j++) // цикл по столбцам
{
printf("%5d ", a[i][j]); // 5 знакомест под элемент массива
}
printf("\n");
}
// Очистка памяти
for (i = 0; i < n; i++) // цикл по строкам
free(a[i]); // освобождение памяти под строку
free(a);
for (i = 0; i < n; i++) // цикл по строкам
free(b[i]); // освобождение памяти под строку
free(b);
getchar();
return 0;
}
Насколько я понимаю, должно быть так:
2
3
4
5
6
7
8
9
10
for (i = n; i < 2*n; i++) // цикл по строкам
{
a[i] = (int*)malloc(m * sizeof(int));
for (j = 0; j < m; j++) // цикл по столбцам
{
a[i][j] = b[counter][j];
counter++;
}
}
Здравствуйте. Задание:В матрице размером NxM упорядочить элементы столбцов, не содержащих нулевых элементов по возрастанию методом выбора.
Можете пожалуйста объяснить, почему в данном случае без помощи костыля(это момент, где я заставляю прогнать весь фрагмент с обработкой дважды) матрица сортируется не до конца? Остаются моменты где не хватает 1-2 замен.
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
#include "math.h"
#include "windows.h"
#include "stdlib.h"
#include <locale.h>
int _tmain(int argc, _TCHAR* argv[])
{ setlocale(0,"rus");
int i,j,i_,j_,N,M,*A,buf,min=10000,k,d=0;
printf("Введите размеры матрицы A");
scanf("%i %i",&N,&M);
A = (int*)malloc(N*M * sizeof(int));
printf("Матрица:\n");
for(i=0; i<N; i++)
{printf("\n");
for(j=0; j<M; j++)
{*(A+i*N+j)=-2 + rand()%(2-(-2)+1);
printf("%2i ",*(A+i*N+j));}}
do{d++;
for(j=0; j<M; j++)
{for(k=0; k<N-1; k++) {min=k;
for(i=k+1; i<N; i++){
if (*(A+i*N+j)==0 || *(A+min*N+j)==0) {continue;}
if (*(A+min*N+j)<*(A+i*N+j)) {min=i;}
else{ buf=*(A+min*N+j);
*(A+min*N+j)=*(A+i*N+j);
*(A+i*N+j)=buf;}}}}
}while (d<2);
printf("\n Преобразование:");
for(i=0; i<N; i++)
{printf("\n");
for(j=0; j<M; j++)
printf("%2i ",*(A+i*N+j));}
printf("\n");
system("pause");
return 0;
}
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
for (i = 0; i < N; i++)
{
printf("\n");
for (j = 0; j < M; j++)
{
*(A + i * M + j) = -2 + rand() % (2 — (-2) + 1);
printf("%2d ", *(A + i * M + j));
}
}
for (j = 0; j < M; j++)
{
int has0 = 0;
for (k = 0; k < N; k++)
{
if (*(A + k * M + j) == 0)
{
has0 = 1; break;
}
}
if (has0 == 1) continue;
for (k = 0; k < N — 1; k++)
{
min = k;
for (i = k + 1; i < N; i++)
{
if (*(A + i * M + j) < *(A + min*M + j))
{
min = i;
}
}
int buf = *(A + k * M + j);
*(A + k * M + j) = *(A + min * M + j);
*(A + min * M + j) = buf;
}
}
Подскажите, пожалуйста, в чем ошибка. Нужно возвести квадратную матрицу А в степень, задаваемую с клавиатуры.
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
#include <conio.h>
#include <malloc.h>
#include <stdlib.h>
int main() {
int i, j, k, s, m;
printf("Power: ", s);
scanf_s("%d", s);
double *a;
double b[3][3];
a = (double*)malloc(3 * 3 * sizeof(double));
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
printf("a[%d][%d] = ", i, j);
scanf_s("%lf", (a + i * 3 + j));
}
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
printf("%.2lf ", (a + i * 3 + j));
}
printf("\n");
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++)
{
b[i][j] = 1;
for (m = 1; m <= s; m++) {
b[i][j] *= a[j][i];
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
printf("%.3lf ", (b + i * 3 + j));
}
printf("\n");
}
free(a);
free(b);
_getch();
return 0;
}
Она тут не одна 🙂
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
#include <conio.h>
#include <malloc.h>
#include <stdlib.h>
int main()
{
int i, j, k, s, m;
printf("Power: ");
scanf_s("%d", &s);
double* a;
double b[3][3];
a = (double*)malloc(3 * 3 * sizeof(double));
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
printf("a[%d][%d] = ", i, j);
scanf_s("%lf", (a + i * 3 + j));
}
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
printf("%.2lf ", *(a + i * 3 + j));
}
printf("\n");
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++)
{
b[i][j] = 1;
for (m = 1; m <= s; m++) {
b[i][j] *= *(a + i * 3 + j);
}
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
printf("%.3lf ", b[i][j]);
}
printf("\n");
}
free(a);
_getch();
return 0;
}
Спасибо!!!
Здравсвуйте, хотел спросить. Существует ли функция, благодаря которой мы можем удалять и прибавлять элементы без нашего участия. (Т.е. как в питоне (имя массива.append)
Для этого нужно использовать список, а не массив
Здравствуйте, подскажите если память выделена в main, а расширение памяти realloc в функции get_string() при выходе из функции память затирается автоматически без использования функции free(), можно ли это обойти?
Да, можно, если вернуть из функции указатель на вновь выделенную память
Здравствуйте. Спасибо за ваш труд! Хотелось бы задать вопрос: а как при выделении памяти, при которой компилятору явно указано количество строк и количество столбцов в массиве(пример с Вашего сайта) воспользоваться функцией realloc для расширения границ массива, в случае со строками и со столбцами, отдельно?
Если память выделяется единым массивом для последовательного хранения всех строк, то воспользоваться функцией realloc затруднительно. В случае если память выделяется в два этапа (сначала для указателей на строки, а затем для самих строк), функцией realloc придется воспользоваться отдельно для расширения массива указателей на строки и отдельно для перераспределения памяти под элементы каждой строки.
Как я понимаю в данном случае:
2
3
4
5
6
mass = (int**)malloc(n * sizeof(int*));
for (int i = 0; i < n; i++)
{
mass[i] = (int*)malloc(m * sizeof(int));
}
происходит выделение памяти в два этапа, значит для расширения массива(на одну строку) функцией realloc придется воспользоваться отдельно для расширения массива указателей на строки и отдельно для перераспределения памяти под элементы каждой строки. Но, к сожалению, не получилось прийти к правильной реализации:
2
3
4
5
for (int i = 0; i < (n+1); i++)
{
mass[i] = (int*)realloc(NULL,m * sizeof(int));
}
Конечно, realloc() работает с уже выделенной памятью, поэтому для вновь добавленных строк память надо выделить функцией calloc() или malloc(), а функцию realloc() использовать только для старых строк
Попробовал реализовать эту ситуацию, но опять ждала неудача:
2
3
4
5
for (int i = 0; i < (n+1); i++)
{
mass[i] = (int*)malloc(m * sizeof(int));
}
Стёрлись все элементы 🙂
2
mass[n] =(int*)malloc(m * sizeof(int));
Это если добавилась одна строка.
Если добавились строка и столбец, то
2
3
4
5
6
mass[n] =(int*)malloc((m+1)* sizeof(int));
for (int i = 0; i < n; i++)
{
mass[i] = (int*)realloc(mass[i], (m+1)* sizeof(int));
}
Огромное спасибо! Теперь все встало на свои места.
Как происходит обращение к элементу в статическом массиве, и как в динамическом. И зачем нам статический массив если есть динамический (простоту использования и уделение внимания на очистку динамического массива не учитывать)
В некоторых случаях выполнение операций выделения и очистки памяти не учитывать не получается.
А иногда нужно привязать массив к размещению в определенной ячейке памяти.
Елена, добрый день!
Подскажите, пожалуйста. В случае использования int **a для выделения памяти для двумерного массива, единица хранения для a это 8 байт (для 64 разрядной архитектуры) — это понятно. А какова единица хранения для *a? У меня *a и *(a+1) всегда 32, независимо от типа (int, char) и количества строк и столбцов.
Да, верно. Любой указатель занимает 4 байта, независимо от типа.
Добрый день!
Этот же способ подойдет для создание динамичного массива, состоящего из символов? Я использовала первый пример и просто попробовала заменить int на char. Работает через раз. В том плане, что когда программа заходит в цикл, чтобы ввести элементы массива, то она игнорирует 1 шаг и сразу переходи ко второму, затем сразу переходит к 3 шагу. Для работы с char есть какие то особые правила? Я делала разные типы циклов, думая, что где-то косячу с шагом, но ничего не изменилось. В моем заданием мне нужно, чтобы пользователь ввел в массив символы и я могла найти среди них определенные. Заранее
Нет, никаких особых правил нет. Всё должно получиться.
У меня схожая проблема, массив печатает через раз
Не удается реализовать алгоритм нахождения числа делителей у массива,прошу помощи в этом деле.
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
#include <stdlib.h>
#include <conio.h>
void sort()//функция нахождения числа делителей и сортировки
{
}
int main(void) {
int n;
int m;
m = 0;
printf("a[n],n=…\n");//число элементов в массиве
scanf("%i", &n);
int a[n];
int i;
for (i = 0; i < n; i++)//задание значений каждого из элементов
{
printf("number %i=", i);
scanf("%i", &a[i]);
}
sort(a, n);//выполнение функции по сортировке элементов массива
for (int i = 0; i < n; ++i)/*вывод элементов в порядке возрастания их
числа делителей*/
{
printf("%i ", a[i]);
}
getch();
return 0;
}
[br]
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*Однако мне удалось реализовать алгоритм поиска делителей отдельного числа*/
int main(void) {
int x;
int i;
int m;
m = 0;
printf("enter x…");
scanf("%i", &x);//прием значения переменной с клавиатуры
for (i = 1; i <= x; i++)/*цикл для вычисления числа делителей
заданной переменной*/
{
if (x % i == 0)
m++;
}
printf("m=%i", m);//вывод числа делителей
return 0;
}
Идея такая, что нужно создать ещё один массив целых чисел, и заполнить его значениями m количества делителей. Потом сортировать уже получившийся массив по возрастанию значений m, а параллельно с ним переставлять значения исходного массива.
Добрый день, не могли бы вы подсказать как обращаться к элементам двухмерного массива, заданного вторым способом (с помощью массива указателей), через указатель, например для вывода данного массива в консоль, используя функцию, которая принимает указатель на начало массива и его размеры, заранее благодарен.
А чем не устраивает a[j]
?
я же в самом комментарии привел пример использования, написание функции для обработки массива, например при создании библиотеки, обращаться к массиву через [j] уже не получится, но я уже дошел до ответа методом проб и ошибок.
2
3
4
5
6
7
8
9
10
11
12
13
{
for(unsigned char i = 0; i < R; i++)
{
for(unsigned char j = 0; j < C; j++)
{
printf(" %5d ", *(*(point + i) + j));
}
printf("\n");
}
}
ну и вызов функции как
showMass(&data[0], r, c);
P.S. r c аналог ваших n m (Rows, Columns)
Ну, да, можно и так.
Только не пойму, почему через p[j] не получится?
Добрый день. Объясните пожалуйста значение строки:
a = (int*)malloc(n*m * sizeof(int));
Зарание спасибо.
Функция malloc() предназначена для динамического выделения памяти. В качестве аргумента ей передается количество байт, которые надо выделить. Оно вычисляется как n строк по m столбцов, где каждый элемент занимает 4 байта. В общем случае количество байтов, занимаемых одним элементом, определяется с помощью функции sizeof(), которой в качестве аргумента передается объект, размер которого в байтах необходимо определить.
Возвращаемое значение функции malloc — указатель на неопределенный тип, или начальный адрес выделенного участка памяти. И этот указатель необходимо привести к указателю того типа данные которого будут храниться в массиве. В данном случае это указатель на int — (int*)
В самом первом примере (выделение памяти для одномерного массива) есть одна маленькая неточность: вводимый элемент не проверяется на «не цифру», в результате чего при наборе «буква + Enter» (у меня так случайно вышло) программа входит в бесконечный цикл. Я думаю, что в данном примере такая проверка не обязательна, но комментарий по этому поводу не был бы лишним, тем более, что далеко не все читатели Вашего замечательного сайта (и я в том числе) — специалисты в Си. Вы, Елена, делаете работу, достойную всяческих комплиментов.
Классные уроки по языку С! Очень понравились. Все доступно и наглядно представлено!
Добрый день! Почему в последнем примере мы <span class='prog'>getchar()</span> пишем два раза
2
3
printf("Next (y/n)? ");
c = getchar();
Почему, если мы напишем один раз, то программа не останавливается и не ждет нашего ввода?
Мы в цикле вызываем функцию scanf() для ввода элементов массива (строка 10). Эта функция считывает, в данном случае, числовое значение до символов «пробел», «табуляция» или «перевод строки». При этом сам «перевод строки» остаётся в буфере обмена. Поэтому если не поставить дополнительный getchar() (строка 14), то этот «перевод строки» из буфера будет воспринят в качестве символа для продолжения ввода. Дополнительный getchar() «гасит» «перевод строки» из буфера и позволяет пользователю ввести символ с клавиатуры.
Аналогичным образом действует двойной getchar() в конце программы.
> При этом сам «перевод строки» остаётся в буфере обмена.
Елена, от куда он там берется в буфере? «Перевод строки»…
Перевод строки состоит из двух символов с кодами 13, 10 (перевод строки, возврат каретки). При этом один из них заканчивает ввод, а второй остается в буфере и автоматически считывается при следующем вводе символа или строки.
Если вводятся подряд несколько чисел, то scanf() этот символ из буфера игнорирует, поскольку ждет ввода числа.
В конце программы, чтобы консоль не схлопывалась, я пишу:
По-моему, так удобнее и информативнее
здравствуйте
у меня такой вопрос и мне нужен помощь.Написать программу которая печатает самое краткое слово строки.. и я это сделал… а теперь для этого вопрос, мне надо выделить память с помощью malloc и calloc… но не знаю как..
Если Вы знаете, сколько букв содержится в слове (N), то выделить память можно так:
char *slovo = (char*) malloc(N+1);
Было бы здорово, если бы Вы описали работу с массивом структур.
Посмотрите здесь:
http://prog-cpp.ru/c-struct/
Спасибо! Долго ждал вашего ответа, но уже нашел решение:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#define ESC 27
#define EOS '\n'
using namespace std;
int main() {
int *a, temp, i;
do {
system("CLS");
temp = 0, i = 0;
a = (int*)malloc(sizeof(int));
cout << "Enter Numbers: ";
do {
cin >> a[temp];
temp++;
if (temp >= (sizeof(a) / sizeof(*a)))
a = (int*)realloc(a, (temp + 1) * sizeof(int));
} while (cin.get() != EOS);
cout << "Result achived: ";
for (i, temp; temp > 0; temp—, i++)cout << a[i] << " ";
free(a);
} while (_getch() != ESC);
return 0;
}
Здравствуйте,не могли бы вы пояснить,почему в данном случае мы не объявляем массив и почему используем указатель "а", как имя массива?:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int *a; // указатель на массив
int i, n;
system("chcp 1251");
system("cls");
printf("Введите размер массива: ");
scanf("%d", &n);
// Выделение памяти
a = (int*) malloc(n*sizeof(int));
// Ввод элементов массива
for(i=0; i<n; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
В данном примере используется динамическое выделение памяти, то есть память выделяется на этапе выполнения программы. Объявляется указатель, в который позже запишется адрес выделенного участка памяти требуемого объема. Выделением памяти занимается функция malloc().
Если бы мы объявили массив, то мы имели бы дело со статическим массивом, в котором максимальное количество элементов задано на этапе компиляции.
Большое спасибо.
Здравствуйте. Объясните пожалуйста почему в указателе две звёздочки? (int **a);
Читайте чуть выше.
В данном случае a представляет собой указатель на массив указателей, каждый из которых, в свою очередь, указывает на свой массив элементов строки.