！！！！一文看懂指针、地址、引用

• 内存地址
• • 首地址
• 指针的定义：
• • 1、指针变量
  • 2、 数组指针
  • 3、 指针数组
  • 4、函数指针
  • 5、指针函数
  • 6、特殊指针
  • • ①空指针
    • ②Void类型指针
    • ③nullptr指针
    • ④结构体指针(类指针)
    • ⑤this指针
• 引用

内存地址

地址相当于是门牌号，每家都有一个门牌号，类似每一个分配的内存空间都有独一无二的地址，
在c++中为8字节的16个16进制的数(可以表示2的64次方个内存地址)：
例如：000000604CAFF9E4

首地址

如果计算机分配的一块内存是连续的，那么第一个元素的内存空间地址就称为首地址，

如数组、函数体，的存储方式为连续存储
例如：数组首地址加上一段地址的变化就能得到相应元素的地址，进而取得数组任意元素的值；
所以我们可以直接用首地址+地址增量来表示这一段内存的全部地址

例如：一栋楼一共有100户，我家在一单元一楼，门牌号为0x01001(假设从一开始)；
你家在6楼，咱们中间一共有4个楼层(0x01002,0x01003,0x01004,0x01005)，
那么你家的门牌号就为0x01006,依次类推第100楼的门牌号就为0x01100；
通过我家的门牌号跟楼层数就能得到所有楼层的门牌号；

指针的定义：

指针(Pointer)是编程语言中的一个对象，利用地址，它的值直接指向（Pointed to）存在电脑存储器中另一个地方的值。

简单的说：指针是一个变量,且这个变量是专门用来存放地址的。

举个栗子：你想给你朋友打电话，你朋友的电话号为12345678，(你记不住)你拿一个小本本记下来，这个小本本就是指针变量，里面记的东西就是电话号，也就是地址，以后你想找你朋友都可以通过小本本里的电话号联系到。

1、指针变量

普通用法
既然叫做变量里面存储的肯定是常量，这个常量就是-----地址；
指针变量的定义形式为：

int * p ;//表示声明了一个能指向int类型内存空间的指针

其中p为一个指针变量，里面可以存int类型普通变量的地址；

int a = 10;//定义一个int类型的变量，变量的值为10;

a为一个普通变量，值为10;

p = &a;//表示p存了变量a的地址，这时候的p指向的就是a的内存空间；

如果这时候输出p，输出的为a的16进制地址；
输出结果为：000000A39A6FF9F4

这时候想要取a的值就有两种情况：
第一种：直接输出变量；

cout << a << endl;

第二种：通过指针取值；

cout << *p << endl;

其中*号在此时作为取值符；

特殊用法
用指针定义数组：

int *d;

这是一个指针变量，里面可以存int类型普通变量的地址，也可以存int类型数组的首地址；
当指针变量中存的值为一块存放变量类型为int的连续内存的首地址时，指针变量可以当作数组；
类似为：

	int *d;
	int b[10];//假设分配10个内存空间
	d = b;

这时候d与b用法类似。
当不知道需要创建多大的数组的时候就可以使用指针来动态创建

int *Arr = (int*)malloc(sizeof(int));//int类型的动态数组

直观一点，直接上代码：

#include <iostream>
using namespace std;

void main()
{
	int *c;
	int a = 10;
	char m = 'a';
	char* p;
	p = &m;
	c = &a;

	int *d;
	int b[10];
	b[0] = 11;
	b[1] = 12;
	d = b;

	int *Arr = (int*)malloc(sizeof(int));//动态数组
	Arr[0] = 30;
	Arr[1] = 31;

	//由于<<操作符重载，遇到字符型指针默认当作字符串,所以需要强制转换
	cout << "p:	" << static_cast<void *>(p) << endl;//输出16进制地址(m的地址)

	cout << "c:	" << c << endl;//输出16进制地址(a的地址)

	cout << "*c:	" << *c << endl;//输出a的值：10

	cout << "a:	" << a << endl;//输出a的值：10

	cout << "b[0]:	" << b[0] << endl;//输出b[0]的值：11

	cout << "&b[0]:	" << &b[0] << endl; //输出16进制地址(b[0]的地址)

	cout << "d:	" << d << endl;//输出16进制地址(b[0]的地址)

	cout << "d[1]:	" << d[1] << endl;//输出b[1]的值：12

	cout << "Arr:	" << Arr << endl;//输出Arr[0]的地址

	cout << "Arr[1]:	" << Arr[1] << endl;//输出Arr[1]的值：31
}

输出结果为：

总结：
1、指针变量是一种变量(有内存也有地址)，里面存的是地址。
2、地址指向的是空间，所以指针指向内存空间。(所以经常说某个指针指向某一块内存)
3、指针变量存的地址可以是连续内存里的首地址(可以用作数组)

2、 数组指针

这是一个文字理解，实际上可以理解为数组的指针(是指针，指向数组第一个元素的内存空间)：
定义为：

int (*p)[10];

其中括号()的优先级最高，所以说这里的整个*p为一个指针变量的定义，p为指针，指向的是一个数组(匿名数组)，数组里面存的是int类型的元素；（规定了数组的大小）

这里解释一下，上面定义的10个数组每个数组相当于一个指针。
（也就是说每个数组元素就是一个数组样子的指针）；
第一个指针为p[0]，第二个为p[1]。。。。，所以说元素p[0]实际上是一个地址，*p[0]就相当于是取p[0]存的地址的值(首地址)，也就是取p[0][0]的元素。

总结：数组指针是数组样子的指针；
（下面上代码）
例子：

#include <iostream>
using namespace std;

void main()
{
	int arr[10];
	arr[0] = 10;
	arr[1] = 11;
	arr[2] = 12;


	int(*p)[10] = &arr;//赋值的是地址，所以是指针
	p[0][0] = 0;
	p[0][1] = 1;
	p[0][2] = 2;
//数组指针
	cout << "p[0][0]:" << p[0][0] << endl;
	//输出为0;输出第一个指针p[0]指向连续存储空间的的第一个元素
	cout << "p[0][1]:" << p[0][1] << endl;
	//输出为1;输出第一个指针p[0]指向连续存储空间的的第二个元素
	cout << "p[0][2]:" << p[0][2] << endl;
	//输出为2;输出第一个指针p[0]指向连续存储空间的的第三个元素

	cout << "p[0]:" << p[0] << endl;//输出为第一个指针中存的地址，也就是arr的地址

	cout << "p[1]:" << p[1] << endl;//输出为第二个指针中存的地址，未赋值，

	cout << "p[2]:" << p[2] << endl;//输出为第三个指针中存的地址，未赋值

	cout << "p[3]:" << p[3] << endl;//输出为第四个指针中存的地址，未赋值

	cout << "*p[0]:" << *p[0] << endl;
	//输出为输出为0;第一个指针p[0]指向连续存储空间的的第一个元素
	cout << "*p[1]:" << *p[1] << endl;
	//输出为输出为（-）无穷;第二个指针p[1]指向连续存储空间的的第一个元素
	cout << "arr[0]:" << arr[0] << endl;
	//输出arr[0]的值
	cout << "&arr[0]:" << &arr[0] << endl;
	//输出arr[0]的地址，也就是arr的地址
	cout << "arr[1]:" << arr[1] << endl;
	//输出arr[1]的值
	cout << "&arr[1]:" << &arr[1] << endl;
	//输出arr[1]的地址
	
}

3、 指针数组

理解为指针的数组(是数组，里面存的是指针,跟二级指针类似)：
定义为

int *p[10];

其中[]的优先级最高，表示它是一个数组。首先申请了一个空间为【10】的数组，然后数组里面存的是指向int类型的指针，p指向的是这个指针数组首地址的内存空间；
二级指针的定义：

int **p;

与二级指针的区别在于预先定义的指针数组的一维大小；

解释一下，p为数组的名字，申请了10个空间，每个空间里面存的是int *（指向存放int类型空间的指针），所以说p[0]里面存的是指针，与上面数组指针不同的是，数组指针是申请的空间本身就是指针(只不过名字看起来像数组)，这里申请的是数组，但是里面存的是指针。

总结：指针数组实际上就是内存空间里面存的是指针的数组；

#include <iostream>
using namespace std;

void main()
{
	int arr[10];
	arr[0] = 10;
	arr[1] = 11;
	arr[2] = 12;


	int*p[10] = {arr};
	//首先赋值方式不一样就能体现是指针还是数组，这是数组的一般赋值方式；
	p[0][0] = 0;
	p[0][1] = 1;
	p[0][2] = 2;

//指针数组
	cout << "p[0]:" << p[0] << endl;//指针的值(也就是arr的首地址)，输出为16位16进制的地址
	cout << "p[1]:" << p[1] << endl;//输出为16位16进制的0;
	cout << "&p[0]:" << &p[0] << endl;//输出为p[0]这个存储空间的地址
	cout << "&p[1]:" << &p[1] << endl;//输出为p[1]这个存储空间的地址
	
	cout << "*p[0]:" << *p[0] << endl;
	//输出为p[1]这个存储空间存的值指向空间的值(有点yao口)
	//p[0]是指针的值，里面最终存的是地址
	//这么一来跟指针变量的用法一样，*号可以取相应地址的值
	
	cout << "p[0][0]:" << p[0][0] << endl;
	//输出arr[0]的值
	cout << "p[0][1]:" << p[0][1] << endl;
	//输出arr[1]的值
	cout << "&p[0][0]:" << &p[0][0] << endl;
	//实际上就是arr[0]的地址也就是arr首地址
	cout << "&p[0][1]:" << &p[0][1] << endl;
	//实际上就是arr[1]的地址
 	cout << "arr[0]:" << arr[0] << endl;
 	//输出arr[0]的值
 	cout << "&arr[0]:" << &arr[0] << endl;
 	//输出arr[0]的地址，也就是arr的地址
 	cout << "arr[1]:" << arr[1] << endl;
 	//输出arr[1]的值
 	cout << "&arr[1]:" << &arr[1] << endl;
 	//输出arr[1]的地址
}

4、函数指针

函数指针是一个指针，因为函数跟数组一样是一个连续的存储空间，所以函数指针可以指向函数的首地址从而调用；
函数指针定义为：

int (*fun)(int x,int y);

表示的是这个fun指针可以指向类型为返回值为int类型，参数为int x,int y的函数的那一段内存空间

例如两个函数声明为：

int func(int x, int y);
int fun0000(int x);

定义为：

int func(int x, int y)
{

	return 0;
}
int fun0000(int x)
{
	
	return 0;
}

函数指针的定义为：

int(*fun)(int x, int y);

调用类型为：

fun = &func;

如果类型不一样则：

5、指针函数

指针函数实际上就是函数，只不过返回值为指针；
看看下面这个函数声明：

int func();

这只是一个没有参数的，返回值为int类型数据的普通函数；
再看看指针函数的定义：

int* func();

仅仅多了一个*号，其返回值是一个 int 类型的指针，是一个地址值。
实际上指针函数和普通函数对比不过就是其返回了一个指针（即地址值）而已。

6、特殊指针

①空指针

定义为：

// Define   NULL   pointer   value 
#ifndef   NULL 
#   ifdef   __cplusplus 
#     define   NULL      0 
#   else 
#     define   NULL      ((void   *)0) 
#   endif 
#endif //   NULL 

short *pa=NULL;//pa保存0地址，pa保存空指针

short *pa = 0;

它指示指针实际上并不涉及任何有效的内存地址。
该特殊值称为空指针（null pointer），并在内部表示为值0，NULL 是一个标准规定的宏定义，用来表示空指针常量。

②Void类型指针

无类型指针，这个就厉害了，在定义上是无类型指针，但是实际上用起来却包罗万象；
通过强制类型转换可以变为所有类型的指针；
例如可以将上文函数指针赋值给它：

int function(int x, int y)
{

	return 0;
}

	int(*fun)(int x, int y);

	fun = &function;
	void * p_void;
	p_void = fun;

可以将函数地址赋值给它：

	int(*fun)(int x, int y);

	fun = &func;
	void * p_void;
	p_void = &function;

甚至可以将函数指针的地址赋值给它：

	int(*fun)(int x, int y);

	fun = &func;
	void * p_void;
	p_void = &fun;

这就是无中生有，道法自然 😊😊😊😊😊

③nullptr指针

C语言：NULL
C++03前：0
C++11：nullptr

nullptr是C++11 新标准引入的方法，在之前使用的是NULL，NULL是一个预处理变量，它的值为0。

int *p1 = nullptr; // 等价于int *p1 = 0
int *p2 = 0;         // 直接将p2初始化为字面常量0
int *p3 = NULL // 等价于int *p3 = 0

④结构体指针(类指针)

结构体(类)类型的指针，也就是指向的是结构体(类)类型的空间的指针。
例如：

class Point
{
int x;
int y 
};
struct Student
{
char* name;
char* sex;
int number;
int age;
};

定义结构体指针为：

Point *pt;
Student *stu;

使用为：

pt->x = 100;
pt->y = 100;
stu->name = "卡尔曼确实慢";
stu->sex  = "未知";
stu->number  = 1;
stu->age  = 23;

⑤this指针

成员函数中都包含一个特殊的指针，这个指针的名字是固定的——this。它是当前类对象的指针。
1)对象o.成员函数x(…){…},则函数体中的this表示“&o”；
2)对象指针p.成员函数x(…){…},则函数体中的this表示“p”；
3)对象引用r.成员函数x(…){…},则函数体中的this表示“&r”;

引用

一句话，引用相当于是别名，指的是同一个东西。
引用常用于函数中的参数传递。

例子

	int a = 1;
	int b = 1;
	int &x = a;
	x = 20;

	cout << a << endl;

结果为20；

与取地址容易混淆的地方：
等号左边或者无等号用&就是引用，
等号右边用&就是取地址。