C语言学习记录 - 字符函数，字符串函数，内存函数

C语言学习记录 - 字符函数，字符串函数，内存函数

1. 字符分类函数

c语言中有一系列函数是专门做字符分类的，也就是一个字符是属于什么类型的字符的函数

这些函数的使用都需要包含一个头文件ctype.h

函数	如果参数符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格’ ‘，换页’\f‘，换行’\n‘，回车’\r‘，制表符’\t‘或者垂直制表符’\v‘
isdigit	十进制数字0~9
isxdigit	十六进制数字，包括0~9，大小写的a~f
islower	小写字母a~z
isupper	大写字母A~Z
isalpha	字母a~z，A~Z
isalnum	字母或数字，a~z，A~Z，0~9
ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

这些函数的使用方法都很类似，就举一个例子：

int islower(int c);

islower是能够判断参数部分的c是否是小写字母的，如果是小写字母就返回非0整数，如果不是就返回0

2. 字符转换函数

c语言提供了2个字符转换函数：

int tolower(int c);//将参数传进去的大写字母转小写
int toupper(int c);//将小写转大写

使用他们需要包含头文件ctype.h

3. 字符串函数

字符串函数的使用都需要包含头文件string.h

1. strlen

size_t strlen(const char* str);

• 字符串以\0作为结束标志，strlen函数返回的是在字符串中\0前面出现的字符个数(不包含\0)
• 参数指向的字符串必须要以\0结束
• 注意函数的返回值size_t是无符号的(易错)
• srelen使用需要包含头文件

为什么说size_t的返回类型易错呢?

可以看看下面这种写法:

int main(){
	if(strlen("abc") - strlen("abcdef") > 0){
		printf(">\n");
	}
	else{
		printf("<=\n");
	}
}

size_t减size_t的结果仍然是size_t是一定>=0的!

模拟实现

方法1

//计数器方式
int my_strlen(const char* str){
    assert(str);
	int ct = 0;
	char* p = str;
	while(*p){
		ct++;
		p++;
	}
	return ct; 
}

方法2

//不创建临时变量计数
//利用递归实现
int my_strlen(const char* str){
    assert(str);
	if(*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}

方法3

//指针-指针的方式
int my_strlen(char* s){
	assert(str);
    char* p = s;
	while(*p != '\0'){
		p++;
	}
	return p-s;
}

2. strcpy

char* strcpy(char* destination, const char* source);

• 源字符串必须以\0结束
• 会将源字符串中的\0拷贝到目标空间
• 目标空间必须足够大，以确保能存放源字符串
• 目标空间必须可修改

模拟实现

char* my_strcpy(char* dest, const char* src){
	char* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while(*dest++ = *src++);
	return ret;
}

3. strcat

原型

char* strcat(char* destination, const char* source);

• 源字符串必须以\0结束
• 目标字符串中也得有\0，否则没法知道追加从哪里开始
• 目标空间必须足够大，能容纳下源字符串的内容
• 目标空间必须可修改

模拟实现

char* my_strcat(char* dest, const char* src){
	assert(dest != NULL);
	assert(src != NULL);
	char*ret = dest;
	while(*dest){
		dest++;
	}
	while(*dest++ = *src++);
	return ret;
}

注意一个问题，当自己拷贝自己的时候，会导致死循环，任何程序崩溃啥的

当然库函数的strcat并没有这种问题

4. strcmp

int strcmp(const char* str1, const char* str2);

• str1大于str2，返回大于0的数字
• str1等于str2，返回0
• str1小于str2，返回小于0的数字

模拟实现

int my_strcmp(const char* str1, const char* str2){
	assert(str1 != NULL);
	assert(str2 != NULL);
	while(*str1 == *str2){
		if(*str1 == '\0'){
			return 0;
		}
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

5. strncpy，strncat和strncmp

这几个函数和strcpy，strcat，strcmp相似，就不模拟了

strncpy

char* strncpy(char* destination, const char* source, size_t num);

• 拷贝num个字符从源字符串到目标空间
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个

strncat

char* strncat(char* destination, const char* source, size_t num);

• 将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加一个\0字符
• 如果source指向的字符串长度小于num，只会将字符串中到\0的内容追加到destination末尾

这个跟strcat还有所不同，因为\0是另外添加的，不是直接从source拷贝过来的

strncmp

int strncmp(const char* str1, const char* str2, size_t num);

• 只比较str1和str2前num个字符，返回同strcmp

6. strstr

char* strstr(const char* str1, const char* str2);

• 函数返回字符串str2在字符串str1中第一次出现的位置
• 字符串的比较匹配不包含\0字符，以\0作为结束表示

模拟实现

char* my_strstr(const char* str1, const char* str2){
	char* cp = (char*)str1;
	char*s1, *s2;
	if(!*str2)
		return ((char*)str1);
	while(*cp){
		s1 = cp;
		s2 = (char*)str2;
		while(*s1 && *s2 && !(*s1 - *s2)){
			s1++;
			s2++;
		}
		if(!*s2)
			return cp;
		cp++;
	}
	return NULL;
}

7. strtok

char* strtok(char* str, const char* sep);

• sep指向一个字符串，定义了用作分隔符的字符集合
• 第一个参数指定一个字符串，它包含了0个或多个由sep字符串中一个或多个分隔符分割的标记
• strtok找到str中的下一个标记，并将其用\0结尾，返回一个指向这个标记的指针
• strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改
• 如果strtok的第一个参数不为NULL，函数将找到str中第一个标记，并保存它在字符串中的位置
• 如果strtok的第一个参数为NULL，函数将在上一个字符串中被保存的位置开始，查找下一个标记
• 如果字符串中不存在更多标记，则返回NULL指针

使用举例

#include <stdio.h>
#include <string.h>
int main()
{
 char arr[] = "192.168.6.111";
 char* sep = ".";
 char* str = NULL;
 for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
 {
 printf("%s\n", str);
 }
 return 0;
}

8. strerror

char* strerror(int errnum);

• strerror函数可以把参数部分错误码对应的错误信息的字符串地址返回来

在不同的系统和C语言标准库的实现中都规定了一些错误码，一般是放在errno.h这个头文件中说明的，c语言程序启动的时候就会使用一个全局变量errno来记录程序的当前错误码，只不过程序启动的时候errno是0表示没有错误，当我们在使用标准库中的函数的时候发生了某种错误，就会将对应的错误码存放在errno中，而一个错误码的数字是整数很难理解是什么意思，所以每一个错误码都是有对应的错误信息的，strerror函数就可以将错误对应的错误信息字符串的地址返回

使用举例：

#include <errno.h>
#include <string.h>
#include <stdio.h>

int main()
{
 int i = 0;
 for (i = 0; i <= 10; i++) {
 printf("%s\n", strerror(i));
 }
 return 0;
}

在win11+vs2022环境下输出结果如下

No error
Operation not permitted
No such file or directory
No such process
Interrupted function call
Input/output error
No such device or address
Arg list too long
Exec format error
Bad file descriptor
No child processes

4. 内存函数

内存函数的使用也都需要包含头文件string.h

1. memcpy

void* memcpy(void* destination, const void* source, size_t num);

• 函数memcpy从source位置开始向后赋值num个字节的数据到destination指向的内存位置
• 这个函数在遇到\0的时候并不会停下来
• 如果source和destination有任何的重叠，赋值的结果都是未定义的

对于重叠的内存，外面教给memmove来处理

模拟实现一下

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

2. memmove

void* memmove(void* destination, const void* source, size_t num);

• 和memcpy的区别就是memmove函数处理的源内存块和目标内存块是可以重叠的
• 如果源空间和目标空间出现重叠，就得使用memmove来处理

模拟实现

void* my_memmove(void* dst, const void* src, size_t count){
	assert(dst && 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;
}

3. memset

void* memset(void* ptr, int value, size_t num);

• 将内存中的值以字节为单位设置成想要的内容

举个栗子：

#include <stdio.h>
#include <string.h>
int main ()
{
 char str[] = "hello world";
 memset (str,'x',6);
 printf(str);
 return 0;
}

//输出xxxxxxworld

4. memcmp

int memcmp(const void* ptr1, const void* ptr2, size_t num);

• 比较从ptr1和ptr2指针指向的位置开始，向后的num个字节
• 返回值同strcmp

举个栗子：

#include <stdio.h>
#include <string.h>
int main()
{
 char buffer1[] = "DWgaOtP12df0";
 char buffer2[] = "DWGAOTP12DF0";
 int n;
 n = memcmp(buffer1, buffer2, sizeof(buffer1));
 if (n > 0) 
 printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
 else if (n < 0) 
 printf("'%s' is less than '%s'.\n", buffer1, buffer2);
 else
 printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
 return 0;
}