精华内容
下载资源
问答
  • Linux C字符串替换函数
    2021-05-10 08:44:23

    #include// 字符串替换(源字符串, 旧字符串, 新字符串)

    char *replace(const char *str, const char *str1, const char *str2)

    {

    char *pstr1, *pstr2, *pbuf1, *pbuf2;

    char ch;

    pbuf1 = NULL;

    pbuf2 = NULL;

    pstr1 = strstr(str, str1);

    while (pstr1 != NULL) {

    ch = *pstr1;

    *pstr1 = 0;

    if (pbuf1 == NULL) {

    pbuf1 = (char *)malloc(strlen(str) + strlen(str2) + 1);

    pbuf1[0] = 0;

    } else {

    pbuf2 = (char *)malloc(strlen(pbuf1) + strlen(str) + strlen(str2) + 1);

    strcpy(pbuf2, pbuf1);

    free(pbuf1);

    pbuf1 = pbuf2;

    }

    strcat(pbuf1, str);

    strcat(pbuf1, str2);

    *pstr1 = ch;

    str = pstr1 + strlen(str1);

    pstr1 = strstr(str, str1);

    }

    if (str && str[0]) {

    if (pbuf1 == NULL) {

    pbuf1 = (char *)malloc(strlen(str) + strlen(str2) + 1);

    pbuf1[0] = 0;

    } else {

    pbuf2 = (char *)malloc(strlen(pbuf1) + strlen(str) + strlen(str2) + 1);

    strcpy(pbuf2, pbuf1);

    free(pbuf1);

    pbuf1 = pbuf2;

    }

    strcat(pbuf1, str);

    }

    return pbuf1;

    }

    main()

    {

    char str[] = "111\n2222\n333";

    char *an;

    printf("%s\n\n", str);

    an = replace(str, "\n2222\n", "");

    printf("%s\n", an);

    }

    更多相关内容
  • 关于字符串常量的几个基础问题学习和记录。


    1. 相同字符串常量的地址是否相同?

    • 源码
    // File: strdemo1.c
    #include <stdio.h>
    char *a = "hello world";
    char c[] = "hello world";
    int main(int argc, char *argv[])
    {
    	char *b = "hello world";
        printf("ap=%p, bp=%p, a%sb\n", a, b, ((a==b)? "==": "!="));
        char d[] = "hello world";
        printf("cp=%p, dp=%p, c%sd\n", c, d, ((c==d)? "==": "!="));
    	return 0;
    }
    
    • 执行
    root@ubuntu:/opt/constval# gcc -Wall -g strdemo1.c -o strdemo1
    root@ubuntu:/opt/constval# ./strdemo1 
    ap=0x55995a62d004, bp=0x55995a62d004, a==b
    cp=0x55995a62f010, dp=0x7fffdebdfa8c, c!=d
    
    • 结论
      (1) 指针形式的字符串常量(*a 和 *b):地址相同,指向同一段存储空间,即仅存储一份相同的字符串。
      (2) 数组形式的字符串常量(c[] 和 d[]):地址不同,指向不同的存储空间,即存储了两份相同的字符串。

    2. 指针形式的字符串常量(char *)可以更改吗?

    • 源码
    // File: strdemo2.c
    #include <stdio.h>
    char *a = "hello world";	// 已初始化
    char *b;					// 未初始化
    int main(int argc, char *argv[])
    {
    	*a = "get out";   		// compile [-Wint-conversion] and execute Segmentation fault
    	// *(a+3) = '-';     	// compile normal and execute Segmentation fault
    	// *a = 123;         	// compile normal and execute Segmentation fault
    	// *a = 't';         	// compile normal and execute Segmentation fault
    	
    	// *b = "get out";   	// compile [-Wint-conversion] and execute Segmentation fault
    	// *(b+3) = '-';     	// compile normal and execute Segmentation fault
    	// *b = 123;         	// compile normal and execute Segmentation fault
    	// *b = 't';         	// compile normal and execute Segmentation fault
    
    	// printf("++ap=%p, ", ++a);	// normal
    	// printf("++ac=%s\n", a);		// normal
    	// printf("++bp=%p, ", ++b);	// normal (++bp=0x1, because *b is uninitialized)
    	// printf("++bc=%s\n", b);		// compile normal and execute Segmentation fault
    	
    	return 0;
    }
    
    • 执行
      执行结果参见源码中的注释,读者可以自行验证每一行。例如"*a = “get out”; //compile [-Wint-conversion] and execute Segmentation fault",即编译时报 [-Wint-conversion] 警告,执行时报Segmentation fault,如下所示。
    root@ubuntu:/opt/constval# gcc -Wall -g strdemo2.c -o strdemo2
    strdemo2.c: In function ‘main’:
    strdemo2.c:6:5: warning: assignment to ‘char’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
        6 |  *a = "get out";   // compile [-Wint-conversion] and execute Segmentation fault
          |     ^
    root@ubuntu:/opt/constval# ./strdemo2
    Segmentation fault (core dumped)
    
    • 结论
      (1) 无论 char * 是否初始化,在编译时,输入int型、char型无警告,输入字符串型报[-Wint-conversion]警告;在执行时,均会报Segmentation fault错误。
      (2) 指针形式的字符串常量存放在不可以更改的静态内存存储区域,更改其指向的任何数据都是不允许的。
      (3) 指针本身是一个变量,单独预留一个存储位置,用于存储字符串常量的地址(指向首字符地址),可进行++a等类似的操作。

    3. 数组形式的字符串常量(char [])可以更改吗?

    • 源码
    // File: strdemo3.c
    #include <stdio.h>
    char c[12] = "hello world";
    int main(int argc, char *argv[])
    {
        printf("cp=%p, cv=%s\n", c, c);
    
    	c[5] = '-';							// normal
        printf("cp=%p, cv=%s\n", c, c);
        *(c+5) = '&';						// normal
        printf("cp=%p, cv=%s\n", c, c);
        
        *c = "get out";						// compile [-Wint-conversion] and execute normal
        printf("\"get out\" pointer is %p\n", "get out");
        printf("cp=%p, cv=%s\n", c, c);
    
    	// *(++c) = '#';					// compile error: lvalue required as increment operand
    	
    	return 0;
    }
    
    • 执行
    root@ubuntu:/opt/constval# gcc -Wall -g strdemo3.c -o strdemo3
    strdemo3.c: In function ‘main’:
    strdemo3.c:16:8: warning: assignment to ‘char’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
       16 |     *c = "get out";
          |        ^
    root@ubuntu:/opt/constval# ./strdemo3
    cp=0x557291653010, cv=hello world
    cp=0x557291653010, cv=hello-world
    cp=0x557291653010, cv=hello*world
    "get out" pointer is 0x557291651012
    cp=0x557291653010, cv=ello&world
    
    • 结论
      (1) 用字符串常量初始化的数组(char [])可以更改,因为它不是存放在不可更改的内存区域。
      (2) 对于 *c = “get out” 进一步说明:*c 实际上指向的是c[12]的第一个字符,将 “get out” 赋值给 *c时,强制将其地址0x557291651012截取后两位,即char型0x12,赋值给c[12]的第一个字符。因为0x12在ASCII码表中对应的是控制字符,即非打印字符,所以其输出为ello&world。
      (3) 编译器会把数组名c看作是数组首元素的地址&c[0]的同义词,即c是个地址常量。可以用c+1来标识下一个元素,但不能使用++c;c[12]在计算机内存中被分配一个有12个元素的数组(其中每个元素对应一个字符,还有一个附加的元素对应结束的空字符’\0’),每个元素都被初始化为相应的字符;通常,被引用的字符串存储在可执行文件的数据段部分,当程序被加载到内存中时,字符串也被加载到内存中,把被引用的字符串复制到数组中。

    4. 动态申请内存的字符串(malloc)可以更改吗?

    • 源码
    // File: strdemo4.c
    #include <stdio.h>
    #include <stdlib.h>
    int main(int argc, char *argv[])
    {
        char *a = "hello world";
        char *b = NULL; 
        if ((b = (char *)malloc(sizeof(char) * 12)) == NULL)
        {
            perror("malloc fail!");
            return -1;
        }
        while(*a != '\0') *b++=*a++;
        *b = '\0';
        b -= 11;
    
        printf("bp=%p, bc=%s\n", b, b);
        *(b+5) = '-';
        printf("bp=%p, bc=%s\n", b, b);
    
        free(b);
        return 0;
    }
    
    • 执行
    root@ubuntu:/opt/constval# gcc -Wall -g strdemo4.c -o strdemo4
    root@ubuntu:/opt/constval# ./strdemo4
    bp=0x559b61db72a0, bc=hello world
    bp=0x559b61db72a0, bc=hello-world
    
    • 结论
      (1) 用动态申请的方法给一个字符串赋值,那么该字符串在程序运行过程中的值依然可以修改。

    5. 参考文献

    1. C语言字符串定义
    2. gcc_warning:assignment makes integer from pointer without a cast
    3. ASCII码字符对照表
    展开全文
  • Linux C 字符串操作

    千次阅读 2017-07-06 15:27:07
    Linux C 字符串操作(连接、复制、长度)

    1、字符串输入

      1 #include <stdio.h>
      2 #include <stdlib.h>     //函数malloc()
      3 #include <string.h>
      4 
      5 int main()
      6 {
      7         int i = 0;
      8         char *tempString;
      9         char *stringArray[3];  //指针数组
     10         for(i = 0; i < 3; i++)
     11         {
     12                 printf("Enter: ");
     13                 scanf("%s", tempString);  //输入
     14                 //malloc() 在 堆中 申请内存空间
     15                 stringArray[i] = (char *)malloc(sizeof(char) * (strlen(tempString) + 1));
     16                 strcpy(stringArray[i], tempString);  //复制 字符串
     17         }
     18         printf("%s %s%s\n", stringArray[0], stringArray[1], stringArray[2]);
     19         for(i = 0; i < 3; i++)
     20         {
     21                 free(stringArray[i]);   //free() 释放
     22         }
     23         return 0;
     24 }
    执行:


    2、字符串长度

      1 #include<stdio.h>
      2 
      3 int main(int argc, char *argv[])
      4 {
      5         printf("string: %s\n", argv[1]);  //输入的第一个参数
      6         printf("length: %d\n", string_length(argv[1]));
      7 
      8         return 0;
      9 }
     10 
     11 int string_length(char *str)
     12 {
     13         int str_len = 0;
     14         char *temp = NULL;
     15         temp = str;
     16         while( *temp != '\0')
     17         {
     18                 str_len++;  //长度 自加
     19                 temp++;
     20         }
     21         return str_len;
     22 }
    执行:



    3、字符串连接

      1 #include <stdio.h>
      2 
      3 char *stringCatenate(char *dest_str, char *src_str);
      4 
      5 int main(int argc, char *argv[])
      6 {
      7         printf("%s\n", stringCatenate(argv[1], argv[2]));
      8 
      9         return 0;
     10 }
     11 
     12 char *stringCatenate(char *dest_str, char *src_str)
     13 {
     14         char *dtemp = NULL;
     15         char *stemp = NULL;
     16         dtemp = dest_str;
     17         stemp = src_str;
     18         while(*dtemp != '\0')
     19         {
     20                 dtemp++;
     21         }
     22         while(*stemp != '\0')
     23         {
     24                 *dtemp = *stemp;
     25                 dtemp++;
     26                 stemp++;
     27         }
     28         *dtemp = '\0';
     29         return dest_str;  //注意:此处不是返回 dtemp
     30 
     31 }
    执行:



    4、字符串复制

      1 #include <stdio.h>
      2 #include <stdlib.h>
      3 
      4 void stringCopy(char *dest_str, char *src_str);
      5 int stringLength(char *str);
      6 
      7 int main(int argc, char *argv[])
      8 {
      9         char *dest_str = NULL;
     10         printf("source string: %s\n", argv[1]);
     11         dest_str = (char *)malloc(sizeof(char) * (stringLength(argv[1]) + 1));
     12         stringCopy(dest_str, argv[1]);
     13         printf("back-up copy: %s\n", dest_str);
     14         return 0;
     15 }
     16 
     17 //___复制
     18 void stringCopy(char *dest_str, char *src_str)
     19 {
     20         char *dtemp = dest_str;
     21         char *stemp = src_str;
     22         while(*stemp != '\0')
     23         {
     24                 *dtemp = *stemp;
     25                 dtemp++;
     26                 stemp++;
     27         }
     28         *dtemp = '\0';
     29 }
     30 
     31 //___长度
     32 int stringLength(char *str)
     33 {
     34         char *temp = str;
     35         int len = 0;
     36         while(*temp != '\0')
     37         {
     38                 len++;
     39                 temp++;
     40         }
     41         return len;
     42 }
    执行:




    展开全文
  • #include #include#include#includechar* genRandomString(intlength){intflag, i;char* string;srand((unsigned) time(NULL ...if ((string = (char*) malloc(length)) ==NULL ){//myLog("Malloc failed!flag:14\n"...

    #include #include#include#include

    char* genRandomString(intlength)

    {intflag, i;char* string;

    srand((unsigned) time(NULL ));if ((string = (char*) malloc(length)) ==NULL )

    {//myLog("Malloc failed!flag:14\n");

    returnNULL ;

    }for (i = 0; i < length - 1; i++)

    {

    flag= rand() % 3;switch(flag)

    {case 0:string[i] = ‘A‘ + rand() % 26;break;case 1:string[i] = ‘a‘ + rand() % 26;break;case 2:string[i] = ‘0‘ + rand() % 10;break;default:string[i] = ‘x‘;break;

    }

    }string[length - 1] = ‘\0‘;return string;

    }intmain()

    {char *buff;

    buff= genRandomString(50);

    printf("buff=%s\n",buff);free(buff);return 0;

    }

    Linux下生成随机数和随机字符串

    1、生成长度为32的随机字符串

    head -c 32 /dev/random | base64

    1

    该方式产生的随机数效果比较好,但是,当不能产生随机数时,它会阻塞在那里,也就是为阻塞程序的执行

    2、用/dev/urandom文件产生

    head -c 32 /dev/random | base64

    1

    该方式产生的随机数随机效果一般是,但是产生速度快,不会阻塞程序的运行

    3、使用openssl方式

    openssl rand -hex 10

    1

    4、生成随机数:

    [[email protected] ~]# echo $RANDOM

    32641

    [[email protected] ~]# echo $RANDOM

    9753

    [[email protected] ~]# echo $RANDOM

    710

    1

    2

    3

    4

    5

    6

    注:得到的这个随机数是介于 0~32767 之间的一个整数。

    5、生成随机字符串

    a、[[email protected] ~]# head -n 5 /dev/urandom |sed ‘s/[^a-Z0-9]//g‘|strings -n 4

    fEVN

    Lfkm0

    PMSZfO

    tEIw

    aKbc

    MWLTk1

    1

    2

    3

    4

    5

    6

    7

    注:生成由a-Z和0-9组成的字符串。

    b、[[email protected] ~]# openssl passwd -stdin <

    5LYYPmuNIFS9c

    c、[[email protected] ~]# head -n 5 /dev/urandom |strings -n 5

    ]bE&O

    p\#P6C

    _\I[K

    C3Hn2,=

    $JfV5q

    {8tD)

    zG}Uw

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    注:

    strings:

    在对象文件或二进制文件中查找可打印的字符串。

    语法:

    语法

    strings [ -a ] [ - ] [ -o ] [ -t Format ] [ -n Number ] [ -Number ] [ File ... ]

    1

    参数:

    -a 或 - 搜索整个文件,而不仅仅是数据段,以寻找可打印的字符串。如果省略这个标志,则 strings 命令只在对象文件的初始化数据空间内寻找。

    -n Number 指定最小的字符串长度(除了缺省的 4 个字符以外)。字符串长度的最大值是 4096。这个标志与 -Number 标志相同。

    -o 列出文件中每个跟随在其八进制偏移量之后的字符串。这个标志与 -t o 标志相同。

    -t Format 列出从文件最开始起,每个跟随在其偏移量之后的字符串。该格式取决于用作 Format 变量的字符。

    d

    以十进制写下偏移量。

    o

    以八进制写下偏移量。

    x

    以十六进制写下偏移量。

    注:当 -o 和 -t Format 标志在一个命令行上多次定义,则最后指定的标志控制 strings 命令的行为。

    -Number 指定最小的字符串长度(除了缺省的 4 个字符以外)。字符串长度的最大值是 4096。这个标志与 -n Number 标志相同。

    File 要搜索的二进制文件或对象文件。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    退出状态

    该命令返回以下退出值:

    0 表示命令成功运行。

    0 表示出错。

    3、从指定字符集合中生成随机字符串:

    #!/bin/bash

    MATRIX="[email protected]#$%^&*()_+="

    LENGTH="9"

    while [ "${n:=1}" -le "$LENGTH" ]

    do

    PASS="$PASS${MATRIX:$(($RANDOM%${#MATRIX})):1}"

    let n+=1

    done

    echo "$PASS"

    exit 0

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    4、通过时间获得随机数(date)

    [[email protected] shell]$date +%s%N

    1287764807051101270

    #这个可以说比较完美了,加入了时间戳,又加上了纳秒

    1

    2

    3

    5、通过系统内部唯一数据生成随机数(/dev/random,urandom)

    [[email protected] shell]$head -1/dev/urandom

    ãņù…•KTþçanVÕã¹Û&¡õ¾“ô2íùU“ ?F¦_ ÿ”†mEðûUráÏ=J¯TŸA•ÌAÚRtÓ

    1

    2

    读一行,怎么是乱码呢?其实它是通过二进制数据保存实时数据的,那么我们怎么样把它变成整型数据呢?

    [[email protected] ~/shell]$head -200/dev/urandom | cksum

    1615228479 50333

    1

    2

    3

    由于urandom的数据是非常多,不能直接通过cat读取,这里取前200行,其实整个数据都是变化的,取多少也一样是唯一的。

    cksum 将读取文件内容,生成唯一的表示整型数据,只有文件内容不变,生成结果就不会变化,与php crc函数

    6、读取linux 的uuid码

    [[email protected] ~/shell]$cat /proc/sys/kernel/random/uuid| cksum |cut -f1 -d" "

    2141807556

    原文:https://www.cnblogs.com/Malphite/p/12298342.html

    展开全文
  • linux用户态程序中,我们经常调用malloc接口根据自身需要灵活分配内存。但是我们是否了解malloc所分配的内存相关数据结构在内存中的具体分布呢?下面我们以实际程序实例介绍malloc分配的内存数据结构。 malloc...
  • 或者malloc一段内存来存储一个字符串 char * str_ptr = (char*) malloc (LEN*sizeof(char)); 定义了数组或字符指针之后,需要做一个初始化,否则里面将是随机值,以后将无法判断改字符串是否为空。 所以,首先要...
  • #includeint com(char *p, char *q, int n, int m){int i,...char *tmp = (char *)malloc(sizeof(char) * 20);if(NULL == tmp){printf("error\n");exit(1);}char *tmp1 = tmp;char *tmp2 = q;char *tmp3 = p;int fla...
  • gets()函数用来从 标准输入设备(键盘)读取字符串直到 回车结束,但回车符('\n')不属于这个字符串。 调用格式为: gets(str); 其中str为字符串变量(字符串数组名或字符串指针)。 gets(str) 函数...
  • Linux下C语言字符串操作之分割字符串 来源网络,如有侵权请告知,即处理!       废话不多说,直接上代码: 1. #include 2. #include < mysql / mysql .h> 3.  4. #define HOST ...
  • linux c/c++ 字符串 操作之 split

    千次阅读 2017-08-03 11:46:51
     * 分割字符串成二维数组  * 可根据传入分割符来计算出二维数组长度大小  * @param msg --需要分割的字符串  * @param splitChar -- 用于分割字符串的字符  * @param arrLen -- 返回二维数据的长度,用于遍历 ...
  • 如果您有一个动态分配的缓冲区,它在运行时以无法预测的方式(例如向量或字符串)改变其大小,则优化分配的一种方法是仅以2的幂(或其他一些边界/阈值),并保留多余的空间.这有助于分摊寻找新的可用内存和复制数据的成本,...
  • 简要描述: 全局定义一个字符串指针: char **a =NULL; 在fun函数中 进行如下操作: a=(char **)malloc( n*sizeof(char *)); for(int i=0;i;i++) a[i]=(char *)malloc(n*sizeof(char )); 之后给指针变量...
  • C++实现 socket 传输任意字符串,在网上看到了许多很不错的代码,但大都是一端发送字符串,另外一端循环接收字符串,并没有对字符串的长度进行比较,试想:若在传完字符串后,还有其他的数据传送,那么在这样的...
  • linux下c/c++ 常用时间和字符串互相转化介绍 c/c++ 中经常会遇到时间和字符串互相转化的情形 用以下2个函数来转就很方便了   1、时间转字符串函数 size_t strftime( char *strDest...
  • linux中快速获取文件里面字符长度
  • 格式化字符串漏洞

    千次阅读 2022-03-15 17:55:21
    格式化字符串漏洞 GDB调试 linux下gdb调试方法https://blog.csdn.net/niyaozuozuihao/article/details/91802994 format1 信息收集 [*] '/home/pwn/桌面/题目/练习题/fmtstr1/fmtstr1' Arch: i386-32-little ...
  • ===》备份自己在业务实现时,对字符串切割实现的一个接口(strstr,strcasestr,strsep,strtok,strdup相关接口) 有如下几个细节可以关注: ===》1:实现不同类型的数据拼接字符串的方案 (3.1) ===》2:char**通
  • 字符串的三种存储方式

    千次阅读 2021-05-19 09:11:12
    @[TOC]在数据结构中,字符串要单独用一种存储结构来存储,称为串存储结构。这里的串指的就是字符串。无论学习哪种编程语言,操作最多的总是字符串。我们平常使用最多的存储结构无疑是利用定长数组存储。但是这种存储...
  • linux c 字符串处理

    2014-10-27 11:00:22
    在C语言中经常需要处理内存问题,特别是在字符串操作时
  • 输入一个字符串,计算字符串中子串出现的次字数 #include<stdio.h> #include<stdlib.h> #include<string.h> int number(char *p,char *q,int n) { int length1 = strlen(p); int length2 = ...
  • linux中C语言函数:字符串处理函数

    千次阅读 2013-11-06 19:45:09
    bcmp :比较两个内存中的内容bcopy : 复制内存中的内容bzero : 将一个内存内容全清零ffs : 在一个整数中查找第一个值为真的位index : 查找字符串中第一个出现的指定字符memccpy :复制内存中的内容memchr :在一块...
  • malloc内存分配机制

    2021-05-11 15:46:52
    8种机械键盘轴体对比本人... Linux虚拟地址空间首先在Linux中的虚拟地址空间主要分成如下几个部分(32位):1) 只读段:包括进程初始化入口代码(.init),代码段(.text),和rodata段(C常量字符串和#define定义的常量)2)...
  • 本文通过代码介绍一维整型数组、二维整型数组的静态创建和动态创建,字符串的动态创建和字符串数组的动态创建。 一、整型数组的创建 1. 一维数组的静态、动态创建 一维数组的静态创建: 这个比较简单,就是遍历数组...
  • Linux C字符串替换函数实例详解

    千次阅读 2017-12-03 11:10:19
    * @param const char* src 源字符串,被替换的字符串 * @param const char* oldstr 旧的子串,将被替换的子串 * @param const char* newstr 新的子串 * @param int len 将要被替换的前len个字符 * * @return char* ...
  • Linux下对字符串的操作使用频率高,在此总结部分功能。其中包括字符串的特征字符的分割、字符串左右边缘空格的去除(也可去掉左右特征字符串)及字符串大小转换。
  • C++实现字符串分割函数split()

    万次阅读 多人点赞 2020-04-30 22:31:47
    最近遇到了一个字符串分割的问题,在C++的标准库里面没有字符分割函数split()。我想这个问题今后可能还会再遇见,所以使用C/C++中的字符串分割方法完成相应的功能。 需求:对一个字符串进行分割,然后将分割后的...
  • Qt 中文字符串问题

    2020-12-19 02:32:18
    一.Qt5假定的执行字符集是UTF8,不再允许用户擅自改动。这样一来,Qt4中setCodecXXX的各种副作用不再存在,而且中文问题更为简单。QString s1 = "汉语";...//只要字符串不需要翻译,请关注这个QString s5 = QString...
  • 您可以动态分配内存:#include #include #include const char* hello(char* name) {char* greeting = malloc(100);snprintf("Hello, %s!\n", 100, name)printf("%s\n", greeting);return gree...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,274
精华内容 12,509
关键字:

linux malloc 字符串