我写的字符串倒序函数，请看看有错吗？有什么改进吗？

[fldx]

char * RadStrRev(const char * src)
{
	char * p = new char[strlen(src)+1];
	
	for(size_t i=0; i<strlen(src); ++i)
	{
		p[i] = src[strlen(src)-i-1];
	}

	p[strlen(src)] = '\0';
	
	return p;
}

void main()
{
    char * zip = "abcdefgh";
    char * target = RadStrRev(zip); 
    printf("%s\n", target);

    getchar();
    delete [] target;
}

[lizhendi1021]

其实这个算法没什么问题的 就是在实际的编程应用中要注意一下编程习惯 例如任何函数的参数传进来的如果得指针类型的 要养成对空指针做相应处理的习惯。例如本题如果传个null指针 由于没做相应处理 strlen（null）会导致程序崩溃。

[Damn_boy]

不是说,数组传递给函数,就退化成指针了,不能求长度了吗?
怎么还可以在函数里用
strlen(char *)

[acrobatyuer]

值得考虑的效率问题...

[zhangzhongke007]

嗯，效率，对我好像还是个遥不可及的问题~

[cxjddd]

方法一：

char * RadStrRev(const char * src)
{
    size_t len = strlen(src);
    char * p = new char[len + 1];
    const char* pe = str + len;
    char * pp = p;
    while (pe != src)
        *pp++ = *--pe;
    *pp = '\0';
    return p;
}

方法二：

char * RadStrRev(char * src)
{
    char * p = src;
    char* pe = str + strlen(str);
    while (p + 1 < pe)
    {
        char ch = *p;
        *p++ = *pe;
        *pe-- = ch;
    }
    return src;
}

C++ 吧：

char * RadStrRev(const char * src)
{
    int len = strlen(src);
    char * p = new char[len + 1];
    *std::reverse_copy(src, src + len, p) = '\0';
    return p;
}

[goodname]

应该将strlen(src)用一个变量保存起来，不要每次都去求长度。

[chenzhp]

#include <iostream>
using namespace std; 


char * RadStrRev(const char * src)
{
    char * p = new char[strlen(src)+1];
    int lentgh = strlen(src); 
    for(size_t i=0; i< lentgh;++i)
    {
        p[i] = src[lentgh-i-1];
    }

    p[lentgh] = '\0';
    
    return p;
}

int main()
{
      char * zip = "abcdefgh";
    char * target = RadStrRev(zip); 
    printf("%s\n", target);

    getchar();
    delete [] target;
    return 0;
}

[lijinfenghust]

RadStrRev函数里面的参数src传空指针会崩溃。
strlen是不能对空指针求长度的，需要判断一下

[licry01]

[Quote=引用 1 楼 goodname 的回复:]
应该将strlen(src)用一个变量保存起来，不要每次都去求长度。
[/Quote]
除了这, for循环的次数可以减少一半, 每次循环交换相对于中间两次对称的值.
比如 字符串 abcdefg, 第一次for, 交换a和g, 第二次, 交换b跟f, ...........................

[信念]

[Quote=引用 4 楼 licry01 的回复:]
引用 1 楼 goodname 的回复:
应该将strlen(src)用一个变量保存起来，不要每次都去求长度。

除了这, for循环的次数可以减少一半, 每次循环交换相对于中间两次对称的值.
比如 字符串 abcdefg, 第一次for, 交换a和g, 第二次, 交换b跟f, ...........................
[/Quote]
顶一下

[ztenv]

[Quote=引用 4 楼 licry01 的回复:]
引用 1 楼 goodname 的回复:
应该将strlen(src)用一个变量保存起来，不要每次都去求长度。


除了这, for循环的次数可以减少一半, 每次循环交换相对于中间两次对称的值.
比如 字符串 abcdefg, 第一次for, 交换a和g, 第二次, 交换b跟f, ...........................
[/Quote]

效率！效率！！

[夹心饼干]

char * RadStrRev(const char * src)
{
char temp;
const int len = strlen(src);
for(size_t i=0; i<len/2; ++i)
{
temp = *(src+i);
*(src+i); = *(src+len);
*(src+len) = temp;
}
return src;
}

这样效率只有原来的一半

[fldx]

[Quote=引用 4 楼 licry01 的回复:]
引用 1 楼 goodname 的回复:
应该将strlen(src)用一个变量保存起来，不要每次都去求长度。


除了这, for循环的次数可以减少一半, 每次循环交换相对于中间两次对称的值.
比如 字符串 abcdefg, 第一次for, 交换a和g, 第二次, 交换b跟f, ...........................
[/Quote]

这的确是。。。

[lijinfenghust]

其实看出来你那个语法的效率了
但是如果不能对原串操作，或者必须返回个新串，也只有用你那种方法。

[licry01]

其实看出来你那个语法的效率了
但是如果不能对原串操作，或者必须返回个新串，也只有用你那种方法。

===============
要返回新串, 可以先堆复制一下原来的串, 再在新串上面原地处理

[fldx]

是的，应该对原串操作的。
[Quote=引用 9 楼 lijinfenghust 的回复:]
其实看出来你那个语法的效率了
但是如果不能对原串操作，或者必须返回个新串，也只有用你那种方法。
[/Quote]

[licry01]

仔细想了下, 如果返回新串, 减少循环不会提升效率, 反而会降低.

1. 完全循环: 每次循环读一次, 读原串一次, 写新串一次

2. 循环减半: 每次循环, 读原串2次, 写新串2次, 开销是一样的, 还多了计算对称位置的开销

所以, 楼主的方法没有问题.

如果是在原串上操作的, 循环减半的方法要稍微高那么一点点, 因为在交换的时候, 可以用异或的方法来实现.
a ^= b ;
b ^= a ;
a ^= b ;

[lijinfenghust]

[Quote=引用 10 楼 licry01 的回复:]
其实看出来你那个语法的效率了
但是如果不能对原串操作，或者必须返回个新串，也只有用你那种方法。

===============
要返回新串, 可以先堆复制一下原来的串, 再在新串上面原地处理
[/Quote]
首先这个算法效率的瓶颈不完全在多做了一半的循环，动态内存分配才是个关键点。在串不长的时候，你可以测试一下。
再次，内存拷贝的时候，你就对每个元素进行遍历了1次，然后再用遍历1半的元素进行反转处理，你觉得哪个会时间短一点呢？

[信念]

char* RevStr(char * StrSrc)
{
	int len=strlen(StrSrc);
	int length=len-1;
	char TempStr;
	for (int i=0;i<len/2;i++)
	{
		TempStr=StrSrc[i];
		StrSrc[i]=StrSrc[length];
		StrSrc[length--]=TempStr;
	}
	return StrSrc;
}

[夹心饼干]

[Quote=引用 7 楼 stormlk1983 的回复:]
char * RadStrRev(const char * src)
{
char temp;
const int len = strlen(src);
for(size_t i=0; i <len/2; ++i)
{
temp = *(src+i);
*(src+i); = *(src+len);
*(src+len) = temp;
}
return src;
}

这样效率只有原来的一半
[/Quote]

刚才这个我的回复有个笔误
temp = *(src+i);
*(src+i); = *(src+len-i);
*(src+len-i) = temp;
里面应该是这样的
这种时间效率是strlen(src)/2