字符串处理函数（strcat、strcpy等）为什么要返回值

这样做的目的是方便程序中语句内联，比如strlen(strcpy(s,t))。

为了实现链式操作，将目的地址返回

int lengh=strlen(strcpy(s,t))。

Strcpy函数可以作为另外一个函数的实参。

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

字符串复制

最常见的字符串复制函数是strcpy：

char *strcpy(char *dst, const char *src);

把src所指的由NULL结尾的字符串复制到由dst所指的字符串中，src和dst不可以相同（可以由c99的restrict关键字声明），dst必有足够的空间存放复制的字符串。

还有一点要注意的是函数返回值，返回值是指向dst的指针，这样做的目的是方便程序中语句内联，比如strlen(strcpy(s,t))。

函数的实现如下：

[cpp] view plain copy print ?

1. char *my_strcpy(char *dst, const char *src){  
2.     assert(NULL!=dst && NULL!=src);  
3.     char *p = dst;  
4.     while((*dst++ = *src++) != '\0');  
5.     return p;  
6. }  

char *my_strcpy(char *dst, const char *src){
	assert(NULL!=dst && NULL!=src);
	char *p = dst;
	while((*dst++ = *src++) != '\0');
	return p;
}

使用strcpy是危险的，因为函数本身是不检查dst指向的空间是否足够存储需要复制的字符串，导致的一个潜在隐患就是字符串溢出。这也是上个世纪常被黑客利用的一个经典漏洞。所以，在大多数情况下都是用strncpy无疑更加保险：

[cpp] view plain copy print ?

1. char *my_strncpy(char *dst, const char *src, size_t n){  
2.     assert(NULL!=dst && NULL!=src);  
3.     char *p = dst;  
4.     while(n){  
5.         if((*dst++ = *src++) == '\0')  
6.             break;  
7.         n--;  
8.     }  
9.     return p;  
10. }  

char *my_strncpy(char *dst, const char *src, size_t n){
	assert(NULL!=dst && NULL!=src);
	char *p = dst;
	while(n){
		if((*dst++ = *src++) == '\0')
			break;
		n--;
	}
	return p;
}

需要注意另外一个函数strdup：

char *strdup(const char *);

该函数和strcpy的不同是，函数会自己申请内存空间存放拷贝的字符串，然后返回指向该字符串的指针。所以在使用strdup函数时需要注意的是，在使用完复制的字符串后使用free函数释放其占用的空间。

另memcpy函数和strncpy类似，只是不会再遇到NULL时终止拷贝，该函数一定会拷贝n个字符。

字符串连接

字符串连接是把一个字符串的头连接到另一个字符串的结尾。

char *strcat(char *s1, const char *s2);

函数的实现如下：

[cpp] view plain copy print ?

1. char *my_strcat(char *s1, const char *s2){  
2.     assert(NULL!=s1 && NULL!=s2);  
3.     char *p =s1;  
4.     while(*s1)s1++;  
5.     strcpy(s1,s2);  
6.     return p;  
7. }  

char *my_strcat(char *s1, const char *s2){
	assert(NULL!=s1 && NULL!=s2);
	char *p =s1;
	while(*s1)s1++;
	strcpy(s1,s2);
	return p;
}

同样，strcat也是不安全的，因为也对缓冲区足够存放连接的字串进行了假设。所以，多数情况下我们应该使用更安全的：

char *strncat(char *s1, const char *s2, size_t n);