<C> 指针补课 - 2017/11/25

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

int main()
{
#if 0 //====================================一维数组================================
    /**
    *     指针  指针类型  指针指向的数据类型   指针指向的数据的内容
    *     malloc  申请内存
    *     free    释放内存
    *     
    *
    *     // 堆内存   int[10]   存放10个int 
    *     指针不能直接赋值
    *     如：
    *           int *q = 1;  // 错误的
    *
    *           int *q;
    *           *q = 1;  // q没有指向什么变量   *q会出错
    *
    *   指针不单独使用   要么变量  数组  堆内存 
    */

    // int(*p)[5];    // 定义一个数组指针变量
    int n;   //
    printf_s("请输入要数据的个数：");
    scanf_s("%d", &n);
    // int arr[n];   // 

    int *p = (int*)malloc(10 * sizeof(int));  // 申请数组   大小40个字节

    /**
    *          取值（解引用） *  []
    *                 *p 相当于 p[0] 
    *                 *(p+i)  相当于 p[i]
    *          &  取变量地址  
    */

    // 用循环赋值
    // 动态数组  malloc实现的
    for (int i = 0; i < n; i++)
    {
        p[i] = i;
        printf_s("%d\t", p[i]);
    }

    // 释放内存
    free(p);


#elif 0  //====================================一维数组================================
    /**
    *     5*10个int数据
    *     <什么申请就什么释放>
    */
    int dArr[5][10];      // 定义一个二维数组变量

    // 指针数组
    int* pointArr[5];
    // 用循环申请空间 
    for (int i = 0; i < 5; i++)  // 申请空间
    {
        pointArr[i] = (int*)malloc(10 * sizeof(int));  
    }

    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            pointArr[i][j] = i*j;
            // *(*(pointArr+i)+j) = i * j;
            printf_s("%d\t", pointArr[i][j]);
        }
        printf_s("\n");
    }

    // 释放内存 
    for (int i = 0; i < 5; i++)  // 释放空间
    {
        free(pointArr[i]);  // 什么申请就什么释放
    }

#elif 0   //===============================二级指针=======================
    /**
    *     二级指针  保存一级指针地址
    */
    //int **pp;  // 定义一个二级指针变量
    int **pp = (int**)malloc(5 * sizeof(int*));    // 申请一个指针数组的内存
    for (int i = 0; i < 5; i++)  // 申请内存
    {
        pp[i] = (int*)malloc(10 * sizeof(int));
    }
    // 用循环赋值并且打印
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            pp[i][j] = i*j;
            // *(*(pp+i)+j) = i * j;
            printf_s("%d\t", pp[i][j]);
        }
        printf_s("\n");
    }

    // 循环释放内存
    for (int i = 0; i < 5; i++)
    {
        free(pp[i]);
    }
    free(pp);  // 释放内存




#elif 0 //================================数组指针=========================
    /**
    *     数组指针（申请堆内存用的不多）和二级指针搭配使用
    */
    int dArr[5][10];
    int(*pDarr)[10];  // 定义一个数组指针  保留列
    pDarr = dArr;
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            pDarr[i][j] = i*j;   // 赋值 
        }
    }




#elif 1  // 指针常量、常量指针
/**
*     比如数组名   一直指向数组首地址指针   不能改变指向  指针常量
*
*     只能看不能改 
*     
*     数组名不能++ 也不能赋值
*/
    int n;
    const double PI = 3.141592654;   // 一旦赋值不能修改  定义的时候要同时赋值
    // PI = 5.3;   定义之后不能修改  好处  防止程序不小心修改了某个值（类型 比较安全）
    
    /*
    const int *q1;  常量指针   const  在*前面    const 修饰*p   *p不能改
    int const *q1;

    int *const q1; // 种是单独一种> 指针常量  *在const前面  const修饰p   说明p不能修改
    */
    int arr[10] = { 0 };  // 数组
    const int *q1;        // 常量指针
    int *const q2 = arr;  // q2要赋初值  常量  <指针常量>

    /*
    q2++;   // 赋值之后不能修改    指针常量
    q2 = &arr[1];
    */
    *q2 = 5;   // 可以修改值   但是不能改指向
    q1 = arr;
    q1++;
    q1 = &arr[1];
    // *q1 = 5;  // 不能通过这个去q1去修改它指向的内容

    
#endif 

    getchar();
    return 0;
}