Как создать динамический двумерный массив

@Non_stop · Регистрация: 23.11.2014

Author24 — интернет-сервис помощи студентам

Здравствуйте. Не знаю как объявить двумерный массив. Пытался так сделать не подходит

C++

1	float ** numbers = (float) realloc (numbers, 2* sizeof(float));

@AVIK · 30.03.2016, 22:51

C

    // Создадим квадратный массив размера size
    int size, i;
    int** array = (int**)malloc(sizeof(int*) * size);
    for(i = 0; i < size; i++)
        array[i] = (int*)malloc(sizeof(int*) * size);
 
//... Что-то поделаем с ним
 
    // Очистим память
    for(i = 0; i < size; i++)
        free(array[i]);
    free(array);

@Aliksan · 08.05.2016, 23:54

C

#include <stdio.h>
#include <stdlib.h>
 
 
int main() {
    int i, j;
    long long n, m;
    long long *ptr;
 
    scanf("%lld %lld", &n, &m);
 
    long long **array = (long long **) malloc(n * sizeof(long long*));
    for (i = 0; i < n; i++) {
        array[i] = (long long **) malloc(m * sizeof(long long*));
    }
 
    for(i = 0; i < n; i++) {
        for(j = 0; j < n; j++) {
//          Sto-to delaem
        }
    }
 
    for(i = 0; i < n; i++) {
        free(array[i]);
    }
    free(array);
 
return 0;
}

Почему у меня вылазит такое предупреждение?

C

1 2	warning: assignment from incompatible pointer type [enabled by default] array[i] = (long long *) malloc(m sizeof(long long*));

Добавлено через 2 часа 25 минут

Сообщение от Aliksan

long long **array = (long long **) malloc(n * sizeof(long long*)); for (i = 0; i < n; i++) { array[i] = (long long **) malloc(m * sizeof(long long*)); }

Сам же и нашел ошибку, так правильно:

C

    long long **array = (long long **) malloc(n * sizeof(long long*));
    for (i = 0; i < n; i++) {
        array[i] = (long long *) malloc(m * sizeof(long long));
    }

@SAV_ · 12.11.2020, 00:26

C

#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;
}

@stake-k26 · 12.11.2020, 07:44

Aliksan, не совсем, malloc может вернуть NULL в случае, если память по каким-то причинам не была выделена, и ваша программа должна на это как-то реагировать, например:

C

#include <stdio.h>
#include <stdlib.h>
 
int main (void) {
    long long n, m;
    if (scanf("%lld%lld", &n, &m) != 2 || n < 1 || m < 1) {
        // если возникла ошибка ввода или размер намеренно был введен некорректно
        fprintf(stderr, "Wrong size!\n");   // сообщаем об ошибке
        return 1;       // выходим из программы с кодом ошибки
    }
 
    int **array = (int **) malloc(sizeof(int *) * n);
    if (array == NULL) {
        // если память не дали
        fprintf(stderr, "Error allocate memory!\n");
        return 2;
    }
 
    long long i;
    for (i = 0; i < n; i++) {
        array[i] = (int *) malloc(sizeof(int) * m);
        if (array[i] == NULL) {
            // если память не дали
            while (--i >= 0) {  // освобождаем всю память, которую успели занять
                free(array[i]);
            }
            free(array);
            fprintf(stderr, "Error allocate memory!\n");    // сообщаем об ошибке
            return 2;   // выходим из программы   с кодом ошибки
        }
    }
 
    // Теперь можно работать с массивом
    long long j;
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++) {
            array[i][j] = rand() %100;
            printf("%4d", array[i][j]);
        }
        puts("");
    }
 
    // освобождаем память и выходим
    for(i = 0; i < n; i++) {
        free(array[i]);
    }
    free(array);
 
    return 0;
}

==3437== Memcheck, a memory error detector
==3437== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==3437== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info

3 7
83 86 77 15 93 35 86
92 49 21 62 27 90 59
63 26 40 26 72 36 11

==3437== HEAP SUMMARY:
==3437== in use at exit: 0 bytes in 0 blocks
==3437== total heap usage: 6 allocs, 6 frees, 2,156 bytes allocated
==3437==
==3437== All heap blocks were freed -- no leaks are possible
==3437==
==3437== For lists of detected and suppressed errors, rerun with: -s
==3437== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Добавлено через 11 минут
Если обратить внимание на количество операций alloc в выводе валгринда. можно заметить, что на массив 3х7 понадобилось 4 таких операции. Есть другой способ, более экономичный:

C

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
 
int main (void) {
    srand( (unsigned)time(NULL)/2 );
 
    /* узнаем размеры массива */
    int rows, columns;
    printf(">> ");
    if (scanf("%d%d", &rows, &columns) != 2 || rows < 1 || columns < 1) {
        fprintf(stderr, "Wrong size.\n");
        return 1;
    }
 
    /* запрашиваем память под массив */
    float ** numbers = (float**) malloc(sizeof(float *) * rows);
    // ^^^ сначала создаем массив указателей на строки двумерного массива
    if (numbers == NULL) {  // если память не дали
        fprintf(stderr, "Error allocate memory.\n");    // сообщаем об ошибке
        return 2;           // выходим с кодом ошибки
    }
 
    numbers[0] = (float *) malloc(sizeof(float) * rows*columns);
    // ^^^ затем создаем одномерный массив для хранения данных
    if (numbers[0] == NULL) {
        fprintf(stderr, "Error allocate memory.\n");
        free(numbers);      // освобождаем память, которую уже успели занять
        return 2;
    }
    // и наконец, "пришиваем" соответствующие строки к указателям
    for (size_t i = 1; i < rows; i++)
        numbers[i] = numbers[i-1] + columns;
 
    /* заполняем массив случайными: */
    int i, k;
    for (i = 0; i < rows; i++)
        for (k = 0; k < columns; k++)
            numbers[i][k] = rand() %5 + 1.0 / (1 + rand() %5);
 
    /* выводим элементы массива на экран */
    for (i = 0; i < rows; i++) {
        for (k = 0; k < columns; k++)
            printf("%6.2lf", numbers[i][k]);
        puts("");
    }
 
    /* освобождаем память и выходим */
    free(numbers[0]);
    free(numbers);
    return 0;
}

==3640== Memcheck, a memory error detector
==3640== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==3640== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info

>> 3 7
2.50 1.50 1.25 4.20 4.20 4.33 0.50
4.20 1.33 0.50 2.25 5.00 1.25 0.20
3.25 3.50 1.20 4.25 2.25 2.50 4.50

==3640== HEAP SUMMARY:
==3640== in use at exit: 0 bytes in 0 blocks
==3640== total heap usage: 4 allocs, 4 frees, 2,156 bytes allocated
==3640==
==3640== All heap blocks were freed -- no leaks are possible
==3640==
==3640== For lists of detected and suppressed errors, rerun with: -s
==3640== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Как видно, в этом случае требуется всего два обращения к памяти, что в два раза меньше. Самое приятное, что при любом размере массива нам всегда понадобится ровно два вызова malloc для запроса памяти под массив и ровно два free для освобождения этой памяти в конце программы.

На первый взгляд разница незначительная. Но предположим, что у нас есть двумерный массив, который хранит цвет каждого пикселя картинки 1920 х 1080.

Просто на то, чтобы создать такой массив первым способом, понадобится 1081 вызов malloc()
Вторым - по-прежнему всего 2.

	12.11.2020, 07:44