11

语境

我正在学习 C，我正在尝试使用指针来反转字符串。（我知道您可以使用数组；这更多是关于学习指针。）

问题

尝试运行下面的代码时，我不断收到分段错误。GCC似乎不喜欢这*end = *begin;条线。这是为什么？

特别是因为我的代码几乎与已经在另一个问题中讨论过的非邪恶 C 函数相同

#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);
}
4

8 回答 8

22

一个问题在于您传递给函数的参数：

char *string = "foobar";

这是在只读部分分配的静态字符串。当您尝试用

*end = *begin;

你会得到段错误。

尝试

char string[] = "foobar";

你应该注意到一个区别。

关键是，在第一种情况下，字符串存在于只读段中，并且只使用指向它的指针，而在第二种情况下，堆栈中保留了具有适当大小的字符数组和静态字符串（始终存在）被复制到其中。之后，您可以自由修改数组的内容。

于 2010-01-23T20:35:47.617 回答
5

您还可以利用字符串末尾的空字符来交换字符串中的字符，从而避免使用任何额外的空间。这是代码：

#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;
}
于 2012-08-14T15:13:53.450 回答
4

在您的代码中，您具有以下内容：

*end--;
*begin++;

这只是纯粹的运气，这样做是正确的（实际上，原因是运算符优先级）。看起来您打算让代码实际执行

(*end)--;
(*begin)++;

这是完全错误的。你拥有它的方式，操作发生在

  • 递减end然后取消引用它
  • 递增begin然后取消引用它

在这两种情况下，取消引用都是多余的，应该删除。您可能希望行为是

end--;
begin++;

这些是驱动开发人员疯狂的东西，因为它们很难追踪。

于 2010-01-23T21:36:14.477 回答
3

这将到位并使用指针

 #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);
}
于 2012-01-13T08:10:07.247 回答
2

更改char *string = "foobar";为char string[] = "foobar";。问题是char *指向只读内存，然后您尝试修改它导致分段错误。

于 2010-01-23T20:37:08.303 回答
0

这是我的就地 C 字符串反转版本。

#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;
}
于 2011-12-10T20:49:47.373 回答
0

这产生了一个小的（ish）递归函数，并通过在堆栈中存储值并在返回（返回）时增加指向字符串开头的指针（* s）来工作。

看起来很聪明的代码，但在堆栈使用方面很糟糕。

#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;
}
于 2012-02-22T10:23:57.390 回答
0

下面，您可以看到我针对此问题的代码：

#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;
}
于 2018-03-10T22:26:02.603 回答