字符串的操作

最新推荐文章于 2022-07-29 09:29:18 发布
最新推荐文章于 2022-07-29 09:29:18 发布
阅读量955 收藏 1
点赞数 2
分类专栏： C++ C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maoliran/article/details/51863302
版权
C++ 同时被 2 个专栏收录
79 篇文章 0 订阅
订阅专栏
C语言
17 篇文章 1 订阅
订阅专栏

一、字符串的初始化
1、定长字符数组

1>

char buf1[128] = {'a', 'b', 'c', 'd'};
printf("sizeof(buf1) = %d\n", sizeof(buf1));    //128
printf("strlen(buf1) = %d\n", strlen(buf1));    //4
printf("buf1[66] : %d\n", buf1[66]);    //0
printf("buf1 : %s----\n", buf1);    //abcd----

定义一个128长度的字符数组，只初始化前4个字符，后面字符默认都是0。

2>

char buf5[128] = "abcd";
    printf("sizeof(buf5) = %d\n", sizeof(buf5));    //128
    printf("strlen(buf5) = %d\n", strlen(buf5));    //4
    printf("buf5[66] : %d\n", buf5[66]);    //0
    printf("buf5 : %s----\n", buf5);    //abcd----
    printf("-------------------------\n");

2、不定长的字符数组

1>

char buf2[] = { 'a', 'b', 'c', 'd' };
printf("sizeof(buf2) = %d\n", sizeof(buf2));    //4
printf("strlen(buf2) = %d\n", strlen(buf2));    //16（不确定长度，直到遇到0结束符为止）
printf("buf1 : %s----\n", buf2);     //abcd烫烫烫烫abcd----

不定长字符数组不会在最后一个字符的后面自动添加0，因为打印出来会出现乱码，直到内存空间遇到一个0为止。

2>

char buf3[] = "abcd";
printf("sizeof(buf3) = %d\n", sizeof(buf3));    //5
printf("strlen(buf3) = %d\n", strlen(buf3));    //4
printf("buf1 : %s----\n", buf3);    //abcd

字符串常量会默认结尾自动带一个0结束符，因此buf3的内存空间包括字符长度加一个结束符长度。
其中内存四区图是这样的：
这里写图片描述

3、字符指针初始化

char *buf4 = "abcd";    //abcd
printf("sizeof(buf4) = %d\n", sizeof(buf4));    //4
printf("strlen(buf4) = %d\n", strlen(buf4));    //4
printf("buf1 : %s----\n", buf4);

其内存四区图：
这里写图片描述

二、通过字符数组和指针操作指针

void test2() {
    char buf[128] = "abcdefg";
    char *p = NULL;
    for (int i = 0; i < strlen(buf); i++)
        printf("%c ", buf[i]);
    printf("\n");
    p = &buf;
    for (int i = 0; i < strlen(buf); i++)
        printf("%c ", *(p + i));
    printf("\n");
    for (int i = 0; i < strlen(buf); i++)
        printf("%c ", *(buf + i));
    printf("\n");
}

输出结果：

这里写图片描述

通过数组下标的方式本质是指针操作的方式是一致的，只不过数组下标的方式更符合程序员的编程习惯：

buf[i] ==》 buf[0 + i] ==》  *(buf + i)

编译器做的工作就是这样的。

buf相当于是一个常量指针，实质是一个内存首地址，不能改变buf指向的内存首地址。也就是说不能进行buf++;这种操作：

这里写图片描述

因为出了函数，系统要释放buf的内存空间，是根据buf指向的首地址即buf的空间大小进行释放的，如果buf可以向上++，改变其指向，比如buf现在指向字符‘e’所在的内存首地址，那么abcd到时候就无法释放内存了，因此，干脆不让修改buf的指向，这也是程序设计的原因，为了保证内存的正确释放。

这也是内存首地址(buf)和普通指针（p）的区别：

普通指针可以进行下面的操作：

p = p + i;

内存首地址不可以。

三、字符串一级指针内存模型

void test3() {
    char buf1[20] = "aaaa";
    char buf2[] = "bbbb";
    char *p1 = "1111111";
    char *p2 = (char*)malloc(100);
    strcpy(p2, "33333");
}

内存模型图：

这里写图片描述

strcpy的过程就是把全局区的”33333”拷贝到堆区。

四、字符串的copy操作演变

1、

void copy1() {
    char a[] = "i am a student";
    char buf[64];
    int i = 0;
    for (i = 0; a[i] != '\0'; i++)
        buf[i] = a[i];
    buf[i] = '\0';
    printf("a : %s\n", a);
    printf("buf : %s\n", buf);

}

输出结果：

这里写图片描述

这里是最简单的遍历拷贝，只需要注意：由于循环中当a[i] = ‘\0’时跳出循环，故buf并没有把‘\0’烤进去，要手动把buf最后一个字符后面的字符设为0，否则打印buf时，会直到遇到’\0’才会停止打印，缺省

buf[i] = '\0';

这句的输出结果为：

这里写图片描述

便会出现乱码。

2、下面都是通过接口实现的，正式公司编写代码中需求的

void copy2(char *from, char *to) {
    for (; *from != '\0'; from++, to++) {
        *to = *from;
    }
    *to = '\0';
}
int main(){
    char *from = "abcdefg";
    char buf[64];
    copy2(from, buf);
    printf("buf : %s\n", buf);
    system("pause");
    return 0;
}

输出结果：

这里写图片描述

这里用到指针间接修改实参的应用，画一个内存四区图：

这里写图片描述

开始main函数和copy2函数中的from指针都指向全局区“abcdefg”的首地址，to指针指向main函数buf的首地址，循环过程中，copy2函数中的from和to的指向不断改变，直到from所指向的内存中存放的是0位置，这个时候跳出循环，并没有把0拷贝进to所指向的内存中，因此仍然要手动加入0表示字符串结束。

3、

void copy3(char *from, char *to) {
    for (; *from != '\0';) {
        *to++ = *from++;
    }
    *to = '\0';
}
int main(){
    char *from = "abcdefg";
    char buf[64];
    copy3(from, buf);
    printf("buf : %s\n", buf);
    system("pause");
    return 0;
}

输出结果同上，这里把赋值和++操作合体了：

*to++ = *from++;

++操作的优先级大于*操作符，因此先执行++操作，但由于是后++，故上面实际执行顺序是：

*to = *from;
from++;
to++;

4、继续演变

void copy4(char *from, char *to) {
    while ((*to = *from) != '\0') {
        from++;
        to++;
    }
}
int main(){
    char *from = "abcdefg";
    char buf[64];
    copy4(from, buf);
    printf("buf : %s\n", buf);
    system("pause");
    return 0;
}

输出结果还是同上，此时就不需要手动添加结束符了，while循环中会自动添加。

5、继续演变

void copy5(char *from, char *to) {
    while (*to++ = *from++) {
    }
}
int main(){
    char *from = "abcdefg";
    char buf[64];
    copy5(from, buf);
    printf("buf : %s\n", buf);
    system("pause");
    return 0;
}

输出结果仍然同上。

可以看到代码越来越简洁，这就是整个字符串copy的演变过程。

五、字符串的copy操作强化

1、不能往NULL内存空间中拷贝

void copy5(char *from, char *to) {
    while (*to++ = *from++) {
    }
}

int main(){
    char *from = "abcdefg";
    char buf[64];
    {
        char* to = NULL;
        copy5(from, to);
    }
    system("pause");
    return 0;
}

执行这一段代码，会报错：

这里写图片描述

NULL主要用来避免野指针问题，NULL内存空间是由系统来保护的内存空间，是不允许往里面拷贝任何东西的。所以一旦执行：

*to = *from;

这样的拷贝语句，程序就会down掉。

此时就要对代码进行优化：

int copy6(char *from, char *to) {
    if (to == NULL || from == NULL)
        return - 1;
    while (*to++ = *from++) {
    }

    return 0;
}
int main(){
    int ret = 0;
    char *from = "abcdefg";
    char buf[64];
    {
        char* to = NULL;
        ret = copy6(from, to);
        if (ret != 0)
            printf("func copy6 err: %d\n", ret);
    }
    system("pause");
    return 0;
}

输出结果：

这里写图片描述

要对传来的指针进行判断，判断是否指向NULL，并通过函数返回值告诉被调用函数是否执行成功。

2、函数调用中通过指针遍历时，借助中间指针变量

对于没有中间指针变量的函数：

int copy7_err(char *from, char *to) {
    if (to == NULL || from == NULL)
        return -1;
    while (*to++ = *from++) {
    }
    printf("from : %s\n", from);
    return 0;
}
int main(){
    int ret = 0;
    char *from = "abcd";
    char buf[64];
    printf("copy7 begin\n");
    copy7_err(from, buf);
    printf("copy7 end\n");

    system("pause");
    return 0;
}

输出结果：
这里写图片描述

可以看到打印from什么都没有，在函数copy7_err中不断改变from的指向，最终指向了0，必然打印的时候打印0，就会什么都没有，这就造成有些时候在函数后面需要打印from的情况，这时候就需要中间指针变量：

int copy7_good(char *from, char *to) {
    if (to == NULL || from == NULL)
        return -1;
    char *fromtemp = from;
    char *totemp = to;
    while (*totemp++ = *fromtemp++) {
    }
    printf("from : %s\n", from);
    return 0;
}
int main(){
    int ret = 0;
    char *from = "abcd";
    char buf[64];
    printf("copy7 begin\n");
    copy7_good(from, buf);
    printf("copy7 end\n");

    system("pause");
    return 0;
}

输出结果：

这里写图片描述

借助中间指针变量，到时候打印from就不会出现问题，from仍然还是指向内存首地址，没有改变指向。这是编程过程中经常出现的错误，切记，切记。

六、字符串项目开发模型

1、字符串查找（strstr）

int strstr_interface(char* mystr /*in*/, char* substr /*in*/, int *count /*out*/) {
    int ret = 0;
    if (mystr == NULL || substr == NULL || substr == NULL) {
        ret = -1;
        printf("func strstr_interface() mystr == NULL || substr == NULL || substr == NULL err : %d\n", ret);
        return ret;
    }
    char *mystrtemp = mystr;
    int counttemp = 0;
    while (mystrtemp = strstr(mystrtemp, substr)) {
        mystrtemp += strlen(substr);
        counttemp++;
        if (counttemp == '\0')
            break;
    }
    *count = counttemp;
    return ret;
}
int main(){
    int ret = 0;
    char* mystr = "11abcd2117732abcd093902shabcd239sdfjajqqabcd";
    char* substr = "abcd";
    int count = 0;
    ret = strstr_interface(mystr, substr, &count);
    if (ret != 0) {
        printf("func strstr_interface() err: %d\n", ret);
    }
    printf("count : %d\n", count);
    system("pause");
    return 0;
}

输出结果为：

这里写图片描述

strstr函数实现子字符串在母字符串中出现的第一个位置，这段代码的精髓不在于如何实现，而是如何实现健壮的代码：

1、count不作为返回值返回给调用函数，而是作为形参传递值，充分利用指针间接赋值的特性（正是指针可以实现返回多个参数的情况，利用形参进行返回）

2、要对传入的指针判断是否为空，检测错误情况，并将错误返回给调用函数；

未完，待续！

新一下的兰天
关注
专栏目录
VBS中常见字符串操作函数
08-26
VBS中常见字符串操作函数 VBS（Visual Basic Scripting）是一种脚本语言，广泛应用于Windows操作系统中。其中，字符串操作函数是VBS中最基本和最常用的函数之一。本文将对VBS中常见的字符串操作函数进行详细的介绍...
C ++ 字符串
SEO开箱图
01-13 591
字符串是一个一维数组： String str; cin>>str str.length() for (i =0, I <= str.lenghth()-1, i ++)
java 算术运算符-字符串“+“操作-自增自减运算符
weixin_49345320的博客
03-09 1035
1.1算术运算符： 运算符:对常量或者变量进行操作的符号 表达式:用运算符把常量或者变量连接起来符合如: int a=0; int b=1;int c=atb; :是运算符，并且是算术运算符 atb:是表达式，由于+是算术运算符，所以这个表达式叫算术表达式 两个都为整数类型的 返回值也为整数型 1.2字符串的“+”操作 字符的“+”操作: 拿字符在计算机底层对应的数值来进行计算的‘A’→65A-Z是连续的 ‘a’→97a-z是连续的‘0’48 0-9是连续的 算术表达式中包含多个基本数据类型的值的时候，整
C语言回顾--常见的字符串操作
PipiAvenger的博客
09-18 560
  前言： 笔试题基本上必考题之一：字符串的处理，涉及到指针、数组、以及字符串数组；近几日的笔试字符串处理让我无从下手，因此根据近几日的笔试题，总结了一波常见的操作； 1.整数与字符数字互换类型： void char_to_int( char *buf, int *num,int size)    //字符串换成数字 {     int         i = 0;     int   ...
[C]指针与数组
小童的博客
05-10 379
指针与数组 指针与地址 指针是一种保存变量地址的变量，在C中指针使用十分广泛，指针常常是表达式某个计算的唯一途径，且相比其他方法，指针可生成更高效、紧凑的代码。但指针和goto语句一样，会导致程序难以理解，故使用指针需更谨慎。 the C programme指出：指针是能够存放一个地址的一组存储单元（通常是两个或4个字节），如果c类型是char，且p是指向c的指针，则可用下图表示它们之间的关系： 一元运算符&可用于取一个对象的地址，如下 char c; char *p = &c; //访问*
多维数组的指针类型转换和参数传递
Jalen_king
07-10 1068
总结： 一维和多维数组的数组名，是一个指针，这个指针指向的是该数组的第一个“元素”。例1： char *p0; char buf0[2] = {1}; p0 = buf0;char *p0; 表示定义一个指向char型的指针。便于理解可以写成char (*p0); *p0是指针，指向 char类型。例2： char (*p1)[4]; char
C语言字符串操作总结大全(超详细)
01-01
1）字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度字符串 strlen(p) 取字符串长度 strcmp(p, p1) 比较字符串 strcasecmp忽略...
易语言字符串操作
07-21
易语言字符串操作源码,字符串操作,字符串_取长度,字符串_取中间,字符串_取左边,字符串_取右边,字符串_替换,到宽字符,到多字节,取文本数据地址,取字节集数据地址,MultiByteToWideChar,WideCharToMultiByte
10中java常见字符串操作实例
08-25
Java 字符串操作实例 Java 中字符串操作是非常常见和重要的编程操作。字符串操作可以分为多种，包括获取字符串的长度、查找指定字符、字符串转换、截取字符串、替换字符串、去掉空格等。在 Java 中，String 类提供...
C#字符串操作
05-15
本篇文章将深入探讨C#中的字符串操作，包括创建、访问、修改以及常见的字符串方法。 一、字符串的创建与初始化 在C#中，有两种主要方式创建字符串： 1. 使用双引号直接赋值：`string str = "Hello, World!";` 2. ...
VC++中字符串的处理
08-03
CString ,BSTR ,LPCTSTR之间关系和区别CString是一个动态TCHAR数组，BSTR是一种专有格式的字符串（需要用系统提供的函数来操纵，LPCTSTR只是一个常量的TCHAR指针。CString 是一个完全独立的类，动态的TCHAR数组，封装了 + 等操作符和字符串操作方法。typedef OLECHAR FAR* BSTR;typedef const char * LPCTSTR;
数组与二维指针
cg1998的博客
07-24 210
重点： 定义变量：按类型分配空间              类型   变量名：              类型   数组名： 初始化： 引用变量：引用内容 ·1、自身内容：变量名：*地址          a         数组名【下标】 1、指针与变量的关系      见源代码 2、指针与数组的关系    2.1指针与一维普通数组     2.2指针数组：专门用于存放...
《C语言基础》 之 第8章 数组
01-08
课程内容：数组的声明、定义（初始化）、数组的赋值、数组在内存中的空间特点、使用 [ ] 访问数组元素、数组元素的指针、数组第一个元素指针的表示方法、数组命令与++、sizeof与数组、数组名总结、函数普通传参回顾、传递数组指针、二维数组。
C语言知识点总结(五)
qq_26538113的博客
07-29 390
C语言知识点总结(五)：字符数组和字符串常量的区别，特殊情况下数组名可表示整个数组以及相关例题分析
*与++
领悟 释然
01-04 655
*与++优先级一样高，且这两个运算符的结合性均是从右向左， 即先计算++，再计算*(因为++在*右边)，但由于该表达式: cksum += *buffer++; 中++是后缀运算符，尽管++先计算，但*取的是++之前的值， 即cksum 加上*buffer中的内容，然后buffer自身加一，指向下 一个内存地址，以供以后的语句使用。 如果该句改为: cksum += *++buffe
C语言中 ++和 *的优先级以及他们的应用实例（*p++、*++p、++*p、(*p)++）
m0_48630293的博客
08-24 3569
一、在此说明 按照书上的说法++ (后置) >++(前置) >* 解引用用 > = 等于 所以说明++的优先级是高于*指针 二、实列代码演示 #include<stdio.h> int main() { //在此说明 按照书上的说法++ (后置) >++(前置) >* 解引用用 > = 等于，但是 //c = ++*p为什么先算的 *p 后算的++ 可以看最后我给的网址 char buf[] = "acegfd"; char
字符串+内存函数
weixin_46660141的博客
06-14 163
1、模拟实现strcpy #include<stdio.h> #include<assert.h> #include<windows.h> char *MyStrcpy(char *arr1, char *arr2) { assert(NULL != *arr1); assert(NULL != *arr2); int *ret = arr1; while (*arr1++ = *arr2++) { ; } printf("%s\n", ret);
字符与字符串的+操作、自增自减运算符、赋值运算符、 逻辑运算符、三元运算符
罪域之骨终成王
05-09 735
ASCII码表、字符与字符串的+操作、自增自减运算符、赋值运算符、逻辑运算符、三元运算符
理解一维数组中 buf、buf[0]、&buf[0]、&buf 四个符号的含义
热门推荐
Silentwest的博客
03-24 2万+
本文内容摘自《C语言内核深度解析》一书的深入学习数组部分。 以 int buf[100]={0} 为例，集中讨论 buf、buf[0]、&buf[0]、&buf 四个字符含义的内涵。 1、buf：有两层含义，一是数组名，sizeof(buf) 时就是数组名的含义；二是等价于 &buf[0]，表示数组的第一个元素的首字节地址，是一个常量值。因此，既然是一个常量值，无论从哪...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值