1.指针的基本概念
1）变量的地址
变量是内存变量的简称，在C++中，每定义一个变量，系统就会给变量分配一块内存，内存是有地址的。
C++用运算符&获取变量在内存中的起始地址。
语法：&变量名
2）指针变量
指针变量简称指针，它是一种特殊的变量，专用于存放变量在内存中的起始地址。
语法：数据类型 *变量名;
数据类型必须是合法的C++数据类型（int、char、double或其它自定义的数据类型）。
星号*与乘法中使用的星号是相同的，但是，在这个场景中，星号用于表示这个变量是指针。
3）对指针赋值
不管是整型、浮点型、字符型，还是其它的数据类型的变量，它的地址都是一个十六进制数。我们用整型指针存放整数型变量的地址；用字符型指针存放字符型变量的地址；用浮点型指针存放浮点型变量的地址，用自定义数据类型指针存放自定义数据类型变量的地址。
语法：指针=&变量名;
注意
● 对指针的赋值操作也通俗的被称为“指向某变量”，被指向的变量的数据类型称为“基类型”。
●如果指针的数据类型与基类型不符，编译会出现警告。但是，可以强制转换它们的类型。
4）指针占用的内存
指针也是变量，是变量就要占用内存空间。
在64位的操作系统中，不管是什么类型的指针，占用的内存都是8字节。
在C++中，指针是复合数据类型，复合数据类型是指基于其它类型而定义的数据类型，在程序中，int是整型类型，int*是整型指针类型，int*可以用于声明变量，可以用于sizeof运算符，可以用于数据类型的强制转换，总的来说，把int*当成一种数据类型就是了。
2.使用指针
声明指针变量后，在没有赋值之前，里面是乱七八糟的值，这时候不能使用指针。
指针存放变量的地址，因此，指针名表示的是地址（就像变量名可以表示变量的值一样）
*运算符被称为间接值或解除引用（解引用）运算符，将它用于指针，可以得到该地址的内存中存储的值，*也是乘法符号，C++根据上下文来确定所指的是乘法还是解引用。
变量和指向变量的指针就像同一枚硬币的两面。
哪个银行？ 什么东西？ 数额
程序在存储数据的时候，必须跟踪三种基本属性：
●数据存储在哪里；
●数据是什么类型；
●数据的值是多少。
用两种策略可以达到以上目的：
声明一个普通变量，声明时指出数据类型和变量名（符号名），系统在内部跟踪该内存单元。
声明一个指针变量，存储的值是地址，而不是值本身，程序直接访问该内存单元。
3.指针用于函数的参数
如果把函数的形参声明为指针，调用的时候把实参的地址传进去，形参中存放的是实参的地址，在函数中通过解引用的方法直接操作内存中的数据，可以修改实数的值，这种方法被通俗的称为地址传递或传地址。
值传递：函数的形参是普通变量。
传地址的意义如下：
●可以在函数中修改实参的值。
● 减少内存拷贝，提升性能。
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
// 调用函数的时候，调用者把数值赋给了函数的参数。
// 实参：调用者程序中书写的在函数名括号中的参数。
// 形参：函数的参数列表。
void func(int *no, string *str) // 向超女表白的函数。
{
cout << "亲爱的" << *no << "号：" << *str << endl;
*no = 8;
*str = "我有一只小小鸟。";
}
// 写一个函数，从3名超女的身高数据中，选出最高的和最矮的。
void func1(int a, int b, int c, int* max, int* min)
{
*max = a > b ? a : b; // 取a和b中的大者。
*min = a < b ? a : b; // 取a和b中的小者。
*max = *max > c ? *max : c; // 取*max和c中的大者。
*min = *min < c ? *min : c; // 取*min和c中的大者。
}
int main()
{
int bh = 3; // 超女的编号。
string message = "我是一只傻傻鸟。"; // 向超女表白的内容。
func(&bh, &message); // 调用向超女表白的函数。
/*{
int *no = &bh;
string *str = &message;
cout << "亲爱的" << *no << "号：" << *str << endl;
*no = 8;
*str = "我有一只小小鸟。";
}*/
cout << "亲爱的" << bh << "号：" << message << endl;
// 从3名超女的身高数据中，选出最高的和最矮的。
int a = 180, b = 170, c = 175, m, n;
func1(a, b, c, &m, &n);
cout << "m=" << m << ",n=" << n << endl;
}
4.用const修饰指针
1）常量指针
语法：const 数据类型 *变量名;
不能通过解引用的方法修改内存地址中的值（用原始的变量名是可以修改的）。
注意：
●指向的变量（对象）可以改变（之前是指向变量a的，后来可以改为指向变量b）。
●一般用于修饰函数的形参，表示不希望在函数里修改内存地址中的值。
●如果用于形参，虽然指向的对象可以改变，但这么做没有任何意义。
●如果形参的值不需要改变，建议加上const修饰，程序可读性更好。
2）指针常量
语法：数据类型 * const 变量名;
指向的变量（对象）不可改变。
注意：
●在定义的同时必须初始化，否则没有意义。
●可以通过解引用的方法修改内存地址中的值。
●C++编译器把指针常量做了一些特别的处理，改头换面之后，有一个新的名字，叫引用。
3）常指针常量
语法：const 数据类型 * const 变量名;
指向的变量（对象）不可改变，不能通过解引用的方法修改内存地址中的值。
常引用。
常量指针：指针指向可以改，指针指向的值不可以更改。
指针常量：指针指向不可以改，指针指向的值可以更改。
常指针常量：指针指向不可以改，指针指向的值不可以更改。
记忆秘诀：*表示指针，指针在前先读指针；指针在前指针就不允许改变。
常量指针：const 数据类型 *变量名
指针常量：数据类型 * const 变量名
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
void func(const int *no, const string *str) // 向超女表白的函数。
{
// *no = 8;
// *str = "我有一只小小鸟。";
cout << "亲爱的" << *no << "号：" << *str << endl;
}
int main()
{
int a = 3, b = 8;
// 常量指针的语法：const 数据类型* 变量名;
// 不能通过解引用的方法修改内存地址中的值（用原始的变量名是可以修改的）。
/*
const int* p = &a;
a = 13;
cout << "a=" << a << ",*p=" << *p << endl;
p = &b;
cout << "b=" << b << ",*p=" << *p << endl;
*/
// 指针常量语法：数据类型* const 变量名;
// 指向的变量（对象）不可改变；在定义的同时必须初始化；可以通过解引用的方法修改内存地址中的值。
int* const p=&a;
*p = 13;
cout << "a=" << a << ",*p=" << *p << endl;
//int bh = 3; // 超女的编号。
//string message = "我是一只傻傻鸟。"; // 向超女表白的内容。
//
//func(&bh, &message); // 调用向超女表白的函数。
//cout << "亲爱的" << bh << "号：" << message << endl;
}
5.void关键字
在C++中，void表示为无类型，主要有三个用途：
1）函数的返回值用void，表示函数没有返回值。
void func(int a,int b)
{
// 函数体代码。
return;
}
2）函数的参数填void，表示函数不需要参数（或者让参数列表空着）。
int func(void)
{
// 函数体代码。
return 0;
}
3）的形参用void *，表示接受任意数据类型的指针。**
注意：
●不能用void声明变量，它不能代表一个真实的变量，但是，用void *可以。
●不能对void *指针直接解引用（需要转换成其它类型的指针）。
●把其它类型的指针赋值给void*指针不需要转换。
●把void *指针赋值给把其它类型的指针需要转换。
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
// 只关心地址本身，不关心里面的内容，用void *可以存放任意类型的地址。
// 显示变量的十六进制地址的函数：varname-变量名，p-变量的地址。
void func(string varname, void* p)
{
cout << varname<< "的地址是：" << p << endl;
cout << varname << "的值是：" << *(char *)p << endl;
}
int main()
{
int a=89;
char b='X';
cout << "a的地址是：" << & a << endl;
cout << "b的地址是：" << & b << endl;
func("a", &a);
func("b", & b);
}
6.二级指针
指针是指针变量的简称，也是变量，是变量就有地址。
指针用于存放普通变量的地址。
二级指针用于存放指针变量的地址。
声明二级指针的语法：数据类型** 指针名;
使用指针有两个目的：1）传递地址；2）存放动态分配的内存的地址。
在函数中，如果传递普通变量的地址，形参用指针；传递指针的地址，形参用二级指针。
把普通变量的地址传入函数后可以在函数中修改变量的值；把指针的地址传入函数后可以在函数中修改指针的值。
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
void func(int **pp)
{
*pp = new int(3);
cout << "pp=" << pp << ",*pp=" << *pp << endl;
}
int main()
{
/*int ii = 8; cout << "ii=" << ii << ",ii的地址是：" << &ii << endl;
int* pii = ⅈ cout << "pii=" << pii << ",pii的地址是：" << &pii << ",*pii=" << *pii << endl;
int** ppii = &pii; cout << "ppii=" << ppii << ",ppii的地址是：" << &ppii << ",*ppii=" << *ppii << endl;
cout << "**ppii=" << **ppii << endl;*/
int* p=0;
func(&p);
/*{
int** pp = &p;
*pp = new int(3);
cout << "pp=" << pp << ",*pp=" << *pp << endl;
}*/
cout << "p=" << p << ",*p=" << *p << endl;
}
7.空指针
在C和C++中，用0或NULL都可以表示空指针。
声明指针后，在赋值之前，让它指向空，表示没有指向任何地址。
1）使用空指针的后果
如果对空指针解引用，程序会崩溃。
如果对空指针使用delete运算符，系统将忽略该操作，不会出现异常。所以，内存被释放后，也应该把指针指向空。
在函数中，应该有判断形参是否为空指针的代码，目的是保证程序的健壮性。
为什么空指针访问会出现异常？
NULL指针分配的分区：其范围是从 0x00000000到0x0000FFFF。这段空间是空闲的，对于空闲的空间而言，没有相应的物理存储器与之相对应，所以对这段空间来说，任何读写操作都是会引起异常的。空指针是程序无论在何时都没有物理存储器与之对应的地址。为了保障“无论何时”这个条件，需要人为划分一个空指针的区域，固有上面NULL指针分区。
2）C++11的nullptr
用0和NULL表示空指针会产生歧义，C++11建议用nullptr表示空指针，也就是(void *)0。
NULL在C++中就是0，这是因为在C++中void* 类型是不允许隐式转换成其他类型的，所以之前C++中用0来代表空指针，但是在重载整形的情况下，会出现上述的问题。所以，C++11加入了nullptr，可以保证在任何情况下都代表空指针，而不会出现上述的情况，因此，建议用nullptr替代NULL吧，而NULL就当做0使用。
注意：在Linux平台下，如果使用nullptr，编译需要加-std=c++11参数。
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
void func(int* no, string* str) // 向超女表白的函数。
{
if ((no == 0) || (str == 0)) return;
cout << "亲爱的" << *no << "号：" << *str << endl;
}
int main()
{
// int bh = 3; // 超女的编号。
// string message = "我是一只傻傻鸟。"; // 向超女表白的内容。
int* bh = 0; // new int(3);
string* message = 0; // new string("我是一只傻傻鸟。");
func(bh,message); // 调用向超女表白的函数。
delete bh; delete message;
}
8.野指针
野指针就是指针指向的不是一个有效（合法）的地址。
在程序中，如果访问野指针，可能会造成程序的崩溃。
出现野指针的情况主要有三种：
1）指针在定义的时候，如果没有进行初始化，它的值是不确定的（乱指一气）。
2）如果用指针指向了动态分配的内存，内存被释放后，指针不会置空，但是，指向的地址已失效。
3）指针指向的变量已超越变量的作用域（变量的内存空间已被系统回收），让指针指向了函数的局部变量，或者把函数的局部变量的地址作为返回值赋给了指针。
规避方法：
1）指针在定义的时候，如果没地方指，就初始化为nullptr。
2）动态分配的内存被释放后，将其置为nullptr。
3）函数不要返回局部变量的地址。
注意：野指针的危害比空指针要大很多，在程序中，如果访问野指针，可能会造成程序的崩溃。是可能，不是一定，程序的表现是不稳定，增加了调试程序的难度。
9.函数指针
函数的二进制代码存放在内存四区中的代码段，函数的地址是它在内存中的起始地址。如果把函数的地址作为参数传递给函数，就可以在函数中灵活的调用其它函数。
使用函数指针的三个步骤：
a）声明函数指针；
b）让函数指针指向函数的地址；
c）通过函数指针调用函数。
1）声明函数指针
声明普通指针时，必须提供指针的类型。同样，声明函数指针时，也必须提供函数类型，函数的类型是指返回值和参数列表（函数名和形参名不是）
假设函数的原型是：
int func1(int bh,string str);
int func2(int no,string message);
int func3(int id,string info);
bool func4(int id,string info);
bool func5(int id);
则函数指针的声明是：
int (*pfa)(int,string);
bool (*pfb)(int,string);
bool (*pfc)(int);
pfa、pfb、pfc是函数指针名，必须用括号，否则就成了返回指针的函数。
2）函数指针的赋值
函数名就是函数的地址。
函数指针的赋值：函数指针名=函数名;
3）函数指针的调用
(*函数指针名)(实参);
函数指针名(实参);
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
void func(int no, string str)
{
cout << "亲爱的" << no << "号：" << str << endl;
}
int main()
{
int bh = 3; // 超女的编号。
string message = "我是一只傻傻鸟。"; // 向超女表白的内容。
func(bh, message);
void (*pfunc)(int, string); // 声明表白函数的函数指针。
pfunc = func; // 对函数指针赋值，语法是函数指针名=函数名。
pfunc(bh, message); // 用函数指针名调用函数。 C++
(*pfunc)(bh, message); // 用函数指针名调用函数。 C语言
}
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
void zs(int a) // 张三的个性化表白函数。
{
cout <<"a=" << a << "我要先翻三个跟斗再表白。\n"; // 个性化表白的代码。
}
void ls(int a) // 李四的个性化表白函数。
{
cout << "a=" << a << "我有一只小小鸟。\n"; // 个性化表白的代码。
}
void show(void (*pf)(int),int b)
{
cout << "表白之前的准备工作已完成。\n"; // 表白之前的准备工作。
pf(b); // 用函数指针名调用个性化表白函数。
cout << "表白之后的收尾工作已完成。\n"; // 表白之后的收尾工作。
}
int main()
{
show(zs, 3); // 张三要表白。
show(ls, 4); // 李四要表白。
}
参考资料：
慕课网