C++指针总结（不包括智能指针）
一、指针的类型
1.int* p;
类似于这种形式的指针，可指向一个对应类型的变量，比如
int *p; int a; p=&a;
可以让指针p指向整型变量a，int型的指针变量p里面放的是int型变量a的地址。
2.int* p[3];
表示p是一个数组，数组里面有3个元素，每一个元素都是一个可指向int型的指针变量
#include<iostream>
using namespace std;
int main()
{
int* p[3];
int a = 10;
int b = 20;
int c = 30;
p[0] = &a;
p[1] = &b;
p[2] = &c;
cout << *p[0] << endl;
cout << *p[1] << endl;
cout << *p[2] << endl;
return 0;
}
最后输出为：
10
20
30
3.int (*p)[3];
这表示指针p可指向一个类型为int，大小为3的数组
#include<iostream>
using namespace std;
int main()
{
int(*p)[3];
int a[3] = { 1,2,3 };
p = &a;
cout << (*p)[0] << endl;
cout << (*p)[1] << endl;
cout << (*p)[2] << endl;
return 0;
}
p=&a,代表用数组a的地址给指针p赋值，至于为什么用&a，而不是a，为什么用(*p)[0]这种形式来取得数组元素，我们在后面的“数组名退化成指针”里面讨论。
这里程序会输出:
1
2
3
4.const int *p、int const *p以及其他const用以修饰参数类型的情况;
const关键字会优先和左边的关键字或者运算符结合，所以这两种写法都可以可以使指针p能够指向一个常量，或者一个变量；这样的指针有一个名字叫常量指针，但我更喜欢叫它指向常量的指针
const int *p; const int a = 10; int b = 20;
对于一般的指针，比如int *p1来说，就不能让他指向a这个常量，如果指向，他就会报错，所以常量指针的指向范围比一般的指针要宽一些
5.int* const p以及其他const用来修饰*的情况;
根据const关键字先和左边的关键字或者运算符结合的特性，这里的const是用来修饰*的，所以这里的指针本身是一个常量，并且具有常量的性质。实际上，这里的p被叫做指针常量，意为类型为指针的常量，既然是常量，那值就不能改变，所以，在我们定义这个指针的时候，一定要给他赋值，否则编译器就会报错。
并且，在没有const运算符修饰int的情况下，他只能指向一个非常量，并且一旦指向一个变量，就不能再指向另一份变量，因为这个指针本身具有常量的性质，即值不能改变；
改变指针指向对象时会报错：
指向一个常量时也会报错：
6.int* func();
这个没什么好说的，有个名字叫指针函数，意为返回值是指针的函数，该例子返回一个int型指针
7.double (*func)(int a,int b)；
他也有个名字叫函数指针，意为指向函数的指针，比如该例子中的这个函数指针，它可以指向一个接收两个int型参数，并且返回一个double类型值的函数，也就是说，它所指向的函数，除了函数名以外（在该例子中也就是(*func)）其他都要和它相同，当然，它是一个指针，没有函数体，自然不要求函数体相同；
#include<iostream>
using namespace std;
double(*fun)(int a, int b);
double sum(int x, int y)
{
return x + y;//int自动向上转换为double
}
int main()
{
fun = sum;
int a = 10;
int b = 20;
double c = fun(a, b);
cout << c << endl;
return 0;
}
这里输出30
二、指针的大小
指针是存储地址的工具，所以他的大小应该和寻址的范围有关，32位计算机的地址需要32位二进制数才能完全表示，所以在32位操作系统下，指针的大小为4字节(32位2进制的大小)，同理，64位操作系统下，指针的大小为8字节。
三、数组名退化成指针
数组名只有在3种情况下，才代表数组本身：
1.对数组名使用sizeof关键字的时候
#include<iostream>
using namespace std;
int main()
{
int a[] = { 1,2,3,4,5 };
cout << sizeof(a) << endl;
return 0;
}
这段代码输出20，代表数组的大小为20字节
2.对数组名取地址的时候
#include<iostream>
using namespace std;
struct Te
{
int a[5] = { 1,2,3,4,5 };
int b = 10;
}te;
int main()
{
int(*p)[5] = &te.a;
int *p2 = te.a;
++p;
++p2;
cout << (*p)[0] << endl;
cout << *p2 << endl;
return 0;
}
这段代码输出：
10
2
因为指针p的类型是int*[5]，所以让他自增1的话，他就会越过整个数组（4*5=20字节），指向数组最后一个元素的后一位，在这里p就指向了b的地址；
而我们使用括号将*和p括起来的原因是[]运算符的优先级在*之上，如果不使用括号，这里的p就会先和[]结合进行运算，然后再用运算的结果来和*进行运算（当然对于(*p)[0]加不加括号并不会对结果造成影响，毕竟p[0]代表在p的地址上加上0个该类型指针的大小，比如p[1]，就代表在p的基础上加上20个字节，详见下文，指针的运算）；
而p2是一个普通的int类型的指针，所以他自增后，越过的地址只有一个int型变量的大小，即4字节。
3.给整个数组初始化的时候
int a[]={1,2,3,4,5};
char c[]={'1','2','3','4','5','\0'};
在其他情况下，数组名均会退化成普通指针，不在具有数组名的性质。
四、指针的运算
两个指针相加没有什么意义，但是两个指针相减通常可以用来表示他们之间在内存上的距离
指针自增，代表地址加上指针所指类型的大小，对指针使用[]运算符，代表在当前指针所指的地址上加上指针所指类型的大小*[]里的数字，来看个例子：
#include<iostream>
using namespace std;
int main()
{
char c[][3] = { {'a','b','c'},{'d','e','f'},{'g','h','i'},{'j','k','l'} };
char(*pc1)[3] = &c[0];
cout << (*pc1)[0] << endl;
cout << (*pc1)[1] << endl;
cout << (*pc1)[2] << endl;
++pc1;
cout << (*pc1)[0] << endl;
cout << (*pc1)[1] << endl;
cout << (*pc1)[2] << endl;
cout << "-----------------------------------------------" << endl;
cout << pc1[0][0] << endl;
cout << pc1[1][0] << endl;
cout << pc1[2][0] << endl;
int *pi = (int*)&c[0][0];
cout << (char)*pi << endl;
++pi;
cout << (char)*pi << endl;
return 0;
}
这一段代码的输出如下：
首先我们用pc1指针指向了c数组的第一个一维数组，然后我们先对pc1进行解引用操作，得到c[0]，这时的c[0]不满足保持数组名的三种情况之一，退化成一个普通的char型指针，指向c数组的第一维数组的第一个元素，也就是'a'，所以，我们对它分别进行[0],[1],[2]操作后，分别代表，目前地址加0字节、1字节、2字节(1个char型变量占一字节)，所以前三条输出语句输出a,b,c；
之后我们让pc1自增1，所谓的自增1，其实也就是让pc1加上一个单位的自己所指类型的大小，pc1的类型是char*[3]，大小为3个字节，于是pc1自增1，其实就是在原有的基础上加上3个字节；
所以我们可以看到，后面再执行同样的三条语句时，输出的是def，而不是bcd；
再然后，我们尝试对pc1进行[]操作，pc1的类型是char*[3]，我们进行[0],[1],[2]操作时，等同于在pc1原有值的基础上加上0*3字节，1*3字节，2*3字节，然后，分别找到了c[1],c[2],c[3]，他们代表c数组里面第2、3、 4个一维数组的首地址，也可以看做是指向第2、3、 4个一维数组的首地址的类型为char的指针，所以我们最后的结果是dgj，分别是第2、3、 4个一维数组的首元素；
我们之后再用一个int*类型的指针pi指向数组c的首地址，即c[0][0]的地址，然后再让pi自增，根据前面的规则，pi的地址要加上一个int型变量的大小，也就是4字节，所以本来指向c[0][0]的指针现在指向了c数组的第5个元素，即c[1][1]，即字母'e'。
暂时完结