字符函数和字符串函数 ———程序小白的c语言学习

原创已于 2025-05-22 00:31:54 修改 · 1k 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #学习 #开发语言

于 2025-05-22 00:31:01 首次发布

自勉专栏收录该内容

4 篇文章

订阅专栏

各位大佬好，这是我学习c语言的一些记录，用于后续自己的复习，共勉。

我的gitee对应的链接 Stream cday37，cday38

字符函数和字符串函数

⽬录：

1. 字符分类函数

2. 字符转换函数

3. strlen的使⽤和模拟实现

4. strcpy的使⽤和模拟实现

5. strcat的使⽤和模拟实现

6. strcmp的使⽤和模拟实现

7. strncpy函数的使⽤

8. strncat函数的使⽤

9. strncmp函数的使⽤

10. strstr的使⽤和模拟实现

11. strtok函数的使⽤

12. strerror函数的使⽤

1.字符分类函数

在写程序的过程中，我们总是会遇见一些字符，大小写字母，各种数字，c语言为我们提供了这一类用来作字符分类的，这些函数的使用需要包含一个头文件ctype.h

下面贴出对应的函数

函数的使用非常类型，下面用一个函数进行解释

函数原型：

int islower ( int c );

islower 是能够判断参数部分的 c 是否是⼩写字⺟的。

通过返回值来说明是否是⼩写字⺟，如果是⼩写字⺟就返回⾮0的整数，如果不是⼩写字⺟，则返回 0。

下面是举例：将小写字母转换成大写字母，其他字符不变中，islower的应用

#include<stdio.h>
#include<ctype.h>
int main()
{
    int i = 0;
    char str[] = "Test A Code";
    char c; 
    while(str[i])
    {
        c = str[i];
        if(islower(c))
            c -= 32;
            putchar(c);
            i++;
    }
    return 0;
}

2.字符转换函数

c语言提供了两个字符转换函数：

1. int tolower ( int c ); //将参数传进去的⼤写字⺟转⼩写
     
2. int toupper ( int c ); //将参数传进去的⼩写字⺟转⼤写

那么我们用字符转换函数来完成上面一段代码的效果

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

简单替换即可。

下面进入字符串函数部分。

3.strlen的使用和模拟实现

size_t strlen (const char* str);

• 字符串以 '\0' 作为结束标志，

strlen函数返回的是在字符串中 '\0' 前⾯出现的字符个数（不包含' \0 ')

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

• 注意函数的返回值为size_t，是⽆符号的（易错)

• strlen的使⽤需要包含头⽂件<string.h>

• 学会strlen函数的模拟实现

#include <stdio.h>
#include <string.h>
int main()
 {
     const char* str1 = "abcdef";
     const char* str2 = "bbb";
     if(strlen(str2)-strlen(str1)>0)
     {
         printf("str2>str1\n");
     } 
    else
     {
         printf("srt1>str2\n");
     }
     return 0;
 }

strlen的模拟实现

1.用计数器的方法，刚好到'\0'的位置结束循环

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

2.利用递归的方法

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

3.利用指针减指针的方式，

指针减指针可以得到其指针类型之间的个数

int my_strlen(char *s)
 {
     assert(str);
     char *p = s;
     while(*p != '\0' )
     p++;
     return p-s;
 }

4.strcpy的使⽤和模拟实现

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

• CopiestheCstringpointedbysourceintothearraypointedbydestination,
including theterminating null character(and stopping at that point).
>源字符串必须以'\0'结束。
•会将源字符串中的'\0'拷⻉到⽬标空间。
•⽬标空间必须⾜够⼤，以确保能存放源字符串。
•⽬标空间必须可修改。
•学会模拟实现。

strcpy有两个参数，一个是目标字符串，一个是你要复制的字符串。

要注意有三点

1.复制的字符串要有'\0',不然复制过去的字符串没有'\0',结束不了，会有问题。

2.目标字符串要足够大，不然放不下。要提前设置目标字符串的大小，下面有体现

3.是将源字符串覆盖到目的字符串上

strcpy模拟实现

模拟实现
1.参数顺序
2.函数的功能，停⽌条件
3.assert
4.const 修饰指针
5.函数返回值

	char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while ((*dest++ = *src++))  
	{
		;
	}
	return ret;
}

这个代码写得很是巧妙，可以体会一下

先赋值，再返回值，这个返回的值应当是 *dest

出⾃《⾼质量C / C++ 编程》书籍最后的试题部分

5. strcat的使⽤和模拟实现

Appends a copy of the source string to the destination string. The terminating null character in destination is overwritten by the first character of source, and a null-character is included at the end of the new string formed by the concatenation of both in destination.

•源字符串必须以'\0'结束。
•⽬标字符串中也得有\0，否则没办法知道追加从哪⾥开始。
•⽬标空间必须有⾜够的⼤，能容纳下源字符串的内容。
•⽬标空间必须可修改。
•字符串⾃⼰给⾃⼰追加，如何？

char* my_strcat(char* dest, const char* src)

strcat的模拟实现


char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
assert(dest != NULL);
assert(src != NULL);
while (*dest)
{
	dest++;
}
while ((*dest++ = *src++))  //注意写法
{
	;
}
return ret;
 }

多了一个移地址的循环，不多作解释。

6. strcmp的使⽤和模拟实现

This function starts comparing the first character of each string. If they are equal to each other, it continues with the following pairs until the characters differ or until a terminating null-character is reached.

•标准规定：
◦第⼀个字符串⼤于第⼆个字符串，则返回⼤于0的数字
◦第⼀个字符串等于第⼆个字符串，则返回0
◦第⼀个字符串⼩于第⼆个字符串，则返回⼩于0的数字

总结一下，也就是左边跟右边比
◦那么如何判断两个字符串？

⽐较两个字符串中对应位置上字符ASCII码值的⼤⼩。

说一下大概思路，

1.从第一个字符开始遍历，也就需要一个循环，那循环条件是什么呢？我以 *str1 == *str2 ，也就是两个字符ascii码一样，

2.如果相等，就两个字符地址往后推一

3.直到某一个字符串到达 \0

4.最后返回 *str1 - *str2 的值，也就是前面所写的返回大于（小于）的值的原因

strcmp模拟实现

int my_strcmp(const char* str1, const char* str2)
{
	int ret = 0;
	assert(str1 != NULL);
	assert(str2 != NULL);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	return *str1 - *str2;    //这是一种写法，另一种写法用1，0，-1，if来表达
                             //也就是先判断大小，再人工返回大小，比较直接的思路
}

7.strncpy函数的使用

与前面类似，只是多了个可限制数量的参数，使得函数更为安全

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

Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.

• 拷⻉num个字符从源字符串到⽬标空间。
• 如果源字符串的⻓度⼩于num，则拷⻉完源字符串之后，在⽬标的后边追加0，直到num个。

会追加什么意思呢，下面是举例

int main()
{
    char str1[20] = "xxxxxxxxxxxxxx";
    char str2[] = "bbbbb";
    strncpy(str1, str2, 7);
        return 0;
}

通过调试，可以看到后面＋0了

8.strncat函数的使⽤

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

• Appends the first num characters of source to destination, plus a terminating null-character.（将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加⼀个 \0 字
符）

• If the length of the C string in source is less than num, only the content up to the terminating null-character is copied.（如果source 指向的字符串的⻓度⼩于num的时候，只会将字符串中到\0的内容追加到destination指向的字符串末尾）。

例子

int main()
{
	char str1[20];
	char str2[20];
	strcpy(str1, "To be ");
	strcpy(str2, "or not to be");
	strncat(str1, str2, 6);
	printf("%s\n", str1);
	return 0;
}

9. strncmp函数的使⽤

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

⽐较str1和str2的前num个字符，如果相等就继续往后⽐较，最多⽐较num个字⺟，如果提前发现不⼀样，就提前结束，⼤的字符所在的字符串⼤于另外⼀个。如果num个字符都相等，就是相等返回0.

与前面类似，不过多解释

10.strstr的使⽤和模拟实现

Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.（函数返回字符串str2在字符串str1中第⼀次出现的位置）

The matching process does not include the terminating null-characters, but it stops there.

（字符串的⽐较匹配不包含\0字符，以\0作为结束标志）

这是一个在一个字符串中找另一个字符串的函数，类似与我们平常的搜索

找不到会返回Null，找到返回对应首字符的地址

下面是举例


int main()
{
	char str[] = "This is a simple string";
	char* pch;
	pch = strstr(str, "simple");
	strncpy(pch, "sample", 6);
	printf("%s\n", str);
	return 0;
}

int main()
{
    char arr1[] = "abcdefg";
    char arr2[] = "cde";
    const char* ret = strstr(arr1, arr2);
    if (ret == NULL)
        printf("找不到\n");
    else
        printf("%s\n", ret);

}

strstr的模拟实现

较难，有多种情况

第一,二种情况：

从开头开始找，和从中间找，相对简单，注意先动s1，等到 *s1 == *s2 时，再开始进行比较就行

第三种情况

很是复杂，得进入比较多次，当你第一次进入比较时失败，又得全部重置，让s2回到原始地址，

同时s1也得回归，不然类似在 "bbbc"中找"bbc",会出现问题

那这样就尽量不要动str1，str2的地址，需要多的指针变量来记录重要位置，比如起始位置，现在比较的位置，于是乎我给了多个变量，分别是 str1,str2,cur,s1,s2,

cur 变量用来记录目前在str1字符串中比较到的位置

而s1，s2，用来比较是否符合，s1进入的位置即为 *cur == *str2 ，

后面只需写一个循环让 *s1 == *s2 即可实现功能

注意判断，str1，str2，的结束 "\0",

str1的判断是为了结束查找，当str2还在找时，但str1找完，提前结束

str2的判断是为了找完str2

最后返回 cur的地址就行

再考虑一些特殊情况，就能完成模拟实现了。

特殊情况：str2 为空指针，

1.从开头开始找，
2.从中间
3.重复比如找bbc  "bbbc"   所以这里要记住进入的坐标，不要动初始进来的指针，而是重新创建指针
                         同时还得记住每一次从str1 有可能匹配的位置（移动p）
                          然后回归s1 ————》p1，s2 》str1


const char* my_strstr(const char* str1, const char* str2)
{
    //char* s1 = NULL;
    //char* s2 = NULL;  
     const  char* s1 = str1;//注意这里str1受限制，但是s1不受，扩大了权限，
                            //不安全，所以要加const
     const char* s2 = str2;
     const char* cur/*current*/ = str1;

     assert(str1, str2);
     if (*str2 == '\0')  // 特殊情况
         return NULL;
     //得让 cur指针遍历str1找
     while (*cur)
     {
         s1 = cur;   
         s2 = str2;
         //if (*s1 == *s2)
         //{
         //    s1++;
         //    s2++;
         //}                这里可以直接开始找，看看能不能匹配完，
         while (*s1 == *s2 && *s2 != '\0' && *s1 != '\0') // 保证s1到末尾会停下来
                                                          //，s2找完，一样           
         {
             s1++;
             s2++;
         }          
         if (*s2 == '\0')
             return cur;  //找到了对应的地址 
         cur++;

     }
     //*cur == '\0'
     return NULL;
}


int main()
{
    char arr1[] = "abcdefg";
    char arr2[] = "cde";
    const char* ret = my_strstr(arr1, arr2);
    if (ret == NULL)
        printf("找不到\n");
    else
        printf("%s\n", ret);

}

11.strtok函数的使用

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

• sep参数指向⼀个字符串，定义了⽤作分隔符的字符集合
• 第⼀个参数指定⼀个字符串，它包含了0个或者多个由sep字符串中⼀个或者多个分隔符分割的标
记。
• strtok函数找到str中的下⼀个标记，并将其⽤ \0 结尾，返回⼀个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以被strtok函数切分的字符串⼀般都是临时拷⻉的内容并且可修改。）

• strtok函数的第⼀个参数不为 NULL ，函数将找到str中第⼀个标记，strtok函数将保存它在字符串中的位置。（这里是重点，函数中含有static变量，延长了变量的寿命，保持了位置）
• strtok函数的第⼀个参数为 NULL ，函数将在同⼀个字符串中被保存的位置开始，查找下⼀个标
记。
• 如果字符串中不存在更多的标记，则返回 NULL 指针。

用来切割字符串

strtok用法

int main()
{
	char arr[] = "ababa@obi.com";
	char tmp[30] = { 0 };
	strcpy(tmp, arr);
	const char* sep = "@.";
	//切割tmp中的数据
	char* p = strtok(tmp, sep);
	printf("%s\n", p);
	p = strtok(NULL, sep);
	printf("%s\n",p);
	p = strtok(NULL, sep);
	printf("%s\n", p);
	return 0;
}

上面是用法，但显然不太适合平常使用。

eg1


//显然不适用，太麻烦
int main()
{
	char arr[] = "ababa@obi.com";
	char tmp[30] = { 0 };
	strcpy(tmp, arr);
	const char* sep = "@.";
	//切割tmp中的数据
	char* p = NULL; 
	for (p = strtok(tmp, sep); p != NULL; p = strtok(NULL, tmp))
//为什么第二次传的是NULL呢？strtok函数里头有static静态变量
	{
		printf("%s\n", p);
	}
	return 0;
}

eg2

int main()
{
    char arr[] = "192.168.6.111";
    char* sep = ".";
    char* str = NULL;
    for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
    {
    printf("%s\n", str);
    }
    return 0;
}

12. strerror函数的使用

char* strerror ( int errnum );

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

c语言实现中，库函数的使用，调用如果失败的话，会记录错误码
strerror 函数可以把参数部分错误码对应的错误信息的字符串地址返回来

C语⾔程序启动的时候就会使⽤⼀个全局的变量errno来记录程序的当前错误码，

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

	return 0;
}

下面引入一个函数

fopen（打开文件函数）

成功放到一个地址里
失败放NULL

int main()
{
	FILE* pFile;
	pFile = fopen("unexist.ent", "r");  //这是以r （read）的形式打开
	if (pFile == NULL)
	{
		perror("hehe"); //可加自定义信息  相当于printf +strerror
		printf("Error opening file unexist.ent: %s\n", strerror(errno)); //errno
}
	return 0;
}

其中的perror函数的作用，就是我给的下一行代码的作用。

perror函数相当于⼀次将上述代码中的第9⾏完成了，直接将错误信息打印出来。perror函数打印完参数部分的字符串后，再打印⼀个冒号和⼀个空格，再打印错误信息。