Указатель против массива в C, нетривиальная разность

Я думал, что это действительно понял, и повторное чтение стандарта (ISO 9899: 1990) просто подтверждает мое явно неправильное понимание, поэтому теперь я спрашиваю здесь.

Сбой следующей программы:

#include <stdio.h>
#include <stddef.h>

typedef struct {
    int array[3];
} type1_t;

typedef struct {
    int *ptr;
} type2_t;

type1_t my_test = { {1, 2, 3} };

int main(int argc, char *argv[])
{
    (void)argc;
    (void)argv;

    type1_t *type1_p =             &my_test;
    type2_t *type2_p = (type2_t *) &my_test;

    printf("offsetof(type1_t, array) = %lu\n", offsetof(type1_t, array)); // 0
    printf("my_test.array[0]  = %d\n", my_test.array[0]);
    printf("type1_p->array[0] = %d\n", type1_p->array[0]);
    printf("type2_p->ptr[0]   = %d\n", type2_p->ptr[0]);  // this line crashes

    return 0;
}

Сравнение выражений my_test.array[0] и type2_p->ptr[0] в соответствии с моей интерпретацией стандарта:

6.3.2.1 Подписывание массива

"Определение индекса оператор [] состоит в том, что E1 [E2] идентичны (* ((E1) + (E2))).

Применяя это, получаем:

my_test.array[0]
(*((E1)+(E2)))
(*((my_test.array)+(0)))
(*(my_test.array+0))
(*(my_test.array))
(*my_test.array)
*my_test.array

type2_p->ptr[0]
*((E1)+(E2)))
(*((type2_p->ptr)+(0)))
(*(type2_p->ptr+0))
(*(type2_p->ptr))
(*type2_p->ptr)
*type2_p->ptr

type2_p->ptr имеет тип "указатель на int", а значение является начальным адресом my_test. Таким образом, *type2_p->ptr оценивает целочисленный объект, чье хранилище имеет тот же адрес, что и my_test.

Далее:

6.2.2.1 Lvalues, массивы и обозначения функций

"За исключением случаев, когда это операнд оператор sizeof или унарный & оператор,..., l значение, которое имеет тип array of type преобразуется в выражение с типом pointer to type, которое указывает на начальную элемент объекта массива и не является lvalue."

my_test.array имеет тип "array of int" и как описано выше, преобразован в "указатель на int" с адресом первого элемента как значения. Таким образом, *my_test.array оценивает целочисленный объект, чье хранилище находится на том же адресе, что и первый элемент в массиве.

И наконец

6.5.2.1 Спецификации структуры и объединения

Указатель на объект структуры, соответствующим образом преобразованный, указывает на его начальный элемент... и наоборот. Внутри объект структуры, но не начиная, по мере необходимости, соответствующее выравнивание.

Так как первым элементом type1_t является массив, начальный адрес что и весь объект type1_t тот же, что описан выше. Поэтому я понял, что *type2_p->ptr оценивает целое число, чье хранилище имеет тот же адрес, что и первый элемент в массиве и, таким образом, идентичен *my_test.array.

Но это не может быть так, потому что программа постоянно срабатывает на Solaris, cygwin и linux с версиями gcc 2.95.3, 3.4.4 и 4.3.2, поэтому любая экологическая проблема не может быть и речи.

Где мои рассуждения неправильные/чего я не понимаю? Как объявить type2_t, чтобы ptr указывал на первый член массива?

ОТВЕТЫ

Ответ 1

Массив - это своего рода хранилище. Синтаксически он используется как указатель, но физически нет никакой переменной "указатель" в этой структуре - только три int. С другой стороны, указатель int является фактическим типом данных, хранящимся в структуре. Поэтому, когда вы выполняете актерский состав, вы, вероятно, * заставляете ptr принимать значение первого элемента в массиве, а именно 1.

* Я не уверен, что это фактически определено поведение, но как он будет работать на большинстве распространенных систем, по крайней мере.

Ответ 2

Пожалуйста, простите меня, если я пропущу что-либо в вашем анализе. Но я думаю, что основная ошибка во всем этом заключается в том, что это неправильное предположение

type2_p- > ptr имеет тип "указатель на int", а значение является начальным адресом my_test.

Нет ничего, что заставило бы иметь это значение. Скорее всего, он, вероятно, указывает где-то на

0x00000001

Потому что вы должны интерпретировать байты, составляющие этот целочисленный массив, как указатель. Затем вы добавляете что-то к нему и подстроку.

Кроме того, я очень сомневаюсь, что ваш кастинг для другой структуры действительно действителен (как, гарантированно, работает). Вы можете бросить, а затем прочитать общую начальную последовательность любой структуры, если оба они являются членами объединения. Но они не в вашем примере. Вы также можете наложить указатель на первый элемент. Например:

typedef struct {
    int array[3];
} type1_t;

type1_t f = { { 1, 2, 3 } };

int main(void) {
    int (*arrayp)[3] = (int(*)[3])&f;
    (*arrayp)[0] = 3;
    assert(f.array[0] == 3);
    return 0;
}

Ответ 3

Где мои рассуждения неправильные/чего я не понимаю?

type_1::array (не строго синтаксис Си) не является int *; это int [3].

Как объявить type2_t, чтобы ptr указывал на первый член массива?

typedef struct 
{    
    int ptr[];
} type2_t;

Объявляет гибкий элемент массива. Из стандарта C (пункт 6.7.2.1, пункт 16):

Однако, когда a. (или → ) имеет левый операнд, который является (указателем на) структуру с гибким членом массива, а правый операнд - этим членом, он ведет себя так, как если бы этот элемент был заменен самым длинным массивом (с тем же типом элемента), который не сделает структуру больше, чем объект, к которому обращаются; смещение массива должно оставаться равным элементу гибкого элемента массива, даже если это будет отличаться от размера заменяющего массива.

I.e., он может правильно использовать type1_t::array.

Ответ 4

Это должно быть определено поведение. Подумайте об этом с точки зрения памяти.

Для простоты предположим, что my_test находится по адресу 0x80000000.

type1_p == 0x80000000
&type1_p->my_array[0] == 0x80000000 // my_array[0] == 1
&type1_p->my_array[1] == 0x80000004 // my_array[1] == 2
&type1_p->my_array[2] == 0x80000008 // my_array[2] == 3

Когда вы набрасываете его на type2_t,

type2_p == 0x80000000
&type2_p->ptr == 0x8000000 // type2_p->ptr == 1
type2_p->ptr[0] == *(type2_p->ptr) == *1

Чтобы сделать то, что вы хотите, вам придется либо создать вторичную структуру, либо присвоить адрес массива ptr (например, type2_p- > ptr = type1_p- > my_array) или объявить ptr как массив (или переменную длину массив, например int ptr []).

В качестве альтернативы вы можете получить доступ к элементам уродливым образом: (& type2_p- > ptr) [0], (& type2_p- > ptr) [1]. Однако будьте осторожны, так как (& type2_p- > ptr) [0] будет фактически int *, а не int. На 64-битных платформах, например, (& type2_p- > ptr) [0] будет фактически 0x100000002 (4294967298).