• C语言本身是不具有字符串类型的，字符串通常都放在常量字符串或者字符数组当中
• 字符串常量适用于哪些对它不做修改的字符串函数

1. strlen的使用和模拟实现

size_t strlen(const char* str);

• 字符串以’\0‘作为结束标注，并且strlen函数返回的是在字符串中’\0’前面出现的字符个数
• 参数指向的字符串必须要以’\0’结束
• 注意函数的返回值为size_t，是无符号的
• strlen的使用需要包含头文件<string.h>

int main()
{
	const char* str1 = "abcdef";
	const char* str2 = "bbb";
	printf("%d %d\n", strlen(str1), strlen(str2));
}

模拟实现

①指针实现

int my_strlen(const char* str)
{
	assert(str != NULL);
	char* cp = str;
	while (*str++ != '\0');
	return str - cp - 1;
}

②计数器

int my_strlen(const char* str)
{
	int count = 0;
	assert(str);
	while (*str)
	{
		str++;
		count++;
	}
	return count;
}

③递归

int my_strlen(const char* str)
{
	assert(str);
	if(!*str)
		return 0;
	else
		return 1+my_strlen(str+1);
}

2. strcpy的使用和模拟实现

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

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

int main()
{
	char str1[] = "Sample string";
	char str2[40];
	strcpy(str2,str1);
	return 0;
}

模拟实现

char* my_strcpy(char* str, const char* src)
{
	assert(str && src);
	char* ret = str;
	while (*str++ = *src++);
	return ret;
}

3. strcat的使用和模拟实现

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

• 将源字符串的副本附加到目标字符串上。目的地的终止空字符’\0’被源的第一个字符覆盖，而在目的节点中将两者串接形成的新字符串末尾包含一个空字符。
• 源字符串必须以’\0’结束
• 目标字符串中必须也得有’\0’
• 目标字符串必须足够大，能够容纳下源字符串的内容，目标空间必须可修改
• 一般不能用于自身的追加，会破坏字符串的终止符’\0’

int main()
{
	char str[80];
	strcpy(str, "ehese ");
	printf("%s\n", str);
	strcat(str, "strings");
	printf("%s\n", str);
	strcat(str, "are ");
	printf("%s\n", str);
	return 0;
}

模拟实现

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest) { //先找到'\0'的位置
		dest++;
	}
	//while(*++dest);
	while (*dest++ = *src++);
	return ret;
}

4. strcmp的使用和模拟实现

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

• 标准规定：
  • 第一字符串 > 第二字符串：返回大于0的数字
  • 第一字符串 = 第二字符串：返回0
  • 第一字符串 < 第二字符串：返回小于0的数字

int main()
{
	char arr1[] = "abced";
	char arr2[] = "askkl";
	printf("%d",strcmp(arr1, arr2));//-1
	return 0;
}

模拟实现

int my_strcmp(const char* src, const char* dst)
{
	int ret = 0;
	assert(src != NULL);
	assert(dst != NULL);
	while (!(ret = *(unsigned char*)src - *(unsigned char*)dst) & *dst)
	{
		dst++; src++;
	}
	if (ret < 0)
		return -1;
	else if (ret > 0)
		return 1;
	else
		return 0;
}

5. strncpy的使用

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

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

int main()
{
	char arr1[10] = "abce";
	char arr2[10] = "cdr";
	strncpy(arr1, arr2, 10);
	printf("%s", arr1);
	return 0;
}

6.strncat的使用

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

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

7.strncmp的使用

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

• 比较str1和str2的前num个字符，如果相等就继续往后比较，最多比较num个字母，如果提前发现不一样，就提前结束，大的字符所在的字符串大于另一个
• 如果num个字符都相等，就是相等返回0

int main()
{
	char* str1 = "abcd";
	char* str2 = "abc";
	printf("%d %d",strncmp(str1,str2,4),strncmp(str1, str2, 3));
}

8.strstr的使用

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

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

int main()
{
	char str[] = "This is a sad";
	char* pch = strstr(str, "a");
	printf("%s\n", pch);//a sad
	strncpy(pch, "happy", 5);//This is happy
	printf("%s\n", str);
	strncpy(pch, "happy", 4);//This is happd
	return 0;
}

模拟实现

char* my_strstr(const char* str1, const char* str2)
{
	char* cp = (char*)str1;
	char* s1,* s2;

	if (!*str2) //str2为空串
		return ((char*)str1);

	while (*cp)
	{
		s1 = cp;
		s2 = (char*)str2;

		//匹配子串中
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')//匹配子串成功
			return cp;
		cp++;
	}
	return NULL;
}

9.strtok的使用

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

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

//分割-for循环版
for(str = strtok(arr,seq);str != NULL;str=strtok(NULL,seq))
{
	printf("%s\n",str);
}

10.strerror的使用

char* strerror(int errnum);

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

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

perror

void perror ( const char * str );

• perro函数打印完参数部分的字符串后，再打印一个冒号和一个空格，再打印错误信息。

int main()
{
    FILE* pFile;
    pFile = fopen("unexist.ent", "rb");
    if (pFile == NULL)
        perror("The following error occurred");
    else
        fclose(pFile);
    return 0;
}

11.字符分类函数

#include <stdio.h>
#include <ctype.h>
int main()
{
	int i = 0;
	char str = 'a';
	printf("%d", islower(str));
	printf("%d", isupper(str));
	printf("%d", isalnum(str));
	printf("%d", isalpha(str));
	return 0;
}

12.字符转换函数

int tolower(int c);
int toupper(int c);

• 上面的代码，我们将小写转大写，是-32完成的效果，有了转换函数，就可以直接使用tolower函数。

#include <stdio.h>
#include <ctype.h>
int main ()
{
	int i = 0;
	char str[] = "Test String.\n";
	char c;
	while (str[i])
	{
		c = str[i];
		if (islower(c)) 
			c = toupper(c);
		putchar(c);
		i++;
	}
	return 0;
}