关于C语言内存移动函数的写法详解

-------------------------------------------------------------------------------------------

          注：转帖自周立功博客http://blog.sina.com.cn/s/blog_5e8facd20100eorv.html

-------------------------------------------------------------------------------------------

编者按：我们知道，优秀的运动员除了自身的天赋和努力之外，出色的教练必不可少。一个成功的企业除了拥有出类拔萃的员工之外，同样需要一位出色的教练，那就是企业的CEO。由此可见，如果我们要想成为一位优秀的程序员，毫无疑问卓越的教练是致关重要的。无数事实告诉我们，成功者之所以成功，是因为成功地选择导师的缘故。

周立功公司之所以在一定程度上取得了一些成功，绝对不是运气所为，除了不断努力选拔优秀人才之外，且不惜代价投入人力和资本培训员工，更重要的是有效的方法，从而保证了初学者的投入与产出的最佳效果，让具备一定潜质的应届大学生脱颖而出。

优秀与平庸全在一念之间，关键在于你的首次择业而非就业，良好的习惯与平和的心态跟人们的第一份工作和第一位导师有很大的关系。当下的利益固然重要，但从某种程度上来看，机会、环境、远景比眼前利益更重要，因为机会、环境和远景等因素会最大限度地将你锻造成为一个在未来有绝对竞争力的人才。同样是赚钱，你是否参与了公司由默默无闻迈向卓越的过程？你是否收获了更多的快乐？你是否找到了前所未有的成就感？而很多人仅仅赚到了一些钱，幸福而不快乐。

你将希望成为哪一类人，何去何从？最初的选择尤其重要。

------------------------------------------------------------------------------------------      本文是我们训练程序员的系列文章之一，仅供参考！

    这几年在全国巡回招聘应届毕业生的过程中，经常会遇到这样的现象：有些同学对自己的笔试比较满意，可是最后却得不到面试的机会，心里大为不解，颇有“死不瞑目”的味道。那么问题到底出现在哪里呢？让我们来看一个例子，这是我们招聘过程中一道常见的题目。

写一个函数，完成内存移动，并为其写一个简单的测试用例来进行测试。

够简单的吧？有的同学很快就写出了答案，详见程序清单1与程序清单2。

程序清单 1 V0.1版程序

1 2 3 4 5 6 7

void  MyMemMove( char  *dst, char  *src, size_t  count)   {            while (count--)      {          *dst++ = *src++;        } }

程序清单 2 测试用例

1 2 3 4 5 6 7 8 9

void  Test() {     char  p1[256] = ”hello,world!”;     char  p2[256] = {0};          MyMemMove(p2, p1,  strlen (p1));          printf (“%s”,p2); }

客观地讲，相比那些交白卷或者函数声明都不会写的同学来说，能够写出这段代码的同学已经非常不错了，至少在C语言这门课程上已经达到了现行高校的教育目标，但是离企业的用人要求还有一定的距离。我们不妨将上面的程序称为V0.1版本，看看还有没有什么地方可以改进。

 首先我们看看函数声明是否合理，V0.1版的程序将源地址和目的地址都用char *来表示，这样当然也没有什么问题，但是让其他人使用起来却很不方便，假如现在要将count个连续的结构体对象移动到另外一个地方去，如果要使用v0.1的程序的话，正确的写法如下：

 MyMemMove((char *)dst,(char *)src,sizeof(TheStruct)*count)

也就是说我们需要将结构体指针强制转换成char * 才能够正常工作，这样除了字符串以外其它的类型都不可避免地要进行指针强制转换，否则编译器就会呱呱叫，比如在VC++2008下就会出现这样的错误：

 error C2664: 'MyMemMove' : cannot convert parameter 1 from 'TheStruct *' to 'char *'

那么如何解决这个问题呢？其实很简单，我们知道有一种特别的指针，任何类型的指针都可以对它赋值，那就是void *，所以应该将源地址和目的地址都用void*来表示。当然函数体的内容也要作相应的改变，这样我们就得到了V0.2版的程序。

程序清单 3 V0.2版程序

1 2 3 4 5 6 7 8 9

void  MyMemMove( void  *dst,  void  *src,  size_t  count) {     while  (count--)     {        *( char  *)dst = *( char  *)src;        dst = ( char  *)dst + 1;        src = ( char  *)src + 1;     } }

有的同学可能会问，这里面不是还有指针强制转换吗？只不过是换了地方。没错，强制指针转换确实是从使用者的代码转移到了库的代码里，但我们可以将MyMemMove理解为库，而将Test理解为使用者，事实上通过调整之后的效果却有天壤之别，V0.1是一逸永劳，而V0.2是一劳永逸！

还有几个细节需要注意，为了实现链式表达式，我们应该将返回值也改为void *。此外，如果我们不小心将“*(char *)dst = *(char *)src;”写反了，写成“*(char *)src = *(char *)dst;”编译照样通过，而为了找出这个错误又得花费不少时间。注意到src所指向的内容在这个函数内不应该被改变，所有对src所指的内容赋值都应该被禁止，所以这个参数应该用const修饰，如果有类似的错误在编译时就能够被发现：

 error C3892: 'src' : you cannot assign to a variable that is const

作为程序员犯错误在所难免，但是我们可以利用相对难犯错误的机器，也就是编译器来降低犯错误的概率，这样我们就得到了V0.3版的程序。

程序清单 4 V0.3版程序

1 2 3 4 5 6 7 8 9 10 11 12 13

void  * MyMemMove( void  *dst,  const  void  *src,  size_t  count) {      void  *ret=dst;            while  (count--)      {         *( char  *)dst = *( char  *)src;         dst = ( char  *)dst + 1;         src = ( char  *)src + 1;      }            return  ret; }

现在再来考虑这样一种情况，有使用者这样调用库：MyMemMove(NULL,src, count)，这是完全可能的，因为一般来说这些地址都是程序计算出来的，那就难免会算错，出现零地址或者其它的非法地址也不足为奇。可以预料的是，如果出现这种情况的话，则程序马上就会down掉，更糟糕的是你不知道错误出在哪里，于是不得不投入大量的精力在浩瀚的代码中寻找bug。解决这类问题的通用办法是对输入参数作合法性检查，也就是V0.4版程序。

 

程序清单 5 V0.4版程序

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

void  * MyMemMove( void  *dst,  const  void  *src,  size_t  count) {      void  *ret=dst;            if  (NULL==dst || NULL ==src)      {          return  dst;      }      while  (count--)      {          *( char  *)dst = *( char  *)src;          dst = ( char  *)dst + 1;          src = ( char  *)src + 1;      }      return  ret; }

 上面之所以写成“if (NULL==dst||NULL ==src)”而不是写“if (dst == NULL || src == NULL)”，也是为了降低犯错误的概率。我们知道，在C语言里面“==”和“=”都是合法的运算符，如果我们不小心写成了“if (dst = NULL || src = NULL)”还是可以编译通过，而意思却完全不一样了，但是如果写成“if (NULL=dst||NULL =src)”，则编译的时候就通不过了，所以我们要养成良好的程序设计习惯：常量与变量作条件判断时应该把常量写在前面。

V0.4版的代码首先对参数进行合法性检查，如果不合法就直接返回，这样虽然程序dwon掉的可能性降低了，但是性能却大打折扣了，因为每次调用都会进行一次判断，特别是频繁的调用和性能要求比较高的场合，它在性能上的损失就不可小觑。

如果通过长期的严格测试，能够保证使用者不会使用零地址作为参数调用MyMemMove函数，则希望有简单的方法关掉参数合法性检查。我们知道宏就有这种开关的作用，所以V0.5版程序也就出来了。

程序清单 6 V0.5版程序

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

void  * MyMemMove( void  *dst,  const  void  *src,  size_t  count) {      void  *ret=dst;   #ifdef DEBUG      if  (NULL==dst||NULL ==src)      {          return  dst;      } #endif      while  (count--)      {          *( char  *)dst = *( char  *)src;          dst = ( char  *)dst + 1;          src = ( char  *)src + 1;      }      return  ret; }

如果在调试时我们加入“#define DEBUG”语句，增强程序的健壮性，那么在调试通过后我们再改为“#undef DEBUG”语句，提高程序的性能。事实上在标准库里已经存在类似功能的宏：assert，而且更加好用，它还可以在定义DEBUG时指出代码在那一行检查失败，而在没有定义DEBUG时完全可以把它当作不存在。assert(_Expression)的使用非常简单，当_Expression为0时，调试器就可以出现一个调试错误，有了这个好东西代码就容易多了。

 

程序清单 7 V0.6版程序

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

void  * MyMemMove( void  *dst,  const  void  *src,  size_t  count) {      assert (dst);      assert (src);            void  *ret = dst;            while  (count--)      {           *( char  *)dst = *( char  *)src;          dst = ( char  *)dst + 1;          src = ( char  *)src + 1;      }            return  ret; }

 

一旦调用者的两个指针参数其中一个为零，就会出现如图1所示的错误，而且指示了哪一行非常容易查错。

 

 图 1 assert（NULL）时，显示错误

 到目前为止，在语言层面上，我们的程序基本上没有什么问题了，那么是否真的就没有问题了呢？这 就要求程序员从逻辑上考虑了，这也是优秀程序员必须具备的素质，那就是思维的严谨性，否则程序就会有非常隐藏的bug，就这个例子来说，如果用户用下面的代码来调用你的程序。

程序清单 8 重叠的内存测试

1 2 3 4 5 6 7 8

void  Test() {     char  p [256]=  "hello,world!" ;          MyMemMove(p+1, p, ( strlen (p)+1));          printf ( "%s\n" ,p); }

如果你身边有电脑，你可以试一下，你会发现输出并不是我们期待的“hhello,world!”（在“hello world！”前加个h），而是“hhhhhhhhhhhhhh”，这是什么原因呢？原因出在源地址区间和目的地址区间有重叠的地方，V0.6版的程序无意之中将源地址区间的内容修改了！有些反映快的同学马上会说我从高地址开始拷贝。粗略地看，似乎能解决这个问题，虽然区间是重叠了，但是在修改以前已经拷贝了，所以不影响结果。但是仔细一想，这其实是犯了和上面一样的思维不严谨的错误，因为用户这样调用还是会出错：

             MyMemMove( p, p+1, strlen(p)+1);

所以最完美的解决方案还是判断源地址和目的地址的大小，才决定到底是从高地址开始拷贝还是低地址开始拷贝，所以V0.7顺利成章地出来了。

程序清单 9 V0.7版程序

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

( void  *dst, const  void  *src, size_t  count) {        assert (dst);        assert (src);              void  * ret = dst;              if  (dst <= src || ( char  *)dst >= (( char  *)src + count))       {           while  (count--)          {              *( char  *)dst = *( char  *)src;              dst = ( char  *)dst + 1;              src = ( char  *)src + 1;          }        }       else         {            dst = ( char  *)dst + count - 1;            src = ( char  *)src + count - 1;            while  (count--)            {                 *( char  *)dst = *( char  *)src;                 dst = ( char  *)dst - 1;                 src = ( char  *)src - 1;             }         }       return (ret); }

经过以上几个版本的修改，我们的程序终于可以算是工业级了。回头再来看看前面的测试用例，就会发现那根本就算不上是测试用例，因为它只调用了最正常的一种情况，根本达不到测试的目的。有了上面的经历，测试用例也就相应地出现了，我们不妨用字符数组来模拟内存。

初写代码的时候，往往考虑的是程序正常工作的情况该怎么处理。当你有了几年经验，写了几万行代码后就会发现，处理异常部分的分支代码有时比正常的主干线代码还要多，而这也正是高质量程序和一般程序拉开差距的地方。如果把软件产品当作一台机器，那么这样一个个细小的函数和类就是零部件，只有当这些零部件质量都很高时，整个软件产品的质量才会高，不然就会像前几年的国产轿车一样，今天这个零件罢工明天那个零件休息。而作为检验这些零部件的测试用例，一定要模拟各种恶劣的环境，将零部件隐藏的缺陷暴露出来，从这意义上说，编写测试用例的程序员要比软件设计的程序员思维要更严谨才行。