Четко ли определен доступ к членам через offsetof?

Насколько я могу судить, это четко определенное поведение. Но только потому, что вы обращаетесь к данным через тип char. Если бы вы использовали какой-либо другой тип указателя для доступа к структуре, это было бы «строгим нарушением псевдонимов».

Строго говоря, обращение к массиву за пределами границ определено нечетко, но правильно определено использование указателя символьного типа для извлечения любого байта из структуры. Используя offsetof, вы гарантируете, что этот байт не является байтом заполнения (что могло бы означать, что вы получите неопределенное значение).

Однако обратите внимание, что отбрасывание квалификатора const приводит к плохо определенному поведению.

РЕДАКТИРОВАТЬ

Точно так же приведение (char**)ptr является недопустимым преобразованием указателя - само по себе это неопределенное поведение, поскольку оно нарушает строгое сглаживание. Сама переменная ptr была объявлена ​​как char*, поэтому вы не можете солгать компилятору и сказать: «Эй, это на самом деле char**», потому что это не так. Это не зависит от того, на что указывает ptr.

Я считаю, что правильный код без плохо определенного поведения будет таким:

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

typedef struct {
    const char* a;
    const char* b;
} A;

int main() {
    A test[3] = {
        {.a = "Hello", .b = "there."},
        {.a = "How are", .b = "you?"},
        {.a = "I\'m", .b = "fine."}};

    for (size_t i = 0; i < 3; ++i) {
        const char* ptr = (const char*) &test[i];
        ptr += offsetof(A, b);

        /* Extract the const char* from the address that ptr points at,
           and store it inside ptr itself: */
        memmove(&ptr, ptr, sizeof(const char*)); 
        printf("%s\n", ptr);
    }
}

Данный

struct foo {int x, y;} s;
void write_int(int *p, int value) { *p = value; }

ничто в Стандарте не различает:

write_int(&s.y, 12); //Just to get 6 characters

а также

write_int((int*)(((char*)&s)+offsetof(struct foo,y)), 12);

Стандарт может быть прочитан таким образом, чтобы подразумевать, что оба вышеприведенных пункта нарушают правила типа lvalue, поскольку в нем не указано, что к хранимому значению структуры можно получить доступ с использованием lvalue типа члена, требуя, чтобы код, желающий для доступа в качестве члена структуры записывается как:

void write_int(int *p, int value) { memcpy(p, value, sizeof value); }

Я лично думаю, что это нелепо; если &s.y нельзя использовать для доступа к lvalue типа int, почему оператор & дает int*?

С другой стороны, я также не думаю, что имеет значение то, что говорит Стандарт. Ни clang, ни gcc не могут быть уверены в правильной обработке кода, который делает что-то «интересное» с указателями, даже в случаях, однозначно определенных Стандартом, за исключением случаев, когда они вызываются с помощью -fno-strict-aliasing. Компиляторы, которые прилагают добросовестные усилия, чтобы избежать любых неправильных «оптимизаций» псевдонимов в случаях, которые были бы определены по крайней мере в некоторых правдоподобных чтениях Стандарта, не будут иметь проблем с обработкой кода, который использует offsetof в случаях, когда все доступы, которые будут выполняться с использованием указатель (или другие производные от него указатели) предшествуют следующему доступу к объекту другими средствами.