несовместимые типы указателей, передающие short * в short * (*) []

Question

Конечно, я тут что-то не так сделал, но, глядя на это, не могу понять, почему я получаю следующие предупреждения:

warning: incompatible pointer types passing '__int16_t *' (aka 'short *') to parameter of type '__int16_t *(*)[4]' [-Wincompatible-pointer-types]
        hammingDistance2d(ptr0, ptr1);

в моем небольшом сегменте кода:

void hammingDistance2d(__int16_t *src0[N][N],
                       __int16_t *src1[N][N]){
    int i, j;
    __uint16_t Hdis[N][N] = {0};

    for (i=0 ; i<N; i++){
        for (j=0; j<N; j++){
            __uint16_t z = *src0[i][j] ^ *src1[i][j];
            while (z > 0)
            {
                Hdis[i][j] += z & 1;
                z >>= 1;
            }
        }
    }
int main(){

    __int16_t src0[N][N] = {  { 1, 1, 1, 1},
                              { 2, 2, 2, 2},
                              { 3, 3, 3, 3},
                              { 4, 4, 4, 4} };
    __int16_t src1[N][N] = {  { 1, 1, 1, 1},
                              { 2, 2, 2, 2},
                              { 5, 5, 5, 5}, // different row
                              { 4, 4, 4, 4} };
    __int16_t *ptr0 =  &src0[0][0];
    __int16_t *ptr1 =  &src1[0][0];

    hammingDistance2d(ptr0, ptr1);
    return 0;
}

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

Answer 1

Эти переменные

__int16_t *ptr0 =  &src0[0][0];
__int16_t *ptr1 =  &src1[0][0];

явно объявлены как имеющие тип __int16_t *.

Но соответствующие параметры функции

void hammingDistance2d(__int16_t *src0[N][N],
                       __int16_t *src1[N][N]){

фактически имеют тип __int16_t * ( * )[N].

Нет явного преобразования из первого типа во второй. Таким образом, компилятор выдает ошибку.

Похоже, вы имеете в виду следующее

void hammingDistance2d(__int16_t src0[N][N],
                       __int16_t src1[N][N]){
    int i, j;
    __uint16_t Hdis[N][N] = {0};

    for (i=0 ; i<N; i++){
        for (j=0; j<N; j++){
            __uint16_t z = src0[i][j] ^ src1[i][j];
            while (z > 0)
            {
                Hdis[i][j] += z & 1;
                z >>= 1;
            }
        }
    }
}

И вызов функции может выглядеть следующим образом:

hammingDistance2d( src0, src1 );

Если вы хотите объявите промежуточные указатели, используемые в качестве аргументов функции, затем вы должны написать

__int16_t ( *ptr0 )[N] =  src0;
__int16_t ( *ptr1 )[N] =  src1;

и вызвать функцию как

hammingDistance2d( ptr0, ptr1 );

Answer 2

Вы передаете 2D-массив __int16, но ваша функция ожидает указатель на __int16_t.

Исправьте определение функции для работы с тем, что вы отправляете.

void hammingDistance2d(__int16_t src0[N][N],
                       __int16_t src1[N][N]){
    int i, j;
    __uint16_t Hdis[N][N] = {0};

    for (i=0 ; i<N; i++){
        for (j=0; j<N; j++){
            __uint16_t z = src0[i][j] ^ src1[i][j];
            while (z > 0)
            {
                Hdis[i][j] += z & 1;
                z >>= 1;
            }
        }
    }

И назовите его так:

hammingDistance2d(src0, src1);

Answer 3

Функция ожидает:

__int16_t *src0[N][N]

Который имеет тип (как рекомендует компилятор) __int16_t *(*)[4], или, на английском языке sh: указатель на [указатель на [массив из 4 __int16_t] ]] (обратите внимание на квадратные скобки, которые я использую для выделения).

Что у вас здесь есть:

__int16_t src0[N][N] = {  { 1, 1, 1, 1},
                          { 2, 2, 2, 2},
                          { 3, 3, 3, 3},
                          { 4, 4, 4, 4} };

Тип __int16_t (*)[4], то есть: указатель на [массив из 4 __int16_t].

Вы, вероятно, хотели заявить:

hammingDistance2d(__int16_t src0[N][N], __int16_t src1[N][N]) {
    // ...
}

То же самое, что:

hammingDistance2d(__int16_t (*src0)[N], __int16_t (*src1)[N]) {
    // ...
}

Обратите внимание, что в этом случае вы не нужно разыменовывать src0[i][j], используя оператор *.