指针2

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



2.堆内存的申请 内存四区  代码区  全局静态常量区  栈区  堆区
        堆区   内存大  但是需要手动申请释放

        int *p;
        p=(int*)malloc(sizeof(int)*100);申请一端内存

        p[i]   访问下标为i的元素*(p+1)

        free(p);//释放内存
        sizeof(int)  4个字节
        对于不同的系统   不同环境下 数据的大小 不是完全一致的
        对于类型的大小 统一用sizeof就行

        char*str="hello world";
        gets(str);错误的
        平时  栈区  
        大量数据 ---->堆区 
        全局共享的数据  用全局变量/传参的方式

        二维数组叫做数组的数组
新内容
    1 指针数组和数组指针
    2 指针常量和常量指针
    3 指针函数和函数指针


*/
#include<stdio.h>
#include<stdlib.h>  //malloc  free  realloc
/* 查找行最小 列最大的元素  找到后直接打印 */
void fun1(int arr[][4], int row)//二维数组   传参需要传递行
{
    int m, n;
    for (int i = 0; i < row; i++)//有多少行就找多少次
    {
        //查找一次的过程 查找这一行的最小值
        m = 0;//列从0开始的 
        for (int j = 0; j < 4; j++)
        {
            if (arr[i][j] < arr[i][m])//m表示这一行最小元素 列数
            {
                m = j;
            }
        }
        //arr[i][m]是这一行的最小元素
        //找一下这一列有没有比arr[i][m]更大的元素
        for (n = 0; n < row; ++n)//arr[0][m] arr[2][m]
        {
            if (arr[n][m]>arr[i][m]) break;
        }
        if (n == row)
        {
            printf("所求的点是[%d,%d]\n", i, m);
        }
    }
}
void test()
{
    int arr[3][4] = {  //arr有三个元素 arr[0] arr[1] arr[2]
        9, 7, 4, 5,  //arr[0]有四个元素arr[0][0] arr[0][1] arr[0][2] arr[0][3]
        7, 7, 3, 2,
        1, 0, 2, 9
    };
    printf("arr[0]的大小%d\n", sizeof(arr[0]));//都一行的大小
    printf("arr[0][0]的大小%d\n", sizeof(arr[0][0]));
    //一级指针和一维数组
    //int brr[10] p=brr//p指向第一个元素
    //p=&brr[0];


    //二维数组  q=qrr;
    //q=&arr[0] 取第一行的地址 （取第一个元素地址）
    //第一个元素 是一个数组  需要用到数组指针  （指向数组的指针）
    //指向的数组  存什么类型的数据
    int(*pd)[4];//一行内容 指向数组的指针 数组指针
    //行指针
    pd = arr;//指向第一行
    (*pd)[0];//相当于第一行的第一个元素 pd[0][0]
    pd[1][2];//都二行第三个元素
    //定义数组指针  然后指向数组之后  用法和数组是一样
    //数组指针的意义



    fun1(arr, 3);//表示数组有三行
    //行最小 列最大  用循环一个一个去比较
    //----->找到每一行中的最小值  用循环一个个比较
    //   然后判断是不是这一列的最大值
    //int brr[4];
    //pd = &brr;
    //pd = &brr[0];
    //pd[0][0]---->brr[0]


    //int x;
    //double y;
    //int *px;
    //px=&y;
}
void test1()
{
    //如果我要一个指针  int *p;
    //如果使用多个指针 指针数组
    //类型 数组名[数组大小]
    int* pArr[10];//指针数组 10个int*
    //一个指针可以申请一段内存 多个指针   申请多个内存
    for (int i = 0; i < 10; ++i)
    {
        pArr[i] = (int*)malloc(sizeof(int)* 4);
    }
    //申请之后相当于一个二维数组10行4列
    //用法和二维数组是一样的
    pArr[1][3];//第二行  第四个元素

    for (int i = 0; i < 10; ++i)
    {
        free(pArr[i]);
    }
}
void test2()//指针常量和常量指针
{
    //const 常属性的意思 不可变（定义的还是变量）
    int const x = 10;//通过 语法限定  x的值不可修改 必须先定义然后赋值
                    //限定x不能作为左值 栈区 const int x 效果一样
    int arr[10];
    const int* p;//int* const q;    //const限定了这个p不能区修改它指向的内容
    p = &arr[0];//先让p指向第一个元素
    //*p = 0;//相当于 arr[0]=0
    //p++;
    //const在前*在后  常量指针
    //const修饰的是*p *p不可修改 p不能修改其他值
    int* const q=&arr[0];
    //q = &arr[0];//q不能赋值
    *q = 0;//说明可以指针q去修改的指向的内容

    //const在*后面 指针常量

    //const修饰是q  说明q不可以修改（不能修改q的指向）

    //使用指针传参  为了效率  修改形参的值
    char *str = (char*)malloc(sizeof(char)* 100);
    str = "hello world";//字符串赋值  必须strcpy
    //让指针指向这个字符串（常量区）
    //后续释放就没法申请的内存 指针指针已经变了
    free(str);

}
void test3()//指针函数和函数指针
{
    //指针函数  返回值为指针的函数  malloc作用申请内存  返回是一个指针
    //函数指针 指向函数的指针
    //函数调用过程  函数 ---->函数  传递形参  计算 得到返回值--->回到主函数

    void * (*pfun)(size_t _Size);//先复制函数声明--->函数名缓冲（*p)
    pfun = malloc;//函数指针的赋值
    //pfun指向函数的地址  --->可以用pfun区调用这个函数

    int*p = (int*)pfun(100 * sizeof(int));
    free(p);
    //函数名作为函数 传递给其他函数
    //实参是函数名  形参  就是函数指针
    //指针  可以指向一类函数
}
void test4()
{
    int *p;  //int
    int *p2[10];// 类型  数组名[数组大小]
    int(*p3)[10];//int [10] 指向这么一个数组 数组指针
    //如果实参是二维数组  形参如何写？
    int(*p4)[3][4];//和三维数组有关 不用考虑
}
int main()
{
    test();
    test1();
    test2();
    test3();
    test4();
    getchar();
    return 0;
}