Безопасно ли выполнять memcpy (0,0,0)?

Я не так хорошо разбираюсь в стандарте C, поэтому, пожалуйста, потерпите меня.

Я хотел бы знать, гарантируется ли это по стандарту, что memcpy(0,0,0)это безопасно.

Единственное ограничение, которое я смог найти, это то, что если области памяти перекрываются, то поведение не определено ...

Но можно ли считать, что области памяти здесь перекрываются?

У меня есть черновая версия стандарта C (ISO / IEC 9899: 1999), и я могу сказать несколько забавных вещей об этом вызове. Для начала, он упоминает (§7.21.1 / 2) в отношении memcpyэтого

Если аргумент, объявленный как size_tn, определяет длину массива для функции, n может иметь нулевое значение при вызове этой функции. Если иное не указано явно в описании конкретной функции в этом подпункте, аргументы указателя при таком вызове должны по-прежнему иметь допустимые значения, как описано в 7.1.4 . При таком вызове функция, которая определяет местонахождение символа, не находит вхождения, функция, сравнивающая две последовательности символов, возвращает ноль, а функция, копирующая символы, копирует ноль символов.

Указанная здесь ссылка указывает на это:

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

Итак, согласно спецификации C, вызов

memcpy(0, 0, 0)

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

Тем не менее, я был бы крайне удивлен, если memcpyбы вы сделали это в какой-либо реальной реализации , поскольку большинство интуитивно понятных реализаций, о которых я могу думать, вообще ничего не сделали бы, если бы вы сказали копировать нулевые байты.

Просто для удовольствия, примечания к выпуску для gcc-4.9 указывают, что его оптимизатор использует эти правила и, например, может удалить условное выражение в

int copy (int* dest, int* src, size_t nbytes) {
    memmove (dest, src, nbytes);
    if (src != NULL)
        return *src;
    return 0;
}

который затем дает неожиданные результаты при copy(0,0,0)вызове (см. https://gcc.gnu.org/gcc-4.9/porting_to.html ).

Я несколько двояко отношусь к поведению gcc-4.9; поведение может соответствовать стандартам, но возможность вызова memmove (0,0,0) иногда является полезным расширением этих стандартов.

Вы также можете рассмотреть такое использование, memmoveувиденное в Git 2.14.x (3 квартал 2017 г.)

См. Commit 168e635 (16 июля 2017 г.) и зафиксировать 1773664 , зафиксировать f331ab9 , зафиксировать 5783980 (15 июля 2017 г.) Рене Шарфе ( rscharfe) .
^{(Объединено Junio ​​C Hamano - gitster- в коммите 32f9025 , 11 августа 2017 г.)}

Он использует вспомогательный макрос,MOVE_ARRAY который вычисляет размер на основе указанного количества элементов для нас и поддерживает NULL указатели, когда это число равно нулю.
Необработанные memmove(3)вызовы с NULLмогут заставить компилятор (чрезмерно) оптимизировать последующие NULLпроверки.

MOVE_ARRAYдобавляет безопасный и удобный помощник для перемещения потенциально перекрывающихся диапазонов записей массива.
Он определяет размер элемента, автоматически и безопасно умножается, чтобы получить размер в байтах, выполняет базовую проверку безопасности типа, сравнивая размеры элементов, и в отличие от memmove(3)него поддерживает NULLуказатели, если необходимо переместить 0 элементов.

#define MOVE_ARRAY(dst, src, n) move_array((dst), (src), (n), sizeof(*(dst)) + \
    BUILD_ASSERT_OR_ZERO(sizeof(*(dst)) == sizeof(*(src))))
static inline void move_array(void *dst, const void *src, size_t n, size_t size)
{
    if (n)
        memmove(dst, src, st_mult(size, n));
}

Примеры :

- memmove(dst, src, (n) * sizeof(*dst));
+ MOVE_ARRAY(dst, src, n);

Он использует макрос,BUILD_ASSERT_OR_ZERO который утверждает зависимость времени сборки, как выражение (с @condусловием времени компиляции, которое должно быть истинным).
Компиляция завершится ошибкой, если условие не выполняется или не может быть оценено компилятором.

#define BUILD_ASSERT_OR_ZERO(cond) \
(sizeof(char [1 - 2*!(cond)]) - 1)

Пример:

#define foo_to_char(foo)                \
     ((char *)(foo)                     \
      + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))

Нет, memcpy(0,0,0)это небезопасно. Стандартная библиотека, скорее всего, не откажется от этого вызова. Однако в тестовой среде в memcpy () может присутствовать дополнительный код для обнаружения переполнения буфера и других проблем. И то, как эта специальная версия memcpy () реагирует на указатели NULL, в общем, не определено.