Ok, hay varios aspectos implícitos en tu pregunta. La función

strcpy( char *s1, const char *s2)

copia el contenido de s2 en s1, añadiendo al final de s1 un carácter nulo de terminación '\0'. La única consideración es que s1 contenga el suficiente espacio disponible para copiar todos los caracteres (al menos la longitud de s2 más uno).

Esto por supuesto requiere que se pueda escribir en el espacio asignado a s1. Si declaras

char *cadena = "hola mundo";

entonces cadena se considerará un string constante y ya no podrás escribir nada nuevo en él. Pero la declaración:

char cadena[] = "hola mundo";

sí permite rescribir el contenido de cadena (siempre y cuando la nueva cadena sea de longitud menor o igual a la que tenías primero, de lo contrario no habrá espacio disponible suficiente). Por ejemplo, puedes poner:

strcpy( cadena, "Pepe");
puts( cadena );

y verás como ahora escribe "Pepe".

----------------------------------------------------------------------------------
NOTA. En cuánto a la declaración de string constantes no se con exactitud si la forma de interpretar la sentencia depende del compilador o de la versión de C, o de si es en C ó en C++. Que alguno de los usuarios más versados en el tema por favor nos complemente.

Totalmente de acuerdo con ambos. Cito una indicación de la página de
cplusplus :


Sin embargo ..... supongo que es el propio compilador el que lleva a cabo la operación de ampliar el espacio de la cadena receptora, que en principio es de 10 y podría provocar el overflow, pero en la práctica eso no sucede.

Está es la salida al código de ejemplo:


Como pueden observar, str2 "se metió" en la cadena str1 que originalmente erra de dimensión 10 sin problemas.

Eso si, destacar que si str2 no tiene suficiente dimensión quedará en la  cadena original el "resto" de la dicha cadena:

#include <stdio.h>
#include <string.h>
int main ()
{
    int i;
    char str1[ ]="A ver si cabe la cadena str1 en srt2";
    char str2[10]="leosansan";
    printf ("\nCadena str1 antes del cambio:\n%s",str1);
    printf ("\n\nCadena str2 antes del cambio:\n%s",str2);
    strcpy (str2,str1);
    printf ("\n\nLo que queda en str1: %s\n\nCopiado, nuevo str2:\n%s\n\n",str1,str2);
    printf("\n\nY la cadena str2 impresa caracter a caracter:\n ");
    for( i=0;str2[i]; i++)
      printf( "%c",str2[i] );
    printf( "\n\nlongitud de la nueva cadena str2=\n%d", strlen(str2) );
    return 0;
}

Espero no haberme liado con este rollito, ¿o tal vez si?. Ya me contaran ustedes.

En el caso que plantea leosansan, supongo que dependerá del compilador. Probablemente cualquier compilador moderno tomará previsiones adecuadas si la cadena de origen excede en longitud a la cadena de destino.

Sin embargo la filosofía de C es que "los programadores saben lo que están haciendo", por eso pienso que a pesar de la ayuda que pueda proporcionar el compilador, un buen programador de C debe garantizarse por sí mismo la consistencia de este tipo de operaciones. Así que al autor del post: pues, ya lo sabes!!!

Interesante un detalle adicional de la cita de cplusplus y que se me había pasado por alto: Las cadenas origen y destino no deben solaparse. Esta es otra consideración a tener en cuenta, no se debe intentar escribir una cadena sobre sí misma.

NOTA: Estas dificultades se evitan cómodamente usando la clase string de C++. Pero personalmente creo que quién se quiera formar como un verdadero programador debería pasar primero por C (con todas sus dificultades asociadas), y luego ir a C++. Hay que "ensuciarse" primero para aprender bien. Bueno, al menos es mi criterio, no se qué opinen los demás (?)

La salida tuya:




A este código:

#include <stdio.h>
#include <string.h>
 
int main ()
{
    int i;
    char str0[ ]="Gran Canaria es Cosita grande y hermosa";
    char str1[  ]="Cosita grande y hermosa";
    char str2[ ]="leosansan";
    char str3[ ]="leosansan es de Gran Canaria";
 
    printf ("\nCadena str1 antes del cambio:\n%s",str1);
    printf ("\n\nCadena str2 antes del cambio:\n%s",str2);
    strcpy (str2,str1);
    printf ("\n\nLo que queda en str1: %s\n\nCopiado, nuevo str2:\n%s\n\n",str1,str2);
    printf("\n\nY la cadena str2 impresa caracter a caracter:\n ");
    for( i=0; str2[i]; i++)
        printf( "%c",str2[i] );
    printf( "\n\nCadena str0 despues del cambio:\n\n%s",str0);
    printf ("\n\nCadena str3 despues del cambio:\n\n%s\n\n",str3);
    return 0;
}

Lo realmente raro es que si declaro varias cadenas str, tres o cuatro, además de str1 y str2, lo que queda en str1 siempre es el resto de lo que teóricamente "sobra en str2, en tu ejemplo y en el mio. Será casualidad o no, pero es un resultado cuando menos inesperado. ¿Por qué juntamente queda en str1 y no en las otras cadenas que he declarado?. He ahí mi gran duda, ¿será casualidad o es un comportamiento normal de la función strcpy "dejar" el resto de la cadena que no quepa en str2?. Y a los ejemplos me remito, claro que tan sólo son dos ejemplos y ya sabemos que no se puede pasr del particular al general, pero ......

Pero lo que dice el manual está claro, yo sólo pongo de manifiesto un hecho contrastado en esos dos ejemplos.

Tengo una teoría.

Suponte este caso:

char inicia[] = "Entrada larga";
char destino[5] = "abcd";

La memoria podría ser:

Y hacemos el strcpy:


Fijate que el puntero "original" apunta a las ultimas posiciones de "destino".

No esque deje lo que sobre, esque estamos viendo los ultimos caracteres de la cadena destino!

Lo acabo de probar y efectivamente str1 da la salida que esperaba: "da larga"

#include <stdio.h>
#include <string.h>
 
int main ()
{
    char str1[] = "Entrada larga";
    char str2[5] = "abcd";
 
    strcpy (str2,str1);
    printf ("\n\nLo que queda en str1: %s\n\nCopiado, nuevo str2:\n%s\n\n",str1,str2);
    printf("\n\nY la cadena str2 impresa caracter a caracter:\n ");
    int i;
    for( i=0; str2[i]; i++)
        printf( "%c",str2[i] );
    return 0;
}
 

Podríamos "rematar" la teoría modificando un valor de str2. A ver si esos cambios aparecen en str1:

#include <stdio.h>
#include <string.h>
 
int main ()
{
    char str1[] = "Entrada larga";
    char str2[5] = "abcd";
 
    strcpy (str2,str1);
 
 
    str2[10] = 'Z';
 
    printf ("\n\nLo que queda en str1: %s\n\nCopiado, nuevo str2:\n%s\n\n",str1,str2);
    printf("\n\nY la cadena str2 impresa caracter a caracter:\n ");
    int i;
    for( i=0; str2[i]; i++)
        printf( "%c",str2[i] );
    return 0;
}
 

Cuya salida es:



¡La Z aparece en las dos cadenas! Parece que mi teoria tiene sentido : )

Eso está bien ^^

Bueno yo hize eso, aunque mucha gente empezó a programar en Python o en Java.

Luego no tuvieron problema en pasar de un lenguaje a otro. Como siempre, lo importante no es el lenguaje sino en saber describir la solución a un problema.

+1, totalmente de acuerdo.