C语言——字符与字符串函数

内容

1.字符
2.字符串
3.检验参数合法性（非常必要）
4.字符串相关库函数实现（面试）

---

*1.字符

• 字符：字符型数据；
  例：‘d’、’!’、’=’、’+’、’?’…

• 在C语言中，字符型数据特点为：
  * 字符型数据只能用单引号括起来，不能用双引号或其它括号。
  * 字符型数据只能是单个字符，不能是字符串。
  * 字符可以是字符集中任意字符。但数字被定义为字符型之后就不能参与数值运算。如’5’和5 是不同的。'5’是字符型数据，不能参与运算。

• 转义字符：转义字符是一种特殊的字符。转义字符以反斜线""开头，后跟一个或几个字符。转义字符具有特定的含义，不同于字符原有的意义，故称“转义”字符。转义字符主要用来表示那些用一般字符不便于表示的控制代码。转义字符链接

• 字符变量的存储：每个字符变量被分配一个字节的内存空间，因此只能存放一个字符。字符值是以ASCII码的形式存放在变量的内存单元之中的。
  * C语言允许对整型变量赋以字符值，也允许对字符变量赋以整型值。在输出时，允许把字符变量按整型量输出，也允许把整型量按字符量输出。
  * 整型量为2个字节单位，字符变量为单字节量，当整型量按字符型量处理时，只有低八位字节参与处理。（‘a’-（十进制整数表示为）97，‘A’=‘a’-32=65;

*2.字符串

• 字符串：字符串是由一对双引号括起的字符序列
  例：“CHINA” ， “C program” ， “$12.5”…
• 字符与字符串区别：
  • 字符由单引号括起来，字符串由双引号括起来。
  • 字符只能是单个字符，字符串则可以含一个或多个字符。
  • 可以把一个字符型数据赋予一个字符变量，但不能把一个字符串赋予一个字符变量。在C语言中没有相应的字符串变量，也就是说不存在这样的关键字，将一个变量声明为字符串。但是可以用一个字符数组来存放一个字符串。
  • 字符占一个字节的内存空间。字符串占的内存字节数等于字符串中字节数加1。增加的一个字节中存放字符"\0" (ASCII码为0)。这是字符串结束的标志。

例：‘a’——内存中存储ASCII仍为’a’； “a”——内存中为 a \0；

*3.检验参数合法性

#include
#include
#include  //包含assert的库函数头文件

int maxNum(int a, int b) {
//assert校验参数
	assert(a != 0);
	assert(b != 0);
//if校验参数
	if (a == 0 || b == 0) {
		return 0;
	}
	else {
		int i = 1;
		int max = 0;
		for (; i <= (a < b ? a : b); i++) {
			if (a % i == 0 && b % i == 0) {
				max = i;
			}
		}
		return max;
	}
}

int main() {
	int a = 1;
	int b = 2;
	//不但要在函数体内检验参数合法性，函数调用时也需检验；
		if (a != 0 && b != 0) {
			int ret = maxNum(a, b);
			printf("%d\n", ret);
		}
	system("pause");
	return 0;
}

以上两种校验方法都可以进行参数合法性检验（校验思想很重要）；

• if 校验参数：针对服务器接收到某次请求有问题时，发现数据有问题，需要用if检验相对温和；不至于影响其他请求的接受和处理；（系统需要一定的容错性/鲁棒性）
• assert校验：针对在启动服务器时，发现数据加载有问题，可能影响服务器后续的接收和处理请求；故采用assert相对强烈的方式检验；可以在数据加载阶段让系统直接停止运行；（可以避免空指针也可以避免野指针）

在函数内部设置校验方法是有必要的；在函数体外函数调用的时候仍需要进行参数合法性判断——因为在实际开发中，一般是多人多人协作完成开发，比如一个人写一个函数另一个人进行使用；所以不同人都对函数进行参数检验，双重保证！

• 在线笔试中，不要使用assert ，因为在提交运行时，系统会给出不合法的参数进行检测；使用assert会使程序崩溃，不利于得分！

*4.字符串库函数实现

• C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在 常量字符串中或者 字符数组 中。 字符串常量 适用于那些对它不做修改的字符串函数。
• const 修饰的字符串表示不可修改；

<1>实现计算字符串长度的库函数strlen

• strlen函数计算字符串长度不包括字符串结尾的’\0’；

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

size_t strlen(const char* str) {
	//校验参数的合法性 1.（不能校验野指针）
	if (str == NULL) {
		return 0;
	}
	//校验参数的合法性 2.(避免野指针）
	assert(str != NULL);
	size_t size = 0;
	while (str[size] != '\0') {
		size++;
	}
	return size;
}

int main() {
	printf("字符串“abcd”的长度为：%d\n", strlen("abcd"));
	char* p = "zxcv";
	if (p != NULL) {
		printf("p的长度为：%d\n", strlen(p));
	}
	system("pause");
	return 0;
}

• strlen 只针对字符串使用；
• size_t 是无符号整数，相减会发生溢出（慎用）；

<2>实现字符串拷贝的库函数strcpy

• 源字符串必须以 ‘\0’ 结束。
• 会将源字符串中的 ‘\0’ 拷贝到目标空间。（这样拷贝给目标的才是一个字符串）
• 目标空间必须足够大，以确保能存放源字符串。
• 函数返回的是一个指向拷贝的目标字符串内存空间的指针（首地址）；

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

typedef struct student {
	int id;
	char name[100];
}stu;

char* Strcpy(char* dest, const char* src) {
	assert(dest != NULL);
	assert(src != NULL);
	int i = 0;
	while (src[i] != '\0') {
		dest[i] = src[i];
		i++;
	}
	dest[i] = '\0';
	return dest;
}

int main() {
	char src[] = "hehe";
	char dest[1024] = { 0 };
	Strcpy(dest,src);
	printf("%s\n", dest);
	stu s = { 1,"zwr" };
	//s.name = "lisa";
	strcpy(s.name, "lisa");
	printf("%s\n", s.name);
	system("pause");
	return 0;
}

• 可修改的左值，其类型不可以被声明为限定符 const，并且可修改的左值 不能是数组类型。 如果把数组名当做左值赋值，会引发lvalue required as increment operand错误。
  
• 若目标数组空间不够大，会发生上图所示异常——数组下标越界！

<3>实现将一个字符串添加在另一个字符串后面——实现两个字符串拼接的库函数strcat

• 源字符src 串必须以 ‘\0’ 结束。
• 目标空间必须有足够的大，能容纳下源字符串的内容。
• 目标空间必须可修改。
• 函数返回的是指向（需要拼接的目标 dest 字符串）空间的指针（地址）；

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

char* Strcat(char* dest, const char* src) {
	assert(dest != NULL);
	assert(src != NULL);
	int destTail = 0;
	while (dest[destTail] != '\0') {
		destTail++;
	}
	//Strcpy(dest + destTail, src);
	int i = 0;
	while (src[i] != '\0'){
		dest[i + destTail] = src[i];
		i++;
	}
	dest[i + destTail] = '\0';
	return dest;
}

int main() {
	char src[] = "heihei";
	char dest[1024] = "xixi";
	Strcat(dest, src);
	printf("%s\n", dest);
	system("pause");
	return 0;
}

<4>实现比较两个字符串是否相等(大小)的库函数strcmp

• 第一个字符串大于第二个字符串，则返回大于0的数字
• 第一个字符串等于第二个字符串，则返回0
• 第一个字符串小于第二个字符串，则返回小于0的数字
• 字符串比较大小，常见 如AB…Z 的字典序；（越靠前越小）

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

int Strcmp(const char* dest, const char* src) {
	assert(dest!= NULL);
	assert(src != NULL);
	const char* p1 = dest;
	const char* p2 = src;
	//方法1：
	while (*p1 != '\0' || *p2 != '\0') {
		int diff = *p1 - *p2;
		if (diff < 0 || diff>0) {
			return diff;
		}
		else if (diff == 0) {
			p1++;
			p2++;
		}
	}
	return 0;
	//方法二：
	//while (*p1 != '\0' && *p2 != '\0') {
	//	if (*p1 < *p2) {
	//		return -1;
	//	}
	//	else if (*p1 > *p2) {
	//		return 1;
	//	}
	//	p1++;
	//	p2++;
	//}
	//if (*p1 < *p2) {
	//	return -1;
	//}
	//else if (*p1 > *p2) {
	//	return 1;
	//}
	//else if(*p1==*p2){
	//	return 0;
	//}
	//return *p1 - *p2;
}

int main() {
	char src[] = "hiii";
	char dest[] = "hiig";
	int ret = Strcmp(dest, src);
	printf("%d\n", ret);
	system("pause");
	return 0;
}

上述程序中 int diff = *p1 - *p2——可以直接表示两个指向字符的指针相减=>两个字符在字典序中相差几位；

<5>实现拷贝特定长度的字符串的库函数strncpy

• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边填充0，直到num个。
• 如果num小于源字符串长度，则将源的前num个字符拷贝给目标dest ，再最后加上’\0’；
• 返回拷贝完成之后的目标字符串；

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

char* Strncpy(char* dest, const char* src, size_t num) {
	assert(dest != NULL);
	assert(src != NULL);
	assert(num != NULL);
	size_t i = 0;
	while (src[i] != '\0' && i < num) {
		dest[i] = src[i];
		i++;
	}
	//dest[i] = '\0';
	while (i <= num) {
		dest[i] = '\0';
		i++;
	}
	return dest;
}

int main() {
	char src[] = "hehe";
	char dest[1024] = { 0 };
	Strncpy(dest, src, 3); //size_num<=sizeof(dest)-1;
	printf("%s\n", dest);
	system("pause");
	return 0;
}

• 在调用strncpy函数时，需要注意传入的num（字节数）值 <= sizeof(dest)-1 ，确保有最后一个字节的空间放置’\0’，使得目标成功拷贝为字符串！
  

<6>实现特定长度将源字符串拼接到目标字符串的库函数strncat

• 目标要足够大以包含连接的结果字符串，包括附加的空字符
• 当源小于num时，只赋值src中空字符之前的字符；最后给目标字符串后加上’\0’
• 当源大于num时，将源src中前num个字符给目标，最后加上’\0’
• 返回的仍然是目标；

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

char* Strncat(char* dest, const char* src, size_t num) {
	assert(dest != NULL);
	assert(src != NULL);
	assert(num != 0);
	size_t  destTail = 0;
	while (dest[destTail] != '\0') {
		destTail++;
	}
	int i = 0;
	while (src[i] != '\0' && i < num) {
		dest[destTail + i] = src[i];
		i++;
	}
	dest[destTail + i] = '\0';
	return dest;
}

int main() {
	char src[] = "hehe";
	char dest[1024] = "haha";
	Strncat(dest, src, 2); //size_num<=sizeof(dest)-1;
	printf("%s\n", dest);
	system("pause");
	return 0;
}

<7>实现两个字符串比较特定长度的大小的库函数strncmp

• 比较两个字符串前num个字符的大小；返回原理和strcmp同理；
• 如果两个字符串第一个字符相等，则继续向后对应位进行比较，直到达到终止空字符，或直到两个字符串中的num 个字符匹配，以先发生者为准；

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

int Strncmp(const char* dest, const char* src, size_t num) {
	assert(dest != NULL);
	assert(src != NULL);
	assert(num != 0);
	size_t i = 0;
	while (dest[i] != '\0' && src[i] != '\0' && i < num) {
		if (dest[i] < src[i]) {
			return -1;
		}
		else if (dest[i] > src[i]) {
			return 1;
		}
		else {
			i++;
		}
	}
	return dest[i - 1] - src[i - 1];
}

int main() {
	char src[] = "hehe";
	char dest[] = "heha";
	int ret = Strncmp(dest, src, 4); 
	printf("%d\n", ret);
	system("pause");
	return 0;
}

<8>实现判断两个字符串前者是否包含于后者的库函数strstr

• 创建两个指针分别指向两个字符串；
• blank指向str1，sub指向str2，red始终=blank；
• 从第一个字符开始比较，若blank指向的字符和sub指向的字符不同，则指针blank向后移动一位（指向第二个字符），再和sub指向的字符进行比较，依次进行比较；
• 直到blank和sub指向的字符相同，则red 和 sub 向后++继续比较；
• 如果比较结果不相等，则blank再继续++向后和初始sub比较；
• 若red==sub 并且sub指向的str2字符都比较完了，则str2包含于str1，可以返回blank；
• 反之，blank==’\0’时，sub 仍没有匹配完, 则返回空，表示str2不包含于str1；
  

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

char* Strstr(const char* str1, const char* str2) {
	assert(str1 != NULL);
	assert(str2 != NULL);
	assert(*str1 != '\0');
	assert(*str2 != '\0');
	const char* blank = str1;
	while (*blank != '\0') {
		char* red = blank; //临时比较
		char* sub = str2;
		while (*sub != '\0' && *red != '\0' && *red == *sub) {
			red++;
			sub++;
		}
		if (*sub == '\0') {
			return blank;
		}
		blank++;
	}
	return NULL;
}

int main() {
	char* str1 = "hello TiMi!";
	char* str2 = "TiMi";
	const char* ret = Strstr(str1, str2);
	printf("%s\n", ret);
	system("pause");
	return 0;
}

• char* 可以赋值给 const char*,发之不能；
  

<9>实现字符串切分的库函数strtok

• 将字符串str通过tokens(分割标记)分割成不同的连续字符；
• 在第一次调用时，该函数需要一个 C 字符串作为str 的参数，其第一个字符用作扫描标记的起始位置。在随后的调用中，该函数需要一个空指针，并使用最后一个标记结束后的位置作为新的扫描起始位置。
• 要确定标记的开头和结尾，该函数首先从起始位置开始扫描不包含在分隔符中的第一个字符（它成为标记的开头））。然后从标记的这个开头开始扫描分隔符中包含的第一个字符，它成为标记的结尾。如果找到终止空字符，扫描也会停止。标记的这一结尾会自动替换为空字符，并且标记的开头由函数返回。
• 一旦在对strtok的调用中找到str的终止空字符，对该函数的所有后续调用（以空指针作为第一个参数）都将返回空指针。

例：

• strtok 缺点：
  • 该函数需要多次调用才能完成功能，复杂；
  • 每次调用参数不同，麻烦；
  • 调用该函数破坏了原有的字符串str；
  • 函数内部，由于每次调用会使用上次的调用位置，使用到static 改变局部变量的生存周期(变量存活于 整个程序进程)，使用静态变量，会导致线程不安全；

<10>实现内存空间的拷贝的库函数memcpy

• 将num个字节的值从source指向的位置直接复制到destination指向的内存块；
• 任意类型的指针都可赋值给void* ，其只知道地址，不知道大小；
• 目标和源参数所指向的数组的大小至少应为num；
• 但是该函数不能实现空间重叠的拷贝；
• memcpy和strcpy及和 字符串没有关系，只是把一块内存中的数据拷贝到另一块内存中；

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

typedef struct stu {
	int id;
	char name[100];
}student;

void* Memcpy(void* dest, const void* src, size_t num) {
	assert(src != NULL);
	assert(num != 0);
	char* cdest = (char*)dest;
	const char* csrc = (const char*)src;
	for (size_t i = 0; i < num; i++) {
		cdest[i] = csrc[i];
	}
	return dest;
}

int main() {
	int a1[] = { 3,2,1 };
	int a2[100] = { 0 };
	Memcpy(a2, a1, sizeof(a1)); //数组传参时，数组名可以隐式转化为首元素地址
	for (int i = 0; i < 3; i++) {
		printf("%d ", a2[i]);
	}
	student s1 = { 1,"zwr" };
	student s2;
	Memcpy(&s2, &s1, sizeof(s1)); 
	printf("\n%d,%s\n", s2.id, s2.name);

	system("pause");
	return 0;
}

<11>实现内存空间拷贝（包括重叠的拷贝）的库函数memmove

• 将num个字节的值从source指向的位置直接复制到destination指向的内存块；
• 允许源和目标内存空间重叠；
• 为了避免溢出，两个指向的数组的大小目标和源参数至少应为num个字节；
  
• 当目标空间重叠了源空间的前面部分空间，则和memcpy拷贝方法同理；

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

void* Memmove(void* dest, const void* src, size_t num) {
	assert(src != NULL);
	assert(num != 0);
	char* cdest = (char*)dest;
	const char* csrc = (const char*)src;
	if (cdest > csrc && cdest < csrc + num) {
		for (size_t i = num; i > 0; i--) {
			cdest[i - 1] = csrc[i - 1];
		}
	}
	else {
		for (size_t i = 0; i < num; i++) {
			cdest[i] = csrc[i];
		}
	}
	return dest;
}

int main() {
	int a1[] = { 3,2,1 };
	int a2[100] = { 0 };
	Memmove(a2, a1, sizeof(a1));
	for (int i = 0; i < 3; i++) {
		printf("%d ", a2[i]);
	}
	system("pause");
	return 0;
}

• 目前的设备内存（大）很少出现内存重叠的现象；