C语言-字符串+内存函数

已于 2023-03-14 18:15:55 修改
阅读量66 收藏
点赞数
文章标签： c语言 c++ 算法 Powered by 金山文档
于 2023-01-31 15:47:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73873022/article/details/128764991
版权

字符串与内存函数

求字符串长度

strlen

size_t strlen ( const char * str )

  • 字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包

含 '\0' )。

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

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

用三种不同的方法实现strlen函数：

法1：（循环）

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

//size_t strlen(const char * str)
size_t my_strlen(const char* str)
{
    assert(str);
    int count = 0;//计数
    while (*str)//遍历数组
    {
        str++;
        count++;
    }
    return count;
}

int main()
{
    char arr[] = "abcdef";
    int len = my_strlen(arr);
    printf("%d\n", len);
    return 0;
}

法2：（递归）

#include <stdio.h>
#include <string.h>
#include <assert.h>
 
//size_t strlen(const char * str)
size_t my_strlen(const char* str)
{
    assert(str);
    if (*str != '\0')
        return 1 + my_strlen(str + 1);
    else
        return 0;
}
 
int main()
{
    char arr[] = "abcdef";
    int len = my_strlen(arr);
    printf("%d\n", len);
    return 0;
}

法3：（指针减指针）

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

//size_t strlen(const char * str)
size_t my_strlen(const char*str)
{
    assert(str);
    const char*start=str;
    while(*str)
    {
        str++;
    }
    return str-start;//指针之间隔着一整个数组
    //数组在内存中是连续存储的，start与str之间相差6个字节
}

int main()
{
    char arr[] = "abcdef";
    int len = my_strlen(arr);
    printf("%d\n", len);
    return 0;
}

长度不受限制的字符串函数

strcpy

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

注：

1.源字符串必须以 '\0' 结束，

2.该函数会将源字符串中的 '\0' 拷贝到目标空间，

3.目标空间必须足够大，以确保能存放源字符串。

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

//char* strcpy(char* destination, const char* source)
char*my_strcpy(char* dest, const char* src)
{
    assert(dest && src);
    char* ret = dest;
    while (*dest++ = *src++)
    {
        ;
    }
    return ret;//返回的是目标字符串的首字符地址

}

int main()
{
    char arr1[10] = "abc";
    char arr2[] = "def";
    my_strcpy(arr1,arr2);
    printf("%s\n", arr1);
    return 0;
}

strcat

char * strcat ( char * destination, const char * source )

注：

1.源字符串必须以 '\0' 结束，

2.目标空间必须有足够的大，能容纳下源字符串的内容，

3.目标空间必须可修改。

#include <assert.h>
#include <stdio.h>
#include <string.h>
 
//char* strcat(char* destination, const char* source)
char* my_strcat(char* dest, const char* src)
{
    assert(*dest && *src);
    char* ret = dest;
    while (*dest)
    {
        dest++;
    }

    while(*dest++= *src++);
    return ret;
}

int main()
{
    char arr1[30] = "welcome to";
    char arr2[] = " my ";
    my_strcat(arr1, arr2);
    my_strcat(arr1, "blog");
    printf("%s\n", arr1);
    return 0;
}

strcmp

int strcmp ( const char * str1, const char * str2 )

注：

1.第一个字符串大于第二个字符串，则返回大于0的数字，

2.第一个字符串等于第二个字符串，则返回0，

3.第一个字符串小于第二个字符串，则返回小于0的数字。

#include <assert.h>
#include <stdio.h>
#include <string.h>
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);
}


int main()
{
    char arr1[] = "abcd";
    char arr2[] = "abcz";
    int ret = my_strcmp(arr1, arr2);//按照字典序来排
    if (ret > 0)
        printf("arr1>arr2\n");
    else if (ret == 0)
        printf("arr1=arr2\n");
    else
        printf("arr1<arr2\n");
    return 0;
}

注：

1.第一个字符串大于第二个字符串，则返回大于0的数字，

2.第一个字符串等于第二个字符串，则返回0，

3.第一个字符串小于第二个字符串，则返回小于0的数字。

长度受限制的字符串函数介绍

strncpy

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

拷贝num个字符从源字符串到目标空间。

如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

#include <assert.h>
#include <stdio.h>
#include <string.h>
 
//char* strncpy(char* destination, const char* source, size_t num)
char* my_strncpy(char* dest, const char* src, size_t num)
{
    assert(dest && src);
    char* ret = dest;
    while (num && (*dest++ = *src++))
    {
        num--;
    }
    if (num)
    {
        while (--num)
        {
            *dest++ = '\0';
        }
    }
        return ret;//返回的是目标字符串的首字符地址
}

int main()
{
    char arr1[20] = "xxxxxxxxxxxxx";
    char arr2[] = "hello";
    my_strncpy(arr1, arr2, 3);
    printf("%s\n", arr1);
    my_strncpy(arr1, arr2, 7);//若追加的字符数量大于字符串中字符的数量,会将多出来的字符补为'0'
    printf("%s\n", arr1);
    return 0;
    }

输出：

helxxxxxxxxxx
hello

strncat

char * strncat ( char * destination, const char * source, size_t num )
#include <assert.h>
#include <stdio.h>
#include <string.h>
 
//char* strncat(char* destination, const char* source, size_t num)
char* my_strncat(char* dest, const char* src, size_t num)
{
    assert(dest && src);
    const char* ret = dest;
    while (*dest++)
    {
        ;
    }
    dest--;
    while (num)
    {
        if (!(*dest++= *src++))
        {
            return ret;//若追加的字符数量大于字符串中字符的数量，则只追加字符串中字符的数量
        }
    }
    *dest = '\0';
    return ret;
}
 
int main()
{
    char arr1[30] = "welcome to";
    char arr2[] = " my ";
    my_strncat(arr1, arr2, 2);
    my_strncat(arr1, "blog", 2);
    printf("%s\n", arr1);
    return 0;
}

输出：

welcome to my blog

strncmp

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

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完

字符串查找

strstr

char * strstr ( const char *str1, const char * str2);

strstr函数可以查找字符串中的字符，并返回他们的地址。

如果找不到对应字符或字符串，就返回空指针。

模拟实现一下strstr函数：

#include<stdio.h>
#include<assert.h>

char* my_strstr(const char* p1, const char* p2)
{
    assert(p1 && p2);
    char* s1 =NULL;
    char* s2 =NULL;
    char* cur = (char*)p1;//cur指针的作用是作为遍历字符串str1的起始地址

    if (*s1 == '\0')
    {
        return (char*)p1;
    }
    while (*cur)
    {
        s1 = cur;
        s2 = (char*)p2;

        while (*s1&&*s2  && (*s1 == *s2))
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')
        {
            return cur;//找到子串
        }
        cur++;
    }
    return NULL;//找不到子串
}

int main()
{
    char* p1 = "abbbcef";
    char* p2 = "bbc";
    char*str=my_strstr(p1, p2);
    printf("%s", str);
    return 0;
}

输出：

bbcef

strtok

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

  • sep参数是个字符串，定义了用作分隔符的字符集合

  • 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标

记。

  • strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：

strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容

并且可修改。）

  • strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串

中的位置。

  • strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标

记。

  • 如果字符串中不存在更多的标记，则返回 NULL 指针。

例：

#include <stdio.h>
#include <string.h>
 
int main()
{
    char arr[] = "asdf@hjkl.qwer";
    char* p = "@.";
    char buf[20] = { 0 };
    strcpy(buf, arr);
 
    char* pa = strtok(buf, p);
    printf("%s\n", pa);
 
    pa = strtok(NULL, p);//传空指针
    printf("%s\n", pa);
 
    pa = strtok(NULL, p);
    printf("%s\n", pa);
 
    return 0;
}

输出：

asdf
hjkl
qwer
#include<stdio.h>
#include<string.h>

int main()
{
    char arr[]= "asdf@hjkl.qwer";
    char* p = "@.";
    char buf[20] = { 0 };
    strcpy(buf, arr);
    char* ret = NULL;
    for (ret = strtok(arr, p); ret != NULL; ret = strtok(NULL, p))
    {
        {
            printf("%s\n", ret);
        }
    }
    return 0;
}

错误信息报告

strerror

C语言的库函数在运行的时候，如果发生错误，

就会将错误码存在一个变量中，这个变量是：errno。

而strerror 函数能将错误码翻译成错误信息。

例：

#include <stdio.h>
#include <string.h>
 
int main()
{
    //错误码是一些数字：1 2 3 4 5 ，他们都有不同的含义
    printf("%s\n", strerror(0));
    printf("%s\n", strerror(1));
    printf("%s\n", strerror(2));
    printf("%s\n", strerror(3));
    printf("%s\n", strerror(4));
    printf("%s\n", strerror(5));
    return 0;
}

输出：

No error
Operation not permitted
No such file or directory
No such process
Interrupted function call
Input/output error

perror

但在平时，perror用的也很多，

举个例子：

#include <stdio.h>
#include <string.h>
#include <errno.h>//这个是errno的头文件
 
int main()
{
    //打开文件
    FILE* pf = fopen("test.txt", "r");
    if (pf == NULL)
    {
        printf("%s\n", strerror(errno));//实际上我们并没有这个文件，就能通过strerror报错
        return 1;
    }
    //读文件
    //关闭文件
    fclose(pf);
    pf = NULL;
 
    return 0;
}

输出：

fopen: No such file or directory

但是使用perror 函数会更方便和灵活。

#include <assert.h>
#include <stdio.h>
#include <string.h>
 
int main()
{
    //打开文件
    FILE* pf = fopen("test.txt", "r");
    if (pf == NULL)
    {
        perror("fopen");
        return 1;
    }
    //读文件
    //关闭文件
    fclose(pf);
    pf = NULL;
 
    return 0;
}

输出：

fopen: No such file or directory

字符操作

字符分类函数：

内存操作函数

memcpy

void * memcpy ( void * destination, const void * source, size_t num )

memcpy是内存拷贝函数：

1.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

2.这个函数在遇到 '\0' 的时候并不会停下来。

3.如果source和destination有任何的重叠，复制的结果都是未定义的（会出问题）。

模拟实现一下memcpy函数：

#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
    assert(dest && src);
    void* ret = dest;//记住起始地址
    while (num--)
    {
        *(char*)dest = *(char*)src;
        ((char*)dest)++;
        ((char*)src)++;
    }
    return ret;
}

memmove

void * memmove ( void * destination, const void * source, size_t num )

memmove函数的功能与memcpy的功能类似，但也有差别：

1.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

2.如果源空间和目标空间出现重叠，就得使用memmove函数处理

例：

如果使用memcpy,拷贝的结果就会出问题：

 #include <assert.h>
#include <stdio.h>
#include <string.h>
 
void print(int* arr, int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
}
 
//void* memcpy(void* destination, const void* source, size_t num)
void* my_memcpy(void* dest, const void* src, size_t num)
{
    assert(dest && src);
    void* ret = dest;//记住起始地址
    while (num--)
    {
        *(char*)dest = *(char*)src;//一个字节一个字节的拷贝
        ++(char*)dest;
        ++(char*)src;
    }
    return ret;
}
 
int main()
{
    int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    my_memcpy(arr1 + 2, arr1, 17);//17个字节
    int sz = sizeof(arr1) / sizeof(arr1[0]);
    print(arr1, sz);
}

输出：

1 2 1 2 1 2 1 8 9 10

我们想要的结果是：1 2 1 2 3 4 5 8 9 10

（注：在VS2019的环境下，memcpy的库函数实现已经和memmove一样了）

那就得使用memmove函数：

#include <stdio.h>
#include <string.h>
 
void print(int* arr, int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
}
 
int main()
{
    int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    memmove(arr1 + 2, arr1, 17);//17个字节
    int sz = sizeof(arr1) / sizeof(arr1[0]);
    print(arr1, sz);
}

输出：

1 2 1 23 4 5 8 9 10

模拟实现一下memmove函数：

#include <assert.h>
#include <stdio.h>

void _my_memmove(void* dest, const void* src, size_t num)
{
    assert(dest && src);
    void* ret = dest;
    if (dest < src)//通过判断避免数组内容覆盖导致的错误
    {
        //从前往后拷贝数组内容
        while (num--)
        {
            *(char*)dest = *(char*)src;
            ++(char*)dest;
            ++(char*)src;
        }
    }
    else
    {
        //从后往前拷贝数组内容
        while (num--)
        {
            *((char*)dest + num) = *((char*)src + num);
        }
    }
}

memset

void * memset ( void * ptr, int value, size_t num )

memset是内存定义函数，我们一般用它来进行初始化操作。

例：

#include <stdio.h>
#include <string.h>
 
void print(int* arr, int sz)
{
    int i = 0;
    for (i = 0; i < sz; i++)
{
    printf("%d ", arr[i]);
}
    printf("\n");
}
 
int main()
{
    int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    memset(arr1, 0, sizeof(arr1));//设置成0
    char arr2[20] = "hello world";
    memset(arr2, 'x', 5);//把五个字节的内容设置成‘x’
    int sz = sizeof(arr1) / sizeof(arr1[0]);
    print(arr1, sz);
    printf("%s\n", arr2);
}

输出：

0 0 0 0 0 0 0 0 0 0
xxxxx world

memset能否把数组中的每个元素设置成1呢？

答案是不能的

例：

#include<stdio.h>
#include<string.h>
int main()
{
    int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    memset(arr1, 1, sizeof(arr1));
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", arr1[i]);
    }
    return 0;
}

输出：

1599732664 1599732664 1599732664 1599732664 1599732664 1599732664 1599732664 1599732664 1599732664 1599732664

答案是不能的,因为memset把每个字节都改成了1。

memcmp

int memcmp ( const void * ptr1,const void * ptr2,size_t num )

memcmp函数能比较从ptr1和ptr2指针开始的num个字节，

ptr1 > ptr2 返回 >0 的数，

ptr1 < ptr2 返回 <0 的数，

ptr1 = ptr2 返回 =0 的数。

例：
#include <stdio.h>
#include <string.h>
 
int main()
{
    char arr1[] = "abcd";
    char arr2[] = "abcz";
    int ret = memcmp(arr1, arr2, 4);//比较四个字节的内容
    if (ret > 0)
    printf("arr1>arr2\n");
    else if (ret == 0)
    printf("arr1=arr2\n");
    else
    printf("arr1<arr2\n");
    return 0;
}

输出：

arr1<arr2

月光迟暮之夜
关注
C语言-字符串常量（超详细）
01-02
"C语言字符串常量超详细" C语言字符串常量是C语言中非常重要的一种数据类型，它们的存储和使用方式与其他类型的变量有所不同。下面我们将详细介绍C语言字符串常量的存储、定义、使用和释放等方面的知识点。 内存...
C语言学习-字符串处理函数
03-12
C语言学习-字符串处理函数 strcat(char str1,char str2) strcpy(char str1,char str2) strncpy(char str1,char str2,int n) strcmp(char str1,char str2)//比较两个字符串大小str1>str2返回值>0，str1=str2...
C语言-字符串-字符数组
ITQWQ的博客
07-07 9244
定义的几种格式和整型一样。
【C语言】字符+字符串函数精讲
LEE180501的博客
10-02 1415
本章主要对字符串以及字符操作函数进行了一个较为全面的介绍，篇幅较长，但干货满满。建议大家反复观看，慢慢食用😊。
C语言学习笔记---字符串转浮点函数
HXYDJ的博客
02-17 1万+
  字符串不仅可以转换为整数，也可以转换为浮点数，字符串转浮点数函数原型如下： float __cdecl __mingw_strtof (const char * __restrict__, char ** __restrict__); double __cdecl __mingw_strtod (const char * __restrict__, char ** __restrict__);   strtof函数返回值是一个单精度浮点数，strtod返回值是一个双精度浮点数。  
C语言-字符串拼接(不用strcat函数)
weixin_45651738的博客
04-14 8469
#include<stdio.h> int main() { char str1[100]; char str2[100]; int i = 0, j = 0; printf("请输入字符串1：\n"); gets(str1); printf("请输入字符串2：\n"); gets(str2); while (str1[i] != '\0') { i++;//找到str1的最后一个字符 } while (str2[j] != '\0') { str1[i++] = .
C语言--字符串的逆置
m0_51961114的博客
11-13 4658
C语言–字符串的逆置 在c语言中虽已有对应库函数，比如reverse()可对字符串进行逆置，但为了更加清晰地了解其工作原理，并为了多多感受指针、递归的魅力，所以本篇博客便是准备介绍几种字符串逆置的方法，辅助于自身探索之用。 （1）无递归，利用指针的简单方法 此法是利用了指针，去依次交换字符，最后实现字符串的逆置。 /* *文件功能：字符串逆置 *编写时间：2020-11-13 */ #include<stdio.h> #include<stdlib.h> /* *函数名： rever
C语言--字符串的截取
热门推荐
不凋零的树叶
04-08 5万+
今天碰到了一个字符串截取的功能实现问题，比较常见所以就做下记录。 一般的实现是这样的： #include <stdio.h> #include <string.h> int main(void){ char dest[5]={0}; char src[]="abcdefghijk"; strncpy(dest,src,4);//注意一下...
C语言-字符串与输入输出
Charge8的博客
10-06 5363
C语言-字符串与输入输出
【C语言】字符串函数「超详细」
"謓泽"正在路上朝着"攻城狮"方向"前进四"!
06-08 8743
字符串函数的使用是我们必须要掌握的知识点很多面试知识点包括对于程序当中运用到字符串函数的形式还是比较多的，所以我们是必须要了解掌握这个知识点的。尽管知识点比较多，但是我们还是要好好吸收消化这个知识点的。听说长按收藏按钮会有惊喜╰(*°▽°*)╯........................
C语言-字符串与转义字符
qq_45967533的博客
01-31 1万+
字符串 C语言中有整形，字符型等等，但是没有字符串类型 由双引号引起的一串字符称字符串类型 "hello!\n" 注意：字符串的结束标志是一个\0的转义字符，在计算字符串长度时，\0是结束标志，不算字符串内容。 int main() { char arr1[]="abc";//可以用一个字符串初始化一个字符数组 char arr2[]={'a','b','c'};//定义第二个数组，观察与第一个数组的不同之处 return 0; } 用vs2022调试时，按f10调试
C语言--使用函数实现字符串复制
m0_55065718的博客
12-11 4780
在C语言中使用自定义函数实现字符串复制以及注意事项
305-字符串函数string.h应用举例(51单片机C语言实例Proteus仿真和代码)
06-16
305-字符串函数string.h应用举例(51单片机C语言实例Proteus仿真和代码)305-字符串函数string.h应用举例(51单片机C语言实例Proteus仿真和代码)305-字符串函数string.h应用举例(51单片机C语言实例Proteus仿真和代码)...
C语言实现字符串操作函数的实例
08-29
C语言实现字符串操作函数的实例 在C语言编程中，字符串操作函数是一个非常重要的组成部分。这些函数可以帮助我们快速地实现字符串的各种操作，例如求字符串长度、拷贝字符串、连接字符串、比较字符串等等。今天，...
C语言 ——— 编写函数，判断一个整数是否是回文整数
weixin_55341642的博客
09-18 229
先用 tmp 变量存储 input 的值，负数肯定不是回文整数，所以 tmp 要大于 0 ，再将 tmp 从低到高的每一位剥离下来，并存储到变量 sum ，且每次存储到 sum 时，都要递乘 10，出循环后 sum 再除 10 ，只要 input 是回文整数，那么 input 的值就会和 sum 的值相同。编写一个函数，用来判断一个整数是否是回文整数，如果是回文整数就返回 true ，如果不是就返回 false。
C语言中union的用法
zyqash的博客
09-21 238
在C语言中，union（联合体）是一种特殊的复合数据类型，它允许多个不同的数据成员共享同一块内存空间。与struct（结构体）不同的是，union中的所有成员共用同一个内存地址，因此同时只能存储一个成员的值。
C++ STL中sort函数
weixin_43349440的博客
09-15 431
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
pyqt瀑布流布局
最新发布
weixin_54217201的博客
09-21 291
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
标准C++（二）
m0_63127040的博客
09-18 796
在C语言中定义的全局变量、函数、结构、联合、枚举、枚举值、宏都在全局作用域下，所以当项目比较庞大时，非常容易造成命名冲突（以模块名作前缀、后缀），所以C++中选择把全局作用域进行拆分成子作用域进行管理，这些子作用域就是作名字空间。把抽象结果（利用面向对象的思维模式，思考、观察出的结果），使用用C++的语法封装出一种类似结构的自定义数据类型（复合数据类型）。使用设计好的类（结构）这种数据类型，定义出的类变量在面向对象编程语言中被称为对象（结构变量），创建类对象的行为也被称为实例化对象。int id;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值