Segmentatiefout tijdens het kopiëren van tekenreeksen in de C-functie

Ik heb een functie in 'C' die mijn eigen strcpy-programma moet implementeren. Dit is wat ik schreef. Ik kan de oorzaak van de segmentatiefout echter niet opsporen.

#include 
#include 

char * mystrcpy(char *dest, char *src) {
    char * ptr = dest;
    while (*src != '\0'){
        *ptr = *src;
        ptr++; src++;
        //printf("Dest is \"%s\" and Source is \"%s\"\n",dest,src);
    }
    *ptr = '\0';
    return dest;
}


int main() {
    char str[] = "I rock always";
    char * dest = NULL;
    dest = mystrcpy(dest, str);
    printf("Source String %s and Destination String %s\n", str, dest);
}

Kan iemand mij dit gedrag uitleggen?

0
'Ik kan de oorzaak van de gesegmenteerde segmentfout niet opsporen' - alleen omdat u het duidelijk niet hebt geprobeerd.
toegevoegd de auteur Jim Balter, de bron
Let op: er is de one-liner K & R-versie van strcpy: while (* dest ++ = * str ++) {;} Misschien vind je het lelijk, maar het is een goede manier om de voorrang te leren begrijpen reglement.
toegevoegd de auteur wildplasser, de bron
Ik denk dat het doel is om de hele string te kopiëren; het is logisch om aan deze '\ 0'-controle te ontsnappen, zodat deze wordt gekopieerd naar de doelreeks. Maar dan is de vraag, wanneer weet het om te stoppen?
toegevoegd de auteur Code4Fun, de bron

5 antwoord

U moet geheugen toewijzen voor de doelreeks:

int main() {
    char str[] = "I rock always";
    char * dest = (char*)malloc(strlen(str) + 1);
    dest = mystrcpy(dest, str);
    printf("Source String %s and Destination String %s\n", str, dest);
}

Natuurlijk zijn het goede manieren om het geheugen uiteindelijk te bevrijden:

    free(dest);
4
toegevoegd
@wildplasser - 1) Klopt, maar kan een waarschuwing in pedante compilers voorkomen. 2) Ook waar, maar dit is algemener: hij wil de malloc verplaatsen naar de mystrcpy -functie, en de sizeof zou niet werk.
toegevoegd de auteur rodrigo, de bron
1) de cast is niet noodzakelijk. 2) de strlen() is niet nodig; sizeof zal ook doen.
toegevoegd de auteur wildplasser, de bron
1) "pedante compilers"? Bedoel je C ++ compilers? 2) In dat geval zou hij zijn functie mystrdup() kunnen noemen.
toegevoegd de auteur wildplasser, de bron
sizeof stopt niet met werken. sizeof ptr levert de grootte op van de aanwijzer , sizeof array levert de grootte van de array op. Wanneer u een functie met een pointer-argument aanroept, ziet de functie de aanwijzer alleen en het type: char * ptr en de grootte sizeof ptr en de waarde ervan ptr . De functie kent de variabelen van de aanroeper niet, alleen over zijn argumenten en lokale variabelen (en globalen).
toegevoegd de auteur wildplasser, de bron
Bedankt rodrigo en wildpasser voor je waardevolle opmerkingen !! Ik begreep de oorzaak.
toegevoegd de auteur Code4Fun, de bron
@wildplasser: ik heb een vraag; Waarom stopt sizeof met werken, wanneer de aanwijzer een externe functie bereikt, zoals hierboven vermeld?
toegevoegd de auteur Code4Fun, de bron

U wijst nooit geheugen toe voor * dest waarnaar wordt verwezen.

Het begint naar NULL te wijzen, en dan probeer je: * ptr = * src .

1
toegevoegd

U moet geheugen toewijzen voor de doelreeksbuffer.

Geheugenbeheer is een zeer groot onderdeel van C ... u moet heel voorzichtig zijn dat u het geheugen toewijst EN de toewijzing opheft terwijl het wordt gebruikt en overbodig wordt. Als u dit niet doet, ontstaan ​​segmenteringsfouten (niet om geheugen toe te wijzen) en geheugenlekken (er is geen geheugen vrij)

Andere antwoorden geven hier voorbeelden van malloc, dus ik zal ze hier niet herhalen.

U moet de functies die al voor u beschikbaar zijn zoveel mogelijk gebruiken in plaats van deze zelf te schrijven. Dit voorkomt fouten bij de implementatie omdat iemand het al voor u heeft debugged en geoptimaliseerd.

http://www.cs.cf.ac.uk/Dave/C /node19.html

0
toegevoegd
Ja ... absoluut waar. Ik ben net aan het leren om te coderen, zodat ik ooit in staat zou zijn zulke robuuste bibliotheken te ontwikkelen.
toegevoegd de auteur Code4Fun, de bron
#include 

    /* this the K&R version of strcpy */
char * mystrcpy(char *dest, char *src) {
    char *ptr = dest;
    while ( *ptr++ = *src++ ) {;}

    return dest;
}


int main(void) {
    char str[] = "I rock always";
    char dest[sizeof str];
    char *result;

    result = mystrcpy(dest, str);
    printf("Source String %s and Destination String %s and result %s\n", str, dest, result);
    return 0;
}
0
toegevoegd

Wijs geheugen toe en probeer ....

         #include 
         #include 

         char * mystrcpy(char *dest, char *src) 
         {
                     char * ptr = dest;
                     int index=0;
                     while (*src != '\0')
                     {
                         *(ptr+index) = *(src+index);
                           index++;
                     }
                     *(ptr+index) = '\0';
                     return dest;

          }




          int main() 
          {
                char str[] = "I rock always";
                char * dest = (char*)malloc((strlen(str)+1)*sizeof(char));
                dest = mystrcpy(dest, str);
                printf("Source String %s and Destination String %s\n", str, dest);
                free(dest);
                return 0;
          }
0
toegevoegd