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

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

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--5for (qq = q; qq < q + 3; qq++)cout << **qq << endl;//3 4 5return 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 = 20return 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)
}