九、指针

指针
Byte字节作为内存最小单元
int占用4个字节
1.内存地址和指针
变量存放在内存当中 ------>找到变量在内存当中的位置就可以操作这个变量
数组元素的首地址--->地址

在形参中传参主要的是传递的地址

指针存放地址的类型指针通过地址去访问去修改变量的值

1.函数传参 2.使用堆内存
2.指针定义和使用方式
指针就是地址
指针变量用来存放地址

 1 int *q = (int *)malloc(sizeof(int)* 100);//申请堆内存 第一个(int*)是强转 第二个(int)是申请int大小的空间
 2     
 3     if (q == NULL)
 4     {
 5         printf("申请失败");
 6         getchar();
 7         return 0;
 8     }
 9     //q指向了这块空间的首地址
10     *q = 12;//===q[0]
11     *(q + 1) = 13;//===q[1]
12     q[2] = 14;//===(*q+2)
13     q[3] = 15;
14     for (size_t i = 0; i < 4; i++)
15     {
16         printf("%d
", q[i]);
17     }
18     q = (int*)realloc(q, sizeof(int)* 200);//把之前的100个int扩充到200个int
19     printf("重新分配后
");
20     for (size_t i = 0; i < 4; i++)
21     {
22         printf("%d
", q[i]);
23     }
24     printf("q的值%p
", q);
25     free(q);//释放内存

int类型 double类型

如果只有一个地址没法判断这个地方是什么类型的数据

指正是有类型的！！！

一个地址里面存放是int类型的值 int* 表示存放int类型的地址
一个地址存放的时候double类型的值

一级指针地址存放基本数据类型

int float double char
%p输出地址
* 运算符解引用

如果变量x的地址存放在指针p 里面 p指向这个变量

int*类型的指针指向int类型的变量

int y;
int*p;//定义一个指向int类型变量的指针
p=&y;//将y的地址赋值给指针p
*p=2;//将y存放的内容赋值2 y就为2
printf("%p=%d",&y,y); &y输出y存放的地址

形参不能改变实参
需要在其他函数中修改实参的值通过传递地址的方式修改

类型* 指针变量名

int* p;//int* 表示指针类型 p表示变量名
一维数组也可以用一级指针

数组名 vs 指针

数组名表示数组的首地址数组名不可以修改(视为常亮)
指针可以修改

sizeof求大小数组名得到的数组的大小
如果得到指针大小

1 void fun(int arr[][5])//形参实际上是指针   int*arr  
2 {
3     int a=sizeof(arr[0]);//求的是形参的大小--->指针的大小
4     int b = sizeof(arr);
5     int c = sizeof(arr[0][0]);
6     printf("arr[0]的大小为：%d
", a);//数组定义的第一个元素的大小
7     printf("arr的大小为：%d
", b);//数组指针arr的大小 为4
8     printf("arr[0][0]的大小为：%d
", c);
9 }

int arr[10]

错误用法 arr++
数组名[下标]

数组名和指针都可以用* []

指针申请堆内存

程序运行的时候代码数据加载内存当中

内存四区
代码区存放代码二进制
全局静态常量区(全局静态常量区)
全局函数外定义的变量作用域是整个程序
静态 static 修饰变量用static修饰的变量存放在全局静态区

1 void fun2()//全局静态常量区
2 {
3     static int x = 0;//静态变量x 每次调用的时候运算结束 值都会改变
4     ++x;
5     printf("x=%d
", x);
6 }

常量区存放一些数字常量或者字符常量

没法取到地址

栈区局部变量(函数循环里面定义变量) 形参
都会存放在栈区
栈区小的空间内存操作系统控制
4M
堆区 1G 需要申请释放需要用到函数专门申请内存
申请内存需要用到指针

申请内存 malloc 用于申请内存
释放内存 free

realloc 内存重分配在原有内存的基础上加/减内存

传参

int 有int*　　一级指针　　保留int的地址

int*p ---> p也是变量 p也有地址如果得到p的地址定义二级指针来接受p的地址
int** pp=&p; 二级指针

*pp --->得到的是pp指向的内容也就是p

printf("%d ",x)

一维数组传参用一级指针
二维数组传参数组指针

int dArr[3][4]---->int (*pd)[4] 数组指针

 1 void fun3(int(*pd)[4])//指针数组相当于int dArr[][4]
 2 {
 3     for (size_t i = 0; i < 12; i++)
 4     {
 5         printf("%d	",(*pd)[i]);//二维数组传入参数 利用指针可以用一级指针的方式进行保存
 6     }
 7     printf("
");
 8     for (size_t i = 0; i < 3; i++)
 9     {
10         for (size_t j = 0; j < 4; j++)
11         {
12             printf("%d	",pd[i][j]);//二维数组进行二维数组下标的方式进行输出
13         }
14     }
15 }

 1 void test()//数组指针vs指针数组
 2 {
 3     int(*pd)[10];//指针数组  数组的行号不定 列号为10 相当于pd[][10]
 4     int* dArr[10];//数组指针需要申请堆内存
 5     for (size_t i = 0; i < 10; i++)
 6     {
 7         dArr[i] = (int*)malloc(sizeof(int)* 4);//申请四个内存的空间 10行4列 相当于dArr[10][4]
 8     }
 9     for (size_t i = 0; i < 10; i++)
10     {
11         for (size_t j = 0; j < 4; j++)
12         {
13             dArr[i][j] = j;
14             printf("%d	", dArr[i][j]);
15             if (j == 3)
16                 printf("
");
17         }
18     }
19 
20     for (size_t i = 0; i < 10; i++)//一个一个释放内存
21     {
22         free(dArr[i]);
23     }
24 }

[] 解引用
p[i]===*(p+i)

基本数据 int x --->实参写整数或者整形变量
变量地址修改变量的值 int*px 实参变量地址
数组名操作一维数组 int *px /int arr[] 实参一维数组的数组名

const 常属性不可变定义的还是变量
通过语法限定 x的值不可以修改必须先定义后赋值
常量指针
const int* p;//int const *p const限定了p不能修改他指向的内容
指针常量
int* const q;

 1 void test1()//const的妙用
 2 {
 3     int arr[10] = {0,1,2,3,4,5,6,7,8,9};
 4     const int* p;//const限定了这个p不能修改他指定的内容 即*p=0是错误的 
 5     p = &arr[0];//但是可以修改指针指向的地址  让p指向第一个元素
 6     p++;//也可以进行后移一位进行指向下一个地址
 7     //const在前*在后 是代表的常量指针
 8     printf("p的地址是：%p
", p);
 9     printf("p的值是：%d
",*p);//此时的p相当于p[1]===arr[1]
10     
11     
12     //const在*后面   指针常量
13     int* const q = &arr[0];//const 后面的q q在定义之后不能赋值
14     //q = &arr[0];//q的值不可修改 只能修改*q的值
15     *q = 0;//指针q可以去修改指向的内容
16     //使用指针传参 提高了效率 修改形参值
17 
18 }

指针传参提高效率修改形参的值

函数指针返回值为指针的函数 malloc作用申请内存返回值是一个指针
函数指针指向函数的指针
函数调用的过程函数名--->函数传递形参计算得到返回值回到主函数

1 void *(*pfun)(size_t _Size);
2 pfun=malloc;
3 //pfun指向函数的地址---->利用pfun来调用这个函数
4 int *p=(int*)pfun(100*sizeof(int));

指针地址效果简介

 1 #include<stdio.h>
 2 int main()
 3 {
 4     int x=3;
 5     int* p=&x;
 6     int y=5;
 7     *p=y;
 8     printf("p的值：%d
",*p);
 9     printf("p的地址：%d
",p);
10     printf("x的地址：%d
",&x);
11     printf("x的值：%d
",x);
12     printf("y的地址：%d
",&y);
13     printf("y的值：%d
",y);
14     getchar();
15     return 0;
16 }

指针效果整体代码

#include<stdio.h>
#include<stdlib.h>//malloc
void fun(int arr[][5])//形参实际上是指针   int*arr  
{
    int a=sizeof(arr[0]);//求的是形参的大小--->指针的大小
    int b = sizeof(arr);
    int c = sizeof(arr[0][0]);
    printf("arr[0]的大小为：%d
", a);//数组定义的第一个元素的大小
    printf("arr的大小为：%d
", b);//数组指针arr的大小 为4
    printf("arr[0][0]的大小为：%d
", c);
}
void fun2()//全局静态常量区
{
    static int x = 0;//静态变量x 每次调用的时候运算结束 值都会改变
    ++x;
    printf("x=%d
", x);
}
void fun3(int(*pd)[4])//指针数组相当于int dArr[][4]
{
    for (size_t i = 0; i < 12; i++)
    {
        printf("%d	",(*pd)[i]);//二维数组传入参数 利用指针可以用一级指针的方式进行保存
    }
    printf("
");
    for (size_t i = 0; i < 3; i++)
    {
        for (size_t j = 0; j < 4; j++)
        {
            printf("%d	",pd[i][j]);//二维数组进行二维数组下标的方式进行输出
        }
    }
}

void test()//数组指针vs指针数组
{
    int(*pd)[10];//指针数组  数组的行号不定 列号为10 相当于pd[][10]
    int* dArr[10];//数组指针需要申请堆内存
    for (size_t i = 0; i < 10; i++)
    {
        dArr[i] = (int*)malloc(sizeof(int)* 4);//申请四个内存的空间 10行4列 相当于dArr[10][4]
    }
    for (size_t i = 0; i < 10; i++)
    {
        for (size_t j = 0; j < 4; j++)
        {
            dArr[i][j] = j;
            printf("%d	", dArr[i][j]);
            if (j == 3)
                printf("
");
        }
    }

    for (size_t i = 0; i < 10; i++)//一个一个释放内存
    {
        free(dArr[i]);
    }
}
void test1()//const的妙用
{
    int arr[10] = {0,1,2,3,4,5,6,7,8,9};
    const int* p;//const限定了这个p不能修改他指定的内容 即*p=0是错误的 
    p = &arr[0];//但是可以修改指针指向的地址  让p指向第一个元素
    p++;//也可以进行后移一位进行指向下一个地址
    //const在前*在后 是代表的常量指针
    printf("p的地址是：%p
", p);
    printf("p的值是：%d
",*p);//此时的p相当于p[1]===arr[1]
    
    
    //const在*后面   指针常量
    int* const q = &arr[0];//const 后面的q q在定义之后不能赋值
    //q = &arr[0];//q的值不可修改 只能修改*q的值
    *q = 0;//指针q可以去修改指向的内容
    //使用指针传参 提高了效率 修改形参值

}
void test2()
{
    void *(*pfun)(size_t _Size);
    pfun = malloc;
    //pfun指向函数的地址---->利用pfun来调用这个函数
    int *p = (int*)pfun(100 * sizeof(int));
}

int main()
{
    int arr[4][5];
    fun(arr);
    fun2();
    fun2();
    fun2();
    int dArr[3][4] = {1,2,3,4,5,6,7,8,10,9,11,12};
    fun3(dArr);
    printf("
");
    int *q = (int *)malloc(sizeof(int)* 100);//申请堆内存 第一个(int*)是强转 第二个(int)是申请int大小的空间
    
    if (q == NULL)
    {
        printf("申请失败");
        getchar();
        return 0;
    }
    //q指向了这块空间的首地址
    *q = 12;//===q[0]
    *(q + 1) = 13;//===q[1]
    q[2] = 14;//===(*q+2)
    q[3] = 15;
    for (size_t i = 0; i < 4; i++)
    {
        printf("%d
", q[i]);
    }
    q = (int*)realloc(q, sizeof(int)* 200);//把之前的100个int扩充到200个int
    printf("重新分配后
");
    for (size_t i = 0; i < 4; i++)
    {
        printf("%d
", q[i]);
    }
    printf("q的值%p
", q);
    free(q);//释放内存
    printf("q的值%p
", q);
    //内存释放后  q指向的空间就不要访问
    //q依然指向这个空间 释放之后再用就会出现问题

    int x=2;
    int *p = &x;//一级指针存放x的地址
    int **pp = &p;

    printf("x=%d
",x);
    printf("p=%d
", p);//x的地址====&x
    printf("pp=%d
", pp);//p的地址===&p

    printf("x的地址%d
", &x);
    printf("p的地址%d
", &p);

    printf("%d
", *pp);//x存放的地址===&x
    printf("%d
", **pp);//x的值===x
    printf("%d
", *p);//x的值===x

    test();
    test1(); 
    test2();
    getchar();
    getchar();

    return 0;
}