Неопределенное поведение при передаче указателя на функцию с формальным параметром указателя на 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 * имеют одинаковое представление (так что преобразование в любом случае не выполняется).

(Спасибо Christoph и awoodland за их комментарии, разъясняющие последнюю ситуацию. В предыдущей версии этого ответа я ошибочно утверждал, что это будет поведением undefined.)

Отредактировано для добавления: обратное определение функции с помощью объявления с параметром указатель на неконстанту, но вызов ее с использованием объявления с параметром указатель на константу также разрешено, для та же самая причина; но попытка фактически изменить данные вполне может привести к неопределенному поведению, в зависимости от того, откуда они получены. (Например, 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);
}