C++ 使用字符数组和递归反转字符串，某些线程1:EXC\u BAD\u访问错误

我试图使用字符数组和递归来反转字符串，但是我得到了“thread1:EXC_BAD_ACCESS（code=2，address=0x7ffeef3ffff8）”。编译器请求大约7个输入，然后开始请求命令，而它应该请求输入一次，然后在下一行打印答案。当我使用循环时，程序运行良好，当我使用递归时，它开始做奇怪的事情

char* reverse(char ss[30], int l){
    char *p = new char;
    int c=0;
    if(c!=l+1){
        p[c]=ss[l-c-1];
        c++;
        reverse(ss, l);
    }
    return p;
} 

int main(int argc, const char * argv[]) {
    string s;
    cin>>s;
    char ss[30];
    for(int i=0; i<s.length(); i++){
        ss[i]=s[i];
    }
    char *answer;
    answer=reverse(ss, s.length());
    cout<<answer<<endl;
    return 0;
}

char*反向（char ss[30]，int l）{
char*p=新字符；
int c=0；
如果（c！=l+1）{
p[c]=ss[l-c-1]；
C++；
反向（ss，l）；
}
返回p；
} 
int main（int argc，const char*argv[]{
字符串s；
cin>>s；
char-ss[30]；
对于（inti=0；i，我们首先读取用户的输入，并将其存储在名为s；
我们将得到的大小添加到一个char数组中（毕竟char数组可以被认为是一个字符串），额外的一个仅用于“\0”字符。
接下来，我将其传递给reverse函数，然后打印出数组

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s;
    cin>>s;
    unsigned int StringSz = s.length();
    char arr[StringSz+1];
    arr[StringSz] = '\0';
    reverse(arr,s);
    cout << arr;
    return 0;
}

我的观点是使用递归-总是用循环替换更好

设置C++标签-使用STD::String 
这是一个单代码的WIV2方法-循环和递归

1） 循环函数反转

2） 递归-函数反向递归

  #include <iostream>
#include <string>


std::string ReverseStrRecusrsion(std::string s, std::size_t pos = 0) { 

    std::swap(s[pos], s[s.length() - pos - 1]);
    if (pos < s.length() /2) {
        s = ReverseStrRecusrsion(s, ++pos);
    }

    return s;
} 


std::string ReverseStr(std::string s) { 

    std::size_t size{s.length()}; 
    for (std::size_t i = 0; i < size / 2; i++) {
        std::swap(s[i], s[size - i - 1]); 
    }

    return s;
} 



int main() { 

    std::string str = "teststring";
    auto new_str{ReverseStr(str)}; 
    auto new_str2{ReverseStrRecusrsion(new_str)};

    std::cout << "old str " << str << std::endl;
    std::cout << "new str " << new_str << std::endl; 
    std::cout << "rev new str " << new_str2 << std::endl; 

    return 0; 
}

#包括
#包括
std:：string reversestRecursion（std:：string s，std:：size\u t pos=0）{
交换（s[pos]，s[s.length（）-pos-1]）；
如果（位置std:：cout
char*p=new char；
为
p
分配了多少个字符？
p[c]=ss[l-c-1]是否足够
写入有效内存？当你的函数停止递归处理时？！可能永远不会…@landstapper看起来很正确：函数既不改变
ss
也不改变
l
，因此它不得不尝试无限递归。记住，你调用的每个反向函数实例的变量c都是局部的。如果您总是将0分配给c（int c=0；）您将无限期调用reverse…为什么
arr[StringSz]='\0'；
您已经完成了
{0}
。您更改了lot函数原型；）@landstapper char arr[StringSz+1]={0}；&arr[StringSz]之间存在差异='\0'；至少我知道这一点，因为我自嘲这个答案可以通过一些解释得到极大的帮助。现在这几乎是一个代码转储，而那些人有一种不幸的教学倾向。解释你做了什么，为什么，以及它是如何解决提问者的问题的。尽量避免非标准代码，如
char-arr[StringSz+1]={0}；
在answers中，因为它不适用于太多的编译器。这是一个可变长度的数组。在我看到的所有扩展允许的情况下，它们都是自动分配的，不需要手动销毁。
delete[]arr；
充其量是错误的，可能是致命的。请尽量保持答案简单。
*（arr+start）=s[s.length（）-start-1]；
可以是
arr[start]=s[s.length（）-start-1]；
另外，如果您要在std:：string
上操作，您最好坚持使用
std:：string`并利用
std:：reverse
  #include <iostream>
#include <string>


std::string ReverseStrRecusrsion(std::string s, std::size_t pos = 0) { 

    std::swap(s[pos], s[s.length() - pos - 1]);
    if (pos < s.length() /2) {
        s = ReverseStrRecusrsion(s, ++pos);
    }

    return s;
} 


std::string ReverseStr(std::string s) { 

    std::size_t size{s.length()}; 
    for (std::size_t i = 0; i < size / 2; i++) {
        std::swap(s[i], s[size - i - 1]); 
    }

    return s;
} 



int main() { 

    std::string str = "teststring";
    auto new_str{ReverseStr(str)}; 
    auto new_str2{ReverseStrRecusrsion(new_str)};

    std::cout << "old str " << str << std::endl;
    std::cout << "new str " << new_str << std::endl; 
    std::cout << "rev new str " << new_str2 << std::endl; 

    return 0; 
}