字符，字符串的函数(C语言)

//strlen的模拟实现
 
//计数器的方式
int main()
{
	char arr[] = "abcdefgh";
	int count = 0;
	int i = 0;

	while (arr[i])
	{
		count++;
		i++;
	}

	printf("%d" ,count);
	return 0;
}

运用指针-指针

//指针-指针
int main()
{
	char arr[] = "abcdefgh";

	char* p = arr;
	while (*p != '\0')
		p++;

	printf("%d", p - arr);
	return 0;
}

递归的方式（不创建临时变量）

//递归
int count(char* p)
{
	if (*p == '\0')
		return 0;
	else
		return count(p + 1) + 1;

}

int main()
{
	char arr[] = "abcdefgh";
	int c=count(arr);

	printf("%d", c);
	return 0;
}

2>.strcpy

strcpy函数是字符串拷贝函数；形式：char* strcpy(char* destination(目的地),const char* source(源头));

注意：源字符串必须以'\0'结尾,没有'\0'拷贝无法结束；拷贝的时候会将源字符串的'\0'进行拷贝；目标空间要足够大；目标空间要是可修改的；strcmp返回的是目标函数的起始地址；

//strcpy函数
int main()
{
	char arr[] = "abcdefgh";
	char arr2[100];

	strcpy(arr2, arr);   //将arr复制到arr2中

	printf("%s", arr2);
	return 0;
}

2>.strcpy的模拟实现

//strcpy的模拟实现
char* myself_strcpy(char* p1, char* p2)
{
	char* ch = p1;
	while ((*p2++ = *p1++))		  //先赋值，在加加，当*p是\0时自动停止
		;
	return p1;
}

int main()
{
	char arr1[] = "abcdefgh";
	char arr2[100] = { 0 };

	myself_strcpy(arr1, arr2);
	printf("%s", arr2);

	return 0;
}

3>.strcat

strcat是字符串追加函数；形式：char* strcat(char* destination,const char* source);

注意：目标空间要有\0；源字符串要有\0；目标空间足够大；目标空间可以修改；strcat不一定能实现自己追加；返回值是目标空间的起始地址；

//strcat追加函数
#include<string.h>
int main()
{
	char arr1[100] = "abcdef";
	char arr2[] = "ghijk";

	strcat(arr1, arr2);  //将arr2追加到arr1后面，并补充'\0'

	printf("%s", arr1);

	return 0;
}

3>.strcat的模拟实现


//strcat的模拟实现
char* myself_strcat(char* p1, char* p2, int num1,int num2)
{
	for (int i = 0; i < num2; i++)
		*(p1 + num1 + i) = *(p2 + i);
}

int main()
{
	char arr1[100] = "abcdef";
	char arr2[] = "ghijk";

	myself_strcat(arr1, arr2, strlen(arr1),strlen(arr2));
	printf("%s", arr1);

	return 0;
}

4>.strcmp

strcmp函数是用来比较字符串的，形式:int strcmp(const char* str1,const char* str2)；

str1>str2返回>0的数；str1<str2返回<0的数；str1=str2返回0；

4>.strcmp的模拟实现

//strcmp的模拟实现
int myself_strcmp(const char* str1,const char* str2)
{
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

int main()
{
	char arr1[] = "abcdefg";
	char arr2[] = "abcg";

	int c = myself_strcmp(arr1, arr2);
	printf("%d", c);
	return 0;
}

5>.strnpy

形式：char* strncpy(char* arr1,char* arr2,size_t num)；其用法和strcpy相同只是增加了num来限制操作字符的个数；运用该函数，不一定会拷贝\0，如果num大于arr2的数组个数，则多余的自动不\0。

strncpy函数与strcpy的区别是，其是长度受限制的字符串函数，就是可以限制复制字符的个数；

5>.strncpy的模拟实现

//strncpy的模拟实现
char* myself_strncpy(char* p2, char* p1, int num)
{
	char* ch = p2;
	for (int i = 0; i < num; i++)
		*(p2 + i) = *(p1 + i);
	return p2;
}

int main()
{
	char arr1[] = "abcdefg";
	char arr2[100] = {0};
	int a = 4;

	char* ch = myself_strncpy(arr2, arr1, a);
	printf("%s", arr2);

	return 0;
}

6>.strncat

形式：char* strcat(char* destination,const char* source,int num);

6>.strncat的模拟实现

//strncat的模拟实现
char* myself_strncat(char* p1, char* p2, int num)
{
	char* ch = p1;
	while (*p1)
		p1++;
	for (int i = 0; i < num; i++)
		*(p1 + i) = *(p2 + i);
	*(p1 + 1) = '\0';
		return ch;
}

int main()
{
	char arr1[110] = "abcdef";
	char arr2[110] = "ghijkl";

	int num = 1;
	char* c = myself_strncat(arr1, arr2, num);
	printf("%s", arr1);

	return 0;
}

7>.strncmp

形式:int strcmp(const char* str1,const char* str2,num)；

7>.strncmp的模拟实现

//strncmp的模拟实现
int myself_strncmp(char* p1, char* p2, int num)
{
	for (int i = 0; i < num; i++)
	{
		if (*p1 = p2)
		{
			if (*p1 == '\0')
				return 0;
			if (i == num - 1)
				return 0;
			p1++;
			p2++;
		}
	}
	return (*p1 - *p2);
}

int main()
{
	char arr1[] = "abcdefg";
	char arr2[] = "abcg";
	int num = 3;

    int  c = myself_strncmp(arr1, arr2, num);
	printf("%d", c);
	return 0;
}

8>.strtok

strtok函数是用来把一个字符串中分割符(. @ )....)去掉的，形式：char* strtok(char* str ,const char* sep);

str指向一个字符串，他包含一个或多个有sep字符串中一个或多个分隔符分割的标志；sep指向字符串，定义用作分隔符的字符集合；

strtok函数找到str中的下一个标记，并将其用\0结尾，返回一个指向标记的指针；strtok会改变被操作的字符串，所以strtok函数切分的字符串一般都是临时拷贝的内容并且可以修改；

strtok有记忆作用，其会记住字符串中被修改的位置，当其第一个参数是NULL的时候，函数就会自动找到str上一次被修改的位置，从哪你开始查找；

9>.strstr

strstr函数是用来在一个字符串中寻找它的子字符串的；

形式：char* strstr(const char* arr1,const char* arr2)在arr1数组的字符串中找arr2字符串，并返回arr2出现的地址；

//strstr函数
#include <string.h>
int main()
{
	char arr1[] = "abcdefgh";
	char arr2[] = "df";

	char* ch = strstr(arr1, arr2);  //在arr1中找是否有子字符串arr2
	printf("%s", ch);

	return 0;
}

没找到，则返回空指针NULL；

9>.strstr的模拟实现

//strstr的模拟实现
char* myself_strstr(const char* p1,const char* p2)
{
	char* s2 =NULL ;
	char* str2 = NULL;
	const char* str =p1;

	while (*str != 0)
	{
		 s2 = p2;
		 str2 = str;
		while (*str2 == *s2&&*s2&&*str2)
		{
			str2++;
			s2++;
			if (*s2 == '\0')
				return str;
		}
		str++;
	}
	return NULL;
}

int main()
{
	char arr1[] = "abcdefgh";
	char arr2[] = "defg";

	char* ch = myself_strstr(arr1, arr2);
	printf("%s", ch);
	return 0;
}

10>.strerror

在程序中有一个全局变量errno只用来羁旅程序当前的错误码的，程序刚启动的时候errno是0，表示无错误，而当我们在使用标准库中的函数是发生某种错误，就会将相应的错误码存放在errno中，错误码是专门用来储存错误信息的，而strerror函数是将错误码对应的错误信息的字符地址返回；形式：char* strerror(int num);erron头文件是<errno.h>