¿Se garantiza que sea seguro realizar memcpy (0,0,0)?

No conozco muy bien el estándar C, así que tengan paciencia conmigo.

Me gustaría saber si está garantizado, según el estándar, que memcpy(0,0,0)es seguro.

La única restricción que pude encontrar es que si las regiones de memoria se superponen, entonces el comportamiento no está definido ...

Pero, ¿podemos considerar que las regiones de memoria se superponen aquí?

Tengo una versión preliminar del estándar C (ISO / IEC 9899: 1999), y tiene algunas cosas divertidas que decir sobre esa llamada. Para empezar, menciona (§7.21.1 / 2) con respecto a memcpyque

Donde un argumento declarado como size_tn especifica la longitud de la matriz para una función, n puede tener el valor cero en una llamada a esa función. A menos que se indique explícitamente lo contrario en la descripción de una función particular en esta subcláusula, los argumentos de puntero en dicha llamada aún tendrán valores válidos, como se describe en 7.1.4 . En tal llamada, una función que localiza un carácter no encuentra ocurrencia, una función que compara dos secuencias de caracteres devuelve cero y una función que copia caracteres copia cero caracteres.

La referencia indicada aquí apunta a esto:

Si un argumento de una función tiene un valor no válido (como un valor fuera del dominio de la función, o un puntero fuera del espacio de direcciones del programa, o un puntero nulo , o un puntero al almacenamiento no modificable cuando el parámetro correspondiente no está calificado const) o un tipo (después de la promoción) no esperado por una función con un número variable de argumentos, el comportamiento no está definido .

Por lo que parece de acuerdo con la especificación C, llamando

memcpy(0, 0, 0)

da como resultado un comportamiento indefinido, porque los punteros nulos se consideran "valores no válidos".

Dicho esto, me sorprendería muchísimo si alguna implementación real de memcpyrompió si hiciera esto, ya que la mayoría de las implementaciones intuitivas en las que puedo pensar no harían nada en absoluto si dijera que se debe copiar cero bytes.

Solo por diversión, las notas de la versión de gcc-4.9 indican que su optimizador hace uso de estas reglas y, por ejemplo, puede eliminar el condicional en

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

que luego da resultados inesperados cuando copy(0,0,0)se llama (consulte https://gcc.gnu.org/gcc-4.9/porting_to.html ).

Soy algo ambivalente sobre el comportamiento de gcc-4.9; el comportamiento puede ser compatible con los estándares, pero poder llamar a memmove (0,0,0) es a veces una extensión útil de esos estándares.

También puede considerar este uso memmovevisto en Git 2.14.x (Q3 2017)

Consulte la confirmación 168e635 (16 de julio de 2017) y la confirmación 1773664 , la confirmación f331ab9 y la confirmación 5783980 (15 de julio de 2017) de René Scharfe ( rscharfe) .
^{(Combinado por Junio ​​C Hamano - gitster- en el compromiso 32f9025 , 11 de agosto de 2017)}

Utiliza una macro auxiliarMOVE_ARRAY que calcula el tamaño en función del número especificado de elementos para nosotros y admite NULL punteros cuando ese número es cero.
Las memmove(3)llamadas sin procesar con NULLpueden hacer que el compilador optimice (demasiado ansiosamente) las NULLcomprobaciones posteriores .

MOVE_ARRAYagrega un ayudante seguro y conveniente para mover rangos potencialmente superpuestos de entradas de matriz.
Infiere el tamaño del elemento, se multiplica de forma automática y segura para obtener el tamaño en bytes, realiza una verificación de seguridad de tipo básica comparando los tamaños de los elementos y, a diferencia de memmove(3), admite NULLpunteros si se deben mover 0 elementos.

#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));
}

Ejemplos :

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

Utiliza la macroBUILD_ASSERT_OR_ZERO que afirma una dependencia en tiempo de compilación, como expresión ( @condsiendo la condición en tiempo de compilación que debe ser verdadera).
La compilación fallará si la condición no es verdadera o el compilador no puede evaluarla.

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

Ejemplo:

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

No, memcpy(0,0,0)no es seguro. Es probable que la biblioteca estándar no falle en esa llamada. Sin embargo, en un entorno de prueba, es posible que haya algo de código adicional en memcpy () para detectar saturaciones de búfer y otros problemas. Y cómo esa versión especial de memcpy () reacciona a los punteros NULL es, bueno, indefinido.