【C】字符串函数

目录

1、字符串创建并初始化

2、字符串获取

  3、字符串打印

4、strlen 求字符串长度

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

（1）strcpy 覆盖

 （2）strcat 追加

(3）strcmp 比较

6、长度受限制的字符串函数（相对安全）

(1)strncpy

（2）strncat

（3）strncmp

7、strstr 查找

（1）strstr

（2）strtok

 8、strerror 错误信息报告

（1）strerror

9、字符操作

（1）字符分类库函数

（1.1）isupper、islower函数使用举例： 

​编辑

（1.2）将字符串中的小写字母转换为大写字母，函数实现及运行结果：

---

1、字符串创建并初始化

char arr1[]="abc";

（1）字符串存放在字符数组中，arr[0]='a'，arr[3]='\0'，在字符串末尾自动添加字符串结束标志'\0'；数组名arr等于数组首元素'a'的地址；

char arr2[]={'a','b','c','\0'};

（2）若作为字符串存放在字符数组中，末尾必须手动添加'\0'；

char* arr3 = "abc";

（3）字符串首元素'a'的地址存放在指针p中；  

char* arr[] = { "enter", "stop", "end" };

 指针数组，每个元素的类型为char*，在数组的每个元素中存放的都是首字符的地址；

即分别是'e'、's'、'e' 的地址；

2、字符串获取

scanf，不能读取空格

gets，可以读取空格 

  3、字符串打印

1、 printf("%s",arr);      //上面三段代码打印结果：abc

2、 puts(arr);

%s的参数为地址，是从给定的地址处打印字符串，直到\0不再打印

4、strlen 求字符串长度

size_t  strlen( const char* str );

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

（2）参数指向的字符串，必须要以'\0'结束；

（3）注意函数的返回值是size_t，计算需要时可强转为int型；

（4）两种情况：

若字符串无结束标志'\0'，函数会一直往后找，直到遇到'\0'，此时返回的是随机值；

若给strlen函数错误传递参数，例如strlen('a')，此时编译器将'a'的ASCLL码作为地址传参，从97这个地址开始统计字符串长度，非法访问内存；（strlen函数不论接收到什么类型的地址，都将强转为字符型指针进行运算，const char* str）;

strlen函数模拟实现

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

size_t my_strlen(char* str)
{
	assert(*str);       //断言非空
	size_t num = 0;
	while (*str++)
	{
		num++;
	}
	return num;
}

int main()
{
	char arr[10] = "a s d";
	printf("%u\n", my_strlen(arr));    //size_t,无符号整形以%u打印
	return 0;
}

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

（1）strcpy 覆盖

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

将源（source指向的）字符串，复制到目的（destination指向的）字符串中，包括源字符串结束标志\0；并在\0后停止； 

源字符串必须以 '\0' 结束; 目标空间必须足够大，以确保能存放源字符串；

目标空间必须可变（常量字符串不可变，举例char* arr="abced"）;

strcpy函数使用举例：将常量字符串arr2，复制到了字符串arr1中arr1[7]处，包括'\0'字符；

int main()
{
	char arr1[] = "I am a treeoooooooooo";
	char* arr2 = "bird";
	char* ret = strcpy(arr1 + 7, arr2);   //选择性覆盖，改变目的地字符串地址即可
	printf("%s\n", arr1);        
	return 0;
}

strcpy函数模拟实现：首先要存目的地字符串原地址，最后返回此地址

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

char* my_strcpy(char* str1, const char* str2)
{
	assert(*str1);     //str1指向的字符串不能为空
	assert(*str2);
	char* ret = str1;
	while (*str1++=*str2++)    //先将'\0'赋给*str，此时表达式结果为'\0',不能进入循环
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[10] = "1234567890";
	char arr2[] = "aaa";
	my_strcpy(arr1+6, arr2);     //也可写为&arr1[6],参数传递地址
	printf("%s\n", arr1);
	return 0;
}

 这里注意：首先创建字符串，设定字符串元素数量和初始化字符串至少做到其一；此处%s打印arr1，首元素是'\0'，打印截止为空；

 （2）strcat 追加

目标空间必须可修改，目标空间必须足够大，能容纳下源字符串的内容；

源字符串必须以 '\0' 结束，从目标字符串的'\0'处，追加源字符串直到源'\0'处；

不可自己追加自己，会造成死循环；

//strcat追加 函数模拟实现

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

char* my_strcat(char* dest, const char* src)
{
	assert(*dest&&*src);
	char* ret = dest;
	while (*dest)	//找到目的字符串的'\0'
	{
		dest++;
	}
	while (*dest++ = *src++)  //在目的'\0'后追加，直到源'\0'
	{
		;
	}
	return ret;
}

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

(3）strcmp 比较

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

两个字符串，从首字符逐较个对应比较，大于返回大于0的数，等于0，小于返回小于0的数；

模拟实现：若每一对比较，对应字符都相等，且都为'\0'，则这两个字符串完全相等，返回0；若有一对不相等，则比较即可；

//strcmp 比较函数 模拟实现

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

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);//断言，保证指针的有效性
	while (*str1 == *str2)
	{
		if (*str1 == '\0')  //上一步已判断*str1==*str2，此处*str1='\0',则*str2='\0';
			return 0;
		str1++;
		str2++;
	}
	if (*str1 > *str2)
		return 1;
	else
		return -1;
}

int main()
{
	char arr1[10] = "ab";
	char arr2[10] = "abb";
	int n = strcmp(arr1, arr2);
	printf("%d\n", n);
}

char arr[10]={0};  创建包含10个元素的数组，初始化为0；

char * str=NULL;  创建了一个字符型空指针；

6、长度受限制的字符串函数（相对安全）

(1)strncpy

char* strncmp(char* dest, const char* src, size_t num);

将arr2中的num个元素，拷贝到arr1中，若arr2中的元素少于要拷贝的数，用'\0'补够num个数；

char* my_strncpy(char* dest, const char* src,size_t num)
{
	assert(dest && src);  //指针断言
	char* ret = dest;     //保存目的字符串地址
	
	size_t count = 0;
	while (count < num)
	{
		if (*src)
		{
			*dest++ = *src++;
			count++;
		}
		else    //源字符串元素个数小于num，用'\0'补够num
		{
			*dest++ = 0;
			count++;
		}
		return ret;
	}

	return ret;
}


int main()
{
	char arr1[10] = "xxx\0xxxx";
	char arr2[] = "abc";
	strncpy(arr1+2, arr2,2);
 	printf("%s\n", arr1);
	return 0;
}

（2）strncat

char * strncat( char* dest, const char* src, size_t num);

追加时，源字符串个数小于num时，用'\0'替代，但只一个'\0'，不完全补够'\0'；

追加完，自动填充末尾'\0',构成完整字符串；

（3）strncmp

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

比较到出现有个字符不一样或者一个字符串结束或者num个字符全部比较完。

int main()
{
    char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
    int n;
    puts("Looking for R2 astromech droids...");
    for (n = 0; n < 3; n++)
        if (strncmp(str[n], "R2xx", 2) == 0)
        {
            printf("found %s\n", str[n]);
        }
    return 0;
}


//运行结果：
Looking for R2 astromech droids...
found R2D2
found R2A6

7、strstr 查找

（1）strstr

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

指向str2指定的的字符串，在str1指定的字符串中，第一次出现的位置（返回的是指针），若不存在返回空指针（简单来说就是在arr1字符串中找arr2字符串第一次出现的位置）；

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

char* my_strstr(const char* str1, const char* str2)
{
	char* p1;
	char* p2;

	if (*str2 == '\0')
		return str1;
	while (*str1)
	{
		p1 = str1;
		p2 = str2;
		while (*p1 && *p2 && (*p1 == *p2))
		{
			p1++;
			p2++;
		}
		if (*p2 == '\0')
			return str1;
		str1++;
	}
	return NULL;

}

int main()
{
	char arr1[] = "this is a simple world";
	char arr2[] = "simple";
	char* ret = my_strstr(arr1, arr2);
	strncpy(ret, "perfect", 6);
	if (ret != NULL)
		puts(arr1);
	else
		printf("找不到\n");
	return 0;
}

（2）strtok

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

sep参数指向字符串，用作分隔符的字符集合；

str参数指向一个字符串，包含了( 0个或多个由sep字符串中一个或多个分隔符分割的 )标记；

strtok函数找到str中的下一个标记，并将其用'\0'结尾，返回一个指向这个标记的指针；（strtok会改变str字符串，所以使用strtok切割的字符串一般都是临时拷贝的内容且可修改；为了保证原str字符串不变，只修改拷贝的内容）；

（1）strtok函数的str参数不为NULL时，函数将找到str中的第一个标记，并保存此标记在字符串中的位置；

（2）strtok函数的str参数为NULL时，函数将在同一个字符串中被保存的位置开始，查找下一个标记；如果字符串中不存在更多的标记，则返回NULL指针；（函数内部有记录功能）

strtok函数使用举例：

#include<stdio.h>
#include<string.h>
char * strtok(char* str,const char* sep);

int main()
{
	char arr[] = "3055648709@qq.com#haihai";
	char sep[] = "@.#";
	char copy[100] = { 0 };
	strcpy(copy, arr);  //拷贝一份，用来修改
	char* ret = NULL;    //创建保存标记位置的指针，初始化为空指针，防止它出去野

	ret = strtok(copy, sep);//第一个参数不为空，将修改此分隔符为\'0',将保存第一个标记的位置，并返回此地址；
	printf("%s\n", copy);
	ret = strtok(NULL, sep);//第一个参数为空时，从上次保存的标记的位置开始，找下一个标记并返回此地址
	printf("%s\n", ret);
	ret = strtok(NULL, sep);
	printf("%s\n", ret);
	ret = strtok(NULL, sep);
	printf("%s\n", ret);
	ret = strtok(NULL, sep);
	printf("%s\n", ret);
	return 0;
}

使用优化： 在于for循环中ret指针只被初始化一次，巧妙

int main()
{
	char arr[] = "3055648709@qq.com#haihai";
	char sep[] = "@.#";
	char copy[100] = { 0 };
	strcpy(copy, arr);  
	char* ret = NULL;    

	for (ret = strtok(copy, sep); ret != NULL; ret = strtok(NULL, sep))
	{
		printf("%s\n", ret);
	}
	return 0;
}

使用优化： 

int main()
{
	char arr[] = "3055648709@qq.com#haihai";
	char copy[100] = { 0 };
	strcpy(copy, arr);  

	char* ret = strtok(copy,"@.#"); 
	while (ret)
	{
		printf("%s\n", ret);
		ret = strtok(NULL, "@.#");
	}

	return 0;
}

 8、strerror 错误信息报告

（1）strerror

char* strerror( int errnum );

库函数在执行的时候，发生了错误，会立马把错误码存放在errno这个变量中，errno是C语言提供的一个全局变量；

函数返回 库函数错误码所对应的 错误信息字符串的 首字符地址；

可使用strerror函数将错误码转换为错误信息，提高可读性；printf(" %s\n ", strerror( errno ) );

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

int main()
{
	FILE* pf = fopen("data.text", "r");  //只读方式，打开当前目录下此文件

	if (pf == NULL)         //打开失败
	{
		//(1)
		printf("fopen:%s\n", strerror(errno));   //strerror:仅将错误码翻译为错误信息
		//(2)
		perror("fopen");   //perror:打印自定义信息，打印一个冒号，再打印错误信息
		return 1;   //函数结束
	}

	//打开成功，读文件...
	//关闭文件
	fclose(pf);
	return 0;
}

（1.1）strerror函数，仅将错误码翻译为错误信息，并返回错误信息字符串的首字符地址；需手动打印错误信息；

（1.2）perror函数：无需错误码，直接打印错误信息； 

（1.3）库函数在执行时，若出错，错误码会被更新，所以要即时检查错误并修正；

9、字符操作

（1）字符分类库函数

（1.1）isupper、islower函数使用举例： 

（1.2）将字符串中的小写字母转换为大写字母，函数实现及运行结果：

ctype：字符类型；%c打印字符

#include<ctype.h>
int main()
{
	char arr[20] = { 0 };
	gets(arr);

	char* p = arr;
	while (*p)
	{
		if (islower(*p))       //判断是否为小写字母
			*p = toupper(*p);  //将小写字母转换为大写字母
		p++;
	}
	puts(arr);