Двумерный массив и указатель на него, Как объявить чтобы можно было обращаться massiv[x][y]? Опции

[mempfis_]

Добрый день.

Чтото не могу понять как правильно объявить указатель на двумерный массив чтобы компилятор не ругался.

Есть такой массив:

Код

[b]unsigned int [/b] [i]__flash[/i] Program1[5][4] =
{
  {0,0,0,0},
  {1,1,1,1},
  {2,2,2,2},
  {3,3,3,3},
  {4,4,4,4}
}

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

Код

typedef struct
{
unsigned int __flash **program;//указатель на текущую исполняемую программу
} stProgram;

stProgram Program; //экземпляр структуры

Стоит задача сделать так чтобы используя указатель Program.program обращаться к двумерному массиву
наиболее понятным образом Program.program[0][1] (без использования * и всяких смещений)

Определил функцию инициализации масива

Код

void SetProgram(unsigned int __flash **program_addr)
{
   Program.program = program_addr;
}

Компилятор ругается на вызов этой функции:

Код

SetProgram(&Program1[0][0]);

Error[Pe167]: argument of type "unsigned int __flash (*)[4]" is incompatible with parameter of type "unsigned int __flash **"

[XVR]

Открою великую тайну - как сделать из массива (любого) тип, который можно будет написать в параметрах функции (например).
Берем исходное определение переменной -

Код

unsigned int __flash Program1[5][4] = {...}

Меняем имя переменной на тип, удаляем = и всё после него и пишем typedef вначале, все

Код

typedef unsigned int __flash ProgramType[5][4];

Используем

Код

void func(ProgramType my_var) {...}

[defunct]

Открою великую тайну - как сделать из массива (любого) тип, который можно будет написать в параметрах функции (например).

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

Не очень изящно на С получается, перейдите на С++, сделайте себе объект - n-мерный массив (примеров - полно),

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

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

Код

int Program_1[] =
{
    /* step1 */  1, 1, 1, 1, 1, 1, 1, 0,
    /* step2 */  2, 2, 2, 0,
    /* step3 */  3, 3, 3, 3, 3, 0,
    /* step4 */  4, 4, 4, 4, 4, 0,
    /* step5 */  5, 5, 0,
    /* end */ 0
};

int Program_2[] =
{
    /* step1 */  11, 11, 11, 0,
    /* step2 */  44, 44, 44, 44, 0,
    /* end */ 0
};


int *Programs[] =
{
   Program_1,
   Program_2
   ...
};

;

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

Код

int *FindStep( int *program, int StepId )
{
     if (!*program)
        return NULL;

     while (StepId)
     {
         if (!*program++)
            if (!*program)
               return NULL;
            else
               StepId--;
     }
    return program;
}

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

Код

DoStep( int *step)
{
    while( *step )
    {
        ... // делаем что надо
        step++
    }
}

DoProgram( int *program)
{
     do
     {
           DoStep( program )
     } while ( program = FindStep( program, 1 ) );
}

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

DoProgram( Programs[ x ] );

[Wano]

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

[Dog Pawlowa]

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

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

[Wano]

Конкретней : получаем в функции указатель:
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_Uk[1][1]=5;

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

[Wano]

Т.е. сначала вручную находите адрес нужной вам строки, потом с этой строкой можете работать как с одномерным массивом или как с указателем.

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;
}

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

[sergeeff]

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

Жуть, что вы тут понаписали.

[Wano]

Жуть, что вы тут понаписали.

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

char array[5][5];

void func(void *temp,char x,char y){
char * c_Uk[20];//заранее больше одной размерности
char i;
c_Uk[0]= (char *)temp;
for(i=1;i<y;i++){
c_Uk[i]=c_Uk[i-1]+x;
}
c_Uk[1][2]=5;
}

int main (void)
{
func(&array[0][0],5,5);
return 0;
}

[Сергей Борщ]

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

Мама!!! "Не так" - реализация. Я не понял, что должна делать ваша функция, поэтому в качестве примера просто прохожу по всему массиву и присваиваю элементам константу 1:

Код

#include <stdint.h>
uint8_t array[5][5];  // у вас ведь массив не символов а именно беззнаковых 8-битных чисел

void func(uint8_t *temp, uint8_t x, uint8_t y) // temp именно указатель на uint8_t, а ни в коем случае не на на void, чтобы случайно не передать в функцию чего попало. Тип, на который указывает temp определяет размер элемента массива и этот размер дальше учитывается в адресной арифметике.
{
    uint8_t *c_Uk;    // размерность неизвестна, поэтому просто указатель
    
    uint8_t i;
    for(i = 0; i < y; ++i) // перебор строк массива
    {
        c_Uk = &temp[i * x];       // находим в линейном массиве temp адрес, с которого начинается i-я строка размером x.
        // c_Uk = temp + i * x;    // то же самое другими словами
        
                                    // теперь c_Uk указывает на строку двумерного массива
        uint8_t j;
        for(j = 0; j < x; ++j)     // проходим по строке
        {
            c_Uk[j] = 1;
        }
    }
    
    
    // "Дембельский" аккорд
    
    c_Uk = &temp[2 * x];       // вторая строка
    c_UK[1] = 5;               // первый элемент в строке. т.е. массив[1][2] = 5
}

int main (void)
{
    func(array                 // имя массива есть указатель на его нулевой элемент. Поэтому & и [0][0] не нужны.
         ,sizeof(array[0]) / sizeof(array[0][0])    // размерность x
         ,sizeof(array) / sizeof(array[0])          // размерность y
        );  
    return 0;
}

А книжку все же почитайте. Как только поймете, что такое указатель - сразу все станет просто.

[Wano]

Ладно шариться по массиву можно хорошо и так:
void func(char *temp,char x,char y){
int i,j;
for(i=0;i<y;i++)//по столбцам
for(j=0;j<x;j++){//по строкам
*(temp+i*y+j)=1;
}
}
и ещё кучей способов.
мне хотелось именно квадратные скобки, дабы повысить наглядность коэффициентов при расчёте определителей матрицы. Определитель матрицы 5х5 , выполненный сначало на индексах - и начинает рябить.И чем больше, тем труднее ошибку в индексе найти.
А огород из void , & и [0][0] начал городить из-за того, что

uint8_t array[5][5];

void func(uint8_t *temp, uint8_t x, uint8_t y){.......}

func(array ,sizeof(array[0]) / sizeof(array[0][0]),sizeof(array) / sizeof(array[0]));

вызывает ошибку компилера RV:
main.c(28): error: #167: argument of type "char (*)[5]" is incompatible with parameter of type "char *"
вот и пошла фонтазия художника

[Сергей Борщ]

мне хотелось именно квадратные скобки, дабы повысить наглядность коэффициентов при расчёте определителей матрицы. Определитель матрицы 5х5 , выполненный сначало на индексах - и начинает рябить.

Если размерность массива неизвестна на этапе компиляции - то только С99 или плюсы. В С89 с квадратными скобками - невозможно. Вам это пытаются объяснить уже 4 страницы. Если размерность известна - то можно и в С89, но тогда нафига ее (размерность) передавать в качестве парметров в функцию?

вызывает ошибку компилера RV:

Да, тут я фигню спопрол. ReAl уже поправил.