Pregunta de entrevista desafiante de C++: ¿Cómo escribir una función strcpy impecable?

c ) Algunos accidentes son previsibles, pero pueden El sexo es relativamente pequeño y básicamente no sucederá a menos que haya una situación muy grave

(como ser alcanzado por un rayo en la vida, como si (p== 0) en el programa falla, c = 100 La falla se debe básicamente a que su sistema operativo o CPU no funciona)

Entonces, quiero decir que evitar accidentes en la vida no se trata solo de evitar todas las situaciones inesperadas. Es para evitar la mayoría de las situaciones inesperadas (como el accidente a y el accidente b), para que básicamente puedas sobrevivir mejor y el programa se ejecute sin problemas.

Debes evitar accidentes de pequeña probabilidad (como el accidente c). Vivirás muy cansado, el programa será inimaginablemente enorme y no podrás ejecutarlo en absoluto.

Finalmente, la llamada búsqueda de la perfección por parte de los programadores no es un autoengaño. ¡Nuestra perfección no es estática, mejora constantemente y no tiene fin!

#include

usando el espacio de nombres std;

char *strcpy( char *to, const char *from )

{

/*

En primer lugar, es imposible determinar el tamaño de la memoria a la que apunta la variable de puntero a través de la variable de puntero.

No sabes el tamaño del espacio al que apuntan el puntero de destino y el puntero de origen.

Solo sabes que el tamaño de los punteros to y form es de 4 bytes (en máquinas x86)

Entonces te encuentras con el primer problema: cómo saber la cadena que se va a copiar ha finalizado (la primera dirección de la cadena a copiar es de)?

Para la cadena apuntada por el puntero de, se puede decir que la cadena tiene un terminador '\0', pero esto no. obligatorio.

Por ejemplo

char s1[4];

char s2[4] = {'a','b','c','d ' }; // ¡s2 no es una cadena C estándar!

strcpy(s1,s2);

Debido a que s2 no tiene el terminador '\0', y en la función strcpy,

solo puede pasar esto terminador '\0' para determinar el final de una cadena que se va a copiar,

Por ejemplo:

while((*from) != '\0' ) // Esto es en cualquier ¡Debe aparecer en la función de copia! ! !

{

(*a) = (*desde);

desde ++;

}

¡Nunca se sabe que la matriz from from está fuera de límites! Seguirá atravesando el espacio de memoria hasta que encuentre un '\0'.

Lo que copias nunca es el s2 real, ¡es solo un fragmento de memoria que comienza con s2!

¡No hay forma de resolver esto! ¡Ni siquiera puedes detectar la excepción!

------------------------------------------------- ---- ---------------------

En segundo lugar, incluso si la cadena que se va a copiar termina honestamente en '\0',

¡Pero no puedes garantizar que el lugar donde copias tenga suficiente espacio para acomodar esta cadena!

Por ejemplo

char s1[4]; // La ubicación copiada solo tiene 4 bytes de espacio

char s2[4] = {'a' ,'b','c','d','\0'} // La cadena a copiar ocupa 5 bytes (incluido '\0')

strcpy(s1, s2);

De manera similar, en strcpy no puedes usar el puntero para determinar el tamaño real de s1 donde se copia (aquí son 4 bytes)

Solo puedes No importa qué, todos ¡Las cadenas a las que apunta from se copian en el espacio señalado por to (incluido '\0')!

¡Nunca se sabe si la matriz señalada por to se ha salido de los límites! Ocuparás el espacio inmediatamente después de

y escribirás datos allí. ¡Quizás se hayan sobrescrito algunos datos muy importantes! ! !

¡No hay manera de resolver esto! ¡Ni siquiera puedes detectar excepciones!

------------------------------------------------- ---- ---------------------

¡Te garantizo que nadie se atreve a escribir un strcpy que nunca salga mal! ! !

Solo puede garantizar que

la cadena a la que apunta desde termina normalmente, y que el espacio al que apunta tiene el tamaño suficiente para acomodar la cadena a la que apunta desde,

Bajo la premisa de escribir un strcpy que esté básicamente libre de errores

*/

// Admito que no puedo escribir el strcpy que deseas. . . .

}

int main(int argc, char *argv[])

{

devuelve 0;

}