двумерный массив

Массив (непрерывный) указателей на непрерывные участи памяти. Или я вопрос неправильно понял?

Массив (непрерывный) указателей на непрерывные участи памяти.

Это массив указателей. А многомерные массивы хранятся непрерывно полностью.

Статический многомерный массив в C хранится непрерывно, так, что

int a[2][3] = {{0,1,2}, {3,4,5}};

int a[2][3] = {0,1,2,3,4,5};

Ну если ты знаешь, то зачем тогда спрашиваешь?

Ну если ты знаешь, то зачем тогда спрашиваешь?

О чем спрашиваю?

Хранится так же, как и одномерный. Это легко поверить тем, что одномерный массив легко превращается в двумерный путем простых мат. операций.

одним жирным блоком n*m

Непрерывно по строкам.

Печально, что динамически так нельзя делать =(

Можно. Но только или размеры массива должны быть статически известны, или запись будет не такая сладкая.

Можно. Но ненужно - такая организация данных для многих задач крайне неэффективна.

интересует хранение двумерного массива.

int mass[m][n];

проблема в том, что при сборке сишным компилятором этот массив имеет один размер, при сборке C++ - другой.

Перепутал тебя с ТС.

Что за компиляторы, какой именно размер получился, что именно ты считаешь за размер?

в документации или стандарте есть что нибудь о хранении многомерных или двумерных массивов?

А как же, конечно есть. На то он и стандарт.

можно поконкретнее, со ссылками и цитатами.

проблема в том, что при сборке сишным компилятором этот массив имеет один размер, при сборке C++ - другой.

простите, что?

#!/bin/bash

function sizeof_arr()
{
  echo "sizeof("
  for i in 1 2 3 4; do
    echo "${i}3=%li 7${i}=%li"
  done
  echo ")"
}

function arr()
{
  for i in 1 2 3 4; do
    echo ", sizeof(arr${i}3), sizeof(arr7$i)"
  done
}

for j in 1 2 4 8 16; do
  for i in "gcc c" "g++ cpp" "clang c" "clang++ cpp" ; do
    for o in "-O0" "-O1" "-O2" "-O3" ; do
      a=($i)
      echo '#include <stdio.h>
#pragma pack(push,'$j')
int arr13[1][3];
int arr23[2][3];
int arr33[3][3];
int arr43[4][3];
int arr71[7][1];
int arr72[7][2];
int arr73[7][3];
int arr74[7][4];
#pragma pack(pop)
int main()
{
  printf("compiler:%10s, optimize:%3s, pack:%3s, '$(sizeof_arr)'\n","'${a[0]}'","'$o'","'$j'"'$(arr)');
  return 0;
}
' >main.${a[1]}
      ${a[0]} $o main.${a[1]} -o out.${a[0]}
      ./out.${a[0]}
    done
  done
done

C11: 6.5.2.1 Array subscripting C++11: 8.3.4 Array

Я балдю, народ не то, шо читать, а даже гуглить разучился.

Ну спроси уже у гугла multidimensional arrays in C

Ссылка на PDF со стандартом (хоть K&R, хоть C99) находится в гугле с полпинка. Найти в этом стандарте описание размещения многоразмерных массивов по оглавлению даже дебилу по силам.

Ну напряги мозги сам хоть немного.

int mass[m][n];

проблема в том, что при сборке сишным компилятором этот массив имеет один размер, при сборке C++ - другой.

Не употребляй больше кокаин.

емнип, a[x+h*y] эффективнее, чем a[x][y], если, например, int** a;

Можно. Но только или размеры массива должны быть статически известны, или запись будет не такая сладкая.

О том и речь, что не известна.

Эффективнее, но в приниципе то же самое что a[x][y] если

int a[Nx][Ny];

а что хорошо?

Например Z-кривые (на основе чисел Мортона). Октодерево с фикс. длиной ветвей.

или запись будет не такая сладкая[/quote Вовсе не обязательно.

#include <stdio.h>
#include <stdlib.h>

int main()
{
        unsigned n, m, i, j, k;
        scanf("%u%u", &m, &n);
        int (*buf)[n] = (int (*)[n]) malloc(sizeof(int[m][n]));
        for (i = 0, k = 0; i != m; ++i)
                for (j = 0; j != n; ++j, ++k)
                        buf[i][j] = k;
        for (i = 0; i != m; ++i) {
                for (j = 0; j != n; ++j)
                        printf(" %d", buf[i][j]);
                puts("");
        }
        return 0;
}

Если значения n или m внезапно поменяются, то капец. (Это ладно, это сишечка, тут сам себе дурак.)

Но вот VLA не обязательно поддерживаются конпелятором. А они нужны, чтобы кастануть к int (*)[n], где n не константа времени компиляции.