Violation d’access lors de l’utilisation de strcpy?

J’ai essayé de réinventer la fonction strcpy C, mais lorsque j’essaie de l’exécuter, l’erreur suivante apparaît:

Unhandled exception at 0x00411506 in brainf%ck.exe: 0xC0000005: Access violation writing location 0x00415760. 

L’erreur se produit dans le *dest = *src; ligne. Voici le code:

 char* strcpy(char* dest, const char* src) { char* dest2 = dest; while (*src) { *dest = *src; src++; dest++; } *dest = '\0'; return dest2; } 

EDIT: Wow, c’était rapide. Voici le code appelant (strcpy est défini dans myssortingng.c):

 #include "myssortingng.h" #include  int main() { char* s = "hello"; char* t = "abc"; printf("%s", strcpy(s, t)); getchar(); return 0; } 

 char* s = "hello"; char* t = "abc"; printf("%s", strcpy(s, t)); 

Le compilateur a placé votre tampon de destination, s, dans une mémoire en lecture seule puisqu’il s’agit d’une constante.

 char s[5]; char* t = "abc"; printf("%s", strcpy(s, t)); 

Devrait résoudre ce problème. Cela alloue le tableau de destination sur la stack, qui est accessible en écriture.

Le problème potentiel évident est que votre mémoire tampon de sortie n’a pas assez de mémoire allouée ou que vous avez passé NULL pour dest . (Probablement pas pour src ou cela aurait déjà échoué sur la ligne.)

Veuillez donner un programme court mais complet pour reproduire le problème, et nous pourrons vérifier …

Voici un exemple qui va pour moi sur Windows:

 #include  char* strcpy(char* dest, const char* src) { char* dest2 = dest; while (*src) { *dest = *src; src++; dest++; } *dest = '\0'; return dest2; } void main() { char *d = malloc(3); strcpy(d, "hello there this is a longish ssortingng"); } 

Notez que dans ce cas, je devais dépasser la mémoire réellement allouée d’un montant considérable avant de provoquer la mort du programme. Juste “bonjour” ne tombait pas en panne, même si cela pouvait dépendre de divers aspects du compilateur et de l’environnement d’exécution.

Votre strcpy () va bien. Vous écrivez dans la mémoire en lecture seule. Voir cette description ici .

Si vous aviez écrit ceci, vous iriez bien:

 #include "myssortingng.h" #include  int main() { char s[] = "hello"; char t[] = "abc"; printf("%s", strcpy(s, t)); getchar(); return 0; } 

Il y a un problème avec l’appel de votre routine strcpy réinventée dans la routine principale, les deux tableaux de caractères: char * s = “hello”; char * t = “abc”; atterrira dans le segment mémoire en lecture seule au moment de la compilation. Lorsque vous essayez d’écrire dans la mémoire pointée par s dans la routine strcpy, et comme elle pointe vers un emplacement dans un segment READ ONLY, elle sera interceptée et vous obtiendrez une exception. Ces chaînes sont en lecture seule!

Assurez-vous que la mémoire est allouée à Dest avant d’appeler cette fonction.

Probablement un problème avec l’appelant: avez-vous vérifié le pointeur de destination ? Cela indique-t-il quelque chose de valable ou juste des déchets? En plus de cela, le moins que vous puissiez faire est de vérifier les pointeurs nuls, comme si (! Dest ||! Source) {/ * fait quelque chose, comme de retourner NULL ou de lever une exception * /} à l’entrée de la fonction. Le code a l’air correct. Pas très sûr, mais ok.

Il y a plusieurs erreurs.

  1. Vous n’allouez pas de tampon de retour pouvant contenir la chaîne copiée.
  2. Vous ne vérifiez pas si src est null avant d’utiliser * src
  3. Vous voulez tous les deux obtenir la réponse dans un paramètre et renvoyer la valeur. Faites l’un ou l’autre.
  4. Vous pouvez facilement saturer le tampon de destination.

Bonne chance.

chaque fois que le code commence à être exécuté (en général, il commence par la fonction principale) ici, le code signifie séquence d’exécution. Ainsi, lorsque le processus (séquence d’exécution) commence, le PCB (processus control block) est créé. .

dans votre code

char * s = “bonjour”;
char * t = “abc”;

c’est ce que vous avez pris les entrées de deux chaînes comme ceci.

ici, les chaînes (c’est-à-dire les guillemets doubles) présentes dans la section texte de l’espace d’adressage du processus. Ici, la section de texte est celle de la section présente dans l’espace d’adressage de processus et la section de texte ne disposant que des permissions de lecture seule. C’est pourquoi, lorsque vous essayez de modifier la chaîne source / chaîne de destination, nous ne devons PAS permettre de modifier les données présentes dans la zone de texte. alors, c’est la raison pour laquelle votre code doit être PRUDENT. J’espère que tu as compris.