指针数组，数组指针，指针函数，函数指针配合代码详细介绍

指针数组

故名思意，本质是个数组，类似整数数组，字符数组一样，指针数组中的所有元素均为指针

char *p[4];

这就是一个指针数组，[]的优先级大于*。所以p先与[]结合形成数组，最后再与char*（指针）结合形成指针数组

代码详解

#include<iostream>
using namespace std;

int main(){
    char* p[4];//指针数组：p是一个数组，数组里面类型为指针类型。
    string str="1234";
    puts("str=1234\n--------------------\np[i]=&str[i];");
    for (int i = 0; i < 4; i ++ )
    {
        p[i]=&str[i];
    }
    for (int i = 0; i < 4; i ++ )
    {
        cout << *p[i];
    }
    puts("\n--------------------\n*p[i]=(*p[i] + 4);");
    for (int i = 0; i < 4; i ++ )
    {
        *p[i]=(*p[i] + 4);
    }
    for (int i = 0; i < 4; i ++ )
    {
        cout << *p[i];
    }
    puts("\n--------------------\nstr=???");
    cout << str;

    return 0;
}

运行结果：

解释：
(注意一个事情：此时的str的size是5sizeof(char) 但为什么我只申请char p[4]呢？ 因为我们只需要改变"1234" 这四个字符，而不需要改变str[5]==’\0’结束字符)
我们先定义一个string类型的字符串，并赋值为str=“1234”；
再定义一个char* p[4] 的指针数组。
并将指针数组中每一个元素依次被str的每一个元素的地址赋值。(初始化：p[i]=&str[i]😉
测试一下赋值后的结果果然*p[i] 输出的是”1234”；(cout << p[i]😉
再试试更改p[i]（ *p[i]=(p[i] + 4); 此处更改为1234–>5678）
依次输出p[i] 和 str 结果都为“5678”。

数组指针

故名思意，本质是个指针，指向的是一个数组，和intp ,charp 一样，只是指针指向的类型是数组，而不是整数或者字符。

char (*p)[4];

*先与p结合，使p成为一个指针，这个指针指向了一个具有4个char型数据的数组。故p中存放了这个char型数组的首地址

代码详解

#include<iostream>
using namespace std;

int main(){
    char(*p)[5];//数组指针：p是一个指针，指向一个数组。
    char str[]="1234";
    puts("str=1234\n--------------------\np=&str;");
    p=&str;
    cout<<*p<<endl;
    puts("--------------------\n*(*p)[i]=((*p)[i] + 4);");
    for (int i = 0; i < 4; i ++ )
    {
        (*p)[i]=((*p)[i] + 4);
    }
    cout << *p;
    puts("\n--------------------\nstr=???");
    cout << str;
    return 0;
}

运行结果：

解释：
(注意一个事情：此时的str的size是5*sizeof(char) 但为什么我需要申请char(*p) [5]呢？ 因为我们他需要大小一一对应才能赋值的，不然会非法)
我们先定义一个大小为5的字符数组，并赋值为str=“1234”；
再定义一个char(p)[5] 的数组指针。
并将数组指针p指向str这个。(初始化： p=&str;)
测试一下赋值后的结果果然p[i] 输出的是”1234”；(cout << *p;)
再试试更改(*p)[I]（ (*p)[i]=((p)[i] + 4); 此处更改为1234–>5678）
依次输出p 和 str 结果都为“5678”。

指针函数

故名思意，本质是个函数，返回值是一个指针，和int f(),char f() 一样，只是函数的返回值是指针，而不是整数或者字符。

char* f();

()的优先级高于*，故f先与()结合，成为函数f()，函数的返回值是char *类型的，故返回值是一个指针。

代码详解

#include<iostream>
using namespace std;
char c='1';
char* f()
{
    char *p=&c;
    return p;
}
int main(){
    puts("*p=f()");
    char *p=f();
    cout<<"c="<<c<<"  p="<<*p<<endl;
    puts("----------------\n*p='2';");
    *p='2';
    cout<<"c="<<c<<"  p="<<*p<<endl;
    puts("----------------\nc='3';");
    c='3';
    cout<<"c="<<c<<"  p="<<*p<<endl;
    puts("----------------");
    return 0;
}

运行结果：

解释：
我们先定义一个字符，并赋值为c=‘1’；
再定义一个char* f() 的指针函数。
用一个字符指针p接收函数指针。(初始化 : char p=f()😉
测试一下赋值后的结果果然p 输出的是’1’;(cout << *p;)
再证明一下p和&d是否指向同一个地址。
*p=‘2’;
c=‘3’;
输出结果依次为
c=2 p=2
c=3 p=3

函数指针

故名思意，本质是个指针，它指向的是一个函数，和int *p,char *p 一样，只是指针指向的是函数，而不是整数或者字符。

void (*f)();

void (*f)();为函数指针，*与f结合成为一个指针，这个指针指向函数的入口地址。函数名就是函数的首地址。函数指针是指向函数的指针变量。 因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是一致的。函数指针有两个用途：调用函数和做函数的参数。

代码详解

#include<iostream>
using namespace std;

void f1()
{
    cout<<"调用f1()";
}
void f2()
{
    cout<<"调用f2()";
}
int main(){
    void (*f)();
    cout<<"f=f1\n";
    f=f1;
    f();
    cout<<"\n-------------\nf=f1\n";
    f=f2;
    f();
    return 0;
}

运行结果：

解释：
现在有两个函数f1,f2
再定义一个void (*f)() 的函数指针。
先将f指向f1。(初始化 : f=f1)
测试一下赋值后的结果，调用f1成功(f()😉
再将f指向f2。(f=f2)
测试一下赋值后的结果，调用f2成功(f()😉