如何写出一个好的程序

深藏阁楼爱情的钟 2022-07-11 11:13 211阅读 0赞

我们以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;
    }

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

![Center][]

这是为什么呢？

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

![Center 1][]

现在我们例子中调用方法图中是第三个，这个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开