strcpy和memcpy内存覆盖还敢用吗？

kevinyu723 2015-02-07 12:23:46
既然存在内存覆盖的可能性，并且具有随机性，在真正的项目中，这两个函数还能用吗？或者什么情况下用，就不担心内存覆盖吗？虽然memcpy有memmove可以替换，但是strcpy并没有可以替换的，即使是采用临时变量来转存，但是也是无法确认是否有内存重叠。
...全文
498 15 打赏 收藏 转发到动态 举报
写回复
用AI写文章
15 条回复
切换为时间正序
请发表友善的回复…
发表回复
赵4老师 2015-02-10
  • 打赏
  • 举报
 回复
在你要看Release版对应汇编指令的那句C函数前临时加DebugBreak();，重新编译链接，成功后按F5开始调试，当程序停在DebugBreak();这句时，按Alt+8打开汇编窗口，查看其后的汇编指令。 一般人我不告诉他！ 计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！
赵4老师 2015-02-09
  • 打赏
  • 举报
 回复
引用 10 楼 zhao4zhong1 的回复:
因为 copy的语义是操作后新目标和旧源内容相同且旧源的内容保持不变。 move的语义是操作后新目标和旧源内容相同且旧源的内容不一定保持不变。 所以 在源和目标内存覆盖的情况下，根本不可能实现copy！只能实现move
如果连这两者的语义都分不清的码农非要在不可能实现copy的情况下使用copy，那只能后果自负了！
luciferisnotsatan 2015-02-09
  • 打赏
  • 举报
 回复
引用 9 楼 layershow 的回复:
我想楼主的问题不是越界应该是 char * p = malloc(1024); memcpy(p + 2, p, 500); strcpy(p + 2, p); 对于重叠，开发人员应该非常清楚，所谓的“随机性"就是你无法确定 dst 的值 比如 "abcdefg" 按字节处理 memcpy(p + 2, p, 8) 可能会变成 "abababab" 但是某些优化的 memcpy 可能按 4 字节拷贝，你就很难想象最终结果是什么 库函数的实现不是唯一的，所以结果是一个不可定义的 开发人员理解库函数能更好的使用，但是不要惧怕使用
不然还要考虑敢不敢用指针了。
赵4老师 2015-02-09
  • 打赏
  • 举报
 回复
因为 copy的语义是操作后新目标和旧源内容相同且旧源的内容保持不变。 move的语义是操作后新目标和旧源内容相同且旧源的内容不一定保持不变。 所以 在源和目标内存覆盖的情况下，根本不可能实现copy！只能实现move
layershow 2015-02-09
  • 打赏
  • 举报
 回复
我想楼主的问题不是越界应该是 char * p = malloc(1024); memcpy(p + 2, p, 500); strcpy(p + 2, p); 对于重叠，开发人员应该非常清楚，所谓的“随机性"就是你无法确定 dst 的值 比如 "abcdefg" 按字节处理 memcpy(p + 2, p, 8) 可能会变成 "abababab" 但是某些优化的 memcpy 可能按 4 字节拷贝，你就很难想象最终结果是什么 库函数的实现不是唯一的，所以结果是一个不可定义的 开发人员理解库函数能更好的使用，但是不要惧怕使用
kevinyu723 2015-02-09
  • 打赏
  • 举报
 回复
引用 7 楼 zjq9931 的回复:
[quote=引用 6 楼 kaiandshan 的回复:] 不好意思，都是“随机性”这个词惹的祸，如果des和src指向不同的空间，这些函数都可以使用；如果指向同一段内存，就会存在空间覆盖的问题，这种情况在函数使用者看来也是可以预见的。
动态分配的内存在堆中，比较难预见。 如果是编写的时候定义好的，在栈区的内存，一般会影响这个数组后面的变量的值。如果覆盖的更多。那就是黑客攻击的范畴了。[/quote] 是的，这些问题如果在定义或者申请的时候保证空间足够大，就不会产生覆盖的问题。
kevinyu723 2015-02-09
  • 打赏
  • 举报
 回复
引用 9 楼 layershow 的回复:
我想楼主的问题不是越界应该是 char * p = malloc(1024); memcpy(p + 2, p, 500); strcpy(p + 2, p); 对于重叠，开发人员应该非常清楚，所谓的“随机性"就是你无法确定 dst 的值 比如 "abcdefg" 按字节处理 memcpy(p + 2, p, 8) 可能会变成 "abababab" 但是某些优化的 memcpy 可能按 4 字节拷贝，你就很难想象最终结果是什么 库函数的实现不是唯一的，所以结果是一个不可定义的 开发人员理解库函数能更好的使用，但是不要惧怕使用
是的，说的正是我所讲的。原来memcpy也会存在优化的问题，我说呢在测试memcpy重叠覆盖的问题时，怎么一直不按照一个一个字节来覆盖，比如输入abcdefg,结果是abababab，可时间结果是ababcdefefg....正在郁闷呢。再请教下，怎么看编译器的优化方式呢？
kevinyu723 2015-02-09
  • 打赏
  • 举报
 回复
引用 12 楼 zhao4zhong1 的回复:
[quote=引用 10 楼 zhao4zhong1 的回复:] 因为 copy的语义是操作后新目标和旧源内容相同且旧源的内容保持不变。 move的语义是操作后新目标和旧源内容相同且旧源的内容不一定保持不变。 所以 在源和目标内存覆盖的情况下，根本不可能实现copy！只能实现move
如果连这两者的语义都分不清的码农非要在不可能实现copy的情况下使用copy，那只能后果自负了！[/quote] 是的，这种情况直接使用move就可以避免了，不用考虑覆盖的可能性了。
蠓虫带着秤砣飞 2015-02-08
  • 打赏
  • 举报
 回复
引用 6 楼 kaiandshan 的回复:
不好意思，都是“随机性”这个词惹的祸，如果des和src指向不同的空间，这些函数都可以使用；如果指向同一段内存，就会存在空间覆盖的问题，这种情况在函数使用者看来也是可以预见的。
动态分配的内存在堆中，比较难预见。 如果是编写的时候定义好的，在栈区的内存，一般会影响这个数组后面的变量的值。如果覆盖的更多。那就是黑客攻击的范畴了。
kevinyu723 2015-02-08
  • 打赏
  • 举报
 回复
不好意思，都是“随机性”这个词惹的祸，如果des和src指向不同的空间，这些函数都可以使用；如果指向同一段内存，就会存在空间覆盖的问题，这种情况在函数使用者看来也是可以预见的。
蠓虫带着秤砣飞 2015-02-08
  • 打赏
  • 举报
 回复
楼主的意思是，会越界吧？越界确实会改变其他内容的值，甚至改变程序的代码。那啥，黑客经常用这种方式进行攻击。 VC有提供安全的函数。 可以查到。前面几楼也已经说过了。
relaxisland 2015-02-07
  • 打赏
  • 举报
 回复
不都在用吗 strcpy，写的时候应该知道你操作的对象是否可能重叠啊。 也可以用 strncpy版本，可以指定要拷贝的字符串的最大长度， 确保你准备的 目标内存足够大
lin5161678 2015-02-07
  • 打赏
  • 举报
 回复
存在覆盖 但谁告诉你覆盖有什么随机性? a = 99; a原来的数据被覆盖了 ? 但 哪里来的毛线随机性?
你怎么了熊吉 2015-02-07
  • 打赏
  • 举报
 回复
晕，随机性不是说不知道会不会覆盖 随机性是说覆盖以后不知道会发生什么 而覆不覆盖，是你可以通过仔细来避免的
帅得不敢出门 2015-02-07
  • 打赏
  • 举报
 回复
这种情况可由写代码的人杜绝。
C/C++面试之算法系列－－几个典型的内存拷贝及字符串函数实现
C/C++面试之算法系列－－几个典型的内存拷贝及字符串函数实现 写一个函数，完成内存之间的拷贝。[考虑问题是否全面，是否考虑内存重叠问题] 返回void *支持链式操作，参数类型是void *以支持任意类型的指针，输入参数加上const修饰，最好加上assert对输入输出指针进行非NULL判断 void* memcpy( void *dest, const void *src, size_t count ) { char* pdest = static_cast( dest ); const char* psrc = static_cast( src ); // 依次从前拷贝，目的地址覆盖了源地址的数，此时从后往前拷贝 if( (pdest>psrc) && (pdest<(psrc+count))) //能考虑到这种情况就行了 { for( size_t i=count-1; i!=-1; --i ) pdest[i] = psrc[i]; } else { for( size_t i=0; imemcpy( str+1, str+0, 9 ); cout << str << endl; memcpy( str, str+5, 5 ); cout << str << endl; system( "Pause" ); return 0; // 0012345678 // 4567845678 } strcmp(): Int simple_strcmp (const char *s1, const char *s2) { int ret; while ((ret = *(unsigned char *) s1 - *(unsigned char *) s2++) == 0 && *s1++); return ret; } memcmp()： int simple_memcmp (const char *s1, const char *s2, size_t n) { int ret = 0; while (n--&& (ret = *(unsigned char *) s1++ - *(unsigned char *) s2++) == 0); return ret; } strcmp只判断s1的‘/0’，没有长度的控制；memcmp有长度参数n的控制 memcpy()： char *simple_memcpy (char *dst, const char *src, size_t n) { char *ret = dst; while (n--) *dst++ = *src++; return ret; } 直接的内存之间的copy，不处理内存重叠的情况。 strcpy()： char *simple_strcpy (char *dst, const char *src) { char *ret = dst; while ((*dst++ = *src++) != '\0'); //相当简约，一句话即搞定 return ret; } 与memcpy区别就是对'\0'作为结束符 strncpy(): char *simple_strncpy (char *dst, const char *src, size_t n) { char *ret = dst; while (n--) { if ((*dst++ = *src++) == '\0') { while (n--) *dst++ = '\0'; return ret; } } return ret; } n和‘\0'都作为结束的控制符。如果n过大，则后面全补'\0'
最新名企标准通用C++面试题，
C++面试题 参考：http://blog.csdn.net/Ghost90/archive/2009/04/22/4099672.aspx 整理：松鼠 时间：2009-5-8 1、const 有什么用途？（请至少说明两种） 答： （1）可以定义 const 常量 （2）const可以修饰函数的参数、返回值，甚至函数的定义体。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。 2、在C++ 程序中调用被 C编译器编译后的函数，为什么要加 extern “C”？ 答：C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名字与C语言的不同。假设某个函数的原型为： void foo(int x, int y); 该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。 C++提供了C连接交换指定符号extern“C”来解决名字匹配问题。 3、请简述以下两个for循环的优缺点（5分） for (i=0; i内存的思考题 void GetMemory(char *p) { p = (char *)malloc(100); } void Test(void) { char *str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); } 请问运行Test函数会有什么样的结果？ 答：程序崩溃。 因为GetMemory并不能传递动态内存， Test函数中的 str一直都是 NULL。 strcpy(str, "hello world");将使程序崩溃。 char *GetMemory(void) { char p[] = "hello world"; return p; } void Test(void) { char *str = NULL; str = GetMemory(); printf(str); } 请问运行Test函数会有什么样的结果？ 答：可能是乱码。 因为GetMemory返回的是指向“栈内存”的指针，该指针的地址不是 NULL，但其原现的内容已经被清除，新内容不可知。 void GetMemory2(char **p, int num) { *p = (char *)malloc(num); } void Test(void) { char *str = NULL; GetMemory(&str, 100); strcpy(str, "hello"); printf(str); } 请问运行Test函数会有什么样的结果？ 答： （1）能够输出hello （2）内存泄漏 void Test(void) { char *str = (char *) malloc(100); strcpy(str, “hello”); free(str); if(str != NULL) { strcpy(str, “world”); printf(str); } } 请问运行Test函数会有什么样的结果？ 答：篡改动态内存区的内容，后果难以预料，非常危险。 因为free(str);之后，str成为野指针， if(str != NULL)语句不起作用。 5、编写strcpy函数（10分） 已知strcpy函数的原型是 char *strcpy(char *strDest, const char *strSrc); 其中strDest是目的字符串，strSrc是源字符串。 （1）不调用C++/C的字符串库函数，请编写函数 strcpy char *strcpy(char* strDest, const char* strSrc) { assert((strDest!=NULL) && (strSrc !=NULL));//2分 char *address = strDest;//2分 while( (*strDest++ = * strSrc++) != ‘\0’ )//2分 NULL; return address;// 2分 } 5.1 strcpy能把strSrc的内容复制到strDest，为什么还要char * 类型的返回值？ 答：为了实现链式表达式。 // 2分 例如int length = strlen( strcpy( strDest, "hello world") ); 6、编写类String的构造函数、析构函数和赋值函数（25分） 已知类String的原型为： class String { public: String(const char *str = NULL);//普通构造函数 String(const String &other);//拷贝构造函数 ~ String(void);// 析构函数 String & operate =(const String &other);// 赋值函数 private: char* m_data;// 用于保存字符串 }; 请编写String的上述4个函数。 标准答案： // String的析构函数 String::~String(void) // 3分 { delete [] m_data; // 由于m_data是内部数据类型，也可以写成delete m_data; } // String的普通构造函数 String::String(const char *str) // 6分 { if(str==NULL) { m_data = new char[1]; // 若能加NULL 判断则更好 *m_data = ‘\0’; } else { int length = strlen(str); m_data = new char[length+1]; // 若能加NULL 判断则更好 strcpy(m_data, str); } } // 拷贝构造函数 String::String(const String &other) // 3分 { int length = strlen(other.m_data); m_data = new char[length+1]; // 若能加NULL 判断则更好 strcpy(m_data, other.m_data); } // 赋值函数 String & String::operate =(const String &other) // 13分 { // (1) 检查自赋值 // 4分 if(this == &other) return *this; // (2) 释放原有的内存资源 // 3分 delete [] m_data; // （）分配新的内存资源，并复制内容// 3分 int length = strlen(other.m_data); m_data = new char[length+1]; // 若能加NULL 判断则更好 strcpy(m_data, other.m_data); // （）返回本对象的引用 // 3分 return *this; } 7、实现双向链表删除一个节点P，在节点P后插入一个节点，写出这两个函数。 void DeleteNode(DuNode *p) { p->prior->next=p->next; p->next->prior=p->prior; } void InsertNode(DuNode *p, DuNode *s)//Node "s" is inserted after "p" { s->next=p->next; p->next->prior=s; p->next=s; s->prior=p; } 8、Windows程序的入口是哪里？写出Windows消息机制的流程。 WINDOWS入口是WinMain函数 消息机制的流程： 系统中发生了某个事件 Windows把这个事件翻译为消息，然后把它放到消息队列中 1. 应用程序从消息队列中接收到这个消息，把它存放在TMsg记录中 2. 应用程序把消息传递给一个适当的窗口的窗口过程 3. 窗口过程响应这个消息并进行处理 9．写一个函数，将其中的\t都转换成4个空格。 #include using namespace std; char* Convert_t(char *des,char *src) { char *temp; des=new char[100]; temp=des; while(*src!='\0') { if(*src=='\t') { src++; *des++=' '; *des++=' '; *des++=' '; *des++=' '; continue; } *des++=*src++; } *des='\0'; des=temp; return des; } int main() { char *t="asdf\tasd\tasasddas\\tdfasdf",*d; cout< using namespace std; char *des=new char[100]; //全局变量的动态空间申请在程序运行之后，main运行之前完成。所以不是所有的动作都是main引起的。 int main() { char *des="abc"; cout<strcpy ( tmp, pStr + n ); strcpy ( tmp + steps, pStr); *( tmp + strlen ( pStr ) ) = '\0'; strcpy( pStr, tmp ); } 正确解答2： void LoopMove(char* pStr,int steps ) { int n = strlen( pStr ) - steps; char tmp[MAX_LEN]; memcpy( tmp, pStr + n, steps ); memcpy(pStr + steps, pStr, n ); memcpy(pStr, tmp, steps ); } 14、写出输出结果 void fun(char s[10]) { char a[10]; cout<<"a:"<内存的分配方式的分配方式有几种? 答: 1. 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量。 2. 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 3. 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。 16.是不是一个父类写了一个virtual 函数，如果子类覆盖它的函数不加virtual ,也能实现多态? 答：virtual修饰符会被隐形继承的。private 也被集成，只事派生类没有访问权限而已。virtual可加可不加。子类的空间里有父类的所有变量(static除外)。同一个函数只存在一个实体(inline除外)。子类覆盖它的函数不加virtual ,也能实现多态。在子类的空间里，有父类的私有变量。私有变量不能直接访问。 17.进程间通信的方式有? 进程间通信的方式有 共享内存， 管道 ，Socket ，消息队列 , DDE等 18.C++中什么数据分配在栈或堆中，New分配数据是在近堆还是远堆中？ 答：栈: 存放局部变量，函数调用参数,函数返回值，函数返回地址。由系统管理 堆: 程序运行时动态申请，new 和　malloc申请的内存就在堆上 (Google搜)：DOS下程序是独占方式，堆分为近堆和远堆，近堆和栈是在数据段开辟的同一块内存地址，栈从下往上增长，堆从上向下分配，中间没有规定分界线，所以程序控制不当，如深层次的递归，大量的动态地址分配很容易造成堆栈冲突，即堆栈地址重叠，从而造成死机和程序运行异常。堆和栈连在一起说的原因就是如此。至于远堆则是指在数据段和代码段以外计算机所有没有使用的剩余基本内存。Windows采用的是虚拟地址，内存分配方式就不一样了 补充：DOS下堆栈的分配是由程序而不是操作系统自己控制的，具体分配大小、方式随编译系统、程序模式不同而异。C语言的堆栈分配代码在启动代码中. 19.全局变量和局部变量在内存中是否有区别？如果有，是什么区别？ 全局变量储存在静态数据库，局部变量在堆栈。 20.TCP/IP 建立连接的过程?(3-way shake) 答：在TCP/IP协议中，TCP协议提供可靠的连接服务，采用三次握手建立一个连接。 第一次握手：建立连接时，客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认； 第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态； 第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。 21.winsock建立连接的主要实现步骤? 答：服务器端：socker()建立套接字，绑定（bind）并监听（listen），用accept（）等待客户端连接。 客户端：socker()建立套接字，连接（connect）服务器，连接上后使用send()和recv（），在套接字上写读数据，直至数据交换完毕，closesocket()关闭套接字。 服务器端：accept（）发现有客户端连接，建立一个新的套接字，自身重新开始等待连接。该新产生的套接字使用send()和recv（）写读数据，直至数据交换完毕，closesocket()关闭套接字。 22.static有什么用途？（请至少说明两种） 1) 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。 3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用 23.引用与指针有什么区别？ 1) 引用必须被初始化，指针不必。 2) 引用初始化以后不能被改变，指针可以改变所指的对象。 3) 不存在指向空值的引用，但是存在指向空值的指针。 24、请写出下列代码的输出内容 #include main() { int a,b,c,d; a=10; b=a++; c=++a; d=10*a++; printf("b，c，d：%d，%d，%d"，b，c，d); return 0; } 答：10，12，120 main() { int a[5]={1,2,3,4,5}; int *ptr=(int *)(&a+1); printf("%d,%d",*(a+1),*(ptr-1)); } 输出：2,5 *(a+1）就是a[1]，*(ptr-1)就是a[4],执行结果是2，5 &a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int） int *ptr=(int *)(&a+1); 则ptr实际是&(a[5]),也就是a+5 原因如下： &a是数组指针，其类型为 int (*)[5]; 而指针加1要根据指针类型加上一定的值， 不同类型的指针+1之后增加的大小不同 a是长度为5的int数组指针，所以要加 5*sizeof(int) 所以ptr实际是a[5] 但是prt与(&a+1)类型是不一样的(这点很重要) 所以prt-1只会减去sizeof(int*) a,&a的地址是一样的，但意思不一样，a是数组首地址，也就是a[0]的地址，&a是对象（数组）首地址，a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的地址，即a[5]
《C语言基础》 之 第9章 字符串
课程内容：字符数组1、字符串越位的问题、指针变量的空间大小、字符串常量、字符串传参、printf格式化输出字符串、字符串的非格式化输出函数、字符串输入函数、strlen函数、strcpy函数和strncpy函数、strcmp函数和strncmp函数、strcat函数和strncat函数。
C/C++面试题目及解答.doc
看看格式，再看看大小，应该看出它的含金量，200多页吧，不多。
部分：
1.多态类中的虚函数表是Compile-Time，还是Run-Time时建立的?
答案：虚拟函数表是在编译期就建立了,各个虚拟函数这时被组织成了一个虚拟函数的入口地址的数组.而对象的隐藏成员--虚拟函数表指针是在运行期--也就是构造函数被调用时进行初始化的,这是实现多态的关键.

2.将一个 1M -10M 的文件，逆序存储到另一个文件，就是前一个文件的最后一个
字符存到新文件的第一个字符，以此类推。

3.main主函数执行完毕后，是否可能会再执行一段代码?（朗讯的一道笔试题）
答案：可以，可以用_onexit 注册一个函数，它会在main 之后执行;
如果你需要加入一段在main退出后执行的代码，可以使用atexit()函数，注册一个函数。
语法：
#include
int atexit(void (*function")(void));
#include
#include
void fn1( void ), fn2( void ), fn3( void ), fn4( void );
int main( void )
{
atexit( fn1 );
atexit( fn2 );
atexit( fn3 );
atexit( fn4 );
printf( "This is executed first.\n" );
}
void fn1()
{
printf( "next.\n" );
}
void fn2()
{
printf( "executed " );
}
void fn3()
{
printf( "is " );
}
void fn4()
{
printf( "This " );
}
结果：
This is executed first.
This is executed next.

4.一个父类写了一个virtual 函数，如果子类覆盖它的函数不加virtual ,也能实现多态?
在子类的空间里，有没有父类的这个函数，或者父类的私有变量? (华为笔试题）
答案：只要基类在定义成员函数时已经声明了virtue关键字，在派生类实现的时候覆盖该函数时，virtue关键字可加可不加，不影响多态的实现。子类的空间里有父类的所有变量(static除外)。

5.给一个字符串、例如 “ababc”要求返回“ab”. 因为“ab”连续重复出现且最长。
用C/C＋＋语言写一函数完成该算法，给出复杂度

6.对序列1、1、2、3、5、8、13。。。。 是Fab..数列
2、3、5、13...是Fab..质数数列，因为他们与自己前面的Fab...数列都互质
给出k，返回第k小的Fab..质数

7.101个硬币100真、1假，真假区别在于重量。请用无砝码天平称两次给出真币重还是假币
重的结论。

8.完成字符串拷贝可以使用 sprintf、strcpy 及 memcpy 函数，请问这些函数有什么区别
，你喜欢使用哪个，为什么？
答案：这些函数的区别在于 实现功能 以及 操作对象 不同。
1.strcpy 函数操作的对象是 字符串，完成 从 源字符串 到 目的字符串 的 拷贝 功能。
2.snprintf 函数操作的对象不限于字符串：虽然目的对象是字符串，但是源对象可以是字符串、也可以是任意基本类型的数据。这个函数主要用来实现（字符串或基本数据类型）向字符串的转换功能。如果源对象是字符串，并且指定 %s 格式符，也可实现字符串拷贝功能。
3.memcpy 函数顾名思义就是 内存拷贝，实现 将一个 内存块 的内容复制到另一个 内存块 这一功能。内存块由其首地址以及长度确定。程序中出现的实体对象，不论是什么类型，其最终表现就是在内存中占据一席之地（一个内存区间或块）。因此，memcpy 的操作对象不局限于某一类数据类型，或者说可 适用于任意数据类型，只要能给出对象的起始地址和内存长度信息、并且对象具有可操作性即可。鉴于 memcpy 函数等长拷贝的特点以及数据类型代表的物理意义，memcpy 函数通常限于同种类型数据或对象之间的拷贝，其中当然也包括字符串拷贝以及基本数据类型的拷贝。

对于字符串拷贝来说，用上述三个函数都可以实现，但是其实现的效率和使用的方便程度不同：
• strcpy 无疑是最合适的选择：效率高且调用方便。
• snprintf 要额外指定格式符并且进行格式转化，麻烦且效率不高。
• memcpy 虽然高效，但是需要额外提供拷贝的内存长度这一参数，易错且使用不便；并且如果长度指定过大的话（最优长度是源字符串长度 + 1），还会带来性能的下降。其实 strcpy 函数一般是在内部调用 memcpy 函数或者用汇编直接实现的，以达到高效的目的。因此，使用 memcpy 和 strcpy 拷贝字符串在性能上应该没有什么大的差别。
对于非字符串类型的数据的复制来说，strcpy 和 snprintf 一般就无能为力了，可是对 memcpy 却没有什么影响。但是，对于基本数据类型来说，尽管可以用 memcpy 进行拷贝，由于有赋值运算符可以方便且高效地进行同种或兼容类型的数据之间的拷贝，所以这种情况下 memcpy 几乎不被使用。memcpy 的长处是用来实现（通常是内部实现居多）对结构或者数组的拷贝，其目的是或者高效，或者使用方便，甚或两者兼有。
9.变量的声明和定义有什么区别？
10.请写出下面代码在 32 位平台上的运行结果，并说明 sizeof 的性质：
#include
#include

int main(void)
{
char a[30];
char *b = (char *)malloc(20 * sizeof(char));
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(b));
printf("%d\n", sizeof(a[3]));
printf("%d\n", sizeof(b+3));
printf("%d\n", sizeof(*(b+4)));
return 0 ;
}

12.请完成以下题目。注意，请勿直接调用 ANSI C 函数库中的函数实现。
a)请编写一个 C 函数，该函数给出一个字节中被置 1 的位的个数，并请给出该题的至少一个不同解法。
第一种unsigned int TestAsOne0(char log)
{
int i;
unsigned int num=0, val;
for(i=0; i<8; i++)
{
val = log >> i; //移位
val &= 0x01; //与1相与
if(val)
num++;
}
return num;
}
第二种unsigned int TestAsOne1(char log)
{
int i;
unsigned int num=0, val;
for(i=0; i<8; i++)
{
val = (~log) >> i; //反码？
val &= 0x00; //与0相与
if(!val)
num++;
}
return num;
}
b)请编写一个 C 函数，该函数将给定的一个字符串转换成整数。
int Invert(char *str)
{
int num=0;
while(*str!='\0')
{
int digital=*str-48;
num=num*10+digital;
str=str+1;
}
return num;
}
c)请编写一个 C 函数，该函数将给定的一个整数转换成字符串。
void IntToCharChange(int num, char* pval)
{
char strval[100];
int i, j;
int val0 = 0;
int val1 = 0;

val0 = num;
for(i=0; i<100; i++)
{
val1 = val0 % 10; //取余
val0 = val0 / 10; //取整
strval[i] = val1 + 48; //数字—字符
if(val0 < 10)
{
i++;
strval[i] = val0 + 48;
break;
}
}
for(j=0; j<=i; j++) //倒置
{
pval[j] = strval[i-j];
}
pval[j] = '\0';
}
d)请编写一个 C 函数，该函数将一个字符串逆序。
void AntitoneValue(char* father, char* child)
{
int i;
char source[100];
int j = 0;

while(father[j]) //放入source，[j]为长度
{
source[j] = father[j];
j++;
if(j > 99)
{
return;
}
}
source[j] = '\0';

for(i=0; i {
child[i] = source[j-i-1]; //反序
}
child[i] = '\0';
}

e)请编写一个 C 函数，该函数在给定的内存区域搜索给定的字符，并返回该字符所在位置索引值。
int search(char *cpSource, int n, char ch) //起始地址，搜索长度，目标字符
{
int i;
for(i=0; ireturn i;
}
f)请编写一个 C 函数，该函数在一个字符串中找到可能的最长的子字符串，该字符串是由同一字符组成的。
int ChildString(char*p) //自己写
{
Char *q=p;
int stringlen=0, i=0,j=1,len=0,maxlen=1;
while(*q!=’\0’) //不能用strlen,求得长度stringlen
{
Stringlen++;
q++;
}
while( i< Stringlen )
{
if(*(p+i)==*(p+j)&&j< Stringlen)
{
len++; //统计子串长度
i++;
j++;
}
else
{
if(len>maxlen) //统计最大子串长度
{
maxlen=len+1;
len=0;
}
else {
len=0;
}
i++;
j++;

}
}
return maxlen;
}
给出演示上述函数功能的一个简单程序，并请编写对应的 Makefile 文件

……
……
……
……
C和C++语言学习总结
知识结构: if,for,switch,goto ；#define,const ；文件拷贝的代码,动态生成内存,复合表达式,strcpy,memcpy,sizeof ；函数参数传递,内存分配方式,内存错误表现,malloc与new区别 ；类重载、隐藏与覆盖区别,extern问题,函数参数的缺省值问题,宏代码与内联函数区别；构造和析构的次序,String函数定义。
C语言

69,377

社区成员

243,076

社区内容

发帖
与我相关
我的任务
社区描述
C语言相关问题讨论
社区管理员
  • C语言
  • 花神庙码农
  • 架构师李肯
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章