指针与数组

目录

指针

认识指针变量

指针的定义与相关操作

数组

认识数组

定义和使用数组

 指针与数组结合

 变量类型的分析方法

数组指针

指针数组 

其他

---

指针

认识指针变量

内存：内存是计算机上重要的存储器，计算机中的程序都是运行在内存中的。为了有效使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是一个字节（Byte）。

地址：为了有效地访问到内存的每个单元，就给内存单元进行了编号，这些编号就称为内存单元的地址，通常使用十六进行表示。

指针变量：是用来存储地址编号的变量。

                        示意图

指针的定义与相关操作

//定义指针语法

type* ptr_name ；

//取变量地址操作

&var_name; //!&后面一定需要是变量

//指针的间接引用（解引用）

*ptr_name;

代码示例：

/*
todo: 定义指针变量，将其指向某个变量的地址，并解引用使用变量
*/

#include <stdio.h>
int main() {
    //*定义指向int类型变量的指针变量
    int* ptr = NULL;        //赋空
    int num = 1;            //定义int变量
    ptr = &num;             //将num的地址赋给指针
    *ptr = 2;               //间接引用使用指针变量
    printf("num = %d, *ptr = %d\n",num, *ptr);
    /*
    输出：
    num = 2, *ptr = 2
    */    
    return 0;
}

数组

认识数组

数组：一组相同类型元素的集合，数组内的每个元素类型相同、所占内存空间连续。

定义和使用数组

定义并初始化：type array_name [len] = { val1, val2, . . . , };

使用：使用array_name[index]访问数组内的每个元素，其中index的范围是0 ~ len - 1。

注意：arr[ index]操作符执行的操作相当于*(arr + index)操作；数组的类型是type [len];

代码示例：

    int arr[5]  = { 1, 2, 3};
    printf("%d, %d\n", arr[0], *(arr + 0));
    /*
    输出：
    1 1
    */

 指针与数组结合

 变量类型的分析方法

当指针与数组直接结合在一起而不经过别名优化时，形式比较复杂，下面给出此种情形下变量类型的分析方法：

step1：优先级 () > [] > *，变量名优先和[]结合，代表这个变量为数组；优先和*结合，则代表这个变量为指针。

step2：当变量为数组时，除去var_name[len]部分，剩下的部分则是该数组中每个元素的基本类型；当变量为指针时，除去*var_name部分，剩下部分则是该指针指向变量的类型。

数组指针

数组指针：从名字描述上可以知道它是一个指针，是一个指向数组的指针。

定义：tyep (*ptr_name)[len]；

代码示例：

    //定义长度为5的数组，该数组的类型是int[5]
    int arr[5] = {1, 2, 3, 4, 5};
    //定义指向数组arr的指针
    int(*ptr_arr)[5] = &arr;
    //使用数组指针
    for (int i = 0; i < 5; i++) {
        printf("%d ", (*ptr_arr)[i]);
    }
    printf("\n");
    /*
    输出：
    1 2 3 4 5
    */

指针数组 

指针数组：从名字描述上可以知道它是一个数组，是一个存放指针变量的数组。

定义：type* arr_name[len];

代码示例:

   //定义整形指针
   int num1 = 1, num2 = 2, num3 = 3;
   int* ptr1 = &num1, *ptr2 = &num2, *ptr3 = &num3;
   //定义指针数组，用来存放以上定义的指针
   int* arr_ptr[3] = {ptr1, ptr2, ptr3};
   //使用指针数组
   for (int i = 0; i < 3; i++) {
        printf("%d ", *arr_ptr[i]);
   }
   printf("\n");
   /*
   输出：
   1 2 3
   */

其他

以下代码则展示了一些不经别名优化直接看起来较为复杂的指针和数组。

代码示例：

#include<iostream>
using namespace std;
 
 int add(int x, int y) {
    return x + y;
 }

 int sub(int x, int y) {
    return x - y;
 } 

 int mult(int x, int y) {
    return x * y;
 }

 int divi(int x, int y) {
    return x / y;
 }

int main() {
    //todo: Demo1:
    //*定义int类型的数组，并定义指向该数组的指针
    int arr1[10] = {1, 2, 3};
    int (*p)[10] = &arr1;
    for (int i = 0; i < 10; i++) {
        cout << (*p)[i] << " ";
    }
    cout << endl;
    /*
    输出：
    1 2 3 0 0 0 0 0 0 0 
    */

    //todo: Demo2:
    //*定义指向函数的指针
    int(* pfun)(int, int) = &add;
    cout << add(1, 2) << " " << (*pfun)(1, 2) << endl;
    /*
    输出：
    3 3
    */

   //todo: Demo3
   //*定义指向函数指针数组的指针
   //*函数指针数组
    int(*funArr[4])(int, int) = {&add, &sub, &mult, &divi};
    for(int i = 0; i < 4; i++) {
        cout << (*funArr[i])(4, 2) << " ";
    }
    cout << endl;
    /*
    输出：
    6 2 8 2
    */
   //*指向函数指针数组的指针
   int(*(*pfunArr)[4])(int, int) = &funArr;
    for (int i = 0; i < 4; i++) {
        cout << ((*pfunArr)[i])(4, 2) << " ";
    }
    cout << endl;
    /*
    输出：
     6 2 8 2
    */

   //todo: Demo4
   //*定义指向数组指针数组的指针
    //*定义数组
    int tarr1[3] = {1, 2, 3};
    int tarr2[3] = {4, 5, 6};
    int tarr3[3] = {7, 8, 9};
    //*定义数组指针数组
    int(*arrArr[3])[3] = {&tarr1, &tarr2, &tarr3};
    /*
    arrArr[3]          -- > arrArr是一个数组
    int arr[3]         -- > 除去数组部分，剩下的部分是数组内每个元素的类型 也就是int
    int(*)[3]          -- > 它是一个指向大小为3的数组的指针
    int* ptr
    arrArr是一个数组，数组内每个元素的类型是int(*)[3]，也就是指向3个空间大小的数组指针
    */
    //*定义指向数组指针数组的指针
    int(*(*parrArr)[3])[3] = &arrArr;
    return 0;
}