Может ли компилятор привести `(void *) 0` в `execl(prog, arg, (void*) 0)` к нулевому указателю соответствующего типа?

Во-первых, компилятор ни при каких обстоятельствах не "приводит". Приведение — это синтаксическая конструкция в исходном коде, которая запрашивает преобразование.

Я предполагаю, что когда вы говорите о «приведении компилятора», вы имеете в виду неявное преобразование, то есть процесс, посредством которого значение одного типа может быть преобразовано в значение другого типа без приведения. оператор.

Стандарт точно определяет контексты, в которых может применяться неявное преобразование; всегда должен быть целевой тип. Например, в коде int x = Y; выражение Y может быть некоторым типом, который не является int, но для которого определено неявное преобразование в int.

Неявное преобразование не применяется к аргументам функции, которые соответствуют ... части прототипа, кроме продвижение аргументов по умолчанию. Для значений указателя продвижение аргументов по умолчанию оставляет их без изменений.

Похоже, что общий поток вашего вопроса заключается в том, что компилятор должен каким-то образом притворяться, что execl ведет себя так, как если бы для последнего аргумента существовал прототип. Но на самом деле его нет, и у компилятора нет магического поведения для конкретных функций. Что вы проходите, то и получаете.

1. Стандарт указывает, что значение выражения (char *)0 является нулевым указателем. Он ничего не говорит о представлении нулевых указателей, и может быть несколько разных представлений, которые все являются нулевыми указателями.

2. Спецификация функции execl говорит, что список аргументов должен заканчиваться (char *)0, который является значением типа char *. Значение типа void * не является значением типа char *, и в этом контексте нет неявных преобразований, как обсуждалось выше.

3. Неявного преобразования по-прежнему нет; текст, который вы цитируете, говорит, что вы можете использовать аргумент неправильного типа в этой конкретной ситуации (нет параметра прототипа; и char * ожидается, но void * предоставлено, или наоборот).

4. Это было бы неопределенным поведением, текст, который вы процитировали в пункте 3, не относится к int *.

5. У функции sigaction есть прототип; рассматриваемый параметр - struct sigaction *oldact. Когда вы пытаетесь инициализировать параметр прототипа (или любую переменную) со значением другого типа, предпринимается попытка неявного преобразования к типу параметра. Существует неявное преобразование любого значения нулевого указателя в значение нулевого указателя другого типа. Это правило находится в C11 6.3.2.3/4. Так что этот код подходит.

Начиная с C99, спецификация va_arg читается частично

Если [тип, переданный в va_arg в качестве аргумента] несовместим с типом фактического следующего аргумента (который продвигается в соответствии с продвижением аргумента по умолчанию), поведение не определено, за исключением следующих случаев:

• один тип — целочисленный тип со знаком, другой тип — соответствующий целочисленный тип без знака, и значение может быть представлено в обоих типах;
• один тип является указателем на void, а другой — указателем на символьный тип.

Второй пункт означает, что для любой функции с переменным числом аргументов, которая использует va_arg для доступа к своим аргументам, вызов формы

variadic_function("a", "b", "c", (void *)0);

будет действительным всякий раз, когда

variadic_function("a", "b", "c", (char *)0);

было бы.

К сожалению, есть одна загвоздка: я не могу найти никаких требований к вариативным функциям стандартной библиотеки¹, чтобы [вести себя так, как если бы они] обращались к своим аргументам, создавая серию звонков на va_arg. Вы, наверное, думаете, ну а как еще они собираются это сделать? На практике это va_arg или написанный от руки язык ассемблера, и, возможно, комитет не хотел требовать, чтобы написанный от руки язык ассемблера был совершенно эквивалентен, но я бы не стал об этом беспокоиться.

Так что книга, которую вы цитируете, технически неверна. Но я бы все равно написал

execl(prog, arg, (char *) NULL);

если бы я собирался использовать NULL в первую очередь (обычно я предпочитаю использовать 0 в качестве константы нулевого указателя), потому что вы не должны писать код, который полагается на NULL, расширяющийся до ((void *)0), и

execl(prog, arg, 0);

безусловно неверно. Например, execl не получит нулевой указатель от этого 0 ни в одном ABI, где int — 32 бита, char * — 64 бита, а int величины не расширяются до 64 битов со знаком или нулем при передаче в составе списка переменных аргументов. .

¹ execl не является частью стандарта C, но является частью стандарта POSIX, и любая система, предоставляющая execl в первую очередь, вероятно, совместима по крайней мере с подмножеством POSIX. Все пункт 7.1.4 стандарта C могут быть Предполагается, что они применяются и к функциям, указанным в POSIX.

1) Требует ли стандарт C представления нулевого указателя так же, как (char*) 0

Да, поскольку константа нулевого указателя имеет тип void *, а void * и char * имеют одинаковое представление.

Это подробно описано в разделе 6.3.2.3p3 документа C. стандарт:

Целочисленное константное выражение со значением 0 или такое выражение, приведенное к типу void * , называется константой нулевого указателя.

И раздел 6.2.5п28:

Указатель на void должен иметь те же требования к представлению и выравниванию, что и указатель на символьный тип. ⁴⁸⁾

...

48) Одни и те же требования к представлению и выравниванию подразумевают взаимозаменяемость в качестве аргументов функций, возвращаемых значений функций и членов объединений.

2) Разве (void *) 0 не является нулевым указателем типа? Если да, то почему компилятор не может преобразовать (void *) 0 в execl(prog, arg, (void*) 0) в "нулевой указатель соответствующего типа"?

Это нулевой указатель типа, и этот тип — void *.

Определение execl:

int execl(const char *path, const char *arg, ...);

Таким образом, он не может привести третий параметр к соответствующему типу, потому что он не знает, какой это подходящий тип, но это не имеет значения, поскольку void * и char * взаимозаменяемы в соответствии с 6.2.4p28 и сноской 48, как упоминалось выше.

3) Может ли теперь компилятор преобразовать (void *) 0 в execl(prog, arg, (void*) 0) в "нулевой указатель соответствующего типа"? Почему это противоречит цитате в моем пункте 2?

Он по-прежнему не может выполнить приведение, потому что не знает, какой тип является подходящим. Но опять же, это не имеет значения, потому что void * и char * взаимозаменяемы.

4) Если я заменю (void *) 0 в execl(prog, arg, (void*) 0) на приведение 0 к указателю любого типа, например (int *) 0, сможет ли компилятор преобразовать (int *) 0 в execl(prog, arg, (int*) 0) к "нулевому указателю соответствующего типа"?

Нет, потому что опять же он не знает, какой тип подходит. И в этом случае у вас может возникнуть проблема, если int * и char * не имеют одинакового представления.

5) Может ли компилятор для невариативного вызова функции, такого как sigaction(SIGINT, &sa, (int*) 0), привести (int *) 0 к "нулевому указателю соответствующего типа"?

Да, потому что (int *)0 — это нулевой указатель, и потому что нулевой указатель можно преобразовать в любой другой указатель.

AFAI понимает, что продвижение аргумента по умолчанию применяется к функции var-args, за исключением указателей, которые остались прежними (пример zwol также поддерживает ¹). Поэтому, когда 0 передается функциям типа var-args, например. семейство exec(), оно распознается как неукрашенное целое число 0 вместо нулевого указателя. Между прочим, execl(prog, arg, 0); может работать в системах, где внутреннее представление нулевого указателя и целое число 0 совпадают, но это не обязательно.

execl(prog, arg, NULL); также может непреднамеренно работать в соответствии с одним из следующих

• Если NULL определено в системе как целое число 0, применяется вышеупомянутое объяснение.
• Если NULL определено в системе как константа нулевого указателя, как (void*)0, хотя в вариационной функции компилятор не может привести (void*)0 к нулевому указателю соответствующего типа, даже если стандарты C говорят char* и void* должны иметь одинаковое внутреннее представление.

Для получения дополнительной информации посетите здесь. Дополнительный пример из здесь.

¹ Например, execl не получит нулевой указатель от этого 0 ни в одном ABI, где int — 32 бита, char * — 64 бита, а int величины не расширяются до 64 битов со знаком или нулем, когда передается как часть списка переменных аргументов.