首页 > 其他分享 >字符函数和字符串函数

字符函数和字符串函数

时间：2024-03-18 09:29:05浏览次数：24  
标签：字符 函数 int ret char 字符串 include

文章目录

字符函数和字符串函数

字符函数

下面介绍的函数均包含在头文件 <ctype.h> 中

字符分类函数

字符分类函数帮你判断一个字符是否是某个类型

我们举几个常见的字符分类函数：

  • 判断字符是否是小写字母
int islower(int c);

如果字符是小写字母，函数返回一个非零的整数；如果字符不是小写字母，返回0

例如：

#include <stdio.h>
#include <ctype.h>
int main()
{
    char c[] = {'g','2','S','!','\0'};
    int len = sizeof(c) / sizeof(c[0]);
    for(int i = 0; i < len - 1; i++)
    {
        int ret = islower(c[i]);
        if(ret)
        {
            printf("%c是小写字母\n",c[i]);
        }
        else
        {
            printf("%c不是小写字母\n",c[i]);
        }
    }
    return 0;
}
//打印结果是：
g是小写字母
2不是小写字母
S不是小写字母
!不是小写字母

字符分类函数的返回逻辑都是这样，判断为是，返回非0整数；判断不是，返回0。

在这里插入图片描述

字符转换函数

C提供了2个字符转换函数：字母大小写转换

int tolower(int c);//转换为小写
int toupper(int c);//转换为大写

以tolower为例，当我们传入的参数不是大写的字母时，返回值是原字符，不会做出任何改变；如果参数是大写的字母，则会返回它的小写字母。

#include <stdio.h>
#include <ctype.h>
int main()
{
    char a[] = "Hello FrIenDs";
    char c = 0;
    int i = 0;
    while(a[i])
    {
        c = toupper(a[i]);
        printf("%c",c);
        i++;
    }
    return 0;
}
//打印结果是：
HELLO FRIENDS

字符串函数

需要包含头文件 <string.h>

strlen

计算字符串长度

size_t strlen(const char* str);

  • 计算的是\0之前的字符的个数（不包含\0)。

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

  • 返回类型是size_t类型，是无符号整数类型，因为一个字符串的长度不可能为负数。

例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[10] = "abcdef";
    size_t ret = strlen(arr);
    printf("%d\n",ret);//打印结果是6
    return 0;
}

模拟实现

//1.
size_t My_strlen(const char* str)
{
    assert(str);
    size_t count = 0;
    while(*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}

//2.
size_t My_strlen(const char* str)
{
    assert(str);
    if(*str == '\0')
        return 0;
    else
    {
        return 1 + My_strlen(str++);
    }
}

//3.
size_t My_strlen(const char* str)
{
    assert(str);
    char* tmp = str;
    while(*str != '\0')
    {
        str++;
    }
    return str - tmp;
}

strcpy

拷贝字符串到指定地址

char* strcpy(char* destination， const char* source);
  • 目标字符串指向的空间必须可以修改，且足够大
  • 源字符串必须以\0结尾
  • 拷贝时会将\0拷贝到目标空间
  • 返回的是目标字符串的起始地址

例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char src[] = "hello friends";
    char des[20] = { 0 };
    char* ret = strcpy(des, src);
    printf("%s\n", ret);//打印hello friends
    return 0;
}

模拟实现

char* My_strcpy(char* des, const char* src)
{
    assert(des && src);
    char* tmp = des;
    while (*des++ = *src++)
    {
        ;
    }
    return tmp;
}

strcat

在某个字符串后追加字符

char* strcat(char* destination, const char* source);
  • 实现逻辑：strcat函数会寻找目标空间的\0,然后将源字符串追加到后面，注意从\0这个位置追加，覆盖目标空间的\0，最终也会将源字符串的\0拷贝过去。
  • 源字符串需要\0结尾，指示追加结束
  • 目标字符串需要\0结尾，指示追加开始的位置
  • 目标空间需要足够大并且可以修改
  • 返回目标字符串的地址

例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char a1[30] = "hello ";
    char a2[] = "friends";
    char* ret = strcat(a1, a2);
    printf("%s\n", ret);//打印hello friends
    return 0;
}

当然，字符串可以追加自己。

模拟实现

char* My_strcat(char* des, const char* src)
{
    assert(des && src);
    char* tmp = des;
    while (*des)
    {
        des++;
    }
    while (*des++ = *src++)
    {
        ;
    }
    return tmp;
}

strcmp

比较两个字符串的内容

int strcmp(const char* str1, const char* str2);
  • 比较方法：strcmp函数会将两个字符串一个一个进行比较，比较的是字符的ASCII码值，当两个字符的ASCII码值相等时，继续向后比较，当不相等时，若str1当前字符大于str2当前字符，函数返回一个大于0的数，相反，返回一个小于0的数

例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char a1[] = "abcdef";
    char a2[] = "abcdy";
    int ret = strcmp(a1, a2);
    if (ret > 0)
    {
        printf("a1 > a2\n");
    }
    else if (0 == ret)
    {
        printf("a1 = a2\n");
    }
    else
    {
        printf("a1 < a2\n");
    }
    printf("%d\n", ret);
    return 0;
}
//最终打印值为：
a1 < a2 
-1

strcmp函数比较的是内容，不是长度，在例子中a1长度比a2长，但是，y的 ASCII码值大于e的，所以a2更大。

模拟实现

int My_strcmp(const char* str1, const char* str2)
{
    assert(str1 && str2);
    while (*str1 == *str2)
    {
        if (*str1 == '\0')
        return 0;
        str1++;
        str2++;
    }
    return *str1 - *str2;
}

strncpy

拷贝指定数量的字符到目标空间

char* strncpy(char* destination, const char* source, size_t num);
  • num就是要拷贝的字符的数量
  • 拷贝后不会在后面放\0
  • 拷贝的个数比源字符串字符数量多，会用\0补充缺失的字符，直到拷贝加补充的字符数量达到num
  • 返回的是目标字符串地址

例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char a1[] = "hello friends";
    char a2[20] = { 0 };
    char* ret = strncpy(a2, a1, 5);
    printf("%s\n", ret);//输出hello
    return 0;
}

strncat

在字符串后追加指定数量的字符

char* strncat(char* destination, const char* source, size_t num);
  • num就是要追加的字符的数量
  • 追加后会自动放一个\0，但是如果想追加的个数比源字符串长，不会补\0，这里要区别strncpy函数
  • 返回目标字符串地址

例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char a1[30] = "hello friends";
    char a2[20] = "! how are you?";
    char* ret = strncat(a1, a2, 5);
    printf("%s\n", ret);//输出hello friends! how
    return 0;
}

strncmp

比较指定数量字符的内容

int strncmp(const char* str1, const char* str2, size_t num);
  • num就是要比较的字符的个数

例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char a1[30] = "abcdefw";
    char a2[20] = "abcdeff";
    int ret = strncmp(a1, a2, 5);
    if (ret > 0)
    {
        printf("a1 > a2\n");
    }
    else if (ret < 0)
    {
        printf("a1 < a2\n");
    }
    else
        printf("a1 = a2\n");
    return 0;
}
//输出：a1 = a2

strstr

在一个字符串里寻找另一个字符串。

char* strstr(const char* str1, const char* str2);
  • 在str1指向的字符串中寻找str2指向的字符串，如果找到了，返回第一次出现的位置；如果找不到返回NULL
  • \0不在比较范围内，作为结束标志

例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char a1[30] = "abcde";
    char a2[20] = "ddabcdeff";
    char* ret = strstr(a2, a1);
    printf("%s\n", ret);//打印abcdeff
    return 0;
}

模拟实现

char* My_strstr(const char* str1, const char* str2)
{
    assert(str1 && str2);
    const char* s1 = NULL;
    const char* s2 = NULL;
    const char* cur = str1;
    if (*str2 == '\0')//特殊情况：要寻找的是空字符串
        return (char*)str1;
    while (*cur)
    {
        s1 = cur;//s1记录每次开始比较的位置，每次寻找失败初始化
        s2 = str2;//s2记录每次开始比较的位置，每次寻找失败初始化
        while (*s1 == *s2 && *s1 != '\0' && *s2 != '\0')//找到相等的字符后面才可能找到指定字符串，继续向后比较，同时保证不是\0这一结束标志
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')//寻找成功的标志
            return (char*)cur;
        cur++;
    }
    return NULL;
}

strtok

通过分隔符（标志），将字符串分割

char* strtok(char* str, const char* delimiters);
  • delimiters指向的字符串，就是我们指定的分隔符（标志）的集合。可以是多个字符，字符内容不变的情况下，顺序无关结果。
  • strtok会在str指向的目标空间寻找指定的标志，找到后会将标志换成\0，然后返回标志位置之前的一段字符串的起始地址。
  • 由于strtok函数会改变目标字符串，所以我们在使用时，会将要查询的字符串strcpy一份，传参时传入拷贝的字符串的起始地址，strtok函数就会修改拷贝产生的空间的内容。
  • 值得注意的是，strtok会记录上一次标志的位置，当我再次调用strtok函数查询上一个目标空间时，第一个参数传NULL，strtok会寻找下一个标志。
  • 当字符串中不再有标志，返回NULL
#include <stdio.h>
#include <string.h>
int main()
{
    char a1[] = "310xxx2934@qq.com";
    char sign[] = "@.";
    char copy[20] = { 0 };
    //拷贝
    char* cop = strcpy(copy, a1);
    //第一次调用
    char* ret = strtok(copy, sign);
    printf("%s\n", ret);
    //之后调用
    ret = strtok(NULL, sign);
    printf("%s\n", ret);
   
    ret = strtok(NULL, sign);
    printf("%s\n", ret);
    
    ret = strtok(NULL, sign);
    printf("%s\n", ret);
    
    return 0;
}

打印结果：
    310xxx2934
    qq
    com
    (null)

strerror

会返回错误码对应的错误信息的字符串的地址

char * strerror ( int errnum );

  • errnum是错误码

  • 我们通常在使用strerror函数时，会传errno这个变量

    errno这个变量是在C程序开始时自动创建的一个全局变量。当我们在调用库函数时出错，errno变量会记录这一错误的错误码，比如0、1、2、3、4等等，我们当然不明白这个错误码是什么意思，基于此，头文件 <errno.h> 中记录了错误码对应的错误信息。

前面提到错误码是从0开始的，我们不妨打印一下0~10对应的的错误信息

#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
    for (int i = 0; i < 11; i++)
    {
        printf("%d  :%s\n", i, strerror(i));
    }
    return 0;
}
//这段代码的打印结果是：
0  :No error
1  :Operation not permitted
2  :No such file or directory
3  :No such process
4  :Interrupted function call
5  :Input/output error
6  :No such device or address
7  :Arg list too long
8  :Exec format error
9  :Bad file descriptor
10  :No child processes

我们再模拟一下调用函数出错的情况，并打印错误信息

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
int main()
{
    int* pi = (int*)malloc(10000000000000000000);
    if(pi = NULL)
    {
        printf("%s\n",strerror(errno));
    }
    free(pi);
    pi = NULL;
    return 0;
}
//malloc是一个库函数，当我们给malloc传入一个相当大的数字，malloc函数会返回NULL，我们将错误信息打印得到：
Not enough space

以上就是常见的字符函数和字符串函数了。

标签：字符,函数,int,ret,char,字符串,include
From： https://blog.csdn.net/xiaokuer_/article/details/136670193

相关文章

  • Python常用内置函数
    Python常用内置函数1类型转换函数2数学相关函数3序列相关函数4对象操作函数1类型转换函数int(a,base=10)用于将一个符合数字规范的字符串或数字转换为整型，参数base表示进制数，默认为十进制，base参数仅针对a参数是字符串时使用，若a参数是数字时使用base参数则会报......
  • 字符串拼接re.sub()用法
    re.sub()用法介绍re.sub()函数会搜索string中满足pattern的子串，并用repl替换它们。替换后的字符串作为函数返回值返回re.sub()语法：re.sub(pattern,repl,string,count=0,flags=0)参数：pattern：表示正则表达式中的模式字符串；repl：被替换的字符串（既可以是字符......
  • 基本常用函数len()
    len()函数len()函数用于返回一个对象的长度或项目个数。len()函数的语法格式如下：len(s)参数说明：●s:要获取其长度或项目个数的对象，如字符串、元组、列表、字典等。●返回值：对象的长度或项目个数。计算字符串的长度：>>>s="莫轻言放弃！”>>>len(s)6计算列表......
  • 【CenterFusion】损失函数Loss初始化_get_losses()函数以及计算过程forward()函数-Cen
    损失函数Loss初始化_get_losses函数以及计算过程forward函数1.损失函数初始化前序运行逻辑2.损失函数初始化2.1loss函数初始化——Trainer类中的_get_losses()函数2.2model_with_loss的初始化3.loss计算过程前序运行逻辑4.loss计算过程4.1loss计算函数调用关系4.......
  • string类对象成员函数及使用【笔记】
    文章目录一、常见构造二、string类对象的容量操作三、string对象的访问及遍历操作四、string类对象的修改操作（仅列举最常用的）五、getline()一、常见构造//1.空参构造，空字符串string(){}//2.用C-string构造string类对象string(constchar*str){}//3.......
  • 459. 重复的子字符串c
    voidbuild(char*s,int*next,intn){next[0]=-1;inti=1,j=-1;while(i<n){if(j==-1||s[j]==s[i-1]){next[i]=j+1;j++;i++;}else{j=next[j];}}for(inti=0;i&l......
  • 小新喊你了解字符串函数了（二）
    接上一篇，我们再学习四个新的字符串函数1.strstr函数的使用和模拟实现 char*strstr(constchar*str1,constchar*str2);strstr函数用于字符串的查到，在一个字符串中查找另一个字符串，找到了就返回字符串str2在字符串str1中第⼀次出现的位置 ，找不到就会返回NULL（空......
  • 代码随想录算法训练营第十天｜LeetCode 20.有效的括号、1047.删除字符串中的所有相邻重
    20.有效的括号题目链接：https://leetcode.cn/problems/valid-parentheses/description/解题思路：题目转化：三种类型的括号，需要做匹配匹配规则是：左右括号的类型要匹配、数量要一致，而且要按照顺序匹配例子是：“()”、“(){}[]”、“(([]))”条件转化：按照顺序匹配：......
  • 一.函数的递归
    简单而通俗易懂的说，函数的递归就是：函数自己调用自己。就是把大事化小事，递的意思就是推进的意思。归就是回归的意思。递归的限制：两个条件：1.递归存在限制条件，当满⾜这个限制条件的时候，递归便不再继续。                        ......
  • 学了 Python 但又感觉没学 Python 不如重学 Python - day2（基础内置函数与变量引用的详
    目录1、int函数2、bin、oct、hex 函数3、type函数4、complex函数5、布尔运算6、chr与ord函数7、max与min函数8、eval函数9、变量对象引用10、对象的垃圾回收11、变量命名规则12、序列赋值13、增强赋值1、int函数按n进制将整数字符串转换为......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99