如何写出一个好的程序

我们以memmove函数作为例子，来看我们如何一步步精简和优化你的代码。

写之前我们应该知道memmove这个函数有什么用？
他就是一个按字节的拷贝函数，把目标的内容按字节拷贝到你指定的地址，他和strcpy

不同的地方就是他是按字节拷贝，他可以拷贝任意的类型的。

现在我们考虑一下，开始第一种方案，只完成拷贝功能

NO'1

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

如果可以写出这个说明，你的水平对于大学的C语言来说就是可以及格的，对于那些白卷的

和函数乱声明的你已经算是很厉害的，但是你距离精英还是有距离的。因为这个程序是可

以运行的，但是可用性不够高，因为你要可以拷贝各种类型的。

NO'2

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

我们可以发现它使用了void*现在这个函数可以接受这种各样的类型，然后经过强制

指针转换 确实是从使用者的代码转移到了库的代码里，但我们可以将 MyMemMove 理解为库，而将

Test 理解 为使用者，事实上通过调整之后的效果却有天壤之别，  NO .1 是一逸永劳，而N 0.2 是一

劳永逸！

NO'3

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

我们给src加上了一个const，其实这个const说到底是一个约束程序员的关键词，他可以防止你在后

面更改src的值 现在再来考虑这样一种情况，有使用者这样调用库： MyMemMove(NULL,src, count) ，

这是完全可能 的，因为一般来说这些地址都是程序计算出来的，那就难免会算错，出现零地址或者

其它的非法地 址也不足为奇。可以预料的是，如果出现这种情况的话，则程序马上就会down掉。 事

实上在标准库 里已经存在解决这些功能的宏： assert（关于assert我还是会有博客介绍的） ，而且

更加好用，它 还可以在定义 DEBUG 时指出代码在那一行检查失败，而在没有定义 DEBUG 时完全可以把

它当作不存在。

NO'4

void * MyMemMove(void *dst, const void *src, int 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);
}

我原来看到这里也是很吃惊，后面那么长的东西是干什么的,其实写到NO'3的时候你已经很优秀了

，但是写程序最重要的是注意程序的严密性，曾经看到过一句话，其实写一个程序主干道用的代码

一般少于个个分枝用来完善的代码。写出一个代码你要保证它的使用范围，保证它不会出BUG。所以

得顾及个个方面，而内存这东西是最容易出问题的。

请看下面的代码

# define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<Windows.h>
#include<assert.h>
void * MyMemMove(void *dst, const void *src, int count)
{
	assert(dst);
	assert(src);
	void *ret = dst;
	while (count--)
	{
		*(char *)dst = *(char *)src;
		dst = (char *)dst + 1;
		src = (char *)src + 1;
	}
	return ret;
}

int main()
{
	char p[256] = "hello,world!";
	MyMemMove(p + 1, p, strlen(p) + 1);
	printf("%s\n", p);
	system("pause");
	return 0;
}

我们一起来看看他的运行结果

这是为什么呢？

调用这个函数的内存分布有4种情况，分别如下

现在我们例子中调用方法图中是第三个，这个hhhhhhhhhh是如何发生的呢？ 我们开始 分析 一下

首先让指针分别指向src指针和dst指针指向p和p+1；

然后开始拷贝，现在src第一个值为h，既p的第一个值为h，然后dst经过拷贝也为h，既p+1为h。

接下来的一步就是把p+1（src++）的值拷贝给p+2(dst++)，结果p+2的值还是h，然后就这样一直

下去，知道src结束，所有拷贝过去的值都是h，也就成了我们的hhhhhhhhh.

但是我们应该怎么解决呢？

看着第三张图，如何拷贝才能保证给dst赋值，没错是倒序拷贝，当拷贝src后 面的内容时，dst开

辟的那些空间刚刚不重叠。 所以我们就有了最后一个版本。完美的解决掉所有问题。

写代码的人很多，写出好代码的就没有多少了，一个好的代码需要你面面俱到，有人说过一个好的

程序员一定是是一个好的侦探，所以写代码一定要细心，从我做起，写这些东西也在警示我自己。