Erreur de segmentation lors de la modification d'une chaîne à l'aide de pointeurs?

Contexte

Je suis en train d'apprendre le C, et je vais essayer d'inverser une chaîne de caractères à l'aide de pointeurs. (Je sais que vous pouvez utiliser un tableau; c'est plus sur l'apprentissage sur les pointeurs.)

Problème

Je reçois des défauts de segmentation lorsque vous essayez d'exécuter le code ci-dessous. GCC semble ne pas aimer la *end = *begin; ligne. Pourquoi est-ce?

Surtout depuis que mon code est presque identique à le non-mal C de la fonction déjà discuté dans un autre question

#include <stdio.h>
#include <string.h>

void my_strrev(char* begin){
    char temp;
    char* end;
    end = begin + strlen(begin) - 1;

    while(end>begin){
        temp = *end;
        *end = *begin;
        *begin = temp;
        end--;
        begin++;
    }
}

main(){
    char *string = "foobar";
    my_strrev(string);
    printf("%s", string);
}

source d'informationauteur brice

c pointers reverse string

18

Un problème, c'est le paramètre que vous passer à la fonction:
```
char *string = "foobar";
```
C'est une chaîne statique alloué à la lecture seule partie. Lorsque vous essayez de l'écraser avec
```
*end = *begin;
```
vous obtiendrez l'erreur de segmentation.

Essayer avec
```
char string[] = "foobar";
```
et vous remarquerez une différence.

Le point clé est que dans le premier cas, la chaîne existe dans le segment en lecture seule et juste un pointeur est utilisé alors que dans le second cas, un tableau de caractères avec la bonne taille est réservé sur la pile et de la chaîne statique (qui existe toujours) est copié dans. Après que vous êtes libre de modifier le contenu du tableau.

Vous pouvez également utiliser le caractère nul de fin de chaîne afin d'échanger des personnages au sein d'une chaîne, évitant ainsi l'utilisation de tout l'espace supplémentaire. Voici le code:

#include <stdio.h>

void reverse(char *str){    
    int length=0,i=0;

    while(str[i++]!='#include <stdio.h>
void reverse(char *str){    
int length=0,i=0;
while(str[i++]!='\0')
length++;
for(i=0;i<length/2;i++){
str[length]=str[i];
str[i]=str[length-i-1];
str[length-i-1]=str[length];
}
str[length]='\0';
}
int main(int argc, char *argv[]){
reverse(argv[1]);
return 0;
}
')
        length++;

    for(i=0;i<length/2;i++){
        str[length]=str[i];
        str[i]=str[length-i-1];
        str[length-i-1]=str[length];
    }

    str[length]='#include <stdio.h>
void reverse(char *str){    
int length=0,i=0;
while(str[i++]!='\0')
length++;
for(i=0;i<length/2;i++){
str[length]=str[i];
str[i]=str[length-i-1];
str[length-i-1]=str[length];
}
str[length]='\0';
}
int main(int argc, char *argv[]){
reverse(argv[1]);
return 0;
}
';
}

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

    reverse(argv[1]);

    return 0;
}

4

Dans votre code, vous avez la suivante:
```
*end--;
*begin++;
```
Il n'est que pure chance que cela fonctionne correctement (en fait, la raison est la priorité de l'opérateur). Il semble que vous ayez prévu au code de le faire réellement
```
(*end)--;
(*begin)++;
```
Qui est entièrement faux. La façon dont vous l'avez, les opérations se passer comme
- décrémenter end puis de déréférencement il
- incrément begin puis de déréférencement il
Dans les deux cas, le déréférencement est superflu et doit être supprimé. Vous avez probablement prévu le comportement de la
```
end--;
begin++;
```
Ce sont les choses que le lecteur d'un développeur batty parce qu'ils sont si difficiles à dépister.

Ce serait en place et en utilisant des pointeurs

 #include<stdio.h>
 #include<string.h>
 #include<stdlib.h>

 void reve(char *s)
 {
    for(char *end = s + (strlen(s) - 1); end > s ; --end, ++s)
    {
        (*s) ^= (*end);
        (*end) ^= (*s);
        (*s) ^= (*end);
    }
 }

int main(void)
{
    char *c = malloc(sizeof(char *) * 250);
    scanf("%s", c);
    reve(c);
    printf("\nReverse String %s", c);
}

2

Changement char *string = "foobar"; à char string[] = "foobar";. Le problème est qu'une char * points de mémoire en lecture seule qui vous essayez ensuite de modifier provoque une erreur de segmentation.

Ce qui rend pour une petite(ish) en fonction récursive et fonctionne en stockant les valeurs sur le chemin en bas de la pile et de l'incrémenter le pointeur au début de la chaîne (*s) sur le chemin du retour (return).

Intelligent à la recherche de code mais terrible en termes de l'utilisation des piles.

#include <stdio.h>

char *reverse_r(char val, char *s, char *n)
{
    if (*n)
        s = reverse_r(*n, s, n+1);
   *s = val;
   return s+1;
}

int main(int argc, char *argv[])
{
    char *aString;

    if (argc < 2)
    {
        printf("Usage: RSIP <string>\n");
        return 0;
    }

    aString = argv[1];
    printf("String to reverse: %s\n", aString );

    reverse_r(*aString, aString, aString+1); 
    printf("Reversed String:   %s\n", aString );

    return 0;
}

Voici ma version de la place C de la chaîne d'inversion.

#include <stdio.h>
#include <string.h>

int main (int argc, const char * argv[])
{
    char str[] = "foobar";
    printf("String:%s\n", str);
    int len = (int)strlen(str);
    printf("Lenth of str: %d\n" , len);
    int i = 0, j = len - 1;
    while(i < j){
        char temp = str[i];
        str[i] = str[j];
        str[j] = temp;
        i++;
        j--;
    }

    printf("Reverse of String:%s\n", str);
    return 0;
}

Ci-dessous, vous pouvez voir mon code pour ce problème:

#include <string>
#include <iostream>

char* strRev(char* str)
{
    char *first,*last;

    if (!str || !*str)
        return str;

    size_t len = strlen(str);
    for (first = str, last = &str[len] - 1; first < last ; first++, last--)
    {
        str[len] = *first;
        *first = *last;
        *last = str[len];
    }
    str[len] = '#include <string>
#include <iostream>
char* strRev(char* str)
{
char *first,*last;
if (!str || !*str)
return str;
size_t len = strlen(str);
for (first = str, last = &str[len] - 1; first < last ; first++, last--)
{
str[len] = *first;
*first = *last;
*last = str[len];
}
str[len] = '\0';
return str;
}
int main()
{
char test[13] = "A new string";
std::cout << strRev(test) << std::endl;
return 0;
}
';
    return str;
}

int main()
{
    char test[13] = "A new string";
    std::cout << strRev(test) << std::endl;
    return 0;
}

Vous devez vous connecter pour publier un commentaire.