C语言-指针

一眼望见你

一、定义指针变量

1. 指针的基本概念

所谓指针变量，就是这个变量存放的是地址
char *pa  //定义一个指向字符型的指令变量
char *pb  //定义一个指向整型的指令变量pa指针指向的是变量a的地址，pf指针指向的是变量f的地址



指令的原理

2. 取址运算符和取值运算符

如果想要获取某个变量的地址，可以使用取址运算符&
char *pa = &a //定义一个指针pa，指向的是a所在的地址  //后面使用时pa = &a
int *pb = &f //定义一个指针pb，指向的是f所在的地址如果想要获取某个指针变量指向的数据，可以使用取值运算符*
printf("%c,%d\n",*pa,*pb);  //在非定义状态时*pa，表示取这个指针对应的地址中的变量的值3. 使用指针
#include <stdio.h>

int main()
{
        char a = 'F';
        int f = 123;

        char *pa = &a;//指针指向地址
        int *pb = &f;//指针指向地址

        printf("a = %c\n",*pa);//通过指针获取变量a的值
        printf("f = %d\n",*pb);//通过指针获取变量f的值  
       
        *pa = 'C'; //通过指针修改变量的值
        *pb += 1; //通过指针修改变量的值
       
        printf("new,a = %c\n",*pa);//打印修改之后a的值
        printf("new,f = %d\n",*pb);//打印修改之后f的值

        printf("sizeof pa = %d\n",sizeof(pa)); //查看指令变量pa的大小
        printf("sizeof pb = %d\n",sizeof(pb)); // 查看指令变量pb的大小

        return 0;
}

****结果****

f = 123
new,a = C
new,f = 124
sizeof pa = 8
sizeof pb = 8二、数组和指针

1. 数组和指针的关系

其实数组名字就是这个数组第一个元素的地址，也就是指针
#include <stdio.h>

int main()
{
        char str[128];
       
        printf("请输入名字：");
        scanf("%s",str);
       
        printf("我的名字是：%s\n",str);
       
        printf("str的地址是：%p\n",str);
        printf("str的地址是：%p\n",&str[0]);
       
        return 0;
}

****结果****
请输入名字：wangqiang
我的名字是：wangqiang
str的地址是：0x7ffc5e939d90
str的地址是：0x7ffc5e939d902. 指向数组的指针

（1）指针指向数组
char *p;
p = a;
p = &a[0]; （2）调整指针对应的数组位置
#include <stdio.h>

int main()
{
        char a[] = "abc";
        char *p = a;
       
        printf("*p = %c, *(p+1) = %c, *(p+2) = %c\n",*p,*(p+1),*(p+2));  //改变指针的位置索引数组
        printf("*a = %c, *(a+1) = %c, *(a+2) = %c\n",*a,*(a+1),*(a+2));  //用数组名表示地址的方式进行索引
}

****结果****
*p = a, *(p+1) = b, *(p+2) = c
*p = a, *(p+1) = b, *(p+2) = c（3）指针指向字符串
#include <stdio.h>
#include <string.h>

int main()
{
        char *str = "I Love You";
        int i,length;
       
        length = strlen(str);
       
        printf("length: %d\n", length);
       
        for(i=0;i<length;i++)
        {
                printf("%c",str);
        }
        printf("\n");
        return 0;
}

****结果****
length: 10
I Love You3. 指针数组和数组指针（有难度）

int *p1[5];   //指针数组
int (*p2)[5];  //数组指针（1）指针数组
指针数组是一个数组，每一个数组存放一个指针变量



指针数组

#include <stdio.h>

int main()
{
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        int e = 5;
        int *p1[5] = {&a,&b,&c,&d,&e};
        int i;
       
        for(i=0;i<5;i++)
        {
                printf("%d\n",*p1);
        }
        return 0;
}

****结果****
1
2
3
4
5（2）数组指针
数组指针是一个指针，它指向的是一个数组



数组指针

******示例代码******
#include <stdio.h>

int main()
{
        int temp[5] = {1,2,3,4,5};
        int (*p2)[5] = &temp; //&temp意思是指向整个数据的地址
        int i;
       
        for(i=0;i<5;i++)
        {
                printf("%d\n",*(*p2+i));
                //p2指向temp数组的地址
                //*p2指向temp数组的第一个元素的地址
                //*(*p2+i)指向temp每一个元素的值
        }
return 0;
}

****结果****
1
2
3
4
54. 二维数组

int b[4][5];


以线性的方式存储

在二维数组中，数组的名字就是指向多个元素的首地址的指针（第一行第一列）
array指向的是array[0][0]
array+1指向的是array[1][0]
*（array+1)表示的是一维数组array[1]，那么指向的是第二行第一个元素的地址



首地址的指针



随意指向其他位置

代码：
#include <stdio.h>

int main()
{
        int array[4][5] = {0};
        int i,j,k = 0;
       
        for(i=0;i<4;i++)
        {
                for(j=0;j<5;j++)
                {
                        array[j] = k++;
                }
        }
       
        printf("*(array+1):%p\n", *(array + 1));
        printf("array[1]:%p\n", array[1]);
        printf("&array[1][0]:%p\n", &array[1][0]);
        printf("**(array+1):%d\n", **(array + 1));
        //任意位置
        printf("&array[1][0]:%d\n", *(*(array+1)+3));
        printf("**(array+1):%d\n", array[1][3]);
       
        return 0;
}

****结果****
*(array+1):0x7ffce5d04034
array[1]:0x7ffce5d04034
&array[1][0]:0x7ffce5d04034
**(array+1):5
&array[1][0]:8
**(array+1):8结论：
*(array +i) == array


结论

5. 数组指针和二维数组

#include <stdio.h>

int main()
{
        int array[2][3] = {{0,1,2},{3,4,5}};
        int (*p)[3] = array; //指向第一个一维数组
       
        printf("**(p+1):%d\n",**(p+1));  //p+1先指向第二列，*(p+1)指向第二列第一个元素，**(p+1)获取第二列第一个元素的值      
        printf("**(array+1):%d\n",**(array+1));
        printf("array[1][0]:%d\n",array[1][0]);
        printf("*(*(p+1)+2):%d\n",*(*(p+1)+2));//p+1先指向第二列，*(p+1)指向第二列第一个元素，*(p+1)+2指向第二列第三个元素
        printf("*(*(array+1)+2):%d\n",*(*(array+1)+2));
        printf("array[1][2]:%d\n",array[1][2]);
       
        return 0;
}

****结果****
**(p+1):3
**(array+1):3
array[1][0]:3
*(*(p+1)+2):5
*(*(array+1)+2):5
array[1][2]:5三、指向指针的指针

1. 基本概念




指针和指向指针的指针

代码：
#include <stdio.h>

int main()
{
        int num = 520;
        int *p = #
        int **pp = &p;
       
        printf("num:%d\n",num);
        printf("*p:%d\n",*p);
        printf("**p:%d\n",**pp);
        printf("&p:%p,pp:%p\n", &p, pp);
        printf("&num: %p, p: %p, *pp: %p\n",&num, p, *pp);
       
        return 0;

}

****结果****
num:520
*p:520
**p:520
&p:0x7ffc062563e8,pp:0x7ffc062563e8
&num: 0x7ffc062563e4, p: 0x7ffc062563e4, *pp: 0x7ffc062563e42. 指针数组和指向指针的指针*

#include <stdio.h>

int main()
{
        char *book[] = {
                "verilog",
                "scala",
                "python",
                "c"
        };
       
        char **v;
        char **soft[3];
        int i;
       
        v = &book[0]; //指向字符串的地址
        soft[0] = &book[1];
        soft[1] = &book[2];
        soft[2] = &book[3];
       
        printf("v = %s\n",*v);
        printf("soft:\n");
       
        for(i=0;i<3;i++)
        {
                printf("%s\n",*soft);
        }
        return 0;
       
}

****结果****
v = verilog
soft:
scala
python
c四、指向常量的指针

1. 指向常量的指针

const int cnum = 880；  //定义一个可读不可写的常量
const int *pc = &cnum；//定义一个指向常量的指针程序:
#include <stdio.h>

int main()
{
        int num = 520;
        const int cnum = 880;
        const int *pc = &cnum;
       
        printf("cnum: %d, &cnum:%p\n",cnum,&cnum);
        printf("*pc: %d, pc:%p\n",*pc,pc);
        return 0;
}

****结果****
cnum: 880, &cnum:0x7ffed96fc1f8
*pc: 880, pc:0x7ffed96fc1f82. 常量指针

#include <stdio.h>

int main()
{
        int num = 520;
        const int cnum = 880;     //指向常量的指针
        int * const p = #    //常量指针（指针本身不可改变，值可变）
       
        *p = 1024; //指针可变
        printf("*p:%d\n", *p);
       
        return 0;
}

****结果****
*p:1024
3. 空指针和通用指针

（1）void指针

void指针我们把它称为通用指针，就是可以指向任意类型的数据。也就是说任何类型的指针都可以赋值给void
#include <stdio.h>

int main()
{
        int num = 1024;
        int *pi = #
        char *ps = "FishC";
        void *pv;
       
        pv = pi;
        printf("pi:%p,pv:%p\n",pi,pv);
       
        pv = ps;
        printf("ps:%p,pv:%p\n",ps,pv);
       
}

****结果****
pi:0x7ffe3d64076c,pv:0x7ffe3d64076c
ps:0x5593b3316004,pv:0x5593b3316004（2）NULL指针

地址0为空指针，空指针不指向任何东西，一般应用在指针的初始化
表示指向一个不被使用的地址

农夫山泉有点疼

在二 2 3中定义了*str为啥下面可以用数组的形式输出出来[思考][大笑]

相伴到老

我理解是char *str = "I Love You" 有三层含义
第一层就是定义一个字符串常量“I Love You”
第二层是定义一个指针变量str，类型为字符型，它其实指向的是字符串“I Love You”的第一个字符，也就是第一个字符的地址
第三层就是可以用指针表示数组名，用指针就可以打印内容（这个确实有点迷）