第三天2017/03/30（上午：二级指针的（输入）内存模型：（共三种模型））

最新推荐文章于 2022-04-05 10:41:03 发布
最新推荐文章于 2022-04-05 10:41:03 发布
阅读量607 收藏
点赞数 1
分类专栏： 传智播客（扫地僧）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GoJawee/article/details/68491570
版权 
二级指针
char a[10][10];     char (*a)[10];
char *a[10];        char **a;
char **a;           char **a;

这里写图片描述
字符数组的操作易犯错误：
1.字符数组在使用前是否分配空间
2.字符数组能否返回地址
3.定义char* p;临时变量p，保存strstr等函数返回的地址。
这里写图片描述
【注】我们只有在使用指针所指向的内存空间的时候，我们才去关心“指针的类型”。

二级指针作“输入”时，有下面三种内存模型


//内存模式一：函数原型下面4个（哪个正确，哪个错误？）
void print_s1(char **p,  int n)    //正确
//void print_s1(char *p[4],int n)  //正确：形参和实参格式一样
//void print_s1(char (*p)[30],int n)    //错误：类型不一致，编译失败
//void print_s1(char p[4][30],int n)  //错误：类型不一致，编译失败
{
    for(int i = 0;i<n;i++)
    {
        cout<<*(p+i)<<endl; //等价于 cout<<p[i]<<endl; 
    }
}

void sort_s1(char **p,  int n)    //正确
//void sort_s1(char *p[4],int n)  //正确
//void sort_s1(char (*p)[30],int n)  //错误  
//void sort_s1(char p[4][30],int n)  //错误
{
    char *temp;
    for(int i = 0;i<n;i++)
        for(int j = i+1;j<n;j++)
        {
            if(strcmp(p[i],p[j])<0)
            {
                //交换的是指向字符串首地址的指针
                temp = p[i];  p[i] = p[j];  p[j] = temp;
            }
        }
}


//内存模式二：函数原型下面4个（哪个正确，哪个错误？）
//void print_s2(char **p,  int n)    //错误，类型不一致，编译失败
//void print_s2(char *p[4],int n)  //错误，类型不一致，编译失败
//void print_s1(char (*p)[30],int n)    //正确，char (*p)[4]相当于char p[][4]
void print_s2(char p[][30],int n)  //正确：形参和实参格式一样
{
    for(int i = 0;i<n;i++)
    {
        cout<<*(p+i)<<endl; //等价于 cout<<p[i]<<endl; 
    }
}

//void sort_s2(char **p,  int n)    //错误
//void sort_s2(char *p[30],int n)  //错误
void sort_s2(char (*p)[30],int n)  //正确
//void sort_s2(char p[][30],int n)  //正确
{
    char temp[100];  
    //char *temp;  //报错，因为没有分配内存就用strcpy往temp中复制元素，肯定崩溃
    for(int i = 0;i<n;i++)
        for(int j = i+1;j<n;j++)
        {
            if(strcmp(p[i],p[j])<0)
            {
                //此处不是（交换的是指向字符串首地址的指针），而是用函数strcpy进行复制
                strcpy(temp,p[i]);
                strcpy(p[i],p[j]);
                strcpy(p[j],temp);              
            }
        }
}

//内存模式三：函数原型下面4个（哪个正确，哪个错误？）==>类似于内存模式
//void print_s3(char **p,  int n)    //正确
void print_s3(char *p[4],int n)  //正确!
//void print_s3(char (*p)[30],int n)   //错误
//void print_s3(char p[4][100],int n)  //错误：类型不一致，编译失败
{
    for(int i = 0;i<n;i++)
    {
        cout<<*(p+i)<<endl; //等价于 cout<<p[i]<<endl; 
    }
}

void sort_s3(char **p,  int n)    //正确
//void sort_s3(char *p[4],int n)  //正确
//void sort_s1(char (*p)[30],int n)   //错误
//void sort_s3(char p[4][100],int n)  //错误
{
    char *temp;
    for(int i = 0;i<n;i++)
        for(int j = i+1;j<n;j++)
        {
            if(strcmp(p[i],p[j])<0)
            {
                //交换的是指向字符串首地址的指针
                temp = p[i];  p[i] = p[j];  p[j] = temp;
            }
        }
}
int main()
{
//内存模式一：
    char *p1[4] = {"AAAAAA","CCCC","BBBB","DDDD"};
    //p1[3][3] = 'F';  //崩溃，因为p[i]指针指向的是字符串常量（例如“AAAAA”），该字符串常量“AAAAA”（存放在常量区）不能被修改

    cout<<"排序之前"<<endl;
    print_s1(p1,4);
    cout<<"排序之后"<<endl;
    sort_s1(p1,4);
    print_s1(p1,4);
    cout<<endl;


//内存模式二：
    char p2[4][30] = {"AAAAAA","CCCC","BBBB","DDDD"};
    p2[3][3] = 'F';  //正确，p[i]="AAAAA"（是静态分配字符数组p[30]）在此处相当于给字符数组初始化，“AAAAA”存放在在栈中，可以被修改

    cout<<"排序之前"<<endl;
    print_s2(p2,4);
    cout<<"排序之后"<<endl;
    sort_s2(p2,4);
    print_s2(p2,4);
    cout<<endl;

//内存模式三：
    char **p3 = (char**)malloc(10*sizeof(char*));
    if(p3==NULL) //如果内存分配失败
        return 0;
    for(int i = 0;i<10;i++)
    {
        *(p3+i) = (char*)malloc(30*sizeof(char));//p3[i] = (char*)malloc(30*sizeof(char));
        if(p3[i]==NULL)  //如果内存分配失败
            return 0;
        sprintf(p3[i],"String%d",i);
    }
    p3[3][3] = 'F';//正确，p[i]（是动态分配的字符数组p[30]），在堆中，可以被修改

    cout<<"排序之前"<<endl;
    print_s3(p3,4);
    cout<<"排序之后"<<endl;
    sort_s3(p3,4);
    print_s3(p3,4);

    //使用完malloc分配的内存，记得释放，防止内存泄漏
    for(int i=0;i<10;i++)
    {
        free(p3[i]);
        p3[i] = NULL; //防止野指针
    }
    free(p3);
    p3 = NULL; //防止野指针



    getchar();
}

【总结——二级指针的解决问题方案】
（1）先判断：是输入？输出？
（2）若是输入？
_则：根据具体情况进行套用是三种模型中的哪一种模型！

作业题：

/*  作业题1：key~value
    查找指针数组中的字符串是否有key？
    如果有，把key~value输出来（去掉空格）  */
int strlen_trimSpace2(char *p,char *q)
{//两头堵模型：求出除去前后空格的字符串的长度
    int count = 0;
    int i = 0,j = 0;
    j = strlen(p)-1;  //记得 -1（减1）
    while(isspace(p[i]) && p[i]!='\0')  //从前往后
    {   //isspace(c)检查参数c是否为空格字符
        i++;
    }
    while(isspace(p[j]) && j>0)   //从后往前
    {
        j--;
    }
    count = j-i+1;
    memcpy(q,p+i,count);
    q[count] = '\0';

    cout<<q<<endl; //为了不修改输入的p字符数组，定义q作为接受数组

    return 0;
}

int key_value(char* input/*key*/,char **array,char* output/*找到的结果字符串*/,int *outstrLen)
{
    int i = 0;
    char* p ;//保存查找到的地址
    if(input==NULL||output==NULL /*||&outstrLen==NULL*/)
    {
        cout<<"input、output有一个为NULL"<<endl;
        return -1; //返回-1表示出现bug
    }
    //在array中查找子串input
    for(i=0;array[i]!=NULL;i++)
    {
        p = strstr(array[i],input);
        if(p!=NULL) //如果查找到
            break;//查找成功(此时查找到的字符串是array[i])就跳出for循环
    }
    if(p==NULL) //如果没查找到
    {
        //cout<<"在array[i]中查找input失败"<<endl;
        return -2; //返回-2表示没查找到
    }
    p = p + strlen(input); //跳过查找到的input字符
    //查找 = 号
    p = strstr(p,"=");
    p++; //跳过 = 号

    char temp[100];
    //两头堵：去掉字符串前后的空格
    strlen_trimSpace2(p,temp);

    strcat(input,"=");
    strcat(input,temp);
    strcpy(output,input);

    *outstrLen = strlen(output)+1;

    return 0; //返回0表示查找到
}
int main()
{
/*  作业题：key~value
    查找指针数组中的字符串是否有key？
    如果有，把key~value输出来（去掉空格）
*/
    char *array[5] = 
        {
            "key1 =     AAAA      ",
            "key2 =     BBBBBBBB",
            "key3 =CC",
            "key4 =  DDD  ",
            "key5 =     EE  "
        };
    char  input[100] = "key111" ;
    char output[100];

    int outstrLen = 0;

    int ret = 0; 
    ret = key_value(input,array,output,&outstrLen);
    if(ret==-2)
    {//返回-2表示没查找到
        cout<<"array中没有input，查找失败"<<endl;
        getchar();
        return 0;
    }
    else if(ret == -1)
    {
        cout<<"程序错误"<<endl;
        getchar();
        return 0;
    }
    else
    {
        cout<<"      找到字符串 :"<<output<<endl;
        cout<<"找到字符串的长度 : "<<outstrLen<<endl;
    }

    getchar();
}

两个指针挖字符串模型
这里写图片描述

//作业题2：有一个字符串：形如“aaaa,bbbbb,ccccc,dddd”。
//      以逗号为分隔符，把aaaa\bbbbb\ccccc\dddd保存到一个二维字符数组中
int array2outarray(char* array,char outarray[10][30],int *count_)  //自己写
{
    strcat(array,",");
    int N = 0; //N表示返回的子串的个数
    if(array==NULL) //如果array是空的字符串
    {
        N = 0;
        return N;
    }
    int count = 0;
    int len = 0;

    char *p = array;
    char *h = p ; //始终指向“子字符串”的头部

    while(*p!='\0')
    {
        p = strstr(h,","); //在字符串中找逗号
        if(p==NULL)
            break;
        len = p-h;
        strncpy(outarray[count],h,len); //count表示第几个子字符串
        outarray[count][len] = '\0';
        len = 0;
        count++;
        p++;
        h = p;

    }

    *count_ = count;

    return 0;

}
int spitString(char* array,char ch /*分隔符*/,char buf[10][30],int *count)  //扫地僧答案
{//两个辅助指针变量“挖字符串”
    //1、p和ptemp初始化，都指向子串首地址
    char *p = array;
    strcat(p,",");
    char *ptemp = p;
    int p_ptemp = 0;
    int count_temp = 0;

    //2、执行strstr或者strchr，结果保存到p中
        //如果找到，那么p和ptemp正好形成一个差值p_ptemp
    //3、再次让p和ptemp都达到检索条件的开始位置
    //4、循环1.2.3，直到不符合while条件退出循环
    while(*p!='\0')
    {
        p = strchr(p,',');
        if(p==NULL)
            break;
        p_ptemp = p-ptemp;

        memcpy(buf[count_temp],ptemp,p_ptemp);
        buf[count_temp][p_ptemp] = '\0';

        p++;
        ptemp = p;
        count_temp++;
        p_ptemp = 0;
    }
    *count = count_temp;
    return 0;
}
int main()
{
    //作业题：有一个字符串：形如“aaaa,bbbbb,ccccc,dddd”。
    //  以逗号,为分隔符，把aaaa\bbbbb\ccccc\dddd保存到一个二维字符数组中
    int count = 0;
    char array[] = "aaaa,bbbbb,ccccc,dddd,ee,,,";
    char buf[10][30];

    //spitString(array,',',buf,&count); //扫地僧写
    array2outarray(array,buf,&count);  //自己写


    cout<<"打印二维数组"<<endl;
    for(int i=0;i<count;i++)
    {
        cout<<*(buf+i)<<endl;
    }
    getchar();
}
GoJawee
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解C语言-二级指针三种内存模型
01-19
这种模型为二级指针的第一种内存模型，在理解的时候应该这样理解：定义了一个指针数组（char * []），数组的每个元素都是一个地址。 在使用的时候，若要使用中间量操作元素，那么此时中间量应该定义为 char *tmp = ...
二级指针的作用详解
热门推荐
【码农在新加坡】的专栏
06-25 10万+
一、概念 在如下的A指向B、B指向C的指向关系中： 首先 C是"一段内容",比如你用malloc或者new分配了一块内存，然后塞进去"一段内容",那就是C了。C的起始地址是0x00000008。 B是一个指针变量,其中存放着C的地址，但是B也要占空间的啊，所以B也有地址，B的起始地址是0x00000004,但是B内存中存放的是C的地址，所以B里面的内容就是0x00000008。 那么到此.....................
c语言二级指针内存释放,详解C语言-二级指针三种内存模型
weixin_33902301的博客
05-19 1458
二级指针相对于一级指针，显得更难，难在于指针和数组的混合，定义不同类型的二级指针，在使用的时候有着很大的区别第一种内存模型char *arr[]若有如下定义char *arr[] = {"abc", "def", "ghi"};这种模型为二级指针的第一种内存模型，在理解的时候应该这样理解：定义了一个指针数组(char * [])，数组的每个元素都是一个地址。在使用的时候，若要使用中间量操作元素，那...
二级指针的三种内存模型
qq_37484168的博客
10-27 593
二级指针的三种内存模型概念分析指针：简单的来说就是指向固定大小内存块的别名。指针中所存放的是其所指向的内存块的地址。 二级指针：也就是指向指针的指针。其中存放的是他所指向的指针的内存地址。 二级指针的内存模型有三种（以字符型为例）： 二级指针第一种内存模型 char *p[] = {"hello", "world", "hello", "CSDN"};二级指针的第一种内存模型因为[]操作符的优先
c\c++ 二级指针的三种内存模型
Zhengzhigang_ZBL的博客
04-05 872
1、第一种 二级指针做输入内存模型 代码如下： ​ //打印 void PrintArray(char** parr,int len) { for(int i=0;i<len;i++) { printf("parr[%d]=%s\n",i,parr[i]); } return; } //排序 void SortArray(char** parr,int len) { for (int i=0;i<len-1;i++) { for(int j=i+1;j<len;
C语言中的二级指针的三种内存模型
修炼之路
04-04 1468
C语言中的指针用的是比较多，一级指针和二级指针时最常见的。其中，在C语言中二级指针相对于一级指针要难一些，下面就介绍一下C语言中二级指针的三种内存模型。 一、二维数组char a[5][5]内存模型 #include #include #include /* C语言中的二级指针的三种内存模型 */ //第一种模型，二维数组char a[5][5] void func1(){ //二维数组,表
【C 语言】二级指针内存模型 ( 指针数组 | 二维数组 | 自定义二级指针 | 将 一、二 模型数据拷贝到 三 模型中 并 排序 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
12-02 817
一、指针数组 和 二维数组 数据 拷贝到 自定义二级指针 中、 1、函数形参 设计规则、 2、三种内存模型 对应 函数形参 指针退化规则、 二、完整代码示例
C/C++二级指针的三种模型（一）
HelloNiGeSB的博客
06-17 2917
C/C++二级指针的三种模型的三种模型之一是，先给出来，下次在进行具体研究 void printfArr(char **arrayPtr, int nLength) { int i = 0; for (; i { printf("%s\n", arrayPtr[i]); } } void sortArrayStr(char **arrayPtr, int n
二级指针三种内存模型
saizo123的博客
08-13 1649
二级指针做输出模型#define _CRT_SECURE_NO_WARNINGS #include <stdlib.h> #include <string.h> #include <stdio.h> //指针做输出：被调用函数分配内存 -----OK //指针做输入：主调用函数 分配内存 //求文件中的两段话的长度 int getMem(char **myp1, int *mylen1, ch
c语言 -> 二级指针三种内存模型
desporado的博客
05-19 1373
说到二级指针，不少刚入门的朋友应该都会和我一样感到十分的头疼；明明一级指针就够我受的，咋又整个二级指针呢？？？二级指针无论是理解还是运用对于我这种刚入门的菜鸟是非常困难的；所以，我特意在网上找了些资料，然后把他们整合到一起，和大家分享下：二级指针主要分成三种内存模型：1. 第一种内存模型 ：指针指向栈区的一段内存的首地址，并且在栈区分配内存空间，每个元素里又装有一个指针指向常量区的某一地址，类似于...
深入理解C语言-二级指针三种内存模型
cj5785
04-02 1497
二级指针相对于一级指针，显得更难，难在于指针和数组的混合，定义不同类型的二级指针，在使用的时候有着很大的区别 第一种内存模型char *arr[] 若有如下定义 char *arr[] = {"abc", "def", "ghi"}; 这种模型为二级指针的第一种内存模型，在理解的时候应该这样理解：定义了一个指针数组（char * []），数组的每个元素都是一个地址。 在使用的时候，若要使用中间量...
UNIX环境高级编程(第二版中文)
05-10
第3章 文件I/O 35 3.1 引言 35 3.2 文件描述符 35 3.3 open函数 35 3.4 creat函数 37 3.5 close函数 37 3.6 lseek函数 38 3.7 read函数 40 3.8 write函数 41 3.9 I/O的效率 41 3.10 文件共享 42 3.11 原子操作 45 ...
UNIX环境高级编程(第二版中文).
05-10
第3章 文件I/O 35 3.1 引言 35 3.2 文件描述符 35 3.3 open函数 35 3.4 creat函数 37 3.5 close函数 37 3.6 lseek函数 38 3.7 read函数 40 3.8 write函数 41 3.9 I/O的效率 41 3.10 文件共享 42 3.11 原子操作 45 ...
2、UNIX、Linux操作系统的发展历程、介绍、应用领域
GoJawee的博客
04-26 2731
先看三个和UNIX相关的伟人 —————>Minix–Unix–Linux UNIXUNIX是多用户、多任务的操作系统。 从70年代末开始在市场上出现了不同的UNIX商品化版本，比较有影响的版本包括： IBM的AIX UNIX（跑在小型机上的） HP的HP-UX UNIX SUN的Solaris UNIX，SUN被甲骨文收购了 FreeBSD（互联网公司还有用的）
c语言框架总结
GoJawee的博客
03-12 1195
c语言框架
第五天2017/04/06（下午2：动态链接库(DLL)）
GoJawee的博客
04-10 885
例1： 【功能介绍】 创建动态库： ①在头文件中声明两个函数 ②一个在.c文件中实现，另一个在.cpp文件中实现 使用动态库： 在main.c和main.cpp使用上面生成的动态库中的两个函数 （1）创建动态库 //DLL.h头文件声明2个函数 #ifndef DLL_H #define DLL_H #ifdef BUILD_DLL #define PORT_DLL
第九天2017/04/18（3、重载/覆盖 PK 重写/重定义、父类子类混搭风、抽象类）
GoJawee的博客
04-20 723
【预备知识】 函数重载 必须在同一个类中发生 子类无法重载父类的函数，父类同名的函数将会被名称覆盖 重载是在编译期间根据参数类型和个数决定函数调用 重载只放在同一个类之中，在编译期间就确定 函数重写 必须发生在父类与子类之间 父类与子类中的函数必须有完全相同的函数原型 使用virtual关键字声明后能够产生多态（如果没有virtual，那叫重定
第十天2017/04/21（1、函数指针、❤动态库回调❤）
GoJawee的博客
04-21 614
1、函数指针的语法基础【函数指针的定义、初始化、使用】 对函数名去多少个&，都不起作用，都是一样的,都还是它本身test。 如：test、&test、&&test、&&&test都表示函数的入口地址 同样： 对函数名去多少个*，都不起作用，都是一样的,都还是它本身test。 如：test、*test、**test、***test都表示函数的入口地址 /* 定义函数指针：
/7306/2.in:Segmentation fault /7306/sample.in:Segmentation fault /7306/test.in:Segmentation fault
最新发布
11-04
这些错误提示都是“段错误”，通常是由于程序试图访问未分配给它的内存或试图访问受保护的内存区域而引起的。这可能是由于程序中的指针错误、数组越界、栈溢出等问题引起的。针对这些错误，可以尝试以下方法进行排查...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值