Недефинирано поведение при предаване на указател към функция с формален параметър на указател към const?

Това е абсолютно добре; компилаторът извършва имплицитно преобразуване от My_Struct * в const My_Struct *. 6.3.2.3 от спецификацията на C99 казва:

За всеки квалификатор q, указател към неq-квалифициран тип може да бъде преобразуван в указател към q-квалифицирана версия на Тип; стойностите, съхранени в оригиналните и преобразуваните указатели, трябва да се сравняват еднакви.

Освен това, дори ако декларирате функцията с две непоследователни декларации, така че един файл да я види декларирана по следния начин:

void myFunction(My_Struct * p_my_struct);

въпреки че всъщност е дефиниран така:

void myFunction(const My_Struct * p_my_struct) { ... }

дори това е позволено от спецификацията, въпреки че компилаторът не знае да извърши имплицитно преобразуване, защото My_Struct * и const My_Struct * имат едно и също представяне (така че преобразуването така или иначе е без операция).

(Благодаря на Кристоф и awoodland за техните коментари, изясняващи последната ситуация. В предишна версия на този отговор погрешно твърдях, че това би било недефинирано поведение.)

Редактирано за добавяне: Обратното дефиниране на функция с декларация с указател към неконстантен параметър, но извикването й с помощта на декларация с указател към константен параметър също е разрешено, за същата причина; но опитът за действително модифициране на данните може да доведе до недефинирано поведение, в зависимост от това откъде идват. (char * може да инициализира константа на низ, например, но е недефинирано поведение да се опитвате да промените данните в тази константа.)

Прехвърлянето на константност към или извън нещата е нещо, което считам за лоша практика - обикновено няма нищо лошо в предаването на неконстантен указател във функция, очакваща константен.

Изключение е, ако има някаква причина, поради която данните могат да се променят по време на изпълнението (напр. друга нишка докосва посочените данни) - тогава може да имате проблем, но това не е проблемът, който преобразуването на типове ще предотврати. В този случай трябва да направите вашата логическа нишка безопасна.

Не забравяйте, че ключовата дума const също не може да се използва от компилатора, за да гарантира постоянство, въпреки че може да се използва за откриване на проблеми, при които смятате, че данните не трябва да се променят, но компилаторът очаква, че искате да ги промените... това е повече инструмент за документиране за вас, отколкото нещо друго.

Първо предполагам, че & в извикването myFunction(&p_struct) е печатна грешка и това, което наистина имахте предвид, е myFunction(p_struct).

static My_Struct * p_struct = &my_useful_struct;
myFunction(p_struct);

Когато подадете p_struct, няма абсолютно никаква причина да прехвърляте указателя p_struct в извикването на функцията. Това е напълно валидно за предаване на указател към T във функция, където параметърът е указател към const T.

В стандарта C това се управлява от ограниченията на оператора за присвояване (C99, 6.5.16.1p1). При извикване на функция на функция, декларирана с прототип, аргументите се преобразуват като чрез присвояване на типа на съответните параметри (C99, 6.5.2.2p7).

Това работи за мен и не мисля, че параметърът на указателя const дава недефинирано поведение, компилаторът прави имплицитно преобразуване, преди да извика функцията:

typedef struct
{
    unsigned char x;
    unsigned short y;
    unsigned char[NUM_DEFINED_ELSEWHERE];
} My_Struct;

static My_Struct my_useful_struct;   // Variables initialized elsewhere in code.

void myFunction(const My_Struct * p_my_struct)
{
    /* Performs various read-only actions utilizing p_my_struct. */
}

void myOtherFunction(void)
{
    static My_Struct * p_struct = &my_useful_struct;
    myFunction(p_struct);
}