实现一些字符串操作标准库函数、解决一些字符串问题

最新推荐文章于 2022-03-16 23:12:06 发布
最新推荐文章于 2022-03-16 23:12:06 发布
阅读量448 收藏
点赞数
分类专栏： C和C++ 文章标签： 字符串库函数

一、实现字符串操作标准库函数

（1）、strcpy、strncpy、memmove、memcpy、memset、strlen、strncat 的实现

// The  strcpy()  function  copies  the  string  pointed to by src, including the terminating null byte ('\0'), to the buffer
// pointed to by dest.  The strings may not overlap, and the destination string dest must be  large  enough  to  receive  thecopy.
char *strcpy(char *dest, const char *src)
{
    assert((src != NULL) && (dest != NULL));
    size_t i;
    for (i = 0; src[i] != '\0'; i++)
        dest[i] = src[i];
    dest[i] = '\0';
    return dest;
}

// The strncpy() function is similar, except that at most n bytes of src are copied.  Warning: If there is no null byte among the first n bytes of src,
// the string placed in dest will not be null-terminated. If the length of src is less than n, strncpy() pads the remainder of dest with null bytes.
char *strncpy(char *dest, const char *src, size_t n)
{
    assert((src != NULL) && (dest != NULL));
    size_t i;
    for (i = 0; i < n && src[i] != '\0'; i++)
        dest[i] = src[i];
    for (; i < n; i++)
        dest[i] = '\0';
    return dest;
}

 SQL Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/* 借助于一个临时缓冲区temp ,即使src 和dest 所指的内存区间有重叠也能正确拷贝。*/
void *memmove(void *dest, const void *src, size_t n)
{
    assert((src != NULL) && (dest != NULL));
    char* temp = (char*)malloc(sizeof(char)*n);
    size_t i;
    char *d = (char*)dest;
    const char *s = (const char*)src;

    for (i = 0; i < n; i++)
        temp[i] = s[i];
    for (i = 0; i < n; i++)
        d[i] = temp[i];

    free(temp);

    return dest;
}


/* 在32位的x86平台上,每次拷贝1个字节需要一条指令,每次拷贝4个字节也只需要一条指
 * 令,memcpy函数的实现尽可能4个字节4个字节地拷贝 */
void *memcpy(void *dest, const void *src, size_t n)
{
    assert((src != NULL) && (dest != NULL));
    char *d = dest;
    const char *s = src;
    int *di;
    const int *si;
    int r = n % 4;
    while (r--)
        *d++ = *s++;
    di = (int *)d;
    si = (const int *)s;
    n /= 4;
    while (n--)
        *di++ = *si++;
    return dest;
}


size_t strlen(const char *p)
{
    assert(p !=  NULL);
    size_t size = 0;
    while (*p++ != '\0')
        ++size;
    return size;
}
char *strncat(char *dest, const char *src, size_t n)
{
    size_t dest_len = strlen(dest);
    size_t i;

    for (i = 0 ; i < n && src[i] != '\0' ; i++)
        dest[dest_len + i] = src[i];
    dest[dest_len + i] = '\0';

    return dest;
}

不用临时空间的memmove实现：

//src可以不保留
void *memmove(void *dst, const void *src, size_t count)
{
    byte *pbTo = (byte *)dst;
    byte *pbFrom = (byte *)src;
    assert(dst != NULL && src != NULL);//不能存在空指针
    if (dst <= src || pbTo >= pbFrom + count)//
    {
        while (count-- > 0)
        {
            *pbTo++ = *pbFrom++; //按递增拷贝
        }
    }
    else  //
    {
        pbTo = pbTo + count - 1; //overlap的情况，从高位地址向低位拷贝
        pbFrom = pbFrom + count - 1;
        while (count-- > 0)
        {
            *pbTo-- = *pbFrom--; //按递减拷贝
        }
    }
    return dst;
}

memset的实现:

void *memset(void *buffer, int c, int count)
{
    char *buffer_p = (char *)buffer;
    assert(buffer != NULL);
    while(count-- > 0)
        *buffer_p++ = (char)c;
    return buffer;
}

二、解决字符串问题

（1）、将单词之间出现一个或多个连续的空白字符都压缩为1个。

//编一个函数，输入一个字符串，要求做一个新字符串，把其中所有的一个或多个连续的空白字符都压缩为一个空格。这里所说的空白包括空格、'\t'、'\n'、'\r'。
char *shrink_space(char *dest, const char *src, size_t n)
{
    assert((src != NULL) && (dest != NULL));
    size_t i, j;

    dest[0] = src[0];

    for (i = 1, j = 1; src[i] != '\0'; i++, j++)
    {
        if (src[i] == '\t' || src[i] == '\n'
                || src[i] == '\r' || src[i] == ' ')

            if (src[i - 1] != '\t' && src[i - 1] != '\n'
                    && src[i - 1] != '\r' && src[i - 1] != ' ')

                dest[j] = ' ';
            else
                j--;
        else
            dest[j] = src[i];
    }
    dest[j] = '\0';

    return dest;
}

（2）、解析URL 中的路径和查询字符串。? 号后面是查询字符串，由 “key=value”形式的键值对组成，以&隔开。

/*************************************************************************
    > File Name: find_url_token.c
    > Author: Simba
    > Mail: dameng34@163.com
    > Created Time: Sat 26 Jan 2013 04:05:32 PM CST
 ************************************************************************/

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

#define N 10
typedef struct
{
    char *tokens[N];
    int count;
} unit_t;

void find_url_token(char str[], const char tok[], unit_t *ptr)
{
    int i;
    char *token = NULL;
    char *saveptr = NULL;

    ptr->count = 0;
    const char *needle = "://";

    if (strstr(str, needle))
    {
        for (i = 0; ; str = NULL, i++)
        {
            token = strtok_r(str, tok, &saveptr);
            if (token == NULL)
                break;
            else
            {
                ptr->tokens[i] = token;
                ptr->count++;
            }
        }
    }
}

int main(void)
{
    /* 不能定义为char *url = "..."; 因为此时是定义一个指向字符串字面值(位于.rodata段)的指针,而
       调用strtok_r函数会修改这个字符串,运行时会产生段错误 */
    char url[] = "http://www.google.cn/search?complete=1&hl=zh-CN&ie=GB2312&q=linux&meta=";
    /* 给url初始化用的这个字符串并没有分配在.rodata段,而是直接写在指令里了,
     * 运行程序时通过movl 指令把字符串写到栈上,这就是url的存储空间*/
    unit_t *ptr = malloc(sizeof(unit_t));
    find_url_token(url, "?&", ptr);
    int i;
    for (i = 0; i < ptr->count; i++)
        printf("%s\n", ptr->tokens[i]);
    free(ptr);
    return 0;
}

3）、去除\r\n，去除左右空白字符

void str_trim_crlf(char *str)
{
    char *p = &str[strlen(str) - 1];
    while (*p == '\r' || *p == '\n')
        *p-- = '\0';

}
void AllTrim( char *str )
{
    char *head, *tail;

    if ( str == NULL )
        return;

    for( head = str; *head == ' ' || *head == '\t'; head ++ );

    for( tail = str + strlen(str) - 1; (*tail == ' ' || *tail == '\t' ) && tail >= head; tail -- );

    while( head <= tail )
        *str ++ = *head ++;

    *str = 0;
}

（4）、判断字符串是否为回文

// 判断字符串是否为回文
bool isSysmmetry(const char *src)
{
    assert(src != NULL);
    int len = strlen(src);
    assert(len != 0);
    const char *tmp = src + len - 1;

    int i;
    for (i = 0; i < len / 2; i++)
    {
        if (*src++ != *tmp--)
            break;
    }

    if (i == len / 2)
        return true;
    else
        return false;

}

（5）、google笔试：编码实现求给定字符串（全为小写英文字母）的最小后继，如 “abc” 的最小后继为“abd”, “dhz” 的最小后继为“di”。

int MinNextStr(const char *src, char *&minnext)
{
    int srclen = strlen(src);
    minnext = (char *)malloc((srclen + 1) * sizeof(char));
    if (minnext == NULL)
        return -1;
    strcpy(minnext, src);

    int i = srclen - 1;
    while (i >= 0)
    {
        minnext[i]++;
        if (minnext[i] <= 'z')
            break;
        i--;
    }

    if (i < 0)
        return 0;
    else
    {
        minnext[++i] = '\0';
        return 1;

    }
}

如果把给定字符串全为小写英文字母改为大小写英文字母，则只要把 第13行改为：

if (minnext[i] <= ‘z’ && minnext[i] >= ‘a’ || minnext[i] <= ‘Z’);

（6）、中兴：编码实现字符串右移n位，如“diopheg” 右移2位为“egdioph”。

bool RightMoveStr(char *src, int n)
{
    int len = strlen(src);
    int mov = n % len;
    char *rstr = (char *)malloc((mov + 1) * sizeof(char));
    if (rstr == NULL)
        return false;

    int i = 0;
    while (i < mov)
    {
        rstr[i] = src[len - mov + i];
        i++;
    }
    rstr[i] = '\0';

    i = len - mov - 1;
    while (i >= 0)
    {
        src[i + mov] = src[i];
        i--;
    }

    i = 0;
    while (i < mov)
    {
        src[i] = rstr[i];
        i++;
    }

    free(rstr);
    return true;
}

bool RightMove(char *src, char *&ssrc, int n)
{
    int len = strlen(src);
    ssrc = (char *)malloc(sizeof(char) * (len + 1));
    if (ssrc == NULL)
        return false;

    n = n % len;
    char *tmp = src + len - n;

    strcpy(ssrc, tmp);
    strncat(ssrc, src, len - n);

    return true;

}

更巧妙的方法：

void reverse(char* str, int left, int right)
{
    char tmp;
    while (left < right)
    {
        tmp = str[left];
        str[left++] = str[right];
        str[right--] = tmp;

    }
}

void rightmove(char* str, int k)
{
    n = strlen(str);
    k = k % n;
    reverse(str, 0, n-k-1);
    reverse(str, n-k, n-1);
    reverse(str, 0, n-1);
}

（7）、新邮通：字符串反转：给定字符串“we;tonight;you;”，编码实现输出”ew;thginot;uoy;“

void ReverseStr(char *src)
{
    int len = strlen(src);
    int i = 0;
    int first = 0;
    int end = 0;
    while (i < len)
    {
        if (src[i] == ';')
        {
            end = i - 1;
            while (first < end)
            {
                char tmp = src[first];
                src[first] = src[end];
                src[end] = tmp;
                first++;
                end--;
            }
            first = i + 1;

        }
        i++;
    }
}

如果给定字符串末尾没有’;’，只需要修改9，10，11行

if (src[i] == ';' || i == len - 1)
{
    if (src[i] == ';')
        end = i - 1;
    else
        end = i;
    while...
}

（8）、不使用局部变量实现strlen、两数交换

#define swap(a,b) \
{ assert(sizeof(a)==sizeof(b)); char tempBuf[sizeof(a)]; memcpy(tempBuf,&a,sizeof(a)); memcpy(&a,&b,sizeof(b)); memcpy(&b,tempBuf,sizeof(b)); }

#define swap(a, b) \
    do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)
// typeof 是gcc支持，iso c支持__typeof__


int mstrlen(char *p)
{
    return ToEnd(p)-p;
}
char * ToEnd(char * p)
{
    while(*p != '\0')
        p++;
    return p;
}

转载自http://blog.csdn.net/jnu_simba/article/details/11714251

Sandeldeng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
标准字符串函数和正则表达式
03-22
标准字符串函数和正则表达式
strcpy 会copy '\0'
yasi_xi的专栏
06-13 5441
SYNOPSIS        #include        char *strcpy(char *dest, const char *src);        char *strncpy(char *dest, const char *src, size_t n); DESCRIPTION        The  strcpy()  function  co
strcpy操作的问题
清新空气的专栏
05-06 409
首先明确strcpy 会copy源字符串的 '\0' 参考csdn SYNOPSIS        #include        char *strcpy(char *dest, const char *src);        char *strncpy(char *dest, const char *src, size_t n); DESCRIPTION        T
lua字符串处理(string库用法)
热门推荐
戴磊的博客
05-10 7万+
原文地址http://www.daileinote.com/computer/lua/02 lua的string库是用来处理字符串的，基础函数如下 string.byte(s [, i [, j]]) string.byte是用来把字符转换成ascii数字，s为目标字符串，i为索引开始位置(从1开始)，j为索引结束位置 string.char(...) string.char是把as...
C++ 标准字符串std函数
生命不息 折腾不止
04-01 839
回顾一些std中string类型的成员函数： allocator_type :作为一种类型； append :追加字符串（可以追加整个字符串，也可以追加字符串的一部分）； assign :字符串初始化或者赋值； at :获取字符串中的第i个字符； back:返回字符串的最后一个字符; 返回的不是迭代器，这个和begin() 不同 ； basic_string :字符串的类型； begin :返回...
实现C语言字符串操作的库函数
07-29
在这里和大家分享一个能实现C语言字符串操作的库函数，感性趣的朋友可以参考下。
c++实现strcat字符串连接库函数的方法详解
09-05
本篇文章是对使用c++实现strcat字符串连接库函数的方法进行了详细的分析介绍，需要的朋友参考下
C语言数字转化为字符串的库函数
01-19
　功 能:把一整数转换为字符串 　用 法:char *itoa(int value, char *string, int radix); 　详细解释:itoa是英文integer to array(将int整型数转化为一个字符串,并将值保存在数组string中)的缩写. 　参数： 　...
c++ 连接两个字符串实现代码 实现类似strcat功能
09-05
c++ 连接两个字符串实现代码 实现类似strcat功能，需要的朋友可以参考下
标准字符串函数及 字符串类--数据结构
weixin_33853827的博客
09-21 64
　　懒得再开一个随笔写心事，直接就在这篇里说了算了。 　　昨天晚上经历了六个小时的纳新面试，掐指头算时我都被震惊到了。简单总结一下：原来真不是只有本事、靠谱就够了。刚刚看见的那条动态说的没错，“有一颗好心不如张一张好嘴”，有本事不会推销自己，那是茶壶煮饺子，顶多算靠谱但不能委以重任，光说不练假把式，最多做个活跃气氛的花瓶，免不了还要被扣上一顶“太浮躁”的帽子，有实力会说话叫“优秀”，这时候就会有...
字符串的基本操作和模式匹配
Death Note
10-17 675
字符串的一些操作和模式匹配 #include #include #define MAX_SIZE 100 #define OK 1 #define ERROR -1 typedef int Status; 字符串的结构体 typedef struct { char ch[MAX_SIZE]; int length; }String;
【C语言】常见字符串库函数的使用与实现
love_guanghui的博客
06-08 516
目录字符串有关库函数介绍及使用简述1.strlen的使用及实现2.strcmp的使用及实现3.strcpy的使用及实现4.strcat的使用及实现5.strstr的使用及实现6.strncat的使用及实现7.strncmp的使用及实现8.strncpy的使用及实现9.strtok的使用 字符串有关库函数介绍及使用 简述 1.strlen的使用及实现 2.strcmp的使用及实现 3.strcpy的使用及实现 4.strcat的使用及实现 5.strstr的使用及实现 6.strncat的使用及实现 7.s
程序崩了，咋办？
weixin_34055787的博客
06-09 195
这两天因为调程序，自己简单的总结了一下C编程中碰到的内存有关的问题和注意事项。 1. 内存溢出是啥？ 举个栈溢出的例子。所有的在函数内部申请的局部变量都是保存在栈中的。比如： #include<string.h>voidfn(void){chara[100];char*p=a;bzero(p,1000);...
C标准库函数实现之字符串比较函数
weixin_30955341的博客
07-20 1863
今天看C标准库，有个比较相关的系列函数，看到了两个不认识的函数，strcoll和strxfrm。 首先来看strcoll函数，原型为：int strcoll(const char *s1, const char *s2); 按照说明，这个函数是用来比较串的，那作用应该和strcmp差不多，但是它的作用不止于此，“若LC_COLLATE为"POSIX"或"C"，则strcoll()与st...
标准库提供的字符串处理函数
xiaomimi1993的博客
08-23 281
strlen strlen()计算字符数组的字符数，以’\0’以标志结束，计算不为’\0’的数据元素个数。 自定义函数实现strlen的功能是： int strlen(const char* str){ assert(str != NULL); int len = 0; while((*str++) != '\0') len++; retu...
字符串常见库函数实现
沧浪之水清兮
08-10 286
strcpy 函数原型：char* _strcpy(char* dest,char* src) 函数功能：将str所指由nullptr的字符串复制到dst所指的数组中，并返回dest的指针。 函数说明：保证src和dest所指内存区域不能重叠且dest必须有足够的空间来容纳src的字符串。 函数实现 char* _strcpy(char* dest, const char* src) { ...
c语言标准字符串函数的使用
qq_36675830的博客
11-27 341
MFC的CString类型有许多缺陷。对一般的应用程序，字符串管理器对象的内存分配方案足以应付，但是，对于大量使用字符串的代码（或多线程代码），默认的内存管理器可能就无法理想地工作。如多线程应用程序的局部CString变量使用不当很容易造成内存泄露。很多时候我们需要用到char*类型。 char* strcpy(char *dest,const char *src)    将字符串src复制到d
字符串常用函数
weixin_44713496的博客
03-16 2736
一、strlen 1、原型：size_t strlen(char const* string); 2、功能：返回字符串 string 的长度（不包含字符串终止符NUL） 3、注意：size_t是一个无符号整数类型 4、举例： #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char* y = "abcdef"; char* x = "abcd"; i
byr上看到的百度面试题
lzshlzsh的专栏
10-16 1157
北邮人上看到的，职位搜索研发：一面：1、strncpy(char* dst, char * src, int n)的实现2、两个有序数组求交集3、N个数里面查找是否存在和为m的两个数4、蚂蚁爬杆5、100层楼，球可能会在某一层楼摔坏，问用2个球，最坏情况下几次测试可以找出该楼层二面1、数据流(不知道规模)，随机抽取N个样本2、百度现在收录了X亿中文网页，叫你估算网页总的数量解答：1。这个先要弄清strncpy的含义，很简单Linux下man一下就知道了，man手册还给出了实现       The strnc
实现字符串拷贝不用库函数
最新发布
03-21
可以使用循环遍历源字符串，逐个字符复制到目标字符串中，直到遍历完整个源字符串。以下是一个示例代码： ```c void string_copy(char *dest, const char *src) { int i = 0; while (src[i] != '\0') { dest[i] ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值