扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > 其他教程 >C语言封装函数字符串练习汇总分享
  • 850

0
分享到

C语言封装函数字符串练习汇总分享

2024-04-02 19:04:59 850人浏览 安东尼
摘要

目录封装函数: 判断闰年和平年封装函数: 字符串查找(参考strstr)封装函数: 字符串比较(参考strcmp)封装函数: 字符串拼接(参考strcat)封装函数: 字符串转整数(

封装函数: 判断闰年和平年

该函数判断传入的年份是否是闰年和平年，通过返回值表示结果。

#include <stdio.h>
//函数声明
int GetYearSate(int year);

int main()
{
    int year;
    printf("请输入年份:");
    scanf("%d",&year);
    //判断闰年和平年
    if(GetYearSate(year))
    {
        printf("平年.\n");
    }
    else
    {
        printf("闰年.\n");
    }
    return 0;
}


int GetYearSate(int year)
{
    if((year%4==0 && year%100!=0)||(year%400==0))
    {
        return 0;
    }
    return 1;
}

封装函数: 字符串查找(参考strstr)

第一步查看帮助: man strstr

#include <stdio.h>
#include <string.h> //声明函数的
char *my_strstr(char *src_str,char *find_str);
int main()
{
    char src_str[100];//"123456789"
    char find_str[100];
    printf("请输入字符串:");
    scanf("%s",src_str);
    printf("请输入查找的字符串:");
    scanf("%s",find_str);
    
    //strstr() //查找到指定的字符串，会返回查找字符串在源字符串里的首地址
    printf("查找的字符串结果:%s\n",strstr(src_str,find_str));
    printf("查找的字符串结果:%s\n",my_strstr(src_str,find_str));
   return 0;
}

//函数功能: 字符串查找函数
//返回值: 返回查找到的字符串地址
char *my_strstr(char *src_str,char *find_str)
{
    int src_len;
    int find_len;
    int i,j;
    src_len=strlen(src_str);
    find_len=strlen(find_str);
    for(i=0;i<src_len;i++)
    {
        for(j=0;j<find_len;j++)
        {
            if(src_str[i+j]!=find_str[j])break;
        }
        //判断是否查找成功
        if(j==find_len)
        {
            //return &src_str[i];
            return src_str+i;
        }
    }
    return NULL;
}

封装函数: 字符串比较(参考strcmp)

#include <stdio.h>
#include <string.h> //声明函数的
int my_strcmp(char *s1,char *s2);

int main()
{
    char str1[100];//"123456789"
    char str2[100];
    printf("请输入字符串1:");
    scanf("%s",str1);
    printf("请输入字符串2:");
    scanf("%s",str2);
    
    //int strcmp(const char *s1, const char *s2);
    //比较两个字符串是否相等。通过返回值表示。
    printf("比较字符串的结果:%d\n",strcmp(str1,str2));
    printf("比较字符串的结果:%d\n",my_strcmp(str1,str2));
    return 0;
}


int my_strcmp(char *s1,char *s2)
{
    while(*s1!='\0' && *s2!='\0')
    {
        if(*s1!=*s2)break;
        s1++;
        s2++;
    }
    if(*s1=='\0'&&*s2=='\0')return 0;
    return 1;
}

封装函数: 字符串拼接(参考strcat)

#include <stdio.h>
#include <string.h> //声明函数的
char *my_strcat(char *s1,char *s2);

int main()
{
    char str1[100];//"123456789"
    char str2[100];
    printf("请输入字符串1:");
    scanf("%s",str1);
    printf("请输入字符串2:");
    scanf("%s",str2);
    
    //strcat 字符串拼接函数，拼接之后返回源字符串的首地址
   // printf("拼接的结果:%s\n",strcat(str1,str2));
    printf("拼接的结果:%s\n",my_strcat(str1,str2));
    return 0;
}

//函数功能: 字符串拼接
char *my_strcat(char *s1,char *s2)
{
    char *p=s1; //记录源字符串的首地址
    while(*s1 != '\0'){s1++;} //偏移到结尾
    while(*s2!='\0')
    {
        *s1=*s2;
        s2++;
        s1++;
    }
    *s1='\0';
    return p;
}

封装函数: 字符串转整数(参考atoi)

#include <stdio.h>
#include <string.h>
int my_atoi(char *str);
int main()
{
    char buff[100];
    printf("请输入一个整数字符串:");
    scanf("%s",buff);
    //字符串转整数
    printf("转换结果:%d\n",atoi(buff));
    printf("转换结果:%d\n",my_atoi(buff));
    return 0;
}


//"123ABC"
int my_atoi(char *str)
{
    int data=0;
    while(*str!='\0')
    {
        if(*str>='0' && *str<='9')
        {
            data*=10; //0  10 120
            data+=*str-'0';//1 12 123
        }
        else
        {
            break;
        }
        str++;
    }
    return data;
}

封装函数: 字符串转浮点数(参考atof)

“123.456789”    456789—>0.456789
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

double my_pow(double x,int y);
double my_atof(char *str,int cnt);

int main()
{
    char buff[100];
    printf("请输入一个浮点数字符串:");
    scanf("%s",buff);
    //字符串转浮点数
    printf("转换结果:%lf\n",atof(buff));
    printf("转换结果:%lf\n",my_atof(buff,3));
    return 0;
}


//"123.456  123"
double my_atof(char *str,int cnt)
{
    int data=0;
    int cnt_f=0;
    double data_f=0.0;
    while(*str!='\0' && *str!='.')
    {
        if(*str>='0' && *str<='9')
        {
            data_f*=10;
            data_f+=*str-'0';
        }
        else
        {
            break;
        }
        str++;
    }
    str++; //跳过 "."   "123.456789"
    while(*str!='\0' && cnt_f!=cnt)
    {
        if(*str>='0' && *str<='9')
        {
            data*=10;
            data+=*str-'0';
            cnt_f++; //记录小数部分数量
        }
        else
        {
            break;
        }
        str++;
    }
    
    //合成浮点数  "123.456"
    if(cnt>cnt_f)
    {
        cnt=cnt_f;
    }
    data_f+=data*my_pow(0.1,cnt);
    return data_f;
}

//函数功能:计算x的y次方
//my_pow(2,3);
double my_pow(double x,int y)
{
    double tmp=1.0;
    int i;
    for(i=0;i<y;i++)
    {
        tmp=tmp*x;//2.0  4.0  8.0
    }
    return tmp;
}

封装函数: 整数转字符串 123 “123”

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

void int_to_str(char *str,int data);
int main()
{
    int data;
    char buff[100];
    printf("请输入一个整数:");
    scanf("%d",&data);
    //整数转字符串
    int_to_str(buff,data);
    printf("buff=%s\n",buff);
    return 0;
}


void int_to_str(char *str,int data)
{
    char buff[100]; //存放第一次分离的数据
    int i=0;
    int j=0;
    while(data) //123
    {
        buff[i]=data%10+'0';
        data=data/10;
        i++;
    }
    for(j=0;j<i;j++)
    {
        str[j]=buff[i-1-j];
    }
    str[j]='\0';
}

//函数功能:计算x的y次方
//my_pow(2,3);
double my_pow(double x,int y)
{
    double tmp=1.0;
    int i;
    for(i=0;i<y;i++)
    {
        tmp=tmp*x;//2.0  4.0  8.0
    }
    return tmp;
}

封装函数: 浮点数转字符串 123.456 – “123.456”

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int my_pow(int x,int y);
void int_to_str(char *str,int data);
void double_to_str(char *str,double data_f,int cnt);
int main()
{
    double data;
    char buff[100];
    printf("请输入一个浮点数:");
    scanf("%lf",&data);
    double_to_str(buff,data,5);
    printf("buff=%s\n",buff);
    return 0;
}


void double_to_str(char *str,double data_f,int cnt)
{
    char buff[50]; //存放第一次分离的数据
    int i=0;
    int j=0;
    int n=0;
    int data_i1;
    int data_i2;
    double temp_f;
      //123.3
    data_i1=data_f; //123
    temp_f=data_f-data_i1;
    data_i2=temp_f*my_pow(10,cnt); //456
    
    while(data_i1)
    {
        buff[i]=data_i1%10+'0';
        data_i1=data_i1/10;
        i++;
    }
    
    for(j=0;j<i;j++)
    {
        str[j]=buff[i-1-j];
    }
    str[j]='.';
       // "123.456"
    while(data_i2)
    {
        buff[n]=data_i2%10+'0';
        data_i2=data_i2/10;
        n++;
    }
    
    for(j=0;j<n;j++)
    {
        str[j+i+1]=buff[n-1-j];
    }
    str[j+i+1]='\0';
}

//函数功能:计算x的y次方
//my_pow(2,3);
int my_pow(int x,int y)
{
    int tmp=1;
    int i;
    for(i=0;i<y;i++)
    {
        tmp=tmp*x;//2.0  4.0  8.0
    }
    return tmp;
}

浮点数转字符串 123.456  -- “123.456” 

float a=123.456;
int b=a; //b=123
a=a-b;  //a=0.456  10*10*10

封装函数: 判断回文字符串

该函数判断传入的字符串是否是回文，通过返回值表示结果。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int func(char *p);
int main()
{
    char buff[100];
    printf("输入字符串:");
    scanf("%s",buff);
    if(func(buff))printf("回文.\n");
    else printf("不是回文.\n");
    return 0;
}

//函数功能: "123"  "121"
int func(char *p)
{
    int i;
    int len;
    len=strlen(p);
    for(i=0;i<len/2;i++)
    {
        if(p[i]!=p[len-1-i])break;
    }
    if(i==len/2)return 1; //回文
    return 0; //不是回文
}

封装函数: 字符串替换

将源字符串里指定的单词替换成指定单词。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void str_func(char *str1,char *str2,char *str3);
int main()
{
    char str1[100];
    char str2[100];
    char str3[100];
    
    printf("输入源字符串:");
    scanf("%s",str1);
    printf("输入查找的字符串:");
    scanf("%s",str2);
    printf("输入替换的字符串:");
    scanf("%s",str3);
    str_func(str1,str2,str3);
    
    printf("str1=%s\n",str1);
    return 0;
}


//"123A789"   ""
void str_func(char *str1,char *str2,char *str3)
{
    int str1_len=0;
    int str2_len=0;
    int str3_len=0;
    int i,j;
    int cnt=0;
    
    
    str1_len=strlen(str1);
    str2_len=strlen(str2);
    str3_len=strlen(str3);
    
    for(i=0;i<str1_len;i++)
    {
        //查找字符串
        for(j=0;j<str2_len;j++)
        {
            if(str1[i+j]!=str2[j])break;
        }
        //如果查找成功就进行替换
        if(j==str2_len)
        {
            //总长度变短了
            if(str2_len>str3_len)
            {
                cnt=str2_len-str3_len; //差值
                //完成数据向前移动--覆盖
                for(j=i+str2_len-cnt;j<str1_len;j++)
                {
                    str1[j]=str1[j+cnt];
                }
                str1[str1_len-cnt]='\0';
            }
            //总长度变长了
            else if(str2_len<str3_len)
            {
                cnt=str3_len-str2_len; //差值
                //完成数据向后移动
                for(j=str1_len;j>=i+str2_len;j--)
                {
                    str1[j+cnt]=str1[j];
                }
                str1[str1_len+cnt]='\0';
            }
            //替换
            for(j=0;j<str3_len;j++)
            {
                str1[i+j]=str3[j];
            }
            //重新计算长度
            str1_len=strlen(str1);
        }
    }
}

封装函数: 清除二维数组的指定行

该函数功能可以通过传入的参数，清除指定二维数组的指定一行数据为0.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void clear(int (*p)[5],int a,int b);
int main()
{
    int i,j;
    int buff[][5]=
    {
        {1,2,3,4,5},
        {11,12,13,14,15},
        {21,22,23,24,25}
    };
    printf("源数据:\n");
    for(i=0;i<sizeof(buff)/sizeof(buff[0]);i++)
    {
        for(j=0;j<sizeof(buff[0])/sizeof(buff[0][0]);j++)
        {
            printf("%d ",buff[i][j]);
        }
        printf("\n");
    }
    
    clear(buff,888,2);
    
    printf("清除之后的数据:\n");
    for(i=0;i<sizeof(buff)/sizeof(buff[0]);i++)
    {
        for(j=0;j<sizeof(buff[0])/sizeof(buff[0][0]);j++)
        {
            printf("%d ",buff[i][j]);
        }
        printf("\n");
    }
    return 0;
}

void clear(int (*p)[5],int a,int b)
{
    int i;
    for(i=0;i<sizeof(p[0])/sizeof(p[0][0]);i++)
    {
        p[b][i]=a;
    }
}

封装函数:字符串里所有大写字母互相替换

将字符串里所有大写字母全部换成小写字母。或者小写字母全部换成大写字母。可以通过形参进行区分。 该功能广泛用在验证码功能上。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void func(char *str,int flag);
int main()
{
    char buff[100];
    printf("从键盘上输入字符串:");
    scanf("%s",buff);
    printf("源字符串:%s\n",buff);
    func(buff,0);
    printf("大写转换小写:%s\n",buff);
    func(buff,1);
    printf("小写转大写:%s\n",buff);
    return 0;
}

//函数功能: 大写小写转换
//flag=0表示大写转换小写  =1表示小写转大写
void func(char *str,int flag)
{
    int data;
    while(*str!='\0')
    {
        if(flag)
        {
            if(*str>='a'&& *str<='z') //小写
            {
                *str=*str-32;
            }
        }
        else
        {
            if(*str>='A'&& *str<='Z') //小写
            {
                *str=*str+32;
            }
        }
        str++;
    }
}

封装GPS解码函数:可以传入GPS格式的字符串

该函数可以传入GPS格式的字符串，在函数里完成所有数据解码输出。经度、纬度、卫星的数量、时间

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

char gps_buff[]=
{
    "$GNGGA,114955.000,2842.4158,N,11549.5439,E,1,05,3.8,54.8,M,0.0,M,,*4F"
    "$GNGLL,2842.4158,N,11549.5439,E,114955.000,A,A*4D"
    "$GPGSA,A,3,10,31,18,,,,,,,,,,5.7,3.8,4.2*37"
    "$BDGSA,A,3,07,10,,,,,,,,,,,5.7,3.8,4.2*2A"
    "$GPGSV,3,1,10,10,49,184,42,12,16,039,,14,54,341,,18,22,165,23*7B"
    "$GPGSV,3,2,10,22,11,318,,25,51,055,,26,24,205,,29,13,110,*7C"
    "$GPGSV,3,3,10,31,50,287,36,32,66,018,*7F"
    "$BDGSV,1,1,04,03,,,07,05,,,29,07,79,246,33,10,52,232,19*62"
    "$GNRMC,114955.000,A,2842.4158,N,11549.5439,E,0.00,44.25,061117,,,A*4D"
    "$GNVTG,44.25,T,,M,0.00,N,0.00,K,A*14"
    "$GNZDA,114955.000,06,11,2017,00,00*47"
    "$GPTXT,01,01,01,ANTENNA OK*35"
};


int GPS_GetData(char *gps_src,char *find_head,char *buff,int cnt)
{
    char *p;
    int number=0; //提取的数量
    int a=0;
    p=strstr(gps_src,find_head);
    if(p!=NULL)
    {
        //查找逗号的位置
        while(*p!='\0')
        {
            if(*p==',')a++; //记录逗号的数量
            if(a==cnt)break; //逗号找成功了
            p++;
        }
        p++; //跨过当前逗号
        //提取数据
        while(*p!='\0')
        {
            if(*p==',')break; //遇到逗号停止提取数据
            buff[number]=*p;
            p++;
            number++;
        }
        buff[number]='\0';
    }
    return number;
}

int main()
{
    char buff[100];
    GPS_GetData(gps_buff,"$GNGGA",buff,2);
    printf("纬度:%s\n",buff);
    GPS_GetData(gps_buff,"$GNGGA",buff,4);
    printf("经度:%s\n",buff);
    return 0;
}

封装函数: 将十进制整数转为16进制输出(字符串形式)

#include <stdio.h>
//定义16进制的数据,方便输出
char hex_val[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; 
int main() 
{ 
    int number=0;
    int a[100]; 
    int i=0; 
    int data; 
    
    printf("输入一个整数:"); 
    scanf("%d",&number); 
    
    while(number>0) 
    { 
        data=number%16; 
        a[i]=data; 
        number=number/16; 
        i++;
    } 
    printf("输入整数的十六进制数: 0x"); 
    
    for(i=i-1;i>=0;i--)
    {
        printf("%c",hex_val[a[i]]); 
    } 
    printf("\n"); 
}

到此这篇关于C语言封装函数字符串练习汇总分享的文章就介绍到这了,更多相关C语言字符串内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

--结束END--

本文标题: C语言封装函数字符串练习汇总分享

本文链接: https://lsjlt.com/news/143337.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • C语言封装函数字符串练习汇总分享
    目录封装函数: 判断闰年和平年封装函数: 字符串查找(参考strstr)封装函数: 字符串比较(参考strcmp)封装函数: 字符串拼接(参考strcat)封装函数: 字符串转整数(...
    99+
    2024-04-02
  • C语言怎么封装函数字符串
    这篇文章主要讲解了“C语言怎么封装函数字符串”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“C语言怎么封装函数字符串”吧！封装函数: 判断闰年和平年该函数判断传入的年份是否是闰年和平年，通过返...
    99+
    2023-06-29
  • C语言每日练习之字符串反转
    目录分析代码实现网上参考总结分析 在第18天：利用递归函数调用方式，将所输入的字符以相反顺序打印出来中，已经用过递归实现字符顺序输入，逆序输出，今天的题目是字符串反转，将以字符数组的...
    99+
    2024-04-02
  • 【C语言】字符函数和字符串函数
    目录 一、函数介绍及其模拟实现 1.strlen 2.strcpy 3.strcat 4.strcmp  5.strncpy 6.strncat  7.strncmp 8.strstr  9.strtok 10.strerror   11....
    99+
    2023-09-15
    c语言 开发语言
  • C语言字符函数与字符串函数详解
    目录本章重点前言1.strlen函数注意点1注意点22.strcpy注意点1：注意点2：注意点3：注意点4：总结本章重点 重点介绍处理字符和字符串的库函数的使用和注意事项 1.求字符...
    99+
    2024-04-02
  • C语言：字符函数和字符串函数(一篇拿捏字符串函数！)
    目录 求字符串长度： 1. strlen(字符串长度) 长度不受限制函数： 2. strcpy(字符串拷贝) 3. strcat(字符串追加) 4. strcmp(字符串比较) 长度受限制函数： 5. strncpy(字符串拷贝) 6. ...
    99+
    2023-10-02
    c语言 开发语言 深度学习 学习 笔记 c++ 算法
  • C语言字符串函数入门
    目录实现字符串库函数功能1.strlen函数2.strcmp函数3.strcpy函数4.strcat函数5.strupr函数6.strlwr函数总结实现字符串库函数功能 有些时候我们...
    99+
    2024-04-02
  • PostgreSQL常用字符串分割函数整理汇总
    目录1. SPLIT_PART2.STRING_TO_ARRAY3. regexp_split_to_array4.regexp_split_to_array5. regexp_matches总结1. SPLIT_PAR...
    99+
    2022-07-06
    pgsql 分割字符串 plsql截取字符串的函数 pgsql拆分字符串
  • C语言的字符函数和字符串函数详解
    目录0. 前言1.函数介绍及部分函数模拟实现1.1 strlen模拟实现1.2 strcpy模拟实现1.3 strcat模拟实现1.4 strcmp 模拟实现1.5 str...
    99+
    2024-04-02
  • C语言中字符函数和字符串函数介绍
    本篇内容介绍了“C语言中字符函数和字符串函数介绍”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！目录前言求字符串长度strlen介绍strle...
    99+
    2023-06-20
  • 从头学习C语言之字符串处理函数
    目录字符串处理函数：存放和使用字符串：获取字符串长度：strlen示例：拷贝字符串：strcpy和strncpy示例：strncpy：示例：连接字符串：strcat和strncat示...
    99+
    2024-04-02
  • C语言字符串函数怎么用
    这篇文章主要介绍C语言字符串函数怎么用，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！一.strlen函数模拟字符串以‘\0'作为结束标志，strlen函数返回的是在字符串中‘\0'前面出现的字符个数（...
    99+
    2023-06-22
  • 深入了解C语言字符函数和字符串函数
    目录前言求字符串长度strlen介绍strlen直接使用：strlen模拟实现：strlen对比sizeof长度不受限制的字符串函数strcpy直接使用模拟实现：strcat直接使用...
    99+
    2024-04-02
  • C语言进阶教程之字符函数&字符串函数
    目录1、strlen1.1、三种模拟实现2、长度不受限制的字符串函数2.1、strcpy2.1.1、模拟实现2.2、strcat2.2.1、模拟实现2.3、strcmp2.3.1、模...
    99+
    2024-04-02
  • C语言的字符函数和字符串函数怎么用
    这篇文章主要讲解了“C语言的字符函数和字符串函数怎么用”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“C语言的字符函数和字符串函数怎么用”吧！一、字符&字符串函数1.strlen--求...
    99+
    2023-06-26
  • 一起来学习C语言的字符串转换函数
    字符串转整数 字符串转换为整数的函数有两个，他们的函数原型如下： int __cdecl atoi(const char *_Str); long __cdecl atol(...
    99+
    2024-04-02
  • C语言字符串函数与内存函数精讲
    目录strlenstrcpystrcatstrcmpstrncpystrncatstrncmpstrstrstrtokstrerrortolower\touppermemcpymem...
    99+
    2024-04-02
  • C语言超全面讲解字符串函数
    目录1、gets函数2、puts函数3、strcat函数4、strcpy函数（strncpy函数）5、strcmp函数（strncmp函数）6、strlen函数7、strlwr函数8...
    99+
    2024-04-02
  • C语言中字符串函数怎么入门
    这篇文章给大家介绍C语言中字符串函数怎么入门，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。实现字符串库函数功能有些时候我们可能会被限制无法使用库函数，这个时候我们需要编写自己的库函数。但了解了字符串库函数的功能之后，想...
    99+
    2023-06-22
  • 实现C语言常用字符串库函数
    目录strlenstrcpystrcatstrcmp总结strlen 数组长度的计算是通过strlen来的,它的作用就是判断给定的数组元素个数，直到碰到\0结束 函数原型 siz...
    99+
    2024-04-02
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作