C标准库函数实现之字符串操作

最新推荐文章于 2019-10-25 17:58:01 发布
最新推荐文章于 2019-10-25 17:58:01 发布
阅读量362 收藏
点赞数 1
分类专栏： c/c++基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/douyacai123123/article/details/43056083
版权

        在C/C++开发工作中会经常遇到操作字符串的情形，只有在了解了其实现方式，运用时才能随心所欲，有的放矢。

        小编结合工作中操作字符串的经验，整理了一些常用的字符串操作函数予以分享。

        持续更新中......


一、前期准备

/* 基本类型定义 */

typedef signed int        Gint32;        /**< -2147483648 ~ 2147483647             */
typedef unsigned int    Guint32;    /**< 0 ~ 4294967295(0xffffffff)           */
typedef signed short    Gint16;        /**< -32768 ~ 32767                       */
typedef unsigned short    Guint16;    /**< 0 ~ 65535(0xffff)                    */
typedef signed char        Gint8;        /**< -128 ~ 127                           */
typedef unsigned char    Guint8;        /**< 0 ~ 255(0xff)                        */
typedef float            Gfloat32;    /**< -3.40E+38 ~ +3.40E+38 精度为6~7位    */
typedef double            Gfloat64;    /**< -1.79E+308 ~ +1.79E+308 精度为15~16位*/

#if defined(PLATFORM_ANDROID) || defined(PLATFORM_MAC) || defined(PLATFORM_TIZEN) || defined(PLATFORM_UBUNTU)
    typedef long long            Gint64;        /**< -9223372036854775808i64 ~ 9223372036854775807i64 */
    typedef unsigned long long    Guint64;    /**< 0 ~ 18,446,744,073,709,551,615(0xffffffffffffffffui64) */
#else
    typedef __int64                Gint64;        /**< -9223372036854775808i64 ~ 9223372036854775807i64 */
    typedef unsigned __int64    Guint64;    /**< 0 ~ 18,446,744,073,709,551,615(0xffffffffffffffffui64) */

#endif


/**
* Gtrue/Gfalse枚举类型
*
*/
typedef enum {
    Gfalse = 0,
    Gtrue  = 1
} Gbool;

#if (defined PLATFORM_WIN32) || (defined PLATFORM_WINCE)
    typedef Guint16        Gchar;
#else
    typedef Guint32        Gchar;
#endif


二、字符串操作

1）窄字符转换为宽字符

Gbool Gmbtowc(Gchar *pwc, const Guint8 *s, Gint32 n)
{
    const Guint8 *ps = s;
    Guint8 c1, c2;
    Gbool bRet = Gfalse;

    if (n >= 2)
    {
        c1 = s[0];
        c2 = s[1];
        if ((0x80u <= c1) && (0x40u <= c2))
        {
            *pwc = gbk_2_unicode[(((Gint32)c1-0x80) * ((0xFF - 0x40) + 1)) + ((Gint32)c2 - 0x40)]; //gbk_2_unicode参照 字符GBK与UNICODE静态对照表
            bRet =  Gtrue;
        }
    }

    return bRet;
}

2）宽字符转换为窄字符
Gbool Gwctomb(Guint8 *r, const Gchar wc, Gint32 n)
{
    Gbool bRet = Gfalse;

    if (n >= 2)
    {
        Guint8 c1, c2;
        Gint32 offset = -1;

        c1 = (Guint8)(wc & 0x00ffu);
        c2 = wc >> 8;
        if (c2 <= 0x04u)
        {
            offset = ((Gint32)c2 * 256) + (Gint32)c1;
        }
        else if ((0x20u <= c2) && (c2 <= 0x26u))
        {
            offset = (((Gint32)c2-0x20) * 256) + (Gint32)c1 + (((0x04 - 0x00) + 1) * 256);
        }
        else if ((0x30u <= c2) && (c2 <= 0x33u))
        {
            offset = (((Gint32)c2-0x30) * 256) + (Gint32)c1 + (((0x26 - 0x20) + 1) * 256) + (((0x04 - 0x00) + 1) * 256);
        }
        else if ((0x4eu <= c2) && (c2 <= 0x9fu))
        {
            offset = (((Gint32)c2-0x4e) * 256) + (Gint32)c1 + (((0x33 - 0x30) + 1) * 256) + (((0x26 - 0x20) + 1) * 256) + (((0x04 - 0x00) + 1) * 256);
        }
        else if ((0xe0u <= c2) && (c2 <= 0xe8u))
        {
            offset = (((Gint32)c2-0xe0) * 256) + (Gint32)c1 + (((0x9f - 0x4e) + 1) * 256) + (((0x33 - 0x30) + 1) * 256) + (((0x26 - 0x20) + 1) * 256) + (((0x04 - 0x00) + 1) * 256);
        }
        else if (0xf9u <= c2)
        {
            offset = (((Gint32)c2 - 0xf9) * 256) + (Gint32)c1 + (((0xe8 - 0xe0) + 1) * 256) + (((0x9f - 0x4e) + 1) * 256) + (((0x33 - 0x30) + 1) * 256) + (((0x26 - 0x20) + 1) * 256)+ (((0x04 - 0x00) + 1) * 256);
        }
        else
        {
            offset = -1;
        }

        if (offset != -1)
        {
            Guint32 uTemp;
            offset = (Gint32)unicode_2_gbk[offset]; //unicode_2_gbk参照字符GBK与UNICODE静态对照表
            uTemp = (Guint32)offset & 0x00ffu;
            r[0] = (Guint8)uTemp;
            uTemp = (Guint32)offset >> 8u;
            r[1] = (Guint8)uTemp;

            bRet = Gtrue;
        }
    }

    return bRet;
}

3）窄字符串转换为宽字符串

Gint32 Gmbstowcs(Gchar *wcstr, Guint32 sizeInWords, const Guint8 *mbstr)
{
    const Guint8 *ps;
    Gchar *pw;
    Gint32 nRet = 0;

    if ((wcstr == GNULL) || (mbstr == GNULL) || (sizeInWords < 1u))
    {
        nRet = 0;
    }
    else
    {
        ps = mbstr;
        pw = wcstr;
        sizeInWords--;    /* for the terminating null */
        while ((*ps != 0) && (sizeInWords > 0u))
        {
            if (*ps <= 0x7F)
            {
                *pw = *ps;
                pw++;
                ps++;
            }
            else
            {
                if (Gtrue == Gmbtowc(pw, ps, 2))
                {
                    ps += 2;
                    pw++;
                }
                else
                {
                    break;
                }
            }
            sizeInWords--;
        }
        *pw = 0;

        nRet = (pw - wcstr) * sizeof(Gchar);
    }

    return nRet;
}

4）宽字符串转换为窄字符串
Gint32 Gwcstombs(Guint8 *mbstr, Guint32 sizeInBytes, const Gchar *wcstr)
{
    Guint8  *ps;
    const Gchar *pw;
    Gint32 nRet = 0;

    if ((wcstr == GNULL) || (mbstr == GNULL) || (sizeInBytes < 1u))
    {
        nRet = 0;
    }
    else
    {
        ps = mbstr;
        pw = wcstr;
        sizeInBytes--;
        while ((*pw != 0) && (sizeInBytes > 0u))
        {
            if (*pw <= 0x7F)
            {
                *ps = (Guint8)*pw;
                pw++;
                ps++;
                sizeInBytes--;
            }
            else
            {
                if (Gtrue == Gwctomb(ps, *pw, 2))
                {
                    ps += 2;
                    pw++;
                    sizeInBytes -= 2u;
                }
                else
                {
                    break;
                }
            }
        }
        *ps = 0;

        nRet = ps - mbstr;
    }

    return nRet;
}

5）宽字符--->宽字符拷贝

Gchar* Gstrcpy(Gchar* strDest, const Gchar* strSource)
{
    Gchar *p = GNULL;
    if ((strDest != GNULL) && (strSource != GNULL))
    {
        p = strDest;
        while( *p++ = *strSource++ );               /* Copy src over dst */
    }
    return strDest;
}

6）窄字符串--->窄字符串拷贝
Gint8* GstrcpyA(Gint8* strDest, const Gint8* strSource)
{
    Gint8 *p = GNULL;
    if ((strDest != GNULL) && (strSource != GNULL))
    {
        p = strDest;
        while( *p++ = *strSource++ );               /* Copy src over dst */
    }
    return strDest;
}

7）窄字符串--->宽字符串拷贝

Gchar* GstrcpyGA(Gchar* strDest, const Gint8* strSource)
{
    Gchar szTmp[GMAX_PATH];

    Gmbstowcs(szTmp, (Guint32)GMAX_PATH, strSource);

    return Gstrcpy(strDest, szTmp);
}

8）宽字符串--->窄字符串拷贝

Gint8* GstrcpyAG(Gint8* strDest, const Gchar* strSource)
{
    Gint8 szTmp[GMAX_PATH];

    (void)Gwcstombs(szTmp, (Guint32)GMAX_PATH, strSource);

    return GstrcpyA(strDest, szTmp);
}

9）宽字符串<--->宽字符串比较

Gint32 Gstrcmp(const Gchar* strSource, const Gchar* strDest)
{
    Gint32 ret = 0;

    while( ! (ret = (Gint32)(*strSource - *strDest)) && *strDest)
    {
        ++strSource;
        ++strDest;
    }

    if ( ret < 0 )
        ret = -1;
    else if ( ret > 0 )
        ret = 1;

    return ret;
}

10）窄字符串<--->窄字符串比较
Gint32 GstrcmpA(const Gint8* strSource, const Gint8* strDest)
{
    Gint32 ret = 0;

    while( ! (ret = (Gint32)(*strSource - *strDest)) && *strDest)
    {
        ++strSource;
        ++strDest;
    }

    if ( ret < 0 )
        ret = -1;
    else if ( ret > 0 )
        ret = 1;

    return ret;
}

11）宽字符串<--->宽字符串链接
Gchar* Gstrcat(Gchar* strDest, Gchar* strSource)
{
    Gchar *p1 = GNULL, *p2 = GNULL;
    
    if ((strDest != GNULL) && (strSource != GNULL))
    {
        p1 = strDest;
        while (*p1 != 0)
        {
            p1++;
        }

        p2 = strSource;
        while (*p2 != 0)
        {
            *p1 = *p2;
            p1++;
            p2++;
        }
        *p1 = *p2;
    }
    return strDest;
}

12）窄字符串<--->窄字符串链接
Gint8* GstrcatA(Gint8* strDest, Gint8* strSource)
{
    Gint8 *p1 = GNULL, *p2 = GNULL;
    
    if ((strDest != GNULL) && (strSource != GNULL))
    {
        p1 = strDest;
        while (*p1 != 0)
        {
            p1++;
        }

        p2 = strSource;
        while (*p2 != 0)
        {
            *p1 = *p2;
            p1++;
            p2++;
        }
        *p1 = *p2;
    }
    return strDest;
}

13）正向查找字符串是否存在某字符

Gchar* Gstrchr(Gchar *str, Gchar ch)
{
    Gchar *p = GNULL;
    Gint32 i, len;

    if (GNULL != str)
    {
        len = Gstrlen(str);
        for (i = 0; i < len; i++)
        {
            if (str[i] == ch)
            {
                p = &str[i];
                break;
            }
        }
    }

    return p;
}

14）逆向查找字符串是否存在某字符

Gchar* Gstrrchr(Gchar *str, Gchar ch)
{
    Gchar *p = GNULL;
    Gint32 i, len;

    if (GNULL != str)
    {
        len = Gstrlen(str);
        for (i = len-1; i >= 0; i--)
        {
            if (str[i] == ch)
            {
                p = &str[i];
                break;
            }
        }
    }

    return p;
}

15）获取窄字符串长度
Gint32 GstrlenA(const Gint8* str)
{
    const Gint8 *p = str;
    Gint32 nRet = 0;

    if (p != GNULL)
    {
        while( *p++ );
        nRet = p - str - 1;
    }

    return nRet;
}

16）获取宽字符串长度
Gint32 Gstrlen(const Gchar* str)
{
    const Gchar *p = str;
    Gint32 nRet = 0;

    if (p != GNULL)
    {
        while( *p++ );
        nRet = p - str - 1;
    }

    return nRet;
}

厚积薄发_1988
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++标准库——字符串（Standard library: String）
RayZ_O的专栏
05-10 1540
Reference：The C++ Programming Language 4th edition (Bjarne Stroustrup) 1.字符分类（Character Classification） #include isspace(c) //' ', '\t', '\n', '\v', '\f', '\r' isalpha(c) //'a'..'z', 'A..Z' is
C语言库函数之字符串
11-23
C语言提供了一系列强大的字符串处理函数，这些函数被封装在标准库中，使得开发人员能够高效地完成字符串操作任务。本章节将详细介绍C语言标准库中的一些常见字符串函数及其使用方法。 #### 二、字符串转换函数 1. ...
C语言的本质——C标准库之字符串操作
LiuenshengUp的博客
10-21 992
字符串处理函数 C语言提供了丰富的字符串处理函数，大致可分为字符串的输入、输出、合并、修改、比较、转换、复制、搜索几类。使用这些函数可大大减轻编程的负担。用于输入输出的字符串函数，在使用前应包含头文件"stdio.h"，使用其它字符串函数则应包含头文件"string.h"。 下面介绍几个最常用的字符串函数。 字符串输出函数 puts 格式： puts (字符数组名) 功能：把字符数组中的字符串输...
浅谈c++字符串——2 c标准库中字符串
木易杨的博客
09-08 553
2 C标准库字符串 2.1 <stdlib.h>定义的宽字节字符wchar_t 在标准C中，字符串有两种char*和wchar_t*，一个是多字节字符串，另一个是宽字节字符串。前者是C的关键字，编译器会直接为其分配空间，而wchar_t在便准库中定义，不包含头文件的话，编译器会报错。但是可以修改项目属性中的SDL选项来更改安全属性，可以避免编译错误。建议不使用，安全性控制由程序员...
【C语言】标准库字符串函数整理
Imba
04-10 361
sscanf 格式化读取函数原型int sscanf( const char *buffer, const char *format, [ argument ] ... ); 参数buffer 存储的数据 format 窗体控件字符串。 有关详细信息，请参阅"格式规范"。 argument 可选自变量 locale 　要使用的区域设置说明sscanf与scanf类似，都是用于输入的，
字符串函数
LG的专栏
02-21 836
bcmp   原型：extern int bcmp(const void *s1, const void *s2, int n);    用法：#include     功能：比较字符串s1和s2的前n个字节是否相等    说明：如果s1=s2或n=0则返回零，否则返回非零值。bcmp不检查NULL。    举例：      // bcmp.c            #include      
利用C语言库函数实现常见的字符串操作.pdf
09-19
- 培养编程技巧：通过编写具有实际功能的简单程序，帮助初学者将抽象的字符串操作函数与实际问题解决结合起来，加深对库函数的理解和应用。 8. 代码可读性和逻辑性： - 可读的代码设计：虽然没有给出完整的代码...
c++实现strcat字符串连接库函数的方法详解
09-05
C++中的`strcat`函数是一个用于字符串连接的库函数，它将源字符串`src`的内容追加到目标字符串`dest`的末尾，然后在`dest`的末尾添加一个空字符`\0`来表示字符串的结束。这个函数通常在处理字符串拼接时非常有用，但...
C语言实现字符串转十进制算法
最新发布
10-08
总的来说，C语言中字符串转十进制涉及字符数组到整数的转换，这需要理解ASCII码、指针操作以及整数的二进制表示。自定义函数允许对转换过程有更多控制，而库函数如`atoi()`则提供了一个简便的解决方案。
常用C语言标准库函数-综合文档
05-20
本综合文档主要涵盖了C语言中的一些常用标准库函数，旨在帮助开发者更有效地利用这些工具。 一、输入/输出函数 1. `printf` 和 `scanf`: 这两个函数分别是格式化输出和输入的代表。`printf`用于向标准输出（通常是...
C标准库字符串处理相关函数
Eaon-嵌入式小站
09-24 501
bcmp 原型：extern int bcmp(const void *s1, const void *s2, int n); 用法：#include <string.h> 功能：比较字符串s1和s2的前n个字节是否相等 说明：如果s1=s2或n=0则返回零，否则返回非零值。bcmp不检查NULL。 bcopy 原型：extern void bcopy(const void *src,...
C库函数中字符串处理函数集合
gaiazhang‘s blog
01-23 476
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/general1982/archive/2009/03/21/4012566.aspx bcmp 原型：extern int bcmp(const void *s1, const void *s2, int n); 用法：#include 功能：比较字符串s1和s2的前n个字节是否相等 说明：如果s1=s2
C字符串处理函数
12-02 3万+
void *memccpy (void *dest, const void *src, int c, size_t n);从src所指向的对象复制n个字符到dest所指向的对象中。如果复制过程中遇到了字符c则停止复制，返回指针指向dest中字符c的下一个位置；否则返回NULL。void *memcpy (void *dest, const void *src, size_t n);从s
uint64 和字符串相互转换
xiaodoubao124的专栏
08-07 2万+
uint64转换成string snprintf函数声明int snprintf(char *restrict buf, size_t n, const char * restrict format, ...);例如：snprintf(string,sizeof(string),"%ju",GID);string转换成uint64GID=strtoull(pszValue, NULL, 0);
C语言实现字符串截取函数left、mid和right
热门推荐
驽马十驾 才定不舍
11-19 4万+
作者：iamlaosong C语言字符串截取需要自己编程实现，不过，网络时代，自然不用自己从头写了，网上各种方法的实现代码已经多如牛毛了，这儿抄录一个感觉不错的备案。 #include #include /*从字符串的左边截取n个字符*/ char * left(char *dst,char *src, int n) { char *p = src; char *q =
C语言实现库函数中的strstr查找字符串中的子串的功能
仗劍走天涯
01-05 6822
自己使用C语言实现的库函数中的strstr函数的功能：代码如下  #include &lt;stdio.h&gt; static const char *strstr_t(const char *str, const char *sub_str) { const char *str_local = NULL; const char *sub_str_local = NU...
golang：string ，int ，int64相互转化
feiger的专栏
10-25 2659
sting ，int ，int64 相互转化是比较高频的操作，备注一下 使用strconv包完成相关转化 string到int int,err:=strconv.Atoi(string) string到int64 int64, err := strconv.ParseInt(string, 10, 64) int到string string:=strconv.Itoa(int) int64...
C语言标准库函数详解：数学、字符与字符串操作
这些函数还包括用于字符串操作的各种其他功能，如复制、比较、查找、填充等。 在程序设计实践中，了解并熟练使用这些标准库函数是至关重要的。C/C++语言的基础包括变量、数据类型、常量、运算符、控制流语句（如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值