Errore di segmentazione durante l'assegnazione dei valori ai puntatori nella funzione

Question

Listener di lunga durata, primo chiamante.

Mi scuso se questo problema è già stato affrontato (immagino che sia è stato ampiamente coperto), ma ho cercato attraverso molte domande su puntatori e altri argomenti apparentemente affini, ma sono ancora in grado di risolvere il mio problema.

Attualmente sto scrivendo una stringa di libreria per progetto di classe, e quando sto ottenendo un errore di segmentazione quando provo questo:

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

void lstrip(char *s) { 

     char *p, *q; 
     p = q = s; 

     while (*p == ' ' && *p != '\0') { 
      *p++; 
     } 

     while (*p != '\0') { 
      *q = *p; //this is where the actual segmentation fault occurs. 
      p++; 
      q++; 
     } 

     *q = '\0'; 
} 

Il mio programma principale si presenta così:

#include <stdio.h> 
#include <stdlib.h> 
#include "str2107.h" 


int main(int argc, char** argv) { 

    char *z1 = "  weeee"; 
    printf("lstrip function\n"); 
    printf("%s\n",z1); 
    lstrip(z1); 
    printf("%s\n",z1); 

    return 0; 
} 

Answer 1

z1 sta puntando a un stringa letterale e la modifica di una stringa letterale è undefined behavior. In alternativa è possibile utilizzare la seguente dichiarazione di z1 che sarà modificabile:

char z1[] = "  weeee"; 

Se guardiamo il progetto C99 standard di sezione 6.4.5stringhe letterali paragrafo dice (sottolineatura mia):

Non è specificato se questi array sono distinti purché i loro elementi abbiano i valori appropriati . Se il programma tenta di modificare un array di questo tipo, il comportamento è indefinito.

alcuni altri punti come WhozCraig sottolinea questa linea:

while (*p == ' ' && *p != '\0') { 

poteva essere più succintamente scritto come:

while (*p == ' ') { 

anche che si sta utilizzando indirezione qui:

*p++; 

ma in realtà non utilizza il valore risultante, in modo da poter cambiare a:

p++; 

Answer 2

Quando si scrive char *z1 = " weeee"; poi z1 è un puntatoreche punta a una memoria che si trova nella parte codice, quindi non è possibile cambiarlo.

Se si modifica char z1[] = " weeee"; poi z1 è un array di caratteri che si trovano sul pila e si può cambiare.

Se avessi scritto char const *z1 = "..."; allora sarebbe un errore di compilazione , che è migliore e preferibile rispetto segmentation fault.

Answer 3

char *z1 = "  weeee"; 

dovrebbero essere

const char *z1 = "  weeee"; 

perché letterali stringa sono costanti. Provare qualcosa di simile:

const char *z1 = "  weeee"; 
char *z2 = strdup(z1); 
lstrip(z2); 

Per chiamare lstrip su una stringa mutabile pur mantenendo z2 un char* (se essere un char[] non è ciò che si desidera).

Answer 4

Come un sacco di altre persone hanno già fatto notare a te, quando si scrive:

char *whatever = "some value";

Questo è molto diverso da quello:

char *whatever = malloc(length("some value") + 1); 
strcpy(whatever, "some value");

La differenza è che qualcosa che è un letterale (cioè una stringa definita in fase di compilazione) può essere una costante, anche se non so se sia sempre o richiesto t o essere costante. Poiché una costante non deve essere modificata e si inserisce un carattere '\ 0' nella stringa, si verifica un errore di segmentazione.

Ci possono essere molti motivi per questo, ma quello facile che so è che il programma può ottimizzare se sa che ogni utilizzo della stessa stringa è sicuro da riutilizzare.

Per fare un esempio:

char *whatever1 = malloc(length("some value") + 1); 
strcpy(whatever1, "some value"); 
char *whatever2 = malloc(length("some value") + 1); 
strcpy(whatever2, "some value"); 
if(whatever1 == whatever2) { 
    printf("This should never happen!\n"); 
} 

if("some value" == "some value") { 
    printf("A good compiler should always do this!\n"); 
}