对strcmp函数学习

总： strcpy函数的实现

已知strcpy函数的原型是：
char *strcpy(char *dst, const char *src);

1. 实现strcpy函数
2. 解释为什么要返回char *
3. 假如考虑dst和src内存重叠的情况，该如何实现strcpy

1.strcpy的实现代码

char* strcpy(char* dst, const char* src)
{
	assert(dst != NULL && src != NULL);
	//分开写为assert(dst != NULL);assert(src != NULL);更能直观判断哪个条件失败
	char* ret = dst;
	while ((*dst++ = *src++) != '\0');
	return ret;
}

（1）const修饰

源字符串参数用const修饰，防止修改源字符串。

（2）空指针检查

1. 不检查指针的有效性，说明答题者不注重代码的健壮性。

2. 检查指针的有效性时使用assert(!dst && !src);
   char *转换为bool即是类型隐式转换，这种功能虽然灵活，但更多的是导致出错概率增大和维护成本升高。

3. 检查指针的有效性时使用assert(dst != 0 && src != 0);
   直接使用常量（如本例中的0）会减少程序的可维护性。而使用NULL代替0，如果出现拼写错误，编译器就会检查出来。

（3）返回目标地址

(A)循环写成while (*dst++=*src++);明显是错误的。

(B)循环写成while (*src!=‘\0’) *dst++=*src++;

循环体结束后，dst字符串的末尾没有正确地加上’\0’。

2.为什么返回char *？

返回dst的原始值使函数能够支持链式表达式。

链式表达式的形式如：

int l=strlen(strcpy(strA,strB));

3.假如考虑dst和src内存重叠的情况，strcpy该怎么实现

char s[10]="hello";

strcpy(s, s+1); //应返回ello，
//
strcpy(s+1, s); //应返回hhello，但实际会报错，因为dst与src重叠了，把'\0'覆盖了

所谓重叠，就是src未处理的部分已经被dst给覆盖了，只有一种情况：src<=dst<=src+strlen(src)

C函数memcpy自带内存重叠检测功能，下面给出memcpy的实现my_memcpy。

#include "assert.h"
#include "stdio.h"
#include "string.h"
char* strcpy(char *dst, const char *src)
{
	assert(dst!=NULL&&src!=NULL);
	char *ret = dst;
	my_memcpy(dst, src, strlen(src) + 1);
	return ret;
}

my_memcpy的实现如下

char* my_memcpy(char* dst, const char* src, int cnt)
{
	assert(dst != NULL && src != NULL);
	char* ret = dst;
	if (dst >= src && dst <= src + cnt - 1)//内存重叠，从高地址开始复制
	{
		dst = dst + cnt - 1;
		src = src + cnt - 1;
		while (cnt--)
			*dst-- = *src--;
	}
	else//正常情况，从低地址开始复制
	{
		while(cnt--)
			*dst++ = *src++;
	}
	return ret;
}

A.断言（assert）的用法

1.assert的理解

assert() 的用法像是一种"契约式编程"，在我的理解中，其表达的意思就是，程序在我的假设条件下，能够正常良好的运作，其实就相当于一个 if 语句：

if(假设成立)
{程序正常运行；}
else
{报错&&终止程序！（避免由程序运行引起更大的错误）}

但是这样写的话，就会有无数个 if 语句，甚至会出现，一个 if 语句的括号从文件头到文件尾，并且大多数情况下，我们要进行验证的假设，只是属于偶然性事件，又或者我们仅仅想测试一下，一些最坏情况是否发生，所以这里有了 assert()。

assert 宏的原型定义在 assert.h 中，其作用是如果它的条件返回错误，则终止程序执行。

#include "assert.h" 
void assert( int expression );

assert 的作用是现计算表达式 expression ，如果其值为假（即为0），那么它先向 stderr 打印一条出错信息,然后通过调用 abort 来终止程序运行。

使用 assert 的缺点是，频繁的调用会极大的影响程序的性能，增加额外的开销。

在调试结束后，可以通过在包含 #include 的语句之前插入 #define NDEBUG 来禁用 assert 调用，示例代码如下：

#include 
#define NDEBUG 
#include

2.用法注意事项

1. 每个assert只检验一个条件,因为同时检验多个条件时,如果断言失败,无法直观的判断是哪个条件失败
2. 不能使用改变环境的语句,因为assert只在DEBUG个生效,如果这么做,会使用程序在真正运行时遇到问题

//错误
assert(i++ < 100)
//正确
assert(i < 100)
i++; 

3. assert和后面的语句应空一行,以形成逻辑和视觉上的一致感

B. ((*strDest++=*strSrc++)!=‘\0’); 的理解

1. 很明显，上面的表达式是一个组合表达式。组合表达式由子表达式组成，子表达式又可能是组合表达式，这样就形成了一个树状的数据结构。对表达式的评估就类似于对树结点的遍历。首先我们应该注意到"()“操作符，它具有最高的优先级，所以从整体来看，整个表达式应该是个”!=“操作。”!=“左边又是一个组合表达式，而右边是一个常量”\0’，很明显下面的工作就是评估(*strDest++=*strSrc++)。

2. 在这一步，我们要对表达式(*strDest++=*strSrc++)进行评估。由于赋值表达式具有较低的优先级，所以表达式 又可以写成：(*strDest++) = (*strSrc++)，所以整个表达式是个"=“操作，”=“左边又是一个组合表达式，右边也是一个组合表达式，这里就需要从关联性来判断左边还是右边也被评估。由于”="的关联性是从右到左，所以(*strSrc++)先被评估，(*strDest++)后被评估。

3. 在这一步，我们要对表达式(strSrc++)进行评估。由于"++“的优先级大于”“，所以表达式又可以写成：(strSrc++)。我们要先对表达式strSrc++进行评估，然后用表达式的值再去评估(strSrc++)的值。对于表达式strSrc++,这里要需要注意区分变量的值和表达式的值。对于"后增1"表达式，表达式的值是变量strSrc的值，然后变量strSrc的值会"加1”，也就是说表达式的值是strSrc变化前的值，而strSrc的值会发生变化。值得注意的是，我们知道strSrc的值会发生变化，但是我们却不知道strSrc的值发生变化的具体时间，这个变化具体的执行时间由编译器决定了，这就决定了任何依赖strSrc的表达式的值是不确定的，具体的值依赖编译器的实现。完成了对strSrc++的评估后，取值操作符就对表达式的值所对应的内存空间进行取值操作。

4. 在这一步，我们要对表达式(*strDest++)进行评估。具体的评估的分析完全和2.1中的分析一致。

5. 在这一步，我们要对表达式(*strDest++) = (*strSrc++)进行评估，这是个赋值表达式，将右表达式的值赋给左边表达式的值。值得注意的是，对于赋值表达式，表达式本身的值等于左边子表达式的值。

C.关于指针

1. int* p = &a和int *p = a

int *p = a是只有a是一个数组时，a代表了数组的首地址，此时这一语句才成立。也就是等同于int *p =&a[0]。

2.int *p[4]和int(*p)[4]的区别

int p[]
[]优先级高于，所以p先是一个数组，然后数组每个元素的类型是int*， int *p[]是一个(int *)类型的指针数组，p本质上是一个数组；

int (p)[]
()优先级高于[]，所以p先与结合，是一个指针，指针的类型是一个int[]数组，int (*p)[]是一个数组指针，p本质上是一个指针

intp[4]------p是一个指针数组，每一个指向一个int型的
int (q)[4]---------q是一个指针，指向int[4]的数组。
定义涉及两个运算符：“”（间接引用）、“[]”（下标），“[]”的优先级别大于“”的优先级别。

首先看int *p[4]，“[]”的优先级别高，所以它首先是个大小为4的数组，即p[4]；剩下的“int *”作为补充说明，即说明该数组的每一个元素为指向一个整型类型的指针。int *p[4]的存储结构如下：(存储方格横向排列或竖向排列没区别，只要按内存地址顺序排列就行，此处只是为画图方便)

再看int (q)[4]。它首先是个指针，即q，剩下的“int [4]”作为补充说明，即说明指针q指向一个长度为4的数组。int (*q)[4]的存储结构如下：请看以下定义：

int a[2][4]={{2,5,6,8},{22,55,66,88}};

int c[4]={5,8,9,4};

int d[3]={23,12,443};

int *p[4],(*q)[4];

q=a;

*p=c;

*(p+1)=d；

则int *p[4]和int (*q)[4]的存储数据为：

3. 函数指针 和 指针函数

指针函数本质是一个函数，其返回值为指针。
函数指针本质是一个指针，其指向一个函数。

函数指针：
int (*f)(int a, int b); 
f指向函数的入口地址

指针函数：
int *f(int a, int b);
返回值是指针类型的

函数指针变量p: 指向函数max，其中max(a,b),

1. 函数指针的赋值
   正确的赋值方式如下：

	int max(int a,int b)
	int (*p)()

	p=max
		//p即函数的入口地址

2. 函数指针的调用

 (*p)(a,b)

4.空指针

转载来源：

1. http://www.cnblogs.com/chenyg32/
2. https://blog.csdn.net/dongqing27/article/details/49227081
3. https://blog.csdn.net/weixin_41585231/article/details/85049396