潜学C语言——字符串+内存函数介绍

函数介绍

求字符串长度：

strlen

长度不受限制的字符串函数：

strcpy

strcat

strcmp

长度受限制的字符串函数介绍：

strncpy

strncat

strncmp

字符串查找：

strstr

strtok

错误信息报告：

strerror

正文开始~

1.strlen

功能：计算字符串s的长度

说明：返回s的长度，不包括结束符NULL。

size_t strlen(const char* str);

1.字符串以 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0'前面出现的字符个数（不包含'\0'）

2.参数指向的字符串必须要以'\0'结束

3.函数的返回值为size_t,是无符号的

例：

int main()
{
	int len = strlen("abcdef");
	printf("%d\n", len);
	return 0;
}

输出值为：6

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	int len = strlen(arr);
	printf("%d\n", len);
	return 0;
}

输出值为；随机值

实现strlen函数的方法：

//1.计数器的方法 如下
//2.递归(不创建临时变量求字符串长度)
//3.指针减指针

模拟实现：

#include<assert.h>
int my_strlen(const char* str)
{
	int count = 0;
	assert(str != NULL);
	while (*str != '\0')//while(*str)
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	int len = my_strlen("abcdef");
	printf("%d\n", len);
	return 0;
}

2.1 strcpy

 功能：把src所指由NUL结束的字符串复制到dest所指的数组中。

返回指向dest结尾处字符(NUL)的指针。

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

1.源字符串必须以 '\0'结束

//错误的示范
char arr2[] = {'a','b','c'};

2.会将源字符串中的'\0'拷贝到目标空间

3.目标空间必须足够大，以确保可以存放源字符串

模拟实现：

 char* my_strcpy(char* dest, const char* src)
{
	assert(dest != NULL);
	assert(src != NULL);
	char* ret = dest;
	//拷贝src指向的字符串到dest指向的空间，包含'\0'
	while (*dest++ = *src++)
	{
		;
	}
	//返回目的空间的起始地址
	return ret;
}
int main()
{
	char arr1[] = "abcdefghi";
	char arr2[] = "bit";

	my_strcpy(arr1, arr2);//
	printf("%s\n", arr1);

	return 0;
}

2.2 strcat

 功能：把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'。

返回指向dest的指针。

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

1.源字符串必须以 '\0'结束

2.目标空间必须足够大，以确保可以容纳下源字符串的内容

3.目标空间必须可修改

int main()
{
	char arr1[] = "hello";
	char arr2[] = "world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);

	return 0;
}

虽然可以将world加到hello的后面，但是却报错了这是为什么呢？

这是因为arr1周围栈区损坏，arr1中的位置不够

int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);

	return 0;
}

模拟实现： 

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

	//1.找到目的字符串的'\0'
	while (*dest != '\0')
	{
		dest++;
	}
	//2.追加
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";
	my_strcat(arr1, arr2);
	printf("%s\n", arr1);

	return 0;
}

2.3 strcmp

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

第一个字符串大于第二个字符串，则返回大于0的数字

第一个字符串等于第二个字符串，则返回0

第一个字符串小于第二个字符串，则返回小于0的数字

模拟实现：

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
		{
			return 0;//相等
		}
		str1++;
		str2++;
	}
	if (*str1 > *str2)
		return 1;//大于
	else(*str1 < *str2)
	return -1;//小于

}
int main()
{
	char* p1 = "abcdef";
	char* p2 = "sqwer";
	int ret = my_strcmp(p1, p2);
	printf("ret = %d\n", ret);

	return 0;
}

函数长度不受限制，只受\0的限制

3.1 strncpy

功能：把src所指由NULL结束的字符串的前n个字节复制到dest所指的数组中。

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

拷贝num个字符从源字符串到目标空间

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

int main()
{
	char arr1[10] = "abcdef";
	char arr2[] = "hello bit";
	strncpy(arr1, arr2,4);
	printf("%s\n", arr1);

	return 0;
}

3.2 strncat

功能：把src所指字符串的前n个字符添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'。

返回指向dest的指针。

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

int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";
	strncat(arr1, arr2, 8);
	printf("%s\n", arr1);
	return 0;
}

3.3 strncmp

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

4.1 strstr

int main()
{
	char* p1 = "abcdef";
	char* p2 = "def";
	char* ret=strstr(p1, p2);
	if (ret == NULL)
	{
		printf("子串不存在\n");
	}
	else
	{
		printf("%s\n", ret);
	}

	return 0;
}

模拟实现：

#include<assert.h>
char* my_strstr(const char* p1, const char* p2)
{
	assert(p1 != NULL);
	assert(p2 != NULL);
	char* s1 = NULL;
	char* s2 = p2;
	char* cur = p1;
	if (*p2 == '\0')
	{
		return p1;
	}
	while (*cur)
	{
		s1 = cur;
		s2 = p2;
		while ((*s1 != '\0') && (*s2 != '\0' && (*s1 == *s2)))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return cur;//找到子串
		}
		cur++;
	}
	return NULL;//找不到子串

}

4.2strtok

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

sep参数是字符串，定义了用作分隔符的字符合集

第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一 个或者多个分隔符分割的标记。
strtok函数找到str中的下一 个标记 ，并将其用\0结尾，返回一个指向这个标记的指针。(注: strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串般都是临时拷贝的内容并且可修改。 )
strtok函数的第一 个参数不为 NULL ,函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

strtok函数的第一 个参数为 NULL , 函数将在同一个字符串中被保存的位置开始，查找下一个标记。

如果字符串中不存在更多的标记，则返回NULL指针。

strerror

char* strerror(int errrnum);

返回错误码，所对应的错误信息

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

必须包含的头文件

int main()
{
	//0 - No error
	//1 - Operation not permitted
	//2 - No such file or directory
	//...
	//errno 是一个全局错误码的变量
	//当C语言的库函数在执行过程中发生了错误，就会把对应的错误码赋值到errno中
	char* str = strerror(2);
	printf("%s\n", str);
	return 0;
}

应用实现：

int main()
{

	//打开文件
	FILE* pf = fopen("test.txt", "r");

	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	else
	{
		printf("open file success\n");
	}
	return 0;
}

字符分类函数：

iscntrl	任何控制字符
isspace	空白字符空格"，换页\f，换行\n' ,回车\r'，制表符'\“或者垂直制表符VW
isdigit	十进制数字0-9
isxdigit	十六进制数字，包括所有十进制数字，小写字母a-f，大写字母A-F
islower	小写字母a~z
isupper	大写字母A~Z
isalpha	字母a-z或A-Z
isalnum	字母或者数字，a~z,A~Z,0~9
ispunct	标点符号，任何不属于数字或者字母的图形字符(可打印)
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

 字符转换：

int  tolower（int c );

int  toupper( int c );

内存函数：

操作对象是整型数组，浮点型数组，结构体数组.....

memcpy

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

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置

这个函数在遇到 '\0' 的时候并不会停下来

如果source和destination有任何的重叠，复制的结果都是未定义的

memmove

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

是不是感觉这两个函数一模一样？确实并不是

根据C语言标准：

memcpy只需处理 不重叠的内存拷贝就可以

memmove 处理重叠内存的拷贝