(面试题的四种答案)重写strcpy库函数..看不懂

[代码库]

下面是四种写法,四种写法的质量依次增强,能解释下这四种写法吗???
第一种:
void strcpy( char *strDest, char *strSrc )
{
　 while( (*strDest++ = * strSrc++) != ‘\0’ );
}
　

第二种:
void strcpy( char *strDest, const char *strSrc )
{
　 while( (*strDest++ = * strSrc++) != ‘\0’ );
}
　　

第三种:
void strcpy(char *strDest, const char *strSrc)
{
　　assert( (strDest != NULL) && (strSrc != NULL) );
　 while( (*strDest++ = * strSrc++) != ‘\0’ );
}
　　


第四种:
char * strcpy( char *strDest, const char *strSrc )
{
　assert( (strDest != NULL) && (strSrc != NULL) );
　char *address = strDest;
　while( (*strDest++ = * strSrc++) != ‘\0’ );
　　return address;
}

这是C C++程序员面试的题目,作者对四种不同的答案进行了评价.......

[pigniyan]

第一种:
void strcpy( char *strDest, char *strSrc )
{
　 while( (*strDest++ = * strSrc++) != ‘\0’ );//把后一个字符串的第一个字符赋值给前面一个字符串的第一个字符的地址上,如果碰到'\0'就退出.此时后一个字符串也把'\0'赋值给了前一个字符串的尾部
}
　

第二种:
void strcpy( char *strDest, const char *strSrc )
{
　 while( (*strDest++ = * strSrc++) != ‘\0’ );//与前一个基本相同,只是多了一个const关键字,const的作用是说明后一个字符串是只读变量,不允许修改
}
　　

第三种:
void strcpy(char *strDest, const char *strSrc)
{
　　assert( (strDest != NULL) && (strSrc != NULL) );assert是一个测试函数,如果条件为真就继续往下前,如果条件为假就直接退出.这里是为了测试这二个字符串是否非空,其它与前面一样.
　 while( (*strDest++ = * strSrc++) != ‘\0’ );
}
　　


第四种:
char * strcpy( char *strDest, const char *strSrc )
{
　assert( (strDest != NULL) && (strSrc != NULL) );
　char *address = strDest;
　while( (*strDest++ = * strSrc++) != ‘\0’ );
　　return address; //这是一个返回字符串的函数,char *strcpy(),address是在函数里面定义的一个指什,它的作用仅仅就是返回它所指向的那个地址,函数结束后,这个指针也就不存在了,return address仅仅就是返回它指向strDest这个字符串的首地址,因为strDest是函数的一个参数,它不属于这个函数定义的变量,所以函数结果后,这个字符串是存在的,所以返回首地址是可以正确的读出这个字符串,strDest的内存空间不会在函数结果后收回.
}

[pigniyan]

while( (*strDest++ = * strSrc++) != ‘\0’ );//补充一下,这里是先赋值在做++

[BuleRiver]

char * strcpy( char *strDest, const char *strSrc ) 
{ 
　assert( (strDest != NULL) && (strSrc != NULL) ); 
　char *address = strDest;
　while( (*strDest++ = * strSrc++) != ‘\0’ ); 
　　return address; 
}

我的意见是，这里的参数address可能就是为了可读性。因为对C语言不甚了解到程序员，如果直接用strDest++，他可能会认为，不但改变了字符串的内容，还改变了指针的值，我刚学C的时候，就是这么认为的。
函数最后返回字符串结尾的地址，我认为这是一个很好的习惯。
但是这个函数的不足还是有的，那就是没有处理越界问题，因为，在这个函数中，并没有任何的策略来防止strDest指向的内存不够长。
当然对于C程序员，也许这个不足并不是不足，因为简单本来就是C语言的一大特性。

[BuleRiver]

对不起，上面写错了，我原来写的是：
“函数最后返回字符串结尾的地址，我认为这是一个很好的习惯。”
应该改成：
“函数最后返回字符串开头的地址，我认为这是一个很好的习惯。”

[代码库]

谢谢大家这么积极的帮我解答,学习了

[代码库]

我按第一种改了下
#include<stdio.h>

void strcpy(char *des,char *res)
{
while((*des++=*res++)!='0');
}
void main()
{
char *p="hello";
char string[20];
strcpy(string,p);
printf("%s",string);


}
为什么运行不出来呢????

[pigniyan]

#include <stdio.h>
void strcpy(char *des,char *res);
void main()
{
char *p="hello";
char string[20];
strcpy(string,p);
printf("%s",string);
getch();
}
void strcpy(char *des,char *res)
{
while((*des++=*res++)!='\0');\\这是里'\0'
}

[iamqk]

问一个问题，在正常代码运行的情况下，有必要将方法1写成方法4么？
方法1正常使用出问题的可能性有多大？
什么情况下会出问题？被黑客修改？或者溢出？

[kondykuang]

[Quote=引用 4 楼 jinwei1984 的回复:]
引用 2 楼 dclchj 的回复:
C/C++ codevoid strcpy(char*strDest,char*strSrc )//字符串的指针{while( (*strDest++=* strSrc++)!= ‘\0’ );//将后者第1个字符赋给前者首地址,然后各自}//自增，将后一个字符赋给前者 直到后者出现//0（字符串结尾）,字符是'\0' 　

第二种:void strcpy(char*strDest,constchar*strSrc )//算法相同，加了const表示是常量，可以防{//止在函数中修改后者的内容while( (*strDest++=* strSrc++)!= ‘\0’ );
}
　　

第三种:void strcpy(char*strDest,constchar*strSrc)
{
　　assert( (strDest!= NULL)&& (strSrc!= NULL) );//判断一下，为空就不需要赋值while( (*strDest++=* strSrc++)!= ‘\0’ );
}
　　


第四种:char* strcpy(char*strDest,constchar*strSrc )
{
　assert( (strDest!= NULL)&& (strSrc!= NULL) );char*address= strDest;// 这个作用不清楚，不过我写函数也习惯在函数里重新定义一个指针接while( (*strDest++=* strSrc++)!= ‘\0’ );//受参数return address;
}


1. 不是直到\0, \0会复制的
2. 第四个中返回类型不一样阿，要保存最初的地址
  这样的strcpy才可以用链式表达式
[/Quote]



正解！！！

[pengzhixi]

推荐第4种

[wbgxx]

学习

[dclchj]

void strcpy( char *strDest, char *strSrc ) //字符串的指针
{ 
　 while( (*strDest++ = * strSrc++) != ‘\0’ );  //将后者第1个字符赋给前者首地址,然后各自
}                                               //自增，将后一个字符赋给前者 直到后者出现
                                                       //0（字符串结尾）,字符是'\0'
 　 

第二种: 
void strcpy( char *strDest, const char *strSrc ) //算法相同，加了const表示是常量，可以防
{                                                //止在函数中修改后者的内容 
　 while( (*strDest++ = * strSrc++) != ‘\0’ ); 
} 
　　 

第三种: 
void strcpy(char *strDest, const char *strSrc) 
{ 
　　assert( (strDest != NULL) && (strSrc != NULL) );  //判断一下，为空就不需要赋值
　  while( (*strDest++ = * strSrc++) != ‘\0’ ); 
} 
　　 


第四种: 
char * strcpy( char *strDest, const char *strSrc ) 
{ 
　assert( (strDest != NULL) && (strSrc != NULL) ); 
　char *address = strDest;   // 这个作用不清楚，不过我写函数也习惯在函数里重新定义一个指针接
　while( (*strDest++ = * strSrc++) != ‘\0’ );  //受参数
　　return address; 
}

[代码库]

不错,看来是得好好看看研究研究了

[jinwei1984]

[Quote=引用 2 楼 dclchj 的回复:]
C/C++ codevoid strcpy(char*strDest,char*strSrc )//字符串的指针{while( (*strDest++=* strSrc++)!= ‘\0’ );//将后者第1个字符赋给前者首地址,然后各自}//自增，将后一个字符赋给前者 直到后者出现//0（字符串结尾）,字符是'\0' 　

第二种:void strcpy(char*strDest,constchar*strSrc )//算法相同，加了const表示是常量，可以防{//止在函数中修改后者的内容while( (*strDest++=* strSrc++)!= ‘\0’ );
}
　　

第三种:void strcpy(char*strDest,constchar*strSrc)
{
　　assert( (strDest!= NULL)&& (strSrc!= NULL) );//判断一下，为空就不需要赋值while( (*strDest++=* strSrc++)!= ‘\0’ );
}
　　


第四种:char* strcpy(char*strDest,constchar*strSrc )
{
　assert( (strDest!= NULL)&& (strSrc!= NULL) );char*address= strDest;// 这个作用不清楚，不过我写函数也习惯在函数里重新定义一个指针接while( (*strDest++=* strSrc++)!= ‘\0’ );//受参数return address;
}
[/Quote]

1. 不是直到\0, \0会复制的
2. 第四个中返回类型不一样阿，要保存最初的地址
这样的strcpy才可以用链式表达式

[dclchj]

谢谢楼上，学习了！
参考：
http://topic.csdn.net/t/20061123/21/5180993.html

[kakashi0309]

网上搜C/C++面试题 这些都有说明的

[xiaoliang_c]

2楼正解

[simon1990]

写的真好，学习了