被指针弄晕了，望帮忙拔云见日（二级指针，字符数组，字符串，强制转换（just for key words of seeking)

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了被指针弄晕了，望帮忙拔云见日（二级指针，字符数组，字符串，强制转换（just for key words of seeking)相关的知识，希望对你有一定的参考价值。

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

int main()

char **p2 = (char **) malloc(10*sizeof(char *));

memset(p2,0x00,(10*sizeof(char *)));//为什么以*p2作为第一个参数不行
memset(p2,'a',(10*sizeof(char)));

printf("%c\n",*p2); /* 输出1个a */
printf("\n");
//printf("%s\n",*p2); /* 段错误,*p2不是字符串首地址吗*/
printf("%s\n",(char *) p2); /* 输出10个a ，为什么要强制转换 */

char *p1="aaaaaaaaaa";
*p2 = p1;
printf("%s\n",*p2); /* 输出10个a,这里又不要强制转换 */

return 0;


请详解，直至小白们都能看懂
胡乱忽悠的，一边玩去

不差分
请详解，直至小白们都能看懂
最好有示意图之类的

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

int main()

char **p2 = (char **) malloc(10*sizeof(char *));

//分配之后是这样的
/*
p2-> p2[0]==没有分配(所以指向的是非法的地方，是多少不确定，有时候是0xcccccccc)
p2[1]==没有分配(所以指向的是非法的地方)
p2[2]==没有分配(所以指向的是非法的地方)
p2[3]==没有分配(所以指向的是非法的地方)
......
p2[9]==没有分配(所以指向的是非法的地方)
*/

memset(p2,0x00,(10*sizeof(char *)));//为什么以*p2作为第一个参数不行
//你讲的*p2也就是p2[0],而p2[0]现在是指向非法地址的,若以*p2作为参数，那就是要清0他指向的内存，上面讲到他指向的是非法地址，当然会出错
/*
清0后是这样的，这样是为了不成为悬挂指针
p2-> p2[0]==0x00000000
p2[1]==0x00000000
p2[2]==0x00000000
p2[3]==0x00000000
......
p2[9]==0x00000000
*/

memset(p2,'a',(10*sizeof(char)));
// 又置为'a'，十六进制是61,
/*
p2-> p2[0]==0x61616161（p[0]是指针型，32位系统下占4字节，他的4个字节都是'a'，所以就是0x61616161）
p2[1]==0x61616161
p2[2]==0x61610000（只有10个字节被置为'a',所以应该是这样的）
p2[3]==0x00000000
......
p2[9]==0x00000000
*/

printf("%c\n",*p2); /* 输出1个a */
// 相当于printf("%c\n", p2[0]);
// 也相当于printf("%c\n", 0x61616161);
// 0x61616161转换为char型，就是十六进制的0x61，也就是10进制的97，也就是'a'的ASCII码

printf("\n");
//printf("%s\n",*p2); /* 段错误,*p2不是字符串首地址吗*/
//这里*p2也就是p2[0]的值为0x61616161,所以他指向内存0x61616161，依然是非法地址

printf("%s\n",(char *) p2); /* 输出10个a ，为什么要强制转换 */
// p2是指向指针的，而不是指向字符的
/*
p2-> p2[0]==0x61616161
p2[1]==0x61616161
p2[2]==0x61610000
p2[3]==0x00000000
......
p2[9]==0x00000000

而转换之后，情况就不同了：
(char *)p2-> p2[0]==0x61
p2[1]==0x61
p2[2]==0x61
......
p2[9]==0x61
p2[10]==0x00
p2[11]==0x00
p2[12]==0x00
......
p2[39]==0x00（注意：是39,因为总共是40个字节长度）

*/

char *p1="aaaaaaaaaa";
*p2 = p1;
// 相当于p2[0] = p1;
/*
p2-> p2[0]==p1->"aaaaaaaaaa"
p2[1]==0x61616161
p2[2]==0x61610000
p2[3]==0x00000000
......
p2[9]==0x00000000
*/

printf("%s\n",*p2); /* 输出10个a,这里又不要强制转换 */
// 因为*p2也就是p2[0]本身就是一个字符指针，当然不要转换

return 0;
 参考技术A 指针也是有不同的，int* 和char* 虽然都是指针，而且都是16位，但却是不同的指针，int*每次+1都会跳4个字节，而char*每次只会跳1个字节

我解释的有问题，改一下

这里*p2是指向char的指针，每次跳1个字节，作用跟char *p是一样的

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

int main()

char **p2 = (char **) malloc(10*sizeof(char *));

memset(p2,0x00,(10*sizeof(char *)));//为什么以*p2作为第一个参数不行

不是用*p2不行，而是因为后面的空间10*sizeof(char *)是以char *作为申请空间单位的，意思是给p2这个指向指针的指针申请了10个指针对象的空间画图示意一下：
p2----0-1-2-3-4-5-6-7-8-9这十个空间
|
这里是*p2
memset(p2,'a',(10*sizeof(char)));

printf("%c\n",*p2); /* 输出1个a */
printf("\n");
//printf("%s\n",*p2); /* 段错误,*p2不是字符串首地址吗

这里报错是因为串最后没有以'\0'结束，持续往下读，就报错了

*/
printf("%s\n",(char *) p2); /* 输出10个a ，为什么要强制转换

强制转换让它每次跳一个字节

*/

char *p1="aaaaaaaaaa";
*p2 = p1;
printf("%s\n",*p2); /* 输出10个a,这里又不要强制转换

*p2最后以'\0'结束，可以输出

*/

return 0;
 参考技术B 楼上回答不错哦
额外建议，看看《C和指针》这本书
指标要先治本，看完这本书，这些问题都是小case 参考技术C 1.
memset(p2,0x00,(10*sizeof(char *)));//为什么以*p2作为第一个参数不行

char **p2 = (char **) malloc(10*sizeof(char *));这句话动态的申请了一个指向指针的数组，大小为4*10，这里你一定要记住，无论是指向什么类型的指针都会占用4个字节（在32机上），整个数组保存的是数组的指针。
*p2 =>p2[0],你现在刚申请空间，都没有赋值，*p2其实是个野指针，编译器根本不可能知道你指向哪里，怎么清零。
2.
memset(p2,'a',(10*sizeof(char)));//你这条语句很有问题10*sizeof(char）
这里只有10个字节，你只是给数组的前十个字节赋值，所以为什么你后面
printf("%s\n",(char *) p2); 这里只会有10个a，应该10*sizeof(char*）;
3.
printf("%s\n",*p2); /* 段错误,*p2不是字符串首地址吗*/,解释这个问题

*p2是字符串首地址，但是你给他的值是什么呢，0x61616161,即是4个a，这样的地址段，在应用程序段是访问不了的，肯定会出错。
4.
printf("%s\n",(char *) p2); /* 输出10个a ，为什么要强制转换 */
printf("%s\n",*p2); /* 输出10个a,这里又不要强制转换 */
第一个p2是一个指针指针的指针，即是 char **p ,%s,是输出 char *p的所以你肯定要把它转换成 char *p，才可以作为字符串输出。
第二个你本身就是一个 char *p得指针，肯定是不用转换的那。

建议楼主多看点书哦，多上机练习就比较容易掌握。

C 语言二级指针作为输入 ( 指针数组 | 将 二级指针 作为函数输入 | 抽象函数业务逻辑 )

文章目录





一、打印 指针数组 中指针指向的字符串


打印 指针数组 中指针指向的字符串 :

  • 指针退化问题 : 传入二级指针 , 同时还要传入 一级指针的个数 ; 实参是 指针数组 , 形参 退化为 二级指针 , 需要人为指定 数组的元素个数 ;
  • 验证指针合法性 : 函数中 , 只要是指针 , 就有可能为 NULL , 函数入口就要验证该指针合法性 ;
/*
 * 打印函数
 */
int printf_array(char **array, int num)

    // 验证指针合法性
    if(array == NULL || num <= 0)
    
        printf("error : array == NULL || num <= 0\\n");
        return -1;
    

    // 循环控制变量
    int i = 0;

    // 打印上述数组
    for(i = 0; i < num; i++)
    
        // 使用 数组下标 与 指针 进行遍历 , 效果相同
        //printf("%s\\n", array[i]);
        printf("%s\\n", *(array + i));
    

    return 0;




二、字符串排序


将 指针数组 作为参数 , 传入函数中 ;

函数的 二级指针 形参 , 既要作为 输入 , 又要作为输出 ;

int sort_array(char **array, int num)

    // 验证指针合法性
    if(array == NULL || num <= 0)
    
        printf("error : array == NULL || num <= 0\\n");
        return -1;
    

    // 循环控制变量
    int i = 0, j = 0;
    // 排序时 , 交换指针变量时的临时变量
    char *tmp;

    // 对 指针数组 进行排序 , 排序依据是 指针 指向的数据对比
    for(i = 0; i < num; i++)
    
        for(j = i; j < num; j++)
        
            // 核心逻辑 : 如果 array[i] 大于 array[j]
            //          就交换两个元素
            if(strcmp(array[i], array[j]) > 0)
            
                // 交换 i, j 位置的指针变量
                tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            
        
    

    return 0;




三、代码示例


完整代码示例 :

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

/*
 * 打印函数
 */
int printf_array(char **array, int num)

    // 验证指针合法性
    if(array == NULL || num <= 0)
    
        printf("error : array == NULL || num <= 0\\n");
        return -1;
    

    // 循环控制变量
    int i = 0;

    // 打印上述数组
    for(i = 0; i < num; i++)
    
        // 使用 数组下标 与 指针 进行遍历 , 效果相同
        //printf("%s\\n", array[i]);
        printf("%s\\n", *(array + i));
    

    return 0;


int sort_array(char **array, int num)

    // 验证指针合法性
    if(array == NULL || num <= 0)
    
        printf("error : array == NULL || num <= 0\\n");
        return -1;
    

    // 循环控制变量
    int i = 0, j = 0;
    // 排序时 , 交换指针变量时的临时变量
    char *tmp;

    // 对 指针数组 进行排序 , 排序依据是 指针 指向的数据对比
    for(i = 0; i < num; i++)
    
        for(j = i; j < num; j++)
        
            // 核心逻辑 : 如果 array[i] 大于 array[j]
            //          就交换两个元素
            if(strcmp(array[i], array[j]) > 0)
            
                // 交换 i, j 位置的指针变量
                tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            
        
    

    return 0;



void main()

    // 循环控制变量
    int i = 0, j = 0;
    // 数组大小
    int num = 0;
    // 排序时 , 交换指针变量时的临时变量
    char *tmp;

    /*
     * 复杂指针阅读
     * 参考 https://blog.csdn.net/shulianghan/article/details/121453520 和
     * https://hanshuliang.blog.csdn.net/article/details/78568351#3____________________2803
     * 博客章节进行阅读
     *
     * 复杂指针解析流程 :
     * 1. 中心标识符是 array
     * 2. 先往右看 , 遇到 [] , 说明这是一个数组 , 挖掉 array[] 内容 , 然后调转方向往左看
     * 3. 发现是 * , 说明数组中的元素是指针 , 挖掉 * , 往右看没内容 , 往左看
     * 4. 发现是 char , 说明指针指向的数据是 char 类型
     *
     * array 是一个数组 , 数组中的元素的 char * 字符串
     *
     * 这是 指针数组 , 数组元素 是 指针
     */
    char *array[] = "abc", "123", "258", "sfd";

    // 计算数组大小
    num = sizeof(array) / sizeof(array[0]);

    // 打印数组
    printf_array(array, num);

    // 对 指针数组 进行排序 , 排序依据是 指针 指向的数据对比
    sort_array(array, num);

    // 打印排序后的数组
    printf("\\nSort:\\n");
    printf_array(array, num);


    // 命令行不要退出
    system("pause");
    return;

执行结果 :

以上是关于被指针弄晕了，望帮忙拔云见日（二级指针，字符数组，字符串，强制转换（just for key words of seeking)的主要内容，如果未能解决你的问题，请参考以下文章

C 语言二级指针作为输入 ( 指针数组 | 将 二级指针 作为函数输入 | 抽象函数业务逻辑 )

C 语言二级指针案例 ( 字符串切割 | 返回 自定义二级指针 作为结果 )

C 语言二级指针作为输入 ( 指针数组 | 指针数组排序 | 字符串排序 | strcmp 函数 )

C 语言二级指针案例 ( 字符串切割 | 返回 二维数组 作为结果 )

C 语言二级指针案例 ( 字符串切割 | 返回 自定义二级指针 作为结果 | 每个 一级指针 指向不同大小内存 | 精准分配每个 一级指针 指向的内存大小 )

oracle拨云见日第5篇之静默安装11g