string头文件中常用函数

已于 2024-08-17 16:41:47 修改
阅读量893 收藏 5
点赞数 29
分类专栏： c语言 文章标签： 开发语言 c语言
于 2024-08-08 23:44:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60489641/article/details/141037755
版权

文章目录

1.1strlen求字符串长度

strlen是一个库函数所包含的头文件为#include<string.h>,这里我们可以在C plusplus上找到strlen所包含的头文件以及strlen传入后函数所生成的一个参数
在这里插入图片描述
这个函数返回的类型为siz_t的值为无符号整形为正数(>=0)的数,参数为const char* str，你需要传入一个字符类型相关的数据来求出从起始地址->'\0’所有符号的长度
在这里插入图片描述
结果为
在这里插入图片描述
因为传入的是arr，arr为你的首元素地址作为参数传入到strlen函数中
因为字符串中大部分都有所对应的ASCII
ASCII值地址

1.2模拟实现strlen函数

如何模拟strlen求出字符串的长度，首先我们肯定需要知道strlen这个函数所需要的函数参数以及返回类型
在这里插入图片描述
如图所示，strlen的返回类型为size_t，它的参数是const char* str
我们先写代码来理解他的含义

#include<stdio.h>
#include<assert.h>
size_t My_strlen(const char* str)
//const为char*类型的指针指向的变量无法进行修改
{
    assert(str);     //==assert(str!=NULL)不为空指针
    size_t count = 0;//数量从0开始返回count类型
    while (*str++)//这里进去之后再去指向数组中第二个地址
    {
       count++ ;//数量++
    }
    return count;
}
int main()
{
    char arr[] = {"abcdef"};
    size_t rec = My_strlen(arr);
    printf("%zu",rec);
    return 0;
}

2.1 strcpy函数

strcpy也是一个经常使用到的函数，cpy顾名思义就是拷贝的意思，他就是将一个字符串拷贝到数组中(你的数组需要将字符串容纳进去)
在这里插入图片描述

它的返回类型也是char* 而参数第一个destination为目的地，将你想要考入的数据放到参数1中，source为源头，至于为什么第二个参数有const第一个没有，因为第二个是你需要将源头的内容拷贝到目的地，源头肯定不可以修改，而目的地这时候已经被修改，参数1不需要加const
在这里插入图片描述
在这里插入图片描述
可以看到已经将str中的字符串拷贝到arr中（如果arr中有字符的情况下，目的地的字符会被源头的字符覆盖掉，源头字符直到\0停止）

2.2 模拟实现strcpy

#include<stdio.h>
#include<assert.h>
char* My_strcpy(char* dest,const char*s)
{
    char *ret = dest;
    assert(s);
    while (*s)
    {
        *dest++= *s++;//将s的字符放到dest中++寻找下个字符
    }
    *dest = *s;//因为while循环\0为0终止循环，最后在拷贝\0，
    return ret;//返回首元素的地址
}
int main()
{
    char arr[30] = {"abcedeadwadwadada"};
    char str[15] = {"Hello, World"};
    My_strcpy(arr,str);
    printf("%s", arr);
    return 0;
}

3.1strcat函数

在这里插入图片描述
在这里插入图片描述
strcat函数介绍为：将源字符串的副本追加到目标字符串，destination中的结束null字符被source的第一个字符覆盖，并且在destination中由两者串联形成的新字符串的末尾包含一个空字符。
目的地和源头不得重叠。
这里的意思就是目的地中的第一个\0会被第一个字符覆盖然后继续覆盖，当源头的字符串覆盖完成生成一个新的\0

在这里插入图片描述
在这里插入图片描述
这里我们可以看到arr1中追加了arr2中的字符。

3.2模拟实现strcat

这里的传入参数的值和上面的步骤相同可以看一下上面
代码实现

#include<stdio.h>
#include<assert.h>
char* My_strcat(char* dest,const char* src)
{
    char *ret = dest;
    assert(dest && src);
    // char* rec = *dest;
    while (*dest!='\0')
    //首先因为我们知道了目的地的值第一个\0开始开始覆盖的，所以我们需要得到找到\0
    {
        dest++;//这里找到第一个\0
    }
    while(*dest++ = *src++)//这里我们开始从第一个\0开始被src覆盖
    {
        ; // *dest++=*src++//也可以这么写
    }
    return ret;
}
int main()
{
    char arr1[30] = {"abcde"};
    char arr2[10] = {"abcd"};
    My_strcat(arr1,arr2);
    printf("%s", arr1);
    return 0;
}

在这里插入图片描述

4.1 strcmp函数

在这里插入图片描述
strcmp函数返回的是int类型，参数为两个，这里可以看到const这个函数开始
比较每个字符串的第一个字符。如果它们彼此相等，则继续执行以下对，直到字符不同或达到终止空字符为止
在这里插入图片描述

#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[] = {"abcd"};
    char arr2[] = {"abcd"};
    int ret = strcmp(arr1, arr2);
//  它的返回值为int因为既返回整数又返回有符号整数又返回0
    if(ret>0)
        printf("大于0");//比较两个数ASCII码值大小不是长度大小
    else if(ret<0)
        printf("小于0");
    else
        printf("==");
    return 0;
}

4.2模拟实现strcmp函数

因为我们知道了strcmp是作为比较的函数而返回的结果是有符号的整数，参数为p1和p2这里我们可以实现一下

int My_strcmp(const char* str1,const char* str2)
{
    while(*str1==*str2)
    {
        if(*str1=='\0')
            return 0;
        str1++;
        str2++;
    }
    return *str1 - *str2;//如果大于str2返回正数，如果小于返回负数
}
int main()
{
    char arr1[] = "abcdef";
    char arr2[] = "abcde";
   int ret =  My_strcmp(arr1, arr2);//ret来接收函数返回值
   if(ret>0)
       printf("大于目标字符串");
    else if(ret<0)
        printf("小于目标字符串");
    else
        printf("两个字符串相等");
}

5.1strstr函数

在这里插入图片描述
返回指向str1中str2第一次出现的指针，如果str2不是str1的一部分，则返回空指针
这里的意思是str2作为str1中作为子集，从str1中寻找str2所有的字符串，然后以一个char*变量来接收如果可以找到就返回结果，找不到返回NULL

#include<string.h>
int main()
{
    char arr1[] = "abcdef";
    char arr2[] = "ef";
    char *ret = strstr(arr1, arr2);
    if(ret==NULL)
        printf("找不到");
    else
        printf("找到了%s", ret);
}

5.2模拟实现strstr

#include<stdio.h>
#include<assert.h>
const char* My_strstr(const char* str1,const char* str2)
{
    assert(str1 && str2);
    const char *a = str1;
    const char *b = str2;
    const char *num = str1;//记录可能开始匹配的位置并返回num值
    while(*num)
    {
        a = num;//当num++后，说明第一次循环的初始位置没有找到\0,需要从第二个字符开始寻找
        b = str2;//str1中的最开始的位置到\0没有找到b需要赋原值
        while (*a && *b && *a == *b) // 如果a=b,说明字符相同，开始循环进来
        //a和b不能为\0,是\0没有比较的字符
        {
            a++;
            b++;
        }
        num++;
         if(*b=='\0')//如果*b已经找到\0了说明在str1中找到了str2
        {
            return num;//num记录了我们最开始的位置，在num的基础上被a赋值++，num没有变化
        }
    }
    return NULL;
}
int main()
{
    char arr1[] = "abcdef";
    char arr2[] = "ef";
    const char* ret = My_strstr(arr1, arr2);
    if(ret ==NULL)
        printf("Not found");
    else
        printf("Yeah the character has been found: %s", arr1);
    return 0;
}```
# 6.1 strncpy函数
![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/3e2ec05926614527a200c4505b746eff.png)
这个函数和strcpy很相似，官网的功能为strncpy参数第一个为destination，参数二为source，参数三为你要将前n个拷贝到目的地
函数实现

```c
#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[] = "abcd";
    char arr2[] = "dcba";
    strncpy(arr1,arr2,2);
    //如果该目标的符号内容不够，需要追加的补\0，strncpy和strcpy只是覆盖不是拼接，将原目的地的字符串内容改变
    printf("%s", arr1);
    return 0;
}

6.2 模拟实现strncpy

char* My_strncpy(char* dest,const char*s,size_t n)
{
    char* ret = dest;
    int num=n;//将一共需要覆盖多少次赋值给num
    while (*s &&num--)num--当num或者s中其中一个条件不满足跳出循环
    {
        *ret++ = *s++;
    }
    for (int i=num; i <=n; i++)//如果num目前已经==n，那么就不满足条件
    {
        *ret++ = 0;
    }
    return dest;
}
int main()
{
    char arr1[] = "abcde";
    char arr2[] = "fghj";
    My_strncpy(arr1, arr2, 6);
    printf("%s", arr1);
    return 0;
}

7.1strncat函数实现

在这里插入图片描述
strncat的意思是将source中的num个字符拼接到destination中

#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[20] = "abcdef";
    char arr2[20] = "poiuy";
    strncat(arr1, arr2,5);//第三个参数指定追加n个字符到目的地，
    //如果传入的追加个数，少于scource的个数，条件不满足的情况下只会追加一个\0
    printf("%s", arr1);
    return 0;
}

7.2模拟实现strncat

#include<stdio.h>
#include<assert.h>
char* My_strncat(char* dest,const char* src,size_t n)
{
    char *ret = dest;
    assert(dest && src);
    while(*dest!='\0')
    {
        dest++;
    }
    while(n--)
    {
        *dest++ = *src++;
    }
    *dest = '\0';
    return ret;
}
int main()
{
    char arr1[] = "abcdef";
    char arr2[] = "cde";
    My_strncat(arr1, arr2, 5);
    //arr1为目的地，arr2为源头，4为将源头的4个字符拼接到arr1
    printf("%s", arr1);
    return 0;
}

8.1memcpy函数

在这里插入图片描述
将num字节的值从源指向的位置直接复制到目标指向的内存块。
源指针和目标指针所指向的对象的底层类型与此函数无关;结果是数据的二进制副本。
该函数不检查源中是否有任何终止null字符——它总是精确地复制num个字节。
为了避免溢出，目标参数和源参数所指向的数组的大小应该至少为num字节，并且不应该重叠(对于重叠的内存块，memmove是一种更安全的方法)。
这个函数的功能和strncpy类似，但是传入的值是以字节为单位，在内存块中以字节的形式复制给destination，我们都知道char*中一个字符单位为1

#include<string.h>
int main()
{
    int arr1[] = {1, 2, 1,3,3,1,2};
    int arr2[] = {1, 2, 1, 2, 0};
    int sz = sizeof(arr1) / sizeof(arr1[0]);
    memcpy(arr1, arr2, 3 * sizeof(int));
    for (int i = 0; i < sz;i++)
    {
        printf("%d ", arr1[i]);
    }
        return 0;
}

8.2模拟实现memcpy

#include <stdio.h>
#include <string.h>
#include<assert.h>
void* My_memcpy(void* dest,const void* src,size_t n)
//我们传入的是3*sizeof(int)类型，sizeof(int)类型占4个字节，*3为12；
//我们传进来的参数为12
{
    void *p = dest;
    assert(dest && src);
    if(src==(void*)0)
    {
        return 0;
    }
    while(n--)//需要循环12次
    {
        *(char *)dest++ = *(char *)src++;
        //我们将源头的数据以内存字节的形式置入给dest然后++找下一个字节的空间
        //memcpy内部实现只是单纯的进行地址内容的赋值操作，并没有对重叠区域进行处理。这就会导致到dst和src的地址存在重叠的时候拷贝出现异常。
    }
    return p;
}
int main ()
{
    char a[] = {"abcdefg"};
    char b[] = {"poiuytt"};
    My_memcpy(a, b,2*sizeof(char));
    char ret = sizeof(a) / sizeof(a[0]);
    for (int i = 0; i < ret;i++)
    {
        printf("%c ", a[i]);
    }
    return 0;
}

9.memmove函数

在这里插入图片描述
将num字节的值从源指向的位置复制到目标指向的内存块。复制就像使用了中间缓冲区一样进行，从而允许目标和源重叠。
源指针和目标指针所指向的对象的底层类型与此函数无关;结果是数据的二进制副本。
该函数不检查源中是否有任何终止null字符——它总是精确地复制num个字节。
为了避免溢出，目的参数和源参数所指向的数组的大小至少为num字节。
memcpy和memmove的参数和使用方式是一样的
而memcpy不考虑重叠的情况，而memmove考虑重叠的情况

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

9.1模拟实现memmove

在这里插入图片描述

#include<stdio.h>
void* My_memmove(void* dest,void* src,size_t n)
{
    void *ret = dest;
    if (dest < src)
    {
        //从前-后
    while(n--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest + 1;//强制类型转换为char*类型，因为char为一个字节+1跳到下一个字节
        src = (char*)src + 1;
    }
    }
    else
    {
      //从后-前
     while(n--)
    {
        *((char*)dest + n) = *((char*)src + n);
    }
    }
    return ret;
}
int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     int sz = sizeof(arr) / sizeof(arr[0]);
     My_memmove(arr+2, arr, 5 * sizeof(int));
     //arr为目标地址，arr+2由第第三个地址拷贝五个元素到arr中
    for (int i = 0; i < sz;i++)
    {
        printf("%d ", *(arr + i));
    }
        return 0;
}

10.memset函数

在这里插入图片描述
将ptr指向的内存块的前num个字节设置为指定的值(解释为unsigned char)。
第一个参数为要设置内存的指针 value为设置的值，num为设置的字节个数
memset是以字节单位来设置的，而不是以元素个数为单位设置
通常情况下这个函数是用来将所有字节数设置为0
如果设置为其他数一定要记得他是将内存中每个字节的数进行修改，而不是修改元素

#include<stdio.h>
#include<string.h>
int main()
{
    int arr[10] = {0};
    for (int i = 0; i < 10;i++)
    {
        arr[i] = i+1;
    }
    //1,2,3,4,5,6,7,8,9,10
    memset(arr, 0, 10 * sizeof(int));
   
    for (int i = 0; i < 10;i++)
    {
        printf("%d ",*(arr+i));
    }
        return 0;
        //如果想要修改char类型字符个数可以直接修改，因为char本身占用一个字节，int类型占用4个
}

11.memcmp函数

在这里插入图片描述
ptr1和ptr2进行比较指向要比较的内存空间，num为比较的字节个数，在num中比较如果ptr1>ptr2返回1,小于返回负数 相同为0

#include<stdio.h>
#include<string.h>
int main()
{
    int arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    // 比较字节的个数
    int arr2[] = {1, 2, 3,3};
    int ret = memcmp(arr1, arr2, 13);
    printf("%d",ret);
    //在内存中有大端字节序与小端字节序，高位字节数据存放在内存高地址处，低位数据存放在内存低地址处
    //高位字节数据存放在内存低地址处，低位字节数据存放在内存高地址处
    return 0;
}
//在大小关系成立后，就不会再次进行比较

12.strtok函数

strtok函数回找到str中的下一个标记，并以\0结尾，返回一个指向这个标记的指针。
strtok函数会改变被操作的字符串，所以在strtok函数切分字符串一般都是临时拷贝的内容可以修改。
strtok第一个参数如果不为NULL,函数找到str中第一个标记，strtok函数将保存他在字符串中的位置。
strtok函数第一个参数如果为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多标记，则返回NULL指针
返回类型为char*
在这里插入图片描述

#include<stdio.h>
#include<string.h>
int main()
{
    // char arr[] = "abcd@yeah.com.c";
    char arr[] = "123@323.909.404";
    char *p = "@.";//分隔符尽量是符号，但是数字也可以作为分割符
    char buf[20] = {0};
    strcpy(buf, arr);
    // char* a = strtok(buf, p);
    // printf("%s\n", a);//返回第一个标记前的内容
    // a = strtok(NULL, p);
    // printf("%s\n", a);//返回第二个标记前内容，为NULL
    // a = strtok(NULL, p);//🈶第二个标记开始从返回\0的内容找
    // printf("%s", a);
    char *ret = NULL;
    for (ret = strtok(buf, p); ret != NULL;ret = strtok(NULL,p))
    //第一次传入为非NULL指针，当第一次调用后为NULL
    {
        printf("%s\n", ret);
    }
        return 0;
}

13.strerror函数

可以将errnum错误码，返回一个错误信息
获得一个指针指向一个错误信息
c语言的库函数在运行的时候，如果发生错误，就会将错误码放到一个变量中，这个变量是error。

在这里插入图片描述

#include<stdio.h>
#include<string.h>
int main()
{
    printf("%s\n", strerror(0));
    printf("%s\n", strerror(1));
    printf("%s\n", strerror(2));
    printf("%s\n", strerror(3));
    printf("%s\n", strerror(3));
    printf("%s\n", strerror(4));
    printf("%s\n", strerror(5));
    return 0;
}

14.perror函数

perror返回类型为void，参数为字符串
perror直接打印出错误的信息
perror可以理解为printf+strerror结合形式
在这里插入图片描述

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
    FILE* pf= fopen("Xcode", "r");//如果没写路径默认打开的是你当前路径下的文件夹
    if(pf==NULL)
    {
        perror("fopen");//在打印错误信息前，先打印自定义的信息
        return 1;
    }
    // else printf("打开成功\n");
    //读取文件
    //关闭文件
    fclose(pf);
    pf = NULL;
    return 0;
}

15.fopen函数

在这里插入图片描述
fopen的函数参数第一个参数为文件名，第二个为打开方式
如果打开成功可以返回一个有效的指针FILE*，返回失败返回NULL

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
    FILE* pf= fopen("Xcode", "r");//如果没写路径默认打开的是你当前路径下的文件夹
    if(pf==NULL)
    {
        printf("%s",strerror(errno));//strerror包含string库函数，errno是errno库函数
        return 1;
    }
    // else printf("打开成功\n");
    //读取文件
    //关闭文件
    fclose(pf);
    pf = NULL;
    return 0;
}
Chris _data
关注
  • 29
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
string头文件函数
加油鸭
03-25 1411
1.strlen（） 原型：extern int strlen（char *s） 用法：#include<string.h> 功能：计算字符串的长度 说明：返回s的长度，不包括结束符NULL 例1： #include<stdio.h> #include<string.h> int main() { char str[10]; gets(str); int len=strlen(str); printf("%d\n",len); r
string相关常用函数
无
05-24 1145
string常用函数
String类实现的头文件
12-15
String 运算符重载等实现c++类与String类定义的串之间的运算
string头文件函数（查删插替...）
young_Klara的博客
04-17 623
string
深入了解strlen和sizeof
最新发布
chenbingjie_c的博客
08-03 434
通过做题深入了解strlen和sizeof的用法和差别
【c语言】＜string.h＞头文件中所有函数详解
weiweiliude2的专栏
03-22 4114
c语言最全的string.h头文件中函数详解,包含20个函数的说明和测试使用
关于string.h头文件的函数——C语言
Lan00009的博客
12-05 2295
一点关于string里函数的理解
C语言头文件＜string.h＞中的常用函数
weixin_43362027的博客
09-06 2528
函数原型：int memcmp(const void *str1, const void *str2, size_t n)说明：strcat(str1, str2)把str1（包括“\0”）复制到str2后面（删除str2原来末尾的“\0”）函数原型：int strcmp(char *str1,char * str2，int n)说明：stricmp(str1,str2)，前者大则值为1，相同则为0，后者大则为-1。说明：strcmp(str1,str2) 前者大则值为1，相同则为0，后者大则为-1。
CC++常用头文件及函数汇总_CC++常用头文件及函数汇总_头文件汇总表_
10-03
以下是对C/C++中一些常用头文件及其包含的函数的详细汇总。 1. `<stdio.h>`：这是C语言的基础输入输出头文件，提供了诸如`printf`、`scanf`、`fopen`、`fclose`等用于处理文件和标准输入输出的函数。例如，`printf`...
c语言中常用函数头文件,c语言中常用的函数和头文件
weixin_28691003的博客
05-19 5678
头文件ctype.h函数列表函数类别函数目的详细说明字符测试为字符和数字的isalnum是否为isalpha字符是否控制字符iscntrl是否为数字isdigit是否能够显示文字(空格除外) isgraph是否可以显示字符(包括空格) isprint非空格或数字的可显示字符ispunct有无空间isspace是否大写isupper是否为十六进制(0-9，A-F )字符isxdigit转换字符大小...
string头文件中有哪些常用函数
04-25
string头文件中常用的函数包括: 1. strlen() ：求字符串长度 2. strcpy() ：将一个字符串复制到另一个字符串中 3. strcat() ：将两个字符串拼接成一个字符串 4. strcmp() ：比较两个字符串是否相等 5. strchr() ：...
mingw to_string()头文件
11-05
补充mingw c++11下部分实现 （to_tring） 包括 wchar.h stdio.h
c++中的string常用函数用法总结
09-05
本文将对C++中的`std::string`常用函数进行详细讲解。 首先，要使用`std::string`，需要包含`<string>`头文件，并可选择性地使用`using namespace std;`来简化代码。例如： ```cpp #include <string> using ...
深扒头文件 ＜string.h＞ 中的函数 ------- C语言
nK的博客
07-22 4535
在日常敲代码的过程中，当我们处理字符串时经常会使用字符串函数，调用字符串函数则需要包含头文件，对于头文件中包含的函数你了解多少呢？本篇博客总结了头文件中一些常用的函数及其使用实例和部分函数的模拟实现，相信跟随本篇博客一起探讨，能让你对头文件中的某些函数有不一样的理解。...
【C/C++入门攻略】常用头文件下的函数介绍：cstring/string.h
一只小杰鸽的博客
09-23 683
文章目录常用头文件下的函数介绍：cstring/string.h1. strlen()2. strcmp()3. strcpy()4. strcat() 常用头文件下的函数介绍：cstring/string.h C语言提供了很多实用的数学函数，如果要使用，需要在程序开头添加头文件cstring或者string.h。 //二者选一 #include <cstring> #include <string.h> 1. strlen() strlen(str)用于得到字符数组中第一个\0前
C++中string的常用函数总结
热门推荐
woxiaozhi的专栏
02-28 1万+
标准c++中string类函数介绍 注意不是CString 之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必 担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据
关于string头文件
chrisxiaoniu的博客
04-28 2918
C++中不包含string头文件和包含string头文件的区别何在，为何都能使用string类来创建对象？答：今天特别无聊，这个问题我也一直奇怪，搜索也没满意的答案，就自己猜测了。代码实测使用string类创建实例只需要包含iostream，然后使用名称空间std即可，而string类的声明是在头文件xstring中，那就只有一个可能是iostream包含了xstring，然后就一顿乱点，还真的找...
string头文件常用方法（C++）
努力搬砖的打工人
01-23 1万+
string 定义字符串，如果未赋初值，则默认是 "" ，即空字符串，结尾也没有结束标志 \0 #include <string> using namespace std; int main() { string s1; // 空字符串 string s2(5, 's'); // s2 = "sssss"; } 常用成员函数： 求字符串长度 str.length(); 字符串的拼接，可以用 + 或者 += 直接拼接字符串 用 + 拼接字符串时，可以两边都是 string字符串；
【个人笔记】关于string头文件
flysky_jay的博客
03-05 1114
1）文件cstring，和string.h对应，c++版本的头文件，包含比如strcpy之类的字符串处理函数2）文件string.h，和cstring对应，c版本的头文件，包含比如strcpy之类的字符串处理函数3）文件string，包含std::string的定义，属于STL范畴4）CString，MFC里的的字符串类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值