【C++】右左法则，指针、函数与数组

右左法则——判断复杂的声明

对于一个复杂的声明，可以用右左法则判断它是个什么东西：

1.先找到变量名称

2.从变量名往右看一个部分，再看变量名左边的一个部分

3.有小括号先看小括号里面的，一层一层往外看

4.先看到的东西优先级大，放在名称的右边

例：

int (*p)[4]——p是一个指针，指向一个可包含4个变量的数组，这四个变量是int类型——数组指针

int(*p[4])(int,int)——p是一个可包含4个变量的数组，数组里面的变量是指针，指针指向参数列表为(int,int)的函数，函数返回int类型的值——函数指针数组

int (*fn(int n))(int,int)——fn是一个参数列表为(int n)的函数，返回值为指针，指针指向参数列表为(int,int)的函数，这个函数的返回值为int类型——函数指针函数

---

指针变量

指针变量有以下分类：单指针，双指针，指针数组，数组指针，指针函数，函数指针

单指针 int *p;

单指针可以和变量、一位数组、二维数组、函数联系

变量取地址改值：p = &a； *p=a；

数组名等于数组首地址： p = b； p=&b[0] ；操作： b[i]== *(b+i)== *(p+i) ==p[i]== *p++

二维数组的数组名不是单指针p = c[0]； p = &c[0][0]； 取值： c[i][j]== *(*(c+i)+j) == *(p+i*4+j) 把二维数组拉成一维数组存；*p++

数组指针 int(*p)[4]

指向数组的指针

一般与二维数组联系 :c是一个数组，p是数组指针p=c; 有c[i][j]==*(*(c+i)+j)==*(*(p+i)+j)==p[i][j]

二维数组的数组名是一个行指针，数组名+1要加一行的字节数：

如int c[3][4],c+1加了16个字节，c+1==c[1][0];

c[0]是一个单指针,+1是加一个单位的字节数：c[0]+1==c[0][1]

指针数组 int *q[3]

存储指针的数组

q是个数组名，不能被赋值，只能q[0]=&a,q[1] = &b;……

使用定个数不定长度的字符串：char* name[3]={“张三”,"李四"，“高启强”};

双指针 int **qq

指针数组的数组名可以当作双指针用:int **qq;int *q[3];qq = q;

int main()
{
    int a = 3, b = 4, c = 6;
    int* q[3] = { &a,&b,&c };
    int** qq = q;
    for (int i = 0; i < 3; i++)
        cout << *q[i] << "--" << **(q + i) << endl;//3--3  4--4  5--5
    for (qq = q; qq < q + 3; qq++)
        cout << **qq << endl;//3 4 5
    return 0;
}

双指针指向单指针：int **qq;int *qm;qq = &qm;

指针函数 char * fn(int n)

返回值为指针的函数

不要返回指向栈内存的指针,在函数内使用的栈空间最终会随着函数结束而释放；

函数返回指针的方法1.可以申请动态内存空间，在堆区中；2.使用static，在静态区中3.从外部传入指针，形参用二级指针接收。

//错误使用方法
char* GetMemory()
{
    char p[100];
    return p;
}
//正确方法
char* GetMemory1()//堆
{
    char* p = new char[100];
    return p;
}
char* GetMemory2()//静态
{
    static char p[100];
    return p;
}
void GetMemory3(char** p, int n)//传参
{
    *p = new char[n];
}
void main()
{
    //   char* p = GetMemory1();
    //  char* p = GetMemory2();
   //    char* p = GetMemory3();
    char* p = NULL;
    GetMemory4(&p, 100);
    strcpy_s(p, 6, "12345");
    puts(p);
    delete[]p;
    p = NULL;
}

函数指针 int(*pfn)(int n)

指向函数的指针

函数名代表函数的入口地址，定义函数指针需要知道函数的基类型。可以直接指向一个同基类的函数

int Max(int a, int b)
{
    return a > b ? a : b;
}
int main()
{
    int (*p)(int,int);//函数指针
    p = MAX;//MAX函数的基类型和p一样
//下面两行的作用一样
    int m = MAX(3,5);
    int n = p(3,5);
}

函数指针的用法：

1.函数转移表

多种同类函数集合在一起方便使用函数指针数组

int Max(int a, int b)
{
    return a > b ? a : b;
}
int Min(int a, int b)
{
    return a < b ? a : b;
}
int Add(int a, int b)
{
    return a + b;
}
int Sub(int a, int b)
{
    return a - b;
}
int Mul(int a, int b)
{
    return a * b;
}
int Div(int a, int b)
{
    if (b != 0)
        return a / b;
}
int main()
{
    int (*p[])(int, int) = { Max,Min,Add,Sub,Mul,Div }; //函数指针数组
    int n = sizeof(p) / sizeof(p[0]);
    for (int i = 0; i < n; i++)//方便4，7各种计算
        cout << p[i](4, 7) << endl;
}

2.作为另一个函数的参数

如下test函数有三个形参：函数指针p，整形a，整形b

void test(int (*p)(int, int), int a, int b) //p = Max
{
    cout << "test:" << p(a, b) << endl;
}
int main()
{
   test(MAX, 9, 0);//函数名是函数首地址，可以直接传入
}

3.作为函数指针函数的返回值

int Add(int a, int b)//2,3
{
    return a + b;
}
int (*fn(int n))(int, int) //fn函数的返回值是个函数指针，指向int (int,int)的函数
{
     cout << "fn : n = "<< n << endl;//fu:n = 20
    return Add;
}
int main()
{
        cout << fn(20)(2, 3) << endl;//5

    // 相当于：int (*q)(int, int) = fn(20); q指向fn的返回值Add
     //cout << q(2, 3) << endl;使用Add(2,3)
}