atoi,itoa,strcpy, strcmp,strcpy, strcpy_s, memc...

布满荆棘的人生 2024-04-19 13:56 51阅读 0赞

**strcpy()、strlen()、memcpy()、memmove()、memset()的实现**

**strcpy(), 字符串拷贝.  
char \*strcpy(char \*strDest, const char \*strSrc)  
\{  
    assert((strDest!=NULL) && (strSrc !=NULL));  
    char \*address = strDest;       
    while( (\*strDest\++ = \* strSrc\++) != '\\0')   
        NULL ;   
    return address ;  
\}  
  
strlen,**

第一种方法：  
int strlen( const char \*str)  
\{  
    assert(str != NULL);  
     int len = 0;  
     while((\*str++) !=  '\\0')  
        len++;  
     return len;  
\}

第二种方法：  
int strlen( const char \*str)  
\{  
    assert(str != NULL);  
     const char \*p = str;  
     while((\*p++) !=  '\\0');  
     return p - str - 1;  
\}

第三种方法：  
int strlen( const char\* str)  
\{  
     if (str\[0\] ==  '\\0')  
         return 0;  
     else  
         return strlen((char \*)(&str\[0\]+1))+1;  
\}

memcpy, 拷贝不重叠的内存块   
   void   \* memcpy( void \*  pvTo,  void \*  pvFrom, size\_t count )    
   \{  
     assert(pvTo != NULL && pvFrom != NULL);  
     byte\* pbTo = (byte\*)pvTo;  
     byte\* pbFrom = (byte\*)pvFrom;  
       
     assert(pbTo>=pbFrom\+count  || pbFrom>=pbTo\+count );  
     while(count \-- > )  
         \*pbTo\++ == \*pbFrom\++;  
     return pvTo;  
\}   
  
 void \*  memmove( void   \* dest,  const   void   \* src,size\_t count )   
 \{    
     if (count  == ) return ;   
     if (dest == NULL) return ;   
     if (src == NULL)    return ;   
     char \*psrc = (char\*)src;   
     char \*pdest = (char\*)dest;   
     if((pdest <= psrc)  ||  (pdest >= psrc \+count ))    
     \{  
           
         while (count \--)  
             \*pdest++ = \*psrc++;  
     \}   
     else   
     \{  
           
         pdest += count  \- 1;  
         psrc += count  \- 1;  
         while (count \--)  
             \*pdest-- = \*psrc--;  
     \}   
     return dest;  
\}   
  
 memset:把buffer所指内存区域的前count个字节设置成字符c  
 void   \*  memset( void \*  buffer,  int  c,  int  count)  
 \{  
    char\* pvTo=(char\*)buffer;  
    assert(buffer != NULL);  
    while(count\-- > )  
        \*pvTo\++=(char)c;  
    return buffer;  
\}   
  
分析：  
memmove、memcpy和memccpy三个函数都是内存的拷贝，从一个缓冲区拷贝到另一个缓冲区。  
memmove(void \*dest,void\*src,int count)  
memcpy(void \*dest,void \*src,int count)  
memccpy(void\*dest,void\*src,int ch,int count)  
表头文件: \#include <string.h>  
定义函数: void \*memcpy(void \*dest, const void \*src, size\_t n)  
函数说明: memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是,memcpy()会完整的复制n个字节,不会因为遇到字符串结束'\\0'而结束  
返回值:   返回指向dest的指针  
表头文件: \#include <string.h>  
定义函数: void \*memccpy(void \*dest, const void \*src, int c, size\_t n);  
函数说明: memccpy()用来拷贝src所指的内存内容前n个字节到dest所指的地址上。与memcpy()不同的是,memccpy()如果在src中遇到某个特定值(int c)立即停止复制。  
返回值:   返回指向dest中值为c的下一个字节指针。返回值为0表示在src所指内存前n个字节中没有值为c的字节。  
表头文件: \#include <string.h>  
定义函数: void \*memmove(void \*dest, const void \*src, size\_t n);  
函数说明:memmove()是从一个缓冲区移动到另一个缓冲区中。   
返回值:   返回指向dest指针。  
当dest <= src-count 或dest >= src+count时，以上三个函数均不会产生覆盖问题，即源数据不会被更改。  
若不在以上范围内，则源数据会被更改。 不妨用个小程序来测一下：  
  
\# include <string.h>

\# include <stdio.h>

int main()

int i = 0;

int a\[10\];

for(i; i < 10; i++)

a\[i\] = i;

memcpy(&a\[4\], a, sizeof(int)\*6);

for(i = 0; i < 10; i++)

printf("%d ",a\[i\]);

printf("\\n");

return 0;

将上面代码gcc之后再运行，结果为：0 1 2 3 0 1 2 3 0 1 。

再把第13行改成：memmove(&a\[4\], a, sizeof(int)\*6)，重新gcc再运行，结果为：0 1 2 3 0 1 2 3 4 5 ！

呵呵，两者的区别出现了。不过其实这样还不够，继续修改13行： memmove(a, &a\[4\], sizeof(int)\*6) //也就是将源、目的置换一下而已。重新gcc编译再运行，结果为：4 5 6 7 8 9 6 7 8 9 。

还不够，继续修改13行为： memcpy(a, &a\[4\], sizeof(int)\*6); gcc并运行，结果仍为： 4 5 6 7 8 9 6 7 8 9 ！

至此真相已经大白了。对比上面四个结果，不难得出以下结论：

1. 当 src 和 dest 所指内存区有重叠时，memmove 相对 memcpy 能提供保证：保证能将 src 所指内存区的前 n 个字节正确的拷贝到 dest 所指内存中；

2. 当 src 地址比 dest 地址低时，两者结果一样。换句话说，memmove 与 memcpy 的区别仅仅体现在 dest 的头部和 src 的尾部有重叠的情况下；

\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
1.//整数转换成字符串itoa函数的实现   
 \#include "stdafx.h"

\#include <iostream>

using namespace std;

void itoaTest(int num,char str\[\] )

int sign = num,i = 0,j = 0;

char temp\[11\];

if(sign<0)//判断是否是一个负数

num = -num;

\};

temp\[i\] = num%10+'0';

num/=10;

i++;

\}while(num>0);

if(sign<0)

temp\[i++\] = '-';//对于负数,要加以负号

temp\[i\] = '\\0';

i--;

while(i>=0)//反向操作

str\[j\] = temp\[i\];

j++;

i--;

str\[j\] = '\\0';

2. //字符串转换成整数atoi函数的实现

int atoiTest(char s\[\])

int i = 0,sum = 0,sign;    //输入的数前面可能还有空格或制表符应加判断

while(' '==s\[i\]||'\\t'==s\[i\])

i++;

sign = ('-'==s\[i\])?-1:1;

if('-'==s\[i\]||'+'==s\[i\])

i++;

while(s\[i\]!='\\0')

sum = s\[i\]-'0'+sum\*10;

i++;

return sign\*sum;

3.//字符串拷贝函数

\#include "stdafx.h"

\#include <assert.h>

\#include <string.h>

\#include <iostream>

using namespace std;

char \*srcpy(char \*dest,const char \*source)

assert((dest!=NULL)&&(source!=NULL));

char \*address = dest;

while(\*source!='\\0')

\*dest++=\*source++;

\*dest = '\\0';

return address;

4.//判断输入的是否是一个回文字符串

\#include "stdafx.h"

\#include <string.h>

\#include <iostream>

using namespace std;

//方法一：借助数组

bool isPalindrome(char \*input)

char s\[100\];

strcpy(s,input);

int length = strlen(input);

int begin = 0,end = length-1;

while(begin<end)

if(s\[begin\]==s\[end\])

begin++;

end--;

else

break;

if(begin<end)

return false;

else

return true;

//方法二：使用指针

bool isPalindrome2(char \*input)

if(input==NULL)

return false;

char \*begin = input;

char \*end = begin+strlen(input)-1;

while(begin<end)

if(\*begin++!=\*end--)

return false;

return true;

int main(int argc, char\* argv\[\])

char \*s ="1234554321";

if(isPalindrome(s))

cout<<"True"<<endl;

else

cout<<"Fasle"<<endl;

if(isPalindrome2(s))

cout<<"True"<<endl;

else

cout<<"Fasle"<<endl;

cin.get();

return 0;

5.//不使用库函数，编写函数int strcmp(char \*source, char \*dest)，若相等返回0，否则返回-1

int strcmp(char \*source, char \*dest)

assert(source != NULL && dest != NULL);

while(\*source++==\*dest++)

if(\*source=='\\0'&&\*dest=='\\0')

return 0;

return -1;

——————————————————————————————  
  
一：strcmp,\_stricmp  
strcmp("ha","he")是可以的。  
但是如下代码：   
string   str1   =   "ha";   
string   str2   =   "he";   
strcmp(str1,   str2);   
会产生如下的ERROR：  
因为：  
1）int   strcmp(const   char\*   str1,   const   char\*   str2);   
这个函数是C标准库的函数，处理的是C风格0结尾字符数组字符串。   
C++标准库中的string类有可以直接使用的<，>，<=，>=，==，!=运算符，通常也用不到这个函数  
或者说：   strcmp()处理的是C风格的字符串。 而你用的是string类，2者是不同的。  
  
但可以通过string成员函数string::c\_str()转换成char\*类型。象这样调用：strcmp(str1.c\_str(),   str2.c\_str())    
  
int ret = strcmp("aa", "ad"); //-1  
int ret = \_stricmp("aa", "ad");//-3  
int ret = \_stricmp("Aa","aD"); //-3  
ret = strcmp("ad", "aa"); //1

ret = strcmp("aa", "aa"); //0  
ret = \_stricmp("aa", "AA"); //0  
  
ret = strcmp("aa", "aad"); //-1  
  
strcmp(s1,s2)与\_stricmp(s1,s2）  
相同点：处理的都是C格式的字串，如果比较C++格式的string类型字串时，可以使用string.c\_str()来转换成C格式的字串再进行比较。  
不同点：1)前者区分大小写，后者不区分大小写  
              2)前者返回-1，0，1，后者返回字串实际差值，即整形数:负数，零，正数  
  
  
二：strcpy\_s&&strcpy的比较  
如下所示：  
char szBuf\[2\] = \{0\};  
strcpy\_s(szBuf, 2, "12131"); //注意第二个参数是申清空间的大小  
strcpy(szBuf, "12131");     
上述代码，明显有缓冲区溢出的问题。 使用strcpy\_s函数则会抛出一个异常。而使用strcpy函数的结果

则未定，因为它错误地改变了程序中其他部分的内存的数据，可能不会抛出异常但导致程序数据错误，

也可能由于非法内存访问抛出异常。使用新的增强安全的CRT函数有什么好处呢？简单地说，新的函数

加强了对参数合法性的检查以及缓冲区边界的检查，如果发现错误，会返回errno或抛出异常。

老版本的这些CRT函数则没有那么严格的检查与校验，如果错误地传输了参数或者缓冲区溢出，

那么错误并不能被立刻发现，对于定位程序错误也带来更大困难。  
  
//--------------------strcpy,strcpy\_s------------------------------------------  
  
//原型：extern char \*strcpy(char \*dest,char \*src);  
//功能：把src所指由NULL结束的字符串复制到dest所指的数组中。  
//说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串，返回指向dest的指针。

//strcpy用法：  
// 若源长<目标长 --->OK。  
//将源串COPY至目标串(包括结尾符)，其它字节保持不变，  
//若源长>目标长 --->溢出报错。  
//将源串COPY至目标串(包括结尾符)，但目标串太短，下标越界而溢出,不正常的字串显然会在导致运行时异常，  
//使用原则总结：使用时保证源长<目标长

//strcpy\_s用法：  
//若源长<目标长 sizeof(\[min, max\])--->OK，但自定义拷贝的字串长度超过目标长度时，会因下标越界而导致运行异常  
//若源长>目标长 sizeof任何一方都会发生运行异常，  
//(有可能是编译器在copy前会先检查两者长度，  
//如果源串较长便会发生告警而退出，因此后续使用sizeof(strlen(strDest)=0)语句已无效)  
//使用原则总结： 1,使用时保证：源长<目标长，2,长度不能超出szDest长度，建议使用sizeof(szDest)

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

\#define STRCPY\_TEST 0  
\#define LEN\_STR 15

void main()  
\{  
char szDest\[10\];  
char szSrc\_shorter\[\] = "1234";  
char szSrc\_longer\[\] ="123456789012";

cout<<"char szDest\[10\];"<<endl;  
cout<<"char szSrc\_shorter\[\] = \\"1234\\";"<<endl;  
cout<<"char szSrc\_longer\[\] = \\"123456789012345\\";"<<endl;

\#if (0 == STRCPY\_TEST)  
cout<<"\\n\[OK\] strcpy(szDest, szSrc\_shorter);\\nstrDest\[1~15\] = ";  
strcpy(szDest, szSrc\_shorter);  
for(int i = 0; i < LEN\_STR; i++)  
\{  
   cout<<szDest\[i\]<<", ";  
\}  
cout<<endl<<"szDest = "<<szDest<<endl;

strcpy(szDest, szSrc\_longer);  
cout<<"\\n\[NG\] strcpy(szDest, szSrc\_longer);\\nstrDest\[1~15\] = ";  
for(int i = 0; i < LEN\_STR; i++)  
\{  
   cout<<szDest\[i\]<<", ";  
\}  
cout<<endl<<"szDest = "<<szDest<<endl;

\#else

cout<<"\\n\[OK\] strcpy\_s(szDest, sizeof(szSrc\_shorter), szSrc\_shorter);\\nstrDest\[1~15\] = ";  
strcpy\_s(szDest, sizeof(szSrc\_shorter), szSrc\_shorter);  
for(int i = 0; i < LEN\_STR; i++)  
\{  
   cout<<szDest\[i\]<<", ";  
\}  
cout<<endl<<"szDest = "<<szDest<<endl;

cout<<"\[OK\] strcpy\_s(szDest, sizeof(szDest), szSrc\_shorter);\\nstrDest\[1~15\] = ";  
strcpy\_s(szDest, sizeof(szDest), szSrc\_shorter);   
for(int i = 0; i < LEN\_STR; i++)  
\{  
   cout<<szDest\[i\]<<", ";  
\}  
cout<<endl<<"szDest = "<<szDest<<endl;

cout<<"\[NG\] strcpy\_s(szDest, sizeof(szSrc\_longer), szSrc\_longer);\\nstrDest\[1~15\] = ";  
strcpy\_s(szDest, sizeof(szSrc\_longer), szSrc\_longer);   
for(int i = 0; i < LEN\_STR; i++)  
\{  
   cout<<szDest\[i\]<<", ";  
\}  
cout<<endl<<"szDest = "<<szDest<<endl;

cout<<"\\n\[NG\] strcpy\_s(szDest, sizeof(szDest), szSrc\_longer);\\nstrDest\[1~15\] = ";  
strcpy\_s(szDest, sizeof(szDest), szSrc\_longer);   
szDest\[sizeof(szDest) - 1\] = 0;  
for(int i = 0; i < LEN\_STR; i++)  
\{  
   cout<<szDest\[i\]<<", ";  
\}  
cout<<endl<<"szDest = "<<szDest<<endl;

\#endif

\}  
  
输出：(NG部分的输出已无意义，可以不看）  
  
(1)STRCPY\_TEST==0  
char szDest\[10\];  
char szSrc\_shorter\[\] = "1234";  
char szSrc\_longer\[\] = "123456789012345";  
\[OK\] strcpy(szDest, szSrc\_shorter);  
strDest\[1~15\] = 1, 2, 3, 4, , ? ? ? ? ? ? ? ? ? ?  
  
szDest = 1234  
\[NG\] strcpy(szDest, szSrc\_longer);  
strDest\[1~15\] = 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, , ? ?  
  
(2)STR\_CPY\_TEST<>0  
char szDest\[10\];  
char szSrc\_shorter\[\] = "1234";  
char szSrc\_longer\[\] = "123456789012345";

\[OK\] strcpy\_s(szDest, sizeof(szSrc\_shorter), szSrc\_shorter);  
strDest\[1~15\] = 1, 2, 3, 4, , ? ? ? ? ? ? ? ? ? ?  
  
szDest = 1234

\[OK\] strcpy\_s(szDest, sizeof(szDest), szSrc\_shorter);  
strDest\[1~15\] = 1, 2, 3, 4, , ? ? ? ? ? ? ? ? ? ?  
  
szDest = 1234

\[NG\] strcpy\_s(szDest, sizeof(szSrc\_longer), szSrc\_longer);  
strDest\[1~15\] = 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, , ? ?  
  
szDest = 123456789012

\[NG\] strcpy\_s(szDest, sizeof(szDest), szSrc\_longer);  
strDest\[1~15\] = 请按任意键继续. . .  
  
//-------------------------------memcpy-------------------------------------  
// 原型：extern void \*memcpy(void \*dest, void \*src, unsigned int count);  
// 原理：由src所指内存区域复制count个字节到dest所指内存区域。  
// 说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。  
//strncpy() 是处理的字符串(遇零结束)，  
//memcpy() 是处理一个缓冲区（void\*类型的），  
//以字串类型的memcpy用法为例：  
//源长<目标长时，第3个参数使用任何一方的size，效果都一样  
//源长>目标长时，第3个参数用sizeof(strSrc)，会造成下标越界，而使目标串溢出，从而导致运行异常  
//                       第3个参数用sizeof(strDest), 末尾字符(\\0)没有被COPY，输出字串会有乱码，  
//                       但不会运行异常，如果不考虑完整性，可以使用strDest\[sizeof(strDest)-1\]=0截取前半部  
//使用原则总结：1)保证源长<目标长；2)第3个参数推荐使用sizeof(strDest) 另外如果字串是指针要考虑一下sizeof的副作用

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

void main()  
\{  
char szSrc\_shorter\[\] = "Good";  
char szSrc\_longer\[\] = "Have a Good Day!";  
char szDest\[10\];

cout<<"char szSrc\_shorter\[\] = \\"Good\\";"<<endl;  
cout<<"char szSrc\_longer\[\] = \\"Have a Good Day!\\";"<<endl;  
cout<<"char szDest\[10\];"<<endl<<endl;

memcpy(szDest, szSrc\_shorter, sizeof(szSrc\_shorter));//<=>  
//memcpy(szDest, szSrc\_shorter, sizeof(szDest));   
cout<<"\[OK\] memcpy(szDest, szSrc\_shorter, sizeof(szSrc\_shorter));";  
cout<<"<=>\\n\[OK\] memcpy(szDest, szSrc\_shorter, sizeof(szDest));\\nszDest\[0~20\] = \\n";  
for (int i = 0; i < 20; i++)  
   cout<<szDest\[i\]<<", ";  
cout<<endl<<"szDest = "<<szDest<<endl;

memcpy(szDest, szSrc\_longer, sizeof(szDest));  
cout<<"\\n\[OK\] memcpy(szDest, szSrc\_longer, sizeof(szDest));\\nszDest\[sizeof(szDest) - 1\] = 0; \\nszDest\[0~20\] = \\n";  
szDest\[sizeof(szDest) - 1\] = 0;  
for (int i = 0; i < 20; i++)  
   cout<<szDest\[i\]<<", ";  
cout<<endl<<"szDest = "<<szDest<<endl;

memcpy(szDest, szSrc\_longer, sizeof(szSrc\_longer));  
cout<<"\\n\[NG\] memcpy(szDest, szSrc\_longer, sizeof(szSrc\_longer));\\nszDest\[sizeof(szDest) - 1\] = 0; \\nszDest\[0~20\] = \\n";  
szDest\[sizeof(szDest) - 1\] = 0;  
for (int i = 0; i < 20; i++)  
   cout<<szDest\[i\]<<", ";  
cout<<endl<<"szDest = "<<szDest<<endl;

\}  
  
  
输出：（NG部分的输出没有意义，可以不看)：  
  
char szSrc\_shorter\[\] = "Good";  
char szSrc\_longer\[\] = "Have a Good Day!";  
char szDest\[10\];

\[OK\] memcpy(szDest, szSrc\_shorter, sizeof(szSrc\_shorter));<=>  
\[OK\] memcpy(szDest, szSrc\_shorter, sizeof(szDest));  
szDest\[0~20\] =  
G, o, o, d, , ?.....?(15个?)  
  
szDest = Good

\[OK\] memcpy(szDest, szSrc\_longer, sizeof(szDest));  
szDest\[sizeof(szDest) - 1\] = 0;  
szDest\[0~20\] =  
H, a, v, e, , a, , G, o, , ? ...?(10个?)  
  
szDest = Have a Go

\[NG\] memcpy(szDest, szSrc\_longer, sizeof(szSrc\_longer));  
szDest\[sizeof(szDest) - 1\] = 0;  
szDest\[0~20\] =  
H, a, v, e, , a, , G, o, , d, , D, a, y, !, , ? ? ?  
szDest = Have a Go

转载于:https://my.oschina.net/alphajay/blog/28721