язык Си массивы

[tutejshy]

Возникла такая проблема: обычно при работе с массивами я не использую синтаксический сахар, а обращаюсь к элементам массива с помощью *(mas + n). Но это правильно работает только с одномерными массивами - если это многомерный (дву-) массив, то выдает ошибку, если ставить **(mas l * SIZE + n), то, хоть никакой ошибки не появляется, программа просто не работает как надо. Как правильно обращаться к элементу многомерного массива не используя синтаксический сахар?

[Black Fregat]

Для того, чтобы работать через конструкцию *(mas + i * SIZE + k), нужно иметь одномерный массив размера M*N (эмуляция двумерности)

Двумерный массмв нужно разыменовывать два раза вложенно, примерно так:

#include <stdio.h>
int main()
{
  int i, k;
  int arr[2][3] = {{1,2,3}, {4,5,6}};
  for (i = 0; i<2; i++)
  {
    for (k = 0; k<3; k++)
    {
      printf("%d ", *(*(arr+i)+k));
    }
    printf("\n");  
  }  
}

Но я не вижу ни одного разумного аргмента за такой способ записи..

[alexzk]

"двумерный массив" (тот, что пишится arr[i][j]) есть массив УКАЗАТЕЛЕЙ на УКАЗАТЕЛИ на ЗНАЧЕНИЯ. Поэтому у вас и не работает, как хотите. В общем случае, там не линейная память.
Для такой записи *(mas + i * SIZE + k) вам нужно делать синтаксичски 1 мерный массив с размером M*N значений.
Кстати удалять двумерные массивы нужно циклом - сначала каждую строку delete[], а потом весь массив так же (и распределять построчно).

[Croessmah]

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

обычно при работе с массивами я не использую синтаксический сахар

Изначально провальная затея.

[tutejshy]

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

Изначально провальная затея.

Интересно почему?

[tutejshy]

Сообщение от Black Fregat

#include <stdio.h>

Сообщение от Black Fregat

Код:


#include <stdio.h>
int main()
{
int i, k;
int arr[2][3] = {{1,2,3}, {4,5,6}};
for (i = 0; i<2; i++)
{
for (k = 0; k<3; k++)
{
printf("%d ", *(*(arr+i)+k));
}
printf("\n");
}
}

Спасибо

[_Bers]

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

В общем случае, там не линейная память.

нет никаких ни "общих случаев",
ни "частных случаев".

есть один единственный случай:
память в массивах всегда располагается линейно.
и это не зависит от его разрядности.

следующий код иллюстрирует,
как найти минимальный элемент в массивах любой разрядности:

http://rextester.com/DOR88516

#include <iostream>
#include <algorithm>

// =======================================================
// =======================================================
// =======================================================

//   вычисляет количество элементов многомерного массива

template<class T> struct elem__
{
    typedef T type;
    static const size_t value = 1;
};

template<class T, size_t N> struct elem__< T[N] >
{
    typedef typename elem__<T>::type
        type;
    static const size_t value = N * elem__<T>::value;
};

template<class T> 
const typename elem__<T>::type& min__(const T& arr)
{
    static_assert(
        std::is_array<T>::value,
        "ERROR: expected array"
    );
    typedef typename elem__<T>::type
        type;
    
    auto* b = reinterpret_cast<const type*>(arr);
    auto* e = b + elem__<T>::value;
    
    return *std::min_element(b,e);
}

// =======================================================
// =======================================================
// =======================================================

void example2d()
{
    int a[2][3] = {
        {3,4,5},
        {6,7,1},
    };
    std::cout << "[must be 1] min value = "<< min__(a) <<std::endl;
}

void example3d()
{
    int a[2][2][3] = {
        {
            {3,4,5},
            {6,7,2},
        },
        {
            {3,4,5},
            {6,7,8},
        },
    };
    std::cout << "[must be 2] min value = "<< min__(a) <<std::endl;
}


int main()
{
    std::cout << "Hello, world!\n";
    example2d();
    example3d();
}

[p51x]

Это если именно массивы, а не их эмуляция через массив указателей и т.д.

[Black Fregat]

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

есть один единственный случай:
память в массивах всегда располагается линейно.

Например, в таком коде компилятор этого уже не знает:

void exampleBadBar(int a[2][3])
{
    std::cout << "[must be 1] min value = "<< min__(a) <<std::endl;
}

void exampleBadFoo()
{
    int a[2][3] = {
        {3,4,5},
        {6,7,1},
    };
    exampleBadBar(a);
}

[_Bers]

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

Это если именно массивы, а не их эмуляция через массив указателей и т.д.

когда речь пойдёт о не массивах,
тогда будем говорить о не массивах.