完全自学C(干货) —— 字符(串)函数

已于 2023-06-02 16:09:54 修改
阅读量250 收藏
点赞数 2
分类专栏： # C 编程语言 文章标签： c语言 编程语言
于 2021-07-08 00:33:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NapoleonCoder/article/details/118557592
版权

目录

一，计算字符串长度函数

strlen

二，与长度无关的字符串函数

strcpy

strcat

strcmp

三，需考虑长度的字符串函数

strncpy

strncat

strncmp

四，字符串查找函数

strstr

strtok

五，报告错误信息函数

strerror

六，字符操作库函数

一，计算字符串长度函数

  • 字符串，通常放在常量字符串或字符数组中；
  • 常量字符串，适用于对它不做修改的字符串函数；

strlen

size_t strlen( const char *string )

  • 求字符串长度，返回\0前出现的字符个数(不包含\0)；
    • 参数指向的字符串必须要以\0结束；
    • 返回size_t，无符号；
#include <stdio.h>
#include <assert.h>
//模拟实现strlen库函数
//计数器版本
size_t my_strlen(const char* str)
{
	assert(str);
	int count = 0;
	while (*str++)
	{
		count++;
	}
	return count;
}

//递归版本<不创建变量>
//指针减指针版本

int main()
{
	char str[] = "abcd";
	printf("%d ", my_strlen(str));
    return 0；
}
int main()
{
	//strlen返回无符号数
	if (strlen("abcd") - strlen("abcdef") > 0)
		printf(">\n");
	else
		printf("<\n");
	return 0;
}
//结果：>

二，与长度无关的字符串函数

  • strcpy
  • strcat
  • strcmp

strcpy

char* strcpy ( char* destination，const char* source )

  • 将源字符串复制到目标字符串内；
    • 源字符串必须要以\0结束；
    • 源字符串中\0也会拷贝到目标空间；
    • 目标空间必须足够大以保证能存放源字符串；
    • 目标空间必须可改变，即可修改；
#include <stdio.h>
#include <assert.h>
//模拟实现strcpy库函数
char* my_strcpy(char* dest, const char* src)
{
	assert(dest);
	assert(src);

	char* tmp = dest;
	while (*dest++ = *src++);

	return tmp;
}

int main()
{
	char dest[] = "abcdefg";
	char sour[] = "efg";
	printf("%s\n", my_strcpy(dest, sour));
	return 0;
}
int main()
{
	//目标为常数字符串，不可修改，结果会报错
	char* dest = "abcd";
	char* src = "efg";
	strcpy(dest, src);
	return 0;
}
//注意，自己向自己后面地址复制，结果错误
//使用自己模拟实现的函数，报错（\0被覆盖）
int main()
{
	char str1[20] = "abcdefg";
	printf("%s ", strcpy(str1 + 2, str1));
	return 0;
}
//结果：abcdcdg

strcat

char* strcat ( char* destination，const char* source )

  • 将源字符串连接或追加到目标字符串；
    • 源字符串必须要以\0结束；
    • 目标空间必须足够大以保证能存放源字符串；
    • 目标空间必须可改变，即可修改；
    • 此库函数无法自己追加自己（末尾\0被覆盖了），自己追加自己可使用strncat；
#include <stdio.h>
#include <assert.h>
//模拟实现strcat库函数
char* my_strcat(char* dest, const char* src)
{
	assert(dest);
	assert(src);

	char* tmp = dest;
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++);

	return tmp;
}

int main()
{
	char dest[20] = "abcdefg";
	char sour[] = "efg";
	printf("%s\n", my_strcat(dest, sour));
	return 0;
}

strcmp

int strcmp ( const char* str1，const char* str2 )

  • 比较两字符串每个字符，无符号值比较；
    • >0，字符串1大于字符串2，返回大于0的数字；
    • =0，字符串1等于字符串2，返回0；
    • <0，字符串1小于字符串2，返回小于0的数字；
#include <stdio.h>
#include <assert.h>
//模拟实现strcmp库函数
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1);
	assert(str2);

	while (*(unsigned char*)str1 == *(unsigned char*)str2 && *str1)
	{
		str1++;
		str2++;
	}

	//大于返回1，小于返回-1，等于返回0
	return (*(unsigned char*)str1 > *(unsigned char*)str2) - (*(unsigned char*)str1 < *(unsigned char*)str2);
}

int main()
{
	char dest[] = "efg";
	char sour[] = "efg";
	printf("%d ", strcmp(dest, sour));
	printf("%d ", my_strcmp(dest, sour));
	return 0;
}
//结果：-1 -1

三，需考虑长度的字符串函数

  • strncpy
  • strncat
  • strncmp

strncpy

char* strncpy ( char* dentination，const char* source，size_t num )

  • 拷贝num个字符，从源字符串到目标字符串；
    • 如源字符串长度小于num，则追加0，直到num个为止；
    • 目标空间必须足够大以保证能存放源字符串；
    • 目标空间必须可改变，即可修改；
#include <stdio.h>
#include <assert.h>
//模拟实现strncpy库函数
char* my_strncpy(char* dest, const char* src, size_t num)
{
	assert(dest);
	assert(src);
	char* tmp = dest;
	//当num小于src长度时，num要放在前面，num为0时*dest++ = *src++就不计算了
	//当num大于src长度时，复制的个数会多一位
	while (num && (*dest++ = *src++)) 
		num--;
	if (num)
	{
		while (--num)
			*dest++ = '\0';
	}
	return tmp;
}

int main()
{
	char str1[] = "abcdefg";
	char str2[] = "qwe";
	printf("%s\n", my_strncpy(str1, str2, 3));
    return 0;
}

strncat

char* strncat ( char* dentination，const char* source，size_t num )

  • 追加num个字符，从源字符串到目标字符串；
    • 如源字符串长度小于num，首个\0后的不在追加；
    • 目标空间必须足够大以保证能存放源字符串；
    • 目标空间必须可改变，即可修改；

注：可自己追加自己；

#include <stdio.h>
#include <assert.h>
//模拟实现strncat库函数
char* my_strncat(char* dest, const char* src, size_t num)
{
	assert(dest);
	assert(src);
	char* tmp = dest;
	while (*dest++);
	dest--;
	while (num)
	{
		if ('\0' == (*dest++ = *src++))
			return tmp;
		num--;
	}	
	*dest = '\0';
	return tmp;
}

int main()
{
	char str1[20] = "abcd";
	char str2[] = "qwe";
	printf("%s\n", my_strncat(str1, str2, 2));
	return 0;
}

strncmp

int strncmp ( const char* str1，const char* str2，size_t num )

  • 比较到出现另个字符不一样；或者一个字符串结束；或者num个字符全部比较完；
    • 1，字符串1大于字符串2，返回大于0的数字；
    • =0，字符串1等于字符串2，返回0；
    •  -1，字符串1小于字符串2，返回小于0的数字；
#include <stdio.h>
#include <string.h>
#include <assert.h>
//模拟实现strncmp库函数
int my_strncmp(const char* str1, const char* str2, size_t num)
{
	assert(str1);
	assert(str2);
	if (!num)
		return 0;
	while (num--)
	{
		if (*str1 == 0 || *str1 != *str2)
		{
			//大于返回1，小于返回-1，等于返回0
			return (*(unsigned char*)str1 > *(unsigned char*)str2) - (*(unsigned char*)str1 < *(unsigned char*)str2);
		}
		str1++;
		str2++;
	}
	return 0;
}

int main()
{
	char str1[] = "abc";
	char str2[] = "ab";
	printf("%d ", strncmp(str1, str2, 3));
	printf("%d ", my_strncmp(str1, str2, 3));
	return 0;
}
//结果：1 1

四，字符串查找函数

  • strstr
  • strtok

strstr

char* strstr(const char* str1，const char* str2)

  • 查找子字符串；
    • 返回首次符合条件的指针，不存在返回NULL；
    • 学习kmp算法；
#include <stdio.h>
#include <assert.h>
//模拟实现strstr库函数
char* my_strstr(const char* str, const char* substr)
{
	assert(str);
	assert(substr);
	const char* s1 = NULL;
	const char* s2 = NULL;
	const char* tmp = str;
	if ('\0' == *substr)
		return (char*)str;
	while (*tmp)
	{
		s1 = tmp;
		s2 = substr;
		while (*s1 && *s2 && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if ('\0' == *s2)
			return (char*)tmp;
		tmp++;
	}
	return NULL;
}

int main()
{
	char str1[] = "abcdef";
	char str2[] = "cf";
	printf("%s\n", my_strstr(str1, "\0"));
	return 0;
}

strtok

char* strtok(char* str1，const char* sep)

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

注：记录位置，可为static修饰的局部变量；

int main()
{
	char str[] = "ab/cde.gh?ex"; //"ab/cde.gh?ex\0"
	char sep[] = "/.?"; //"/.?\0"
	//因为会修改被操作的字符串，一般对临时拷贝进行操作
	char tmp[20] = {0};
	strcpy(tmp, str);

	char* token = NULL;

	token = strtok(tmp, sep); //从头开始查找，返回标记段的首位置指针，并记录第一个分隔符位置；
	printf("%s\n", token); //结果：ab；

	token = strtok(NULL, sep); //从上个记录位置开始查找，返回标记段的首位置指针，并记录第二个分隔符位置；
	printf("%s\n", token); //结果：cde；

	token = strtok(NULL, sep); //从上个记录位置开始查找，返回标记段的首位置指针，并记录第三个分隔符位置；
	printf("%s\n", token); //结果：gh；

	token = strtok(NULL, sep); //从上个记录位置开始查找，返回标记段的首位置指针，查找到\0表示已查找到末尾；
	printf("%s\n", token); //结果：ex；

	token = strtok(NULL, sep); //已查找到末尾，在查找即返回NULL；
	printf("%s\n", token); //结果：(null)；

    return 0；
}
int main()
{
	char str[] = "ab/cde.gh?ex"; //"ab/cde.gh?ex\0"
	char sep[] = "/.?"; //"/.?\0"
	//因为会修改被操作的字符串，一般对临时拷贝进行操作
	char tmp[20] = { 0 };
	strcpy(tmp, str);

	char* token = NULL;
    
    //方法一
	token = strtok(tmp, sep); 
	printf("%s\n", token); //结果：ab；
    //通常循环操作
	while(token = strtok(NULL, sep))
	{
		printf("%s\n", token); 
	}

    //方法二
    strcpy(tmp, str);
	for (token = strtok(tmp, sep); token != NULL; token = strtok(NULL, sep))
	{
		printf("%s\n", token);
	}
	return 0;
}

五，报告错误信息函数

strerror

char* strerror(int errnum)

  • 返回错误码所对应的错误信息；
    • 调用库函数失败时，都会设置错误码；
    • int errno 为全局的错误码，即错误信息对应的错误码储存在此变量内；
    • 关联perror，首先会把错误码转化为错误信息，在打印错误信息(可包含自定义信息)；
#include <stdio.h>
#include <string.h>
int main()
{
    //错误码代表的信息
	printf("%s\n", strerror(0)); //No error
	printf("%s\n", strerror(1)); //Operation not permitted
	printf("%s\n", strerror(2)); //No such file or directory
	printf("%s\n", strerror(3)); //No such process
	printf("%s\n", strerror(4)); //Interrupted function call
	printf("%s\n", strerror(5)); //Input/output error
}
#include <stdio.h>
#include <string.h>
#include <errno.h> //必须包含的头文件

int main()
{
	FILE* pf = fopen("test.txt", "r"); //只读打开test文件

	if (NULL == pf)
	{
		printf("%s\n", strerror(errno)); //No such file or directory
        perror("fopen"); //fopen: No such file or directory
	}

    fclose(pf)
    pf = NULL;

	return 0;
}

六，字符操作库函数

常用字符操作库函数（见下表格）：

 字符转换：

  • tolower - 大写改小写
  • toupper - 小写改大写
#include <ctype.h>
int main()
{
	printf("%d\n", iscntrl('\0')); //32
	printf("%d\n", isspace(' ')); //8
	printf("%d\n", isdigit('1')); //4
	printf("%d\n", isxdigit('f')); //128
	printf("%d\n", islower('a')); //2
	printf("%d\n", isupper('A')); //1
	printf("%d\n", isalpha('a')); //2
	printf("%d\n", isalnum('0')); //4
	printf("%d\n", ispunct('!')); //16
	printf("%d\n", isgraph('{')); //16
	printf("%d\n", isprint(' ')); //64
}
#include <ctype.h>
int main()
{
	char str[] = "AcdD";
	
	int i = 0;
	while (str[i])
	{
		if (islower(str[i]))
			str[i] = toupper(str[i]);
		i++;
	}
	printf("%s\n", str); 
	return 0;
}
//结果：ACDD

挨代码
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
07-字符与字符串-自己使用的C语言教程PPT-适合老师备课或者自学.pptx
11-14
07-字符与字符串-自己使用的C语言教程PPT-适合老师备课或者自学
Go语言自学十八式：字节型、字符型和字符串篇
01-07
byte 和 rune byte，占用1个节字，就 8 个比特位，所以它和 uint8 类型本质上没有区别，它表示的是 ACSII 表中的一个字符。 rune，占用4个字节，共32位比特位，所以它和 ... // 8进制写法: var c byte = '\101' 其中
完全自学C(干货) —— 函数
NapoleonCoder的博客
06-28 207
即子程序，是大型程序中某部分代码，由一个或多个语句块组成，通常被集成为软件库；
0基础C语言自学教程——第十节 字符串函数
jxwd的博客
01-14 606
1、*strlen 2、*strcpy 3、*strcat 4、*strcmp 5、strncpy 6、strncat 7、*strstr 8、strtok 9、*memcpy 10、*memmove 11、memcmp
完全自学C(干货) —— 预处理详解
NapoleonCoder的博客
04-05 783
预处理；
完全自学C(干货) —— 数组
NapoleonCoder的博客
06-30 739
一组相同类型元素的集合，可存储一系列相同类型的数据；
完全自学C(干货) —— C简介
NapoleonCoder的博客
06-15 2031
C介绍
完全自学C(干货) —— 文件
NapoleonCoder的博客
07-25 399
文件名/文件指针/文件的打开和关闭/文件的顺序读写/文件的随机读写/文本文件和二进制文件/文件的结束判定/文件缓冲区；
完全自学C(干货) —— 指针进阶
NapoleonCoder的博客
07-04 222
字符指针； 数组指针/指针数组； 数组传参/指针传参； 函数指针/函数指针数组； 指向函数指针数组的指针； 回调函数
完全自学C(干货) —— 调试
NapoleonCoder的博客
07-01 122
Debug，又称除错，即发现和减少程序错误的过程；
FORTRAN完全自学手册_FORTRAN完全自学手册_yourselfars_
10-03
FORTRAN完全自学手册，用于指导初学者学习
GPU编程自学10——流并行
02-25
传统的中央处理器（CPU，CentralProcessingUnit)内部结构异常复杂，主要是因为其需要很强的通用性来处理各种不同的数据类型，同时又要逻辑判断又会引入大量的分支跳转和中断的处理。为了提高计算能力，CPU通常会采取...
完全自学C(干货) —— 递归
NapoleonCoder的博客
06-28 176
程序调用自身的编程技巧，称为递归；
C++进阶 —— multimap
NapoleonCoder的博客
05-30 6095
关联式容器multimap；
C++初阶 —— 入门/概念
NapoleonCoder的博客
10-20 3608
C++相关概念！
C++进阶 —— 哈希
NapoleonCoder的博客
12-12 3124
哈希表！
C++初阶 —— list类
NapoleonCoder的博客
11-21 2411
list是可在常数范围内，在任意位置插入和删除的双向迭代序列式容器!
C++进阶 —— 列表初始化(C++11新特性）
最新发布
NapoleonCoder的博客
06-01 2238
列表初始化；
python自学第8天字典_python自学日记7——字典
05-26
可以使用`dict()`函数来创建一个字典，也可以使用`{}`来创建一个空字典。 接下来，我们来看一些常用的字典操作。 1. 访问字典元素 可以通过键来访问字典中的元素，例如： ``` print(my_dict['name']) # 输出：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值