fork download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. #define MAX_SIZE 100
  5.  
  6. void read_matrix_static(int matrix[MAX_SIZE][MAX_SIZE], int rows, int cols);
  7. void print_matrix_static(int matrix[MAX_SIZE][MAX_SIZE], int rows, int cols);
  8.  
  9. int** allocate_matrix_dynamic1(int rows, int cols);
  10. void read_matrix_dynamic1(int **matrix, int rows, int cols);
  11. void print_matrix_dynamic1(int **matrix, int rows, int cols);
  12. void free_matrix_dynamic1(int **matrix, int rows);
  13.  
  14. int* allocate_matrix_dynamic2(int rows, int cols);
  15. void read_matrix_dynamic2(int *matrix, int rows, int cols);
  16. void print_matrix_dynamic2(int *matrix, int rows, int cols);
  17. void free_matrix_dynamic2(int *matrix);
  18.  
  19. int** allocate_matrix_dynamic3(int rows, int cols);
  20. void read_matrix_dynamic3(int **matrix, int rows, int cols);
  21. void print_matrix_dynamic3(int **matrix, int rows, int cols);
  22. void free_matrix_dynamic3(int **matrix, int rows);
  23.  
  24. int main() {
  25.     int choice, rows, cols;
  26.     printf("Выберите метод выделения памяти:\n1. Статически\n2. Динамически (2D массив указателей)\n3. Динамически (1D массив)\n4. Динамически (массив указателей на строки)\n");
  27.  
  28.     if (scanf("%d", &choice) != 1 || choice < 1 || choice > 4) {
  29.         printf("n/a\n");
  30.         return 1; // Ошибка выбора
  31.     }
  32.  
  33.     // Чтение размеров матрицы
  34.     if (scanf("%d %d", &rows, &cols) != 2 || rows < 1 || cols < 1 || rows > MAX_SIZE || cols > MAX_SIZE) {
  35.         printf("n/a\n");
  36.         return 1; // Ошибка при считывании размеров матрицы
  37.     }
  38.  
  39.     switch (choice) {
  40.         case 1: {
  41.             int matrix[MAX_SIZE][MAX_SIZE];
  42.             read_matrix_static(matrix, rows, cols);
  43.             print_matrix_static(matrix, rows, cols);
  44.             break;
  45.         }
  46.         case 2: {
  47.             int **matrix = allocate_matrix_dynamic1(rows, cols);
  48.             if (matrix == NULL) {
  49.                 printf("n/a\n");
  50.                 return 1; // Ошибка при выделении памяти
  51.             }
  52.             read_matrix_dynamic1(matrix, rows, cols);
  53.             print_matrix_dynamic1(matrix, rows, cols);
  54.             free_matrix_dynamic1(matrix, rows);
  55.             break;
  56.         }
  57.         case 3: {
  58.             int *matrix = allocate_matrix_dynamic2(rows, cols);
  59.             if (matrix == NULL) {
  60.                 printf("n/a\n");
  61.                 return 1; // Ошибка при выделении памяти
  62.             }
  63.             read_matrix_dynamic2(matrix, rows, cols);
  64.             print_matrix_dynamic2(matrix, rows, cols);
  65.             free_matrix_dynamic2(matrix);
  66.             break;
  67.         }
  68.         case 4: {
  69.             int **matrix = allocate_matrix_dynamic3(rows, cols);
  70.             if (matrix == NULL) {
  71.                 printf("n/a\n");
  72.                 return 1; // Ошибка при выделении памяти
  73.             }
  74.             read_matrix_dynamic3(matrix, rows, cols);
  75.             print_matrix_dynamic3(matrix, rows, cols);
  76.             free_matrix_dynamic3(matrix, rows);
  77.             break;
  78.         }
  79.     }
  80.  
  81.     return 0;
  82. }
  83.  
  84. // Чтение статической матрицы
  85. void read_matrix_static(int matrix[MAX_SIZE][MAX_SIZE], int rows, int cols) {
  86.     for (int i = 0; i < rows; i++) {
  87.         for (int j = 0; j < cols; j++) {
  88.             if (scanf("%d", &matrix[i][j]) != 1) {
  89.                 printf("n/a\n");
  90.                 exit(1); // Ошибка при считывании
  91.             }
  92.         }
  93.     }
  94. }
  95.  
  96. // Печать статической матрицы
  97. void print_matrix_static(int matrix[MAX_SIZE][MAX_SIZE], int rows, int cols) {
  98.     for (int i = 0; i < rows; i++) {
  99.         for (int j = 0; j < cols; j++) {
  100.             printf("%d", matrix[i][j]);
  101.             if (j < cols - 1) {
  102.                 printf(" ");
  103.             }
  104.         }
  105.         if (i < rows - 1) {
  106.             printf("\n");
  107.         }
  108.     }
  109. }
  110.  
  111. // Динамическое выделение: 2D массив указателей
  112. int** allocate_matrix_dynamic1(int rows, int cols) {
  113.     int **matrix = malloc(rows * sizeof(int*));
  114.     if (matrix == NULL) return NULL;
  115.  
  116.     for (int i = 0; i < rows; i++) {
  117.         matrix[i] = malloc(cols * sizeof(int));
  118.         if (matrix[i] == NULL) {
  119.             for (int j = 0; j < i; j++) {
  120.                 free(matrix[j]);
  121.             }
  122.             free(matrix);
  123.             return NULL;
  124.         }
  125.     }
  126.     return matrix;
  127. }
  128.  
  129. // Чтение динамической матрицы 1
  130. void read_matrix_dynamic1(int **matrix, int rows, int cols) {
  131.     for (int i = 0; i < rows; i++) {
  132.         for (int j = 0; j < cols; j++) {
  133.             if (scanf("%d", &matrix[i][j]) != 1) {
  134.                 printf("n/a\n");
  135.                 exit(1); // Ошибка при считывании
  136.             }
  137.         }
  138.     }
  139. }
  140.  
  141. // Печать динамической матрицы 1
  142. void print_matrix_dynamic1(int **matrix, int rows, int cols) {
  143.     for (int i = 0; i < rows; i++) {
  144.         for (int j = 0; j < cols; j++) {
  145.             printf("%d", matrix[i][j]);
  146.             if (j < cols - 1) {
  147.                 printf(" ");
  148.             }
  149.         }
  150.         if (i < rows - 1) {
  151.             printf("\n");
  152.         }
  153.     }
  154. }
  155.  
  156. // Освобождение памяти для динамической матрицы 1
  157. void free_matrix_dynamic1(int **matrix, int rows) {
  158.     for (int i = 0; i < rows; i++) {
  159.         free(matrix[i]);
  160.     }
  161.     free(matrix);
  162. }
  163.  
  164. // Динамическое выделение: 1D массив
  165. int* allocate_matrix_dynamic2(int rows, int cols) {
  166.     return malloc(rows * cols * sizeof(int));
  167. }
  168.  
  169. // Чтение динамической матрицы 2
  170. void read_matrix_dynamic2(int *matrix, int rows, int cols) {
  171.     for (int i = 0; i < rows; i++) {
  172.         for (int j = 0; j < cols; j++) {
  173.             if (scanf("%d", &matrix[i * cols + j]) != 1) {
  174.                 printf("n/a\n");
  175.                 exit(1); // Ошибка при считывании
  176.             }
  177.         }
  178.     }
  179. }
  180.  
  181. // Печать динамической матрицы 2
  182. void print_matrix_dynamic2(int *matrix, int rows, int cols) {
  183.     for (int i = 0; i < rows; i++) {
  184.         for (int j = 0; j < cols; j++) {
  185.             printf("%d", matrix[i * cols + j]);
  186.             if (j < cols - 1) {
  187.                 printf(" ");
  188.             }
  189.         }
  190.         if (i < rows - 1) {
  191.             printf("\n");
  192.         }
  193.     }
  194. }
  195.  
  196. // Освобождение памяти для динамической матрицы 2
  197. void free_matrix_dynamic2(int *matrix) {
  198.     free(matrix);
  199. }
  200.  
  201. // Динамическое выделение: массив указателей на строки
  202. int** allocate_matrix_dynamic3(int rows, int cols) {
  203.     int **matrix = malloc(rows * sizeof(int*));
  204.     if (matrix == NULL) return NULL;
  205.  
  206.     for (int i = 0; i < rows; i++) {
  207.         matrix[i] = malloc(cols * sizeof(int));
  208.         if (matrix[i] == NULL) {
  209.             for (int j = 0; j < i; j++) {
  210.                 free(matrix[j]);
  211.             }
  212.             free(matrix);
  213.             return NULL;
  214.         }
  215.     }
  216.     return matrix;
  217. }
  218.  
  219. // Чтение динамической матрицы 3
  220. void read_matrix_dynamic3(int **matrix, int rows, int cols) {
  221.     for (int i = 0; i < rows; i++) {
  222.         for (int j = 0; j < cols; j++) {
  223.             if (scanf("%d", &matrix[i][j]) != 1) {
  224.                 printf("n/a\n");
  225.                 exit(1); // Ошибка при считывании
  226.             }
  227.         }
  228.     }
  229. }
  230.  
  231. // Печать динамической матрицы 3
  232. void print_matrix_dynamic3(int **matrix, int rows, int cols) {
  233.     for (int i = 0; i < rows; i++) {
  234.         for (int j = 0; j < cols; j++) {
  235.             printf("%d", matrix[i][j]);
  236.             if (j < cols - 1) {
  237.                 printf(" ");
  238.             }
  239.         }
  240.         if (i < rows - 1) {
  241.             printf("\n");
  242.         }
  243.     }
  244. }
  245.  
  246. // Освобождение памяти для динамической матрицы 3
  247. void free_matrix_dynamic3(int **matrix, int rows) {
  248.     for (int i = 0; i < rows; i++) {
  249.         free(matrix[i]);
  250.     }
  251.     free(matrix);
  252. }
Success #stdin #stdout 0.01s 5276KB
comments (?)
stdin
copy 
2
2 2
4 3
9 0
stdout
copy 
Выберите метод выделения памяти:
1. Статически
2. Динамически (2D массив указателей)
3. Динамически (1D массив)
4. Динамически (массив указателей на строки)
4 3
9 0
https://ideone.com/n1jGCK
language:
C (clang 8.0)
created:
10 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!