Блог

Я хочу передать 2-D подмассив в C, как мы можем передать 1-D подмассив:

Я прошел 1-Й подмассив следующим образом:

Код

 #include <stdio.h>

void print_array(int *arr, int len)
{
    for (int i = 0; i < len; i  )
    {
        printf("%d ", arr[i]);
    }
}

int main(void)
{
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(int);
    print_array(amp;arr[2], size - 2);
    return 0;
}
 

Выход

 3 4 5 
 

Но как я могу сделать то же самое для двумерного массива?
У меня есть 2-D массив следующим образом:

 int arr[6][6] = {
        {1, 2, 3, 4, 5, 6},
        {2, 3, 4, 5, 6, 7},
        {3, 4, 5, 6, 7, 8},
        {4, 5, 6, 7, 8, 9},
        {5, 6, 7, 8, 9, 10},
        {6, 7, 8, 9, 10, 11}};
 

Я хочу передать индекс arr[1][1] элемента, чтобы я мог распечатать вспомогательный 2-D массив:

 3 4 5 6 7
4 5 6 7 8
5 6 7 8 9
6 7 8 9 10
7 8 9 10 11
 

Я попробовал сделать это следующим образом, но это не сработало:

Код

 #include <stdio.h>

void print_array(int row, int column, int (*arr)[column])
{
    for (int i = 0; i < row; i  )
    {
        for (int j = 0; j < column; j  )
        {
            printf("%d ", arr[i][j]);
        }
        printf("n");
    }
}

int main(void)
{
    int arr[6][6] = {
        {1, 2, 3, 4, 5, 6},
        {2, 3, 4, 5, 6, 7},
        {3, 4, 5, 6, 7, 8},
        {4, 5, 6, 7, 8, 9},
        {5, 6, 7, 8, 9, 10},
        {6, 7, 8, 9, 10, 11}};

    print_array(5, 5, amp;arr[1]);
    return 0;
}
 

Выход

 2 3 4 5 6 
7 3 4 5 6 
7 8 4 5 6 
7 8 9 5 6 
7 8 9 10 6
 

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

Примечание: Я прошел amp;arr[1] , потому что прохождение amp;arr[1][1] говорит incompatible pointer type for the function argument .

Я знаю, что мы можем сделать это другими способами, но как я могу передать подмассив, как мы можем сделать это в 1-D массиве?

И если это никоим образом невозможно, пожалуйста, скажите мне, в чем основная причина этого, поскольку метод работал для 1-D массива, но не для 2-D массива.

Потому что я думал, что передача arr делает то же самое (т. Е. Доступ к своим членам как arr[0][0] arr[1][0] и так далее. Так почему бы не передать начальный индекс подмассива, чтобы легко получить весь подмассив.

Один из способов достичь этого-передать исходные размеры arr и начальные индексы, srow scol а затем запустить циклы по этим индексам.

 #include <stdio.h>

void print_array(int row, int column, int srow, int scol, int (*arr)[column])
{
    for (int i = srow; i < row; i  )
    {
        for (int j = scol; j < column; j  )
        {
            printf("%d ", arr[i][j]);
        }
        printf("n");
    }
}

int main(void)
{
    int arr[6][6] = {
        {1, 2, 3, 4, 5, 6},
        {2, 3, 4, 5, 6, 7},
        {3, 4, 5, 6, 7, 8},
        {4, 5, 6, 7, 8, 9},
        {5, 6, 7, 8, 9, 10},
        {6, 7, 8, 9, 10, 11}};

    print_array(6, 6, 1, 1, arr);
    return 0;
}
 

Если у вас есть двумерный массив, подобный этому

 enum { M = 6, N = 6 };
int arr[M][N] = 
{
    { 1, 2, 3, 4,  5,  6 },
    { 2, 3, 4, 5,  6,  7 },
    { 3, 4, 5, 6,  7,  8 },
    { 4, 5, 6, 7,  8,  9 },
    { 5, 6, 7, 8,  9, 10 },
    { 6, 7, 8, 9, 10, 11 }
};
 

и хотите вывести его, начиная с позиции строки pos , где pos какое-то значение меньше, чем M тогда, вы можете передать его в функцию, такую как выражение

 arr   pos
 

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

 int ( *arr )[columns]
 

где columns указывает фактическое количество столбцов в исходном массиве.

Что вам также нужно передать функции, так это начальный номер столбца, из которого вы собираетесь вывести подмассив.

Вот демонстрационная программа

 #include <stdio.h>

void print_array( size_t rows, size_t columns, size_t pos, int ( *arr )[columns] )
{
    if ( pos < columns )
    {
        for ( size_t i = 0; i < rows; i   )
        {
            for ( size_t j = pos; j < columns; j   )
            {
                printf( "- ", arr[i][j] );
            }
            putchar( 'n' );
        }
    }
}

int main(void) 
{
    enum { M = 6, N = 6 };
    int arr[M][N] = 
    {
        { 1, 2, 3, 4,  5,  6 },
        { 2, 3, 4, 5,  6,  7 },
        { 3, 4, 5, 6,  7,  8 },
        { 4, 5, 6, 7,  8,  9 },
        { 5, 6, 7, 8,  9, 10 },
        { 6, 7, 8, 9, 10, 11 }
    };
    
    for ( size_t pos = 1; pos < M;    pos )
    {
        print_array( M - pos, N, pos, arr   pos );
        putchar( 'n' );
    }
    
    return 0;
}
 

Вывод программы является

  3  4  5  6  7 
 4  5  6  7  8 
 5  6  7  8  9 
 6  7  8  9 10 
 7  8  9 10 11 

 5  6  7  8 
 6  7  8  9 
 7  8  9 10 
 8  9 10 11 

 7  8  9 
 8  9 10 
 9 10 11 

 9 10 
10 11 

11 
 

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

 print_array( M - 3, N, 1, arr   3 );
 

Я бы рекомендовал использовать вложенные std::array или std::vector . Если размер вашего массива неизвестен во время выполнения, используйте vector. Если размер вашего массива известен, используйте std::array

 #include <array>
using nested_int_array = std::array<std::array<int, 6> >, 6>; //6 = size of array

void printsubarray(int begin_row, int begin_column, const nested_int_arrayamp; ar)
{
   for (int r = begin_row; r < ar.size(); r  )
   {
      for (int c = begin_column; c < ar[0].size(); c  )
      {
           printf("%i ", ar[r][c]);
      }
      printf("n");
   }
}