做一个简单的小总结

注意最后面的词语，前面的是修饰

数组指针

本质是一个数组
直接看代码

#include <iostream>
using namespace std;

#define size 3
typedef int(*test_ptr)[size]; //test_ptr类型 int(*)[3] 代表一个数组大小为3 类型为int的数组指针

int main()
{
    int test_array[size]{1,2,3};
    test_ptr array_pt = &test_array; //把test_array指针传给array_pt，现在array_pt是一个数组指针

    for(int i = 0; i < size; i++) {
        cout << (*array_pt)[i] << endl;  //首先相当于array_pt的地址取值变为test_array，然后就和正常的数组一样使用
    }
    /*  1
        2
        3
    */
    //那么和指针指向一个数组的区别在哪
    int* low_array = test_array; //low_array的类型是int*，把test_array这个数组首元素赋值给low_array
    for(int i = 0; i < size; i++) {
        cout << low_array[i] << endl;  //low_array直接代表数组首元素所以可以直接遍历
    }
    /*  1
        2
        3
    */
    //我们再来看一下指针加一的区别
    cout << "test_array  " << array_pt << endl;   //数组名代表数组首元素的地址
    cout << "array_pt  " << array_pt << endl;     //&test_array代表这个数组的存放地址是和数组首元素地址相同
    cout << "low_array  " << low_array << endl;   //数组首元素地址
    cout << "array_pt + 1  " << array_pt + 1 << endl; //类型为(int*)[3]，array_pt + 1 = 0x61fe74 + 3 * sizeof(int) * 1 = 0x61fe80 
    cout << "low_array + 1  " << low_array + 1 << endl; //类型为 int* ， low_array + 1 = 0x61fe74 + sizeof(int) * 1 = 0x61fe78
    /*
    test_array     0x61fe74
    array_pt       0x61fe74
    low_array      0x61fe74
    array_pt + 1   0x61fe80
    low_array + 1  0x61fe78
    */
    //可以看到初始地址都是相同的
    return 0;
}

图解指针数组

和普通指针比较

数组指针和二维数组

其实本质来说和上面是一样的，这里还是说一下

#include <iostream>
using namespace std;

#define size 3
typedef int(*test_ptr)[size]; //test_ptr类型 int(*)[3] 代表一个数组大小为3 类型为int的数组指针

int main()
{
    int test_array[2][size] = {
    {1,2,3},
    {2,3,4}
    };
    test_ptr array_pt = test_array; //test_array是二维数组的名字，等于第一个一维数组的地址
    //所以这里array_pt指向了第一个一维数组
    std::cout << (*array_pt)[0] << std::endl; //1
    std::cout << (*array_pt)[1] << std::endl; //2
    std::cout << (*array_pt)[2] << std::endl;//3
    std::cout << array_pt<< std::endl; //0x61fe74

    std::cout << sizeof(*array_pt)<< std::endl; //12


    array_pt++; //array_pt指针类型int(*)[3]， 0x61fe74 + 1*12 = 0x61fe80

    std::cout << array_pt<< std::endl; //0x61fe80

    std::cout << (*array_pt)[0] << std::endl; //2
    std::cout << (*array_pt)[1] << std::endl; //3
    std::cout << (*array_pt)[2] << std::endl; //4
    return 0;
}

图解

指针数组

根据开始的总结，指针数组是一个数组，存储的都是指针

#include <iostream>
using namespace std;
int main()
{
    const char* a[3]{"12", "23", "45"};
    //a这个char类型的数组存储了三个指向字符串的指针
    std::cout << a[0] << std::endl;
    //12
    std::cout << a[1] << std::endl;
    //23
    std::cout << a[2] << std::endl;
    //45
    return 0;
}

这个比较好理解，就是存储的是指针

数组引用

根据第一个总结，这是一个引用，引用的是一个数组

#include <iostream>
using namespace std;
typedef int(&array_define)[3];
int main()
{
    int array[3]{1,2,3};
    array_define quote = array;
    //既然普通引用是变量直接赋值，那么数组引用也就是数组直接赋值
    //引用之后，对数组引用的操作和对数组的操作相同
    std::cout << quote[0] << std::endl;
    //1
    std::cout << quote[1] << std::endl;
    //2
    std::cout << quote[2] << std::endl;
    //3
    std::cout << quote + 1 << std::endl;
    //打印和array + 1相同的地址,数组首元素后移动4个字节

    //普通变量引用
    int a = 1;
    int quote_a = a;
    std::cout << quote_a << std::endl;
    //1

    return 0;
}

插一句题外话，关于指针地址相加，你可以想象变量、都是地址连续的排列的，那么指针向后移动，其实就是指针的地址向前走

引用数组

根据第一句总结，是一个数组，里面是引用
这里你是不是觉得和引用指针有点像
但是！！！！
c++不支持引用数组
原因是对于数组而言，数组存储的变量地址都是连续的，但是引用是引用其他变量的，其他变量可能来自不同的地方，有不同的地址值
对引用取地址就是对变量取地址，那么这就和数组的根本定义矛盾了！！！

#include <iostream>
using namespace std;
int main()
{
    string& a[3] = {"2", "3", "4"};
    return 0;
}
//报错
D:Qt_testuntitled1main.cpp:6: error: declaration of 'a' as array of references
     string& a[3] = {"2", "3", "4"};
                ^
错误：将a声明引用数组

以上就是四种容易混淆的称呼解释

最后例子总结一下
int a = 1;//普通 int
char* b = "1";//普通char类型指针
int a[3]{1,2,3}; //类型为int[3]的数组
int(* aa) [3] = &a; //类型为int( * )[3]的指针,数组指针
char* aa[3]={"1","2","3"};//类型为int*[3]的数组,指针数组
int(&bb)[3] = a;//类型为int(&)[3]的引用，引用数组
//不存在的int& bb[3];