Violazione di accesso quando si utilizza strcpy?

Question

Ho provato reinventare la funzione strcpy C, ma quando provo a farlo funzionare ottengo questo errore:

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

L'errore si verifica nella linea *dest = *src;. Ecco il codice:

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

EDIT: Wow, che è stato veloce. Ecco il codice chiamante (strcpy è definito in mystring.c):

#include "mystring.h"
#include <stdio.h>

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

Answer 1

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

Il compilatore è stato effettuato l'buffer di destinazione, s, in memoria di sola lettura dal momento che è una costante.

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

dovrebbe risolvere questo problema. Questo alloca la matrice di destinazione in pila, che è scrivibile.

Answer 2

Il potenziale problema evidente è che il vostro buffer di uscita non ha abbastanza memoria allocata, o hai passato in NULL per dest. (Probabilmente non per src o sarebbe fallito sulla linea prima.)

Si prega di dare un programma breve ma completo per riprodurre il problema, e possiamo controllare ...

Ecco un esempio che va bang per me su Windows:

#include <stdlib.h>

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 string");
}

Si noti che in questo caso ho dovuto superare la memoria effettiva allocata da una discreta quantità prima che potessi provocare il programma di morire - semplicemente "ciao" non ha in crash, anche se sicuramente potrebbe a seconda di vari aspetti del compilatore e ambiente di esecuzione.

Answer 3

Il tuo strcpy () va bene. Si sta scrivendo a memoria di sola lettura. Vedere questa descrizione qui .

Se avessi scritto questo, si sarebbe bene:

#include "mystring.h"
#include <stdio.h>

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

Answer 4

C'è un problema con la chiamata della vostra routine strcpy reinventato nella routine principale, sia array di caratteri:     char * s = "ciao";     char * t = "abc"; atterrerà nella memoria SOLA LETTURA segmento in fase di compilazione. Come si sta cercando di scrivere nella memoria puntato dal s nel strcpy di routine, e dal momento che punta a una posizione in un LEGGI unico segmento, sarà catturato, e si otterrà un'eccezione. Queste stringhe sono di sola lettura!

Answer 5

Assicurarsi dest ha la memoria allocata prima di chiamare tale funzione.

Answer 6

Probabilmente un problema con il chiamante: hai controllato il dest puntatore? Ha puntare a qualcosa di valido o solo spazzatura? Oltre a questo, il minimo che si possa fare è controllare per puntatori nulli, come se (! Dest ||! Fonte) {/ * fare qualcosa, come NULL ritorno o un'eccezione * /} all'ingresso della funzione. Il codice sembra OK. Non molto sicuro, ma OK.

Answer 7

Ci sono diversi errori.

1. Non è allocare un buffer di ritorno che può contenere la stringa copiata.
2. non controlli per vedere se src è nullo prima di utilizzare * src
3. Stai sia Tring per ottenere la risposta in un parametro e restituire il valore. Fare uno o l'altro.
4. Si può facilmente sovraccarico del buffer dest.

In bocca al lupo.

Answer 8

quando mai il codice che inizia esecuzione (Generaly inizia dalla funzione main). qui il codice indica sequenza di execution.so, quando il processo (sequenza di esecuzione) inizia, viene creato il PCB (Process Control Block), il pcb avente infromation complete sul processo come lo spazio di indirizzi di elaborazione, pila kernal, tavolo OFDT simili .

nel codice

  

char * s = "ciao";
      char * t = "abc";

questa è la cosa ha assunto ingressi di due stringhe come questo.

qui, le corde (che significa doppia quotate) che sono presenti nella sezione testo dello spazio di indirizzamento del processo. qui sezione di testo è quella della sezione che è presente nella sezione di spazio di indirizzi di elaborazione e testo avendo solo i permessi di sola lettura. è per questo che quando si cerca di modificare la stringa di origine della stringa / destinazione, non dobbiamo ammissibile per modificare il qualsiasi dato è presente nel setion testo. così, questo è ciò che il motivo per il vostro codice che devono essere prudenti. spero che tu capisca.