Copia de una cadena en C

Question

Estoy confundido acerca de este código: (http://www.joelonsoftware.com/articles/CollegeAdvice.html)

while (*s++ = *t++); 

¿Cuál es el orden de ejecución? ¿Se hace * s = * t primero, y luego cada uno se incrementa? O de otra manera?

Gracias.

EDIT: ¿Y si era:

while(*(s++) = *(t++)); 

y

while(++*s = ++*t); 

Answer 1

while (*s++ = *t++); 

Desde el precedence table se puede ver claramente ++ es tener mayor precedencia que *. Pero ++ se usa aquí como operador de incremento posterior, por lo que el incremento ocurre después de la expresión de asignación. Entonces *s = *t ocurre primero, luego s y t se incrementan.

EDIT:

while(*(s++) = *(t++)); 

Es igual que el anterior. Lo estás haciendo más explícito con el uso de paréntesis. Pero recuerda ++ sigue siendo un incremento de publicación.

while(++*s = ++*t); 

Solo hay un operador al lado de s. Por lo tanto, * se aplica primero y en ese resultado se aplica ++ que da como resultado el error lvalue required.

while(*++s = *++t); 

De nuevo solo operador al lado de s, t. Entonces el incremento ocurre primero seguido de copia. Así que estamos omitiendo la copia del primer carácter char de t para s.

Answer 2

el incremento es de un incremento posterior. Publicar no solo porque viene después de que la variable se incrementa, sino también porque viene después de que se evalúa la expresión. Por lo que el orden de ejecución es

*s = *t 

entonces s ++ y t ++

Answer 3

EDITAR ::

@chrisgoyal

orden de ejecución es un término ambiguo. Hay dos cosas diferentes aquí. El orden sintáctico y la semántica de la expresión.

Sintácticamente, el operador ++ se aplica primero. Si se aplica por primera vez el * s, entonces lo siguiente es equivalente a lo que dijo @Hogan:

(*s)++ = (*t)++ 

Cuál es muy diferente de la muestra de Joel.

La semántica del operador ++ es que se ejecuta después de la expresión.

Espero que aclare lo que carne.

---

En realidad, s++ y t++ se aplican en primer lugar. No olvide que el operador posterior a la corrección es ejecutado después de la expresión está hecha. Básicamente, el operador ++ se aplica para ambos, , luego*s = *t se ejecuta.

Answer 4

Tienes razón. * s = * t se hace primero, y luego se incrementan.

Answer 5

En Incremento de publicación, la variable de operación se usa primero y luego se modifica.

Answer 6

Así que hay dos formas de incremento

++s // increment before using value 
s++ // increment after using value 

Y el resultado de estos pueden ser dereferenced:

*++s // or... 
*s++ 

Esto funcionó muy bien en una de las primeras máquinas para C para funcionar encendido, el PDP-11, que tenía un modo de direccionamiento indirecto de registro que incrementa el registro después. Las siguientes operaciones estaban disponibles en el hardware:

*--s // or 
*s++ 

que podría hacer cualquiera

*x++ = *y++; // or 
*--x = *--y; // or some combination 

Y si lo hizo, toda la línea ocurrieron en una sola instrucción. Dado que // los comentarios fueron introducidos por C99, sin embargo, no se pudo salir con la sintaxis de mi comentario.

Answer 7

El código: (while *s++ = *t++); es más o menos equivalente a:

while (*s = *t) { 
    ++s; 
    ++t; 
} 

La segunda es exactamente la misma - los parens adicionales no cambian nada (en este caso). Para que los padres hagan algo, tendrían que ser como: while ((*s)++ = (*t)++);. Esto haría más o menos lo mismo que su tercer ejemplo (cubierto en el párrafo siguiente).

El último ejemplo: while(++*s = ++*t); es completamente diferente. Como la desreferencia (*) está más cerca del operando, esto desreferencia el operando e incrementa el resultado de la desreferencia, lo que significa que incrementa lo que el puntero apunta a AT, en lugar de incrementar el puntero mismo. Como resultado, esto copiaría el primer carácter, luego incrementaría ese carácter, luego verificaría si ese carácter no era cero y continuaría igual hasta que fuera cero. El resultado sería tanto el origen como el destino convirtiéndose en cadenas vacías (ya que el primer carácter de ambos sería ahora cero, que se usa para terminar cadenas).