strcpy和memcpy的区别

strcpy和memcpy都是标准C库函数，它们有下面的特点。

strcpy提供了字符串的复制。即strcpy只用于字符串复制，并且它不仅复制字符串内容之外，还会复制字符串的结束符。

已知strcpy函数的原型是：char* strcpy(char* dest, const char* src);
memcpy提供了一般内存的复制。即memcpy对于需要复制的内容没有限制，因此用途更广。
void *memcpy( void *dest, const void *src, size_t  count );

 

char* strcpy(char* dst,const char* src) 　 {       if((dst == NULL) && (src == NULL))    //assert( (dest != NULL) && (src != NULL) );       return NULL;   char* tempdst=dst; 　while((*dst++ = *src++)!='\0');    // 赋值表达式返回左操作数   　 return tempdest; } void *memcpy(void *dst,const void *src, size_t size) { 　　if((dst == NULL) || (src == NULL))       // 必须有效           return NULL; 　　char *tempsrc = (char *)src;              //保存src首地址 　　char *tempdst = (char *)dst;                 //保存dst首地址      　　while(size -- > 0)                   //循环size次，复制src的值到dst中        　　*tempdst++ = *tempsrc++ ;   　　return dst; }

strcpy和memcpy主要有以下3方面的区别。
1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。
2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。
3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy 

 

 memcpy和memmove区别：

1、当内存发生局部重叠的时候，memmove保证拷贝的结果是正确的，memcpy不保证拷贝的结果的正确。但memcopy比memmove的速度要快一些.

2、对于库函数来说，由于没有办法知道传递给他的内存区域的情况，所以应该使用memmove()函数。通过这个函数，可以保证不会出现任何内存块重叠问题。而对于应用程序来说，因为代码“知道”两个内存块不会重叠，所以可以安全地使用memcpy()函数。

=======================================================

内存重叠：拷贝的目的地址在源地址范围内。

 

内存重叠环境的例子：

int main()

{char *p = NULL;

 p=(char*)malloc(100);

 memcpy(p,"123456789",strlen("123456789"));   //会等到错误的结果，有一个长度参数，只能拷贝cnt个

                       //字节就结束了

 printf("before p =%s\n",p);

 strcpy(p+1,p);           //注意：这里重叠了，而strcpy是根据判断原串中的'\0'

 printf("after p =%s\n",p);

free(p);

}

 

========================================================

atoi()函数

atoi():int atoi(const char *str );

功能：把字符串转换成整型数。

str：要进行转换的字符串

返回值：每个函数返回 int 值，此值由将输入字符作为数字解析而生成。 如果该输入无法转换为该类型的值，则atoi的返回值为 0。

说明：当第一个字符不能识别为数字时，函数将停止读入输入字符串。

 

 

[cpp] view plain copy

1. #include<iostream>  
2.   
3. using namespace std;  
4.   
5. int atoi_my(const char *str)  
6. {  
7.     int s=0;  
8.     bool falg=false;  
9.       
10.     while(*str==' ')        //字符串前的空白
11.     {  
12.         str++;  
13.     }  
14.   
15.     if(*str=='-'||*str=='+')     //字符串所表示数值的正负号,正号，指针指向下一个字符,负号，则置flag为true
16.     {  
17.         if(*str=='-')  
18.             falg=true;  
19.         str++;  
20.     }  
21.   
22.     while(*str>='0'&&*str<='9')     // 把数字字符串逐个转换成整数 
23.     {  
24.         s=s*10+*str-'0';  
25.         str++;  
26.         if(s<0)  
27.         {  
28.             s=2147483647;    //考虑溢出
29.             break;  
30.         }  
31.     }  
32.     return s*(falg?-1:1);   
33. }  
34.   
35. int main()  
36. {  
37.     char *s1="333640";  
38.     char *s2="-12345";  
39.     char *s3="123.3113";  
40.     char *s4="-8362865623872387698";  
41.     char *s5="+246653278";  
42.   
43.   
44.     int sum1=atoi(s1);  
45.     int sum_1=atoi_my(s1);  
46.   
47.     int sum2=atoi(s2);  
48.     int sum_2=atoi_my(s2);  
49.   
50.     int sum3=atoi(s3);  
51.     int sum_3=atoi_my(s3);  
52.   
53.     int sum4=atoi(s4);  
54.     int sum_4=atoi_my(s4);  
55.   
56.     int sum5=atoi(s5);  
57.     int sum_5=atoi_my(s5);  
58.   
59.     cout<<"atoi:  :"<<sum1<<endl;  
60.     cout<<"atoi_my:"<<sum_1<<endl;  
61.   
62.     cout<<"atoi:  :"<<sum2<<endl;  
63.     cout<<"atoi_my:"<<sum_2<<endl;  
64.   
65.     cout<<"atoi:  :"<<sum3<<endl;  
66.     cout<<"atoi_my:"<<sum_3<<endl;  
67.   
68.     cout<<"atoi:  :"<<sum4<<endl;  
69.     cout<<"atoi_my:"<<sum_4<<endl;  
70.   
71.     cout<<"atoi:  :"<<sum5<<endl;  
72.     cout<<"atoi_my:"<<sum_5<<endl;  
73.   
74.     system("pause");  
75.     return 0;  
76. } 

这是因为s是个int型数据，即使在VC环境下，系统也仅仅给它分配四个字节的内存。它能表示的整数范围为： -2147483648~2147483647（如果是在16位操作系统中，比如你用TC编译环境，int仅占2个字节，表示的范围为：-32768~32767）

当s的值超过int型数据所能表示的最大的2147483647时，就叫做溢出.

（不信你可以做个测试，令s=2147483647，然后输出s+1，你看到的输出结果是一个负值），

溢出以后s会 变成负的（这是因为二进制数据在计算机中以它的补码存放）