实例1

我们在pointer_test.c的文件中写一个test2()函数，我们定义一个有3个元素的字符数组初始化值分别为，’A’, ’B’, ’C’，然后定义一个字符指针pc，把数组ca的首地址复制给字符指针pc,然后通过访问指针变量pc,来读取指针变量pc所指向地址的数据，代码如下：

void test2()
{
    char ca[3]={'A','B','C'};
    char *pc;

    /*第一步 : 所有变量都保存在内存中，我们打印一下变量的存储地址*/
    printf("ca  =%p\n",ca);
    printf("&pc =%p\n",&pc);

    /*第二步：所有变量都可以保存某些值,接着赋值并打印*/
    //前面已经有ca[3]={'A','B','C'};
    pc = ca;
    printf("pc =%p\n",pc);

    /*第三步：使用指针：1)取值  2)移动指针*/
    printf("pc =%p\t",pc);  printf("*pc =0x%x\n",*pc); pc=pc+1;
    printf("pc =%p\t",pc);  printf("*pc =0x%x\n",*pc); pc=pc+1;
    printf("pc =%p\t",pc);  printf("*pc =0x%x\n",*pc);  
    printf("//=================\n");            
}

main()函数

int main(int argc,char **argv)
{
    printf("sizeof(char   )=%d\n",sizeof(char   ));
    printf("sizeof(int    )=%d\n",sizeof(int    ));
    printf("sizeof(char  *)=%d\n",sizeof(char  *));
    printf("sizeof(char **)=%d\n",sizeof(char **)); 
    printf("//=================\n");
    //test0();
    //test1();
    test2();
    return 0;
}

编译

 gcc -m32 -o pointer_test pointer_test.c

运行：

 ./pointer_test

结果：

 sizeof(char   ) = 1
 sizeof(int    ) = 4
 sizeof(char  *) = 4
 sizeof(char **) = 4
 //==============
 ca  =0xffb946b9
 &pc =0xffb946b4
 pc =0xffb946b9
 pc =0xffb946b9  *pc =0x41
 pc =0xffb946ba  *pc =0x42
 pc =0xffb946bb  *pc =0x43
 //=================

分析：

• 第一步：

首先定义一个3个元素的字符数组ca(数组名表示该数组存储的首地址)，然后定义一个字符指针pc，然后通过printf()函数把定义这两个变量在内存中的地址打印出来。

• 第二步：

执行pc = ca;就是把数组ca的首地址复制给指针变量pc，然后通过printf()函数打印pc的值可以看出pc的值就是字符数组ca的首地址0xffb946b9。

• 第三步：

通过移动指针我们可以发现数组所占用的内存是连续的，0x41(的ascii值‘A‘)，0x42(的ascii值‘B‘)，0x43(的ascii值‘C‘)。如图

实例2

我们在pointer_test.c的文件中写一个test3()函数，我们定义一个有3个元素的整型数组ia,初始化值分别为，0x12345678, 0x87654321, 0x13572468，然后定义一个整型指针pi，把数组ia的首地址复制给整型指针pi,然后通过访问指针变量pi,来读取指针变量pi所指向地址的数据，代码如下：

void test3()
{
    int ia[3]={0x12345678,0x87654321,0x13572468};
    int *pi;

    /*第一步 : 所有变量都保存在内存中，我们打印一下变量的存储地址*/
    printf("ia  =%p\n",i);
    printf("&pi =%p\n",&pi);

    /*第二步：所有变量都可以保存某些值,接着赋值并打印*/
    //前面已经有ia[3]={0x12345678,0x87654321,0x13572468};
    pi = ia;
    printf("pi =%p\n",pi);

    /*第三步：使用指针：1)取值  2)移动指针*/
    printf("pi =%p\t",pi);  printf("*pi =0x%x\n",*pi); pi=pi+1;
    printf("pi =%p\t",pi);  printf("*pi =0x%x\n",*pi); pi=pi+1;
    printf("pi =%p\t",pi);  printf("*pi =0x%x\n",*pi); 
    printf("//=================\n");    
}   

把main()函数test2()修改为test3().

编译

gcc -m32 -o pointer_test pointer_test.c

运行：

./pointer_test

结果：

 sizeof(char   ) = 1
 sizeof(int    ) = 4
 sizeof(char  *) = 4
 sizeof(char **) = 4
 //==============
 ia  =0xff91c060
 &pi =0xff91c05c
 pi =0xff91c060
 pi =0xff91c060  *pi =0x12345678
 pi =0xff91c064  *pi =0x87654321
 pi =0xff91c068  *pi =0x13572468

分析：

• 第一步：

我们定义一个有3个元素的整型数组ia数组名表示该数组存储的首地址),初始化值分别为，0x12345678, 0x87654321, 0x13572468, 然后定义一个整型指针pi，然后通过printf()函数把定义这两个变量在内存中的地址打印出来。

• 第二步：执行pi = ia; 就是把数组ia的首地址复制给指针变量pi，然后通过printf()函数打印pi的值可以看出pi的值就是整型数组ia的首地址0xff91c060。
• 第三步：我们知道 pi是整型指针变量，并且整型变量占用四个字节，所以整型指针变量pi是以四字节为单元进行访问的，所以pi和pi+1之间的差是一个整型变量的大小（4个字节）。

实例3

定义一个指向字符串的指针pc，然后对字符串指针进行初始化设置为abc，代码如下：

void test4()
{
    char *pc="abc";
    /*第一步 : 所有变量都保存在内存中，我们打印一下变量的存储地址*/
    printf("&pc =%p\n",&pc);

    /*第二步：所有变量都可以保存某些值,接着赋值并打印*/
    //前面已经有pc="abc";

    /*第三步：使用指针：1)取值  2)移动指针*/
    printf("pc    =%p\n", pc);  
    printf("*pc   =%c\n",*pc);
    printf("pc str=%s\n", pc);  
}   

把main()函数test3()修改为test4().编译

gcc -m32 -o pointer_test pointer_test.c

运行：

./pointer_test

结果：

 sizeof(char   ) = 1
 sizeof(int    ) = 4
 sizeof(char  *) = 4
 sizeof(char **) = 4
 //==============
 &pc   =0xfff49a68
 pc    =0x08048b4b
 *pc   =a
 pc str=abc

分析：

• 第一步：

定义一个指向字符串的指针pc，然后对字符串指针进行初始化设置为abc，此时，指针变量pc的值就是字符串abc的首地址，然后通过printf()函数把指针pc的地址打印出来为0xfff49a68

• 第二步：

首先通过printf()函数打印出指针变量pc的值(字符串abc的首地址)，pc的值为0x08048b4b，然后通过pc指针访问第一个字符(pc的就是字符串的首地址)，所以pc的值就是字符‘a‘的地址，所以*pc的值就是’a‘，如图所示:

下面分析一下指向数组的指针和指向字符串的指针:

 char ca[3]={'A','B','C'};
 char *pc0 = ca;

pc0是指向字符数组的字符指针,pc0就是数组首元素的地址,pc0=&a[0]

char *pc11=”abc”;

pc是指向字符串的字符指针,pc1就是字符串”abc”的首字符’a’的地址。

「新品首发」STM32MP157开发板火爆预售！首批仅300套