И первое и второе неверно.




В смысле размер может быть переменным, но его надо или отдельно передать, или ограничить признаком, скажем, в реальной программе не бывает отрицательных чисел, тогда так


Кстати, прототип функции С/С++ воспринимают как

т.е. как функцию, принимающую указатель на 4-интовые массивы.

ЫЫЫЫЫ чего-то не катит

typedef char TypeD[5][5];

char array[5][5];

void func(TypeD * temp){
*temp[1][0]=5;//лезет не в &array+5 ,а в &array+25
}

int main (void)
{
func(&array);
return 0;
}

В disassembly видно что забит сдвиг от начала массива не на пять байт ,а на 25. Всё щастье пашет только на диапазоне *temp[0][0]....*temp[0][4]

Потому что надо вот так:
typedef char[5][5] TypeD;

Естественно.
temp объявлен как указатель на массив char[5][5]
Соответственно temp[1] - это следующий такой массив (temp[1] есть массив char[5][5]), temp[1][0] - первый его подмассив, *temp[1][0], рассматриваемый как *(temp[1][0]) (приоритеты операций в С желательно выучить до начала программирования) - это нулевой элемент данного подмассива.
То, чего Вы хотите, можно достичь двумя способами

причём в первом я не вижу никакого смысла.

Ну а как бы я делал это (точнее, как я уже это делал) - я изобразил в предыдущем своём сообщении.

Кстати, С99 позволяет вообще так:


Только, хоть и прошло уже десять лет, не все компиляторы поддерживают все возможности С99.


И ещё вдогонку.

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

Есть указатели и развитая арифметика с ними. Есть некий "макрос" из квадратных скобок, который облегчает запись этой арифметики. Именно поэтому функции в "можно достичь двумя способами" выше имеют тождественный код и хоть и должны вызывться по разному на уровне исходника
но код вызова тоже тождественный


Более того (специально сделал элемент массива двухбайтовым, чтобі біло чётко видно, что множится на два всегда "истинный" индекс, даже если он стоит перед скобками):


в полном соответствии со стандартом (цитата из C89, в C99 аналогично)
Обратите внимание - "одно из выражений ... другое ..." а не "первое выражение ... второе ...".
Ну а если E1 - интегральный тип а E2 массив (или, что эквивалентно, указатель на его первый элемент), то тогда это будет E1-тый элемент массива E2.

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

А вот ещё из стандарта С++, чтобы окончательно запутать развеять сомнения.


p.s. выделения везде мои

в RealView как то не очень прошло,если только size_y не забить статично.

вообще не трогая указатели и typedef пашет и


Просто массив может быть разной размерности как и способ расчёт их определителя(матрицы), а раз верхний пример не катит, дабы не зацикливаться как на размерности массив так и на размере элементов в функцию кидаю адрес первого элемента :


Но никак не получается красивая конструкция типа temp[1][1] . Собственно если отбросить красоту,как помимо (начало+1*x+1) может произойти обращение с помощью скобок к элементам двумерного массива? Конструкция [][] скрывает тот же расчёт, и вроде даже сложнее.Смотрел на:

Да, блин! Все рассказали, объяснили, примеры привели. Ан нет. По новой дискуссия разворачивается. Чего вы хотите добиться, никак в толк не возьму? Не очень изящно на С получается, перейдите на С++, сделайте себе объект - n-мерный массив (примеров - полно), и передавайте в вашу функцию хоть указатель, хоть ссылку. Причем есть очень хорошие примеры, когда обращение к конкретным элементам массива можно выполнить даже без операции умножения.

еще проще - написать по вкусу PVOID или PCHAR



Не будет изящной реализации на любом языке, когда выбран КРИВОЙ алгоритм решения задачи изначально.

описать действия можно и в одномерном массиве, причем прекрасно читаемо:

;

где каждый "step" может быть любой длины и отделен от остальных 0-терминатором. конец программы - step начинающийся с терминатора.
далее пишем функцию для поиска очередного "step'a":



Ну а потом уже и DoProgram c DoStep'ом



работаем с этим как:

DoProgram( Programs[ x ] );

не рычите люди. С тем, что через void* можно бросить указатель в функцию хоть слона это ясно, искать маркер конца строк массива тоже ясно(один чёрт оно и так всё в ряд). Дайте ответ на вопрос:
Можно ли элементарно преобразовать указатель чего угодно, переданный в функцию, к виду [][] , а не работать со сдвигами? Зная размерность. И не трогать при это с++.
С чего угодно малость загнул, хотябы разобраться с char.

Сдвиги то откуда взялись?
И вообще - Вам шашечки (двумерный массив) или ехать (управление по программе).
Если все-таки ехать, то defunct все подробно описал, когда я поленился.

Конкретней : получаем в функции указатель:
void func(void *temp)
создаём указатель на нужный объект, char :
char * c_Uk;
связываем:
c_Uk= (char *)temp;
Вопрос: почему, если :
*(c_Uk+2)=5;
и
c_Uk[2]=5;
синонимы, то не проходят коснтрукции типа
c_Uk[1][1]=5;

Не хочет народ читать книги отцов-основателей.
Для двумерных массивов в С необходимо всегда знать максимальный размер второго индекса, иначе невозможно адресовать конкретный элемент массива. Если вы преобразуете указатель на двумерный массив к обычному указателю, то там, как вы догадываетесь, никакой информации о размерностях нет. Именно поэтому, при передаче в функцию указателя на двумерный массив, приходится явно указать размер старшего индекса. Или же вы должны в функцию передать абстрактный указатель, и максимальные значения обеих размеров. Или использовать C++ объект, информация о размерах которого хранится в нем самом.

Потому что неизвестна первая размерность массива.
Можно вот так:

Потому что c_Uk - указатель, из которого можно получить лишь одномерный массив. Вы не сообщили компилятору размер строки, а хотите от него получить адрес по формуле: номер строки * размер строки + номер столбца. Попробуйте сами написать формулу, которую компилятор должен подставить для вычисления адреса элемента c_Uk[1][1]. Если вы хотите обращаться с c_Uk как с двумерным массивом, то и объявляйте его как указатель на двумерный массив. Но при этом вам надо отдавать себе отчет, что правила языка С89 требуют, чтобы одно из измерений такого массива было фиксировано на этапе компиляции. Если вам надо внутри функции работать с массивом, в котором оба измерения неизвестны на этапе компиляции - вам прямой путь или в С99 (как показал ReAl), или в адресную арифметику. Т.е. сначала вручную находите адрес нужной вам строки, потом с этой строкой можете работать как с одномерным массивом или как с указателем.

Не первого, а второго (если вы не считаете с нулевого, конечно)

void func(void *temp){//для массива 5х5
char * c_Uk[20];
c_Uk[0]= (char *)temp;
c_Uk[1]= c_Uk[0]+5;
c_Uk[2]= c_Uk[1]+5;
c_Uk[3]= c_Uk[2]+5;
c_Uk[4]= c_Uk[3]+5;

c_Uk[2][2]=5;
}

если забить на лишние указатели,то не плохо. Всем спасибо.