指向引用的指针
 
使用指针的一个简单例子就是：
 
int v = 1;
int *p = &v;
 
需要预先强调的是没有指向引用的指针!因为引用不是对象，没有地址。但是指向引用的指针是什么形式呢？
 是对一个引用进行如下取地址吗：
 
int v = 1;
int &ri = v;	// 整型变量v的引用
int *p = &ri;	// 这是指向引用的指针吗？
 
事实上不是，这是一个普通的整型指针，虽然我们说引用没有地址，但是对引用ri的操作实际上是对v的操作。这是是定义了一个整型指针，并且让它指向了v。
 那如何定义一个指向引用的指针呢(虽然是不合理的请求)？当我们定义指针的时候，我们用到了*，那么当我们定义指向引用的指针时，免不了要用到*和&。
 
int v = 1;
int &ri = v;
// int &*p = &ri;
 
由于引用并不存在地址，因此第三行将会报错。我们可以从右往左读，*表明p是一个指针，余下的&说明了p指向类型的类型。
 
指针的引用
 
之前说到指向引用的指针，现在来说指针的引用就容易多了。
 
int v = 1;
int *p = &v;'
int *&rp = p;
 
&说明r是一个引用。*确定r引用的类型是一个指针。
 
其他
 
因为引用不是对象，故无引用的数组，无指向引用的指针，无到引用的引用：
 
int& a[3]; // 错误
int&* p;   // 错误
int& &r;   // 错误
 
[1] 引用声明
 [2] 指向指针的引用

概述
 
前面整理了指针的用法，但是经常和指针拿来对比东西是引用。确实指针在使用的过程中会有很多的麻烦，比如赋初值、使用时判空、无效指针、深浅拷贝等等。在我看来引用的指针的高级替代，它的使用规则规避了很多出错的可能。下面就对引用进行整理。
 
需要注意的是C11引入了右值引用，我们这里所说的引用都是在讨论左值引用。
 
1、什么是引用？
 
引用是给对象起了一个别名，它也是一种复合类型。通过将声明符写成&d的形式来定义引用类型，其中d是声明的变量名。
 
定义引用时，程序把引用和它的初始值绑定在一起，而不是将初始值拷贝给引用。一旦初始化完成，引用将和它的初始值对象一直绑定在一起。因此引用必须初始化，而且引用不能重新绑定到另一个对象，类型要和绑定的类型一致。
 
引用本身不是独立的数据类型，所以不占用空间，引用的地址就是对象的地址。也就无法定义指向引用的指针，无法声明存储引用类型的数组等。
 
int ivalue = 97;
int ivalue2 = 98;

int& refvalue = ivalue;		//refvalue是给ivalue起的的别名
refvalue = ivalue2;		//没有重新绑定，这里是赋值操作

int& refvalue2;			//编译出错，没有进行初始化 
     
int& refvalue4 = 10；		//只能绑定到对象上
int&* p = &refvalue;		//不能定义指向引用的指针

int& arr[5] = {1,2,3,4,5};	//不能定义引用数组    
int&& refvalue5 = refvalue;	//不能定义引用 引用的引用    
double& refvalue3 = ivalue;	//编译出错，类型不一致
 
2、引用的使用
 
引用跟指针很相似，使用也差不多，这里就介绍一些其中差别有点大的地方，至于细节可以去看前面整理的指针内容，只要将*改成&使用就行。
 
2.1、引用作为函数参数
 
1.当用引用作为函数的参数时，其效果和用指针作为函数参数的效果相当。当调用函数时，函数中的形参就会被当成实参变量或对象的一个别名来使用，也就是说此时函数中对形参的各种操作实际上是对实参本身进行操作，而非简单的将实参变量或对象的值拷贝给形参。
 
2.通常函数调用时，系统采用值传递的方式将实参变量的值传递给函数的形参变量。此时，系统会在内存中开辟空间用来存储形参变量，并将实参变量的值拷贝给形参变量，也就是说形参变量只是实参变量的副本而已；并且如果函数传递的是类的对象，系统还会调用类中的拷贝构造函数来构造形参对象。而使用引用作为函数的形参时，由于此时形参只是要传递给函数的实参变量或对象的别名而非副本，故系统不会耗费时间来在内存中开辟空间来存储形参。因此如果参数传递的数据较大时，建议使用引用作为函数的形参，这样会提高函数的时间效率，并节省内存空间。
 
3.使用指针作为函数的形参虽然达到的效果和使用引用一样，但当调用函数时仍需要为形参指针变量在内存中分配空间，而引用则不需要这样，故在C++中推荐使用引用而非指针作为函数的参数。
 
4.如果在编程过程中既希望通过让引用作为函数的参数来提高函数的编程效率，又希望保护传递的参数使其在函数中不被改变，则此时应当使用对常量的引用作为函数的参数。
 
5.数组的引用作为函数的参数：C++的数组类型是带有长度信息的，引用传递时如果指明的是数组则必须指定数组的长度。
 
void func(int(&a)[5])//数组引用作为函数的参数，必须指明数组的长度 
{
	sizoef(a);		//这里是20
	for(auto& i : a)
		i++;
}

int main()
{
    int number[5]={0,1,2,3,4};
    func(number); 
    return 0; 
 }
 
2.2、和const的使用
 
因为引用的定义就不能对它重新绑定，所以只有能不能通过引用修改其绑定的变量或对象。
 
int a=10;
const int &new_a=a;
new_a=11;		//错误！不允许通过常引用对其所绑定的变量或对象进行修改 
 
特别注意：
 
#include<iostream>
#include<string> 
using namespace std;
string func1()
{
    string temp="This is func1";
    return temp;
}
void func2(string &str)
{
    cout<<str<<endl;
}

int main()
{
    func2(func1());
    func2("Tomwenxing");
    return 0;
}
 
编译器时会报错：error C2664: “func2”: 不能将参数 1 从“const char [11]”转换为“std::string &”。
 
这是由于func1()和“Tomwenxing”都会在系统中产生一个临时对象（string对象）来存储它们，而在C++中所有的临时对象都是const类型的，而上面的程序试图将const对象赋值给非const对象，这必然会使程序报错。如果在函数func2的参数前添加const，就没问题了。
 
3、指针和引用的区别
 
引用必须初始化，指针可以不用
引用不能为空，指针可以
引用不能更换绑定对象，指针可以更换指向对象
引用不占内存，指针占用内存
不能声明引用数组，可以声明指针数组
不能引用 引用的引用（int&& b = a）,可以定义指针的指针
 
4、总结
 
在引用的使用中，单纯给某个变量起别名是毫无意思的，引用的目的主要用于函数参数的传递中，解决大块数据或对象的传递效率和空间不如意的问题。
用引用传递函数的参数，能保证参数在传递的过程中不产生副本，从而提高传递效率，同时通过const的使用，还可以保证参数在传递过程中的安全性。
引用本身是目标变量或对象的别名，对引用的操作本质上就是对目标变量或对象的操作。因此能使用引用时尽量使用引用而非指针。
没有void类型的引用。
 
感谢大家，我是假装很努力的YoungYangD（小羊）。
 
参考资料：
 《C++ primer 第五版》
 https://www.cnblogs.com/duwenxing/p/7421100.html

C++ 函数传递指针的引用或指针的指针，指针的值被改变
 
标签（空格分隔）： C++ Pointer
 
 
如下图的代码：容易误以为tree1的值会在函数Mod…中随着p1,p2改变，但实际上tree1与p1,p2只是在Tree这一级别一起改变，在Tree* 这一级别，就像普通的int变量之间的赋值。
 
#include <iostream>
#include <vector>

using namespace std;

class Tree{
public:
    int val;
    Tree* left;
    Tree* right;
    Tree():val(-1),left(NULL),right(NULL) {}
    Tree(int value){
        val = value;
    }
};

void ModReference(Tree*& s)
{
    s = new Tree(5);
}

void ModPointer(Tree** s)
{
    *s = new Tree(6);
}
int main()
{
    Tree* tree1 = new Tree(3);
    Tree* p1 = tree1;
    ModReference(p1);
    cout << "Ref: tree1: " << tree1->val << " p1: " << p1->val << endl;
    Tree* p2 = tree1;
    ModPointer(&p2);
    cout << "Pointer: tree1: " << tree1->val << " p2: " << p2->val << endl;
    tree1 = p1;
    cout << "tree1: " << tree1->val << endl;
    tree1 = p2;
    cout << "tree1: " << tree1->val << endl;

}
 
Ref: tree1: 3 p1: 5 
 Pointer: tree1: 3 p2: 6 
 tree1: 5 
 tree1: 6

标题列出了5个概念，以指针为一组，常量为一组的两组概念内部是非常容易混淆的。希望以本文来清晰区分它们。
 
一. const限定符
 
将const理解为一个修饰词似乎更容易理解一些。一旦出现const，一定要看清楚它究竟修饰的是什么。虽然这句话比较抽象且模糊，但接下来所述的所有内容将举出例子，理解下面的内容就会理解这句话的含义。
 
如下面所看到的，所有涉及指针的概念为一组（即常指针和指针常量为一组），涉及引用的概念为一组（引用、常引用、引用常量）。
 
非常清楚这些内容的人可能会说：没有引用常量这个说法。这里我们暂且先这样说，后文将会阐述清楚这个说法不存在的事实。
 
二. 常指针和指针常量
 
首先能看到这篇文章的读者一定清楚：const是常量，是“只读”而“不可写”的。这个说法毋庸置疑的正确，然而不够具体，因为语法上可能会出现问题，例如这节说的“常指针”和“指针常量”。
 
永远不要死记硬背，下面的代码只是为了先看下“常指针”和“指针常量”在语法上长什么样子：
 
 
const int* pt;	//常指针
int* const ps;	//指针常量
很显然，这两者区别就是const的位置，当然也可以说是int*位置的不同，但是int*代表int类型的指针，再看之前所说的const理解为一个修饰词，可以试着理解下面的话： 
 
常指针const int* pt中const修饰int*，连起来说就是“常整型指针”，但是随着指针指向的数据类型不同这个说法也将随之改变，例如const char* pt就是“常字符型指针”，因此省略中间的指针指向的数据类型名，统一称为“常指针”。
 
 
再来看常指针的作用。仍然以const int* pt为例：const修饰了int*，并未直接修饰pt，也就是说指针变量pt并不是“只读”的，而说的是pt是指向整型常量的指针，指针指向的数据不可更改。因此常指针的作用是保护指向的数据不被更改。
 
如果理解了常指针，指针常量就比较好理解了：int* const ps中，const修饰指针ps本身，因此指针ps就是“只读”的，不能再改变指针本身的值，也即不能改变指针的指向，但指向的数据却是能更改的。
 
三.常引用和引用常量
 
常引用和引用常量实际上跟常指针和指针常量基本一致，只不过这里把指针换成了引用就可以了，并且作用与常指针和指针常量是一致的，因此不再赘述。但是要说明：实际上不存在引用常量这个说法，也不存在引用常量这个东西。可以尝试在VS中作如下定义：
 
 
int a=0;
int& const b=a;
编译时并不会报错，但是会有如下提示 
 
warning C4227: 使用了记时错误: 忽略引用上的限定符
 
 
而当去掉const时此警告就会消失，也就说明了其实并不存在引用常量这个东西。
 
实际上这就涉及了一个问题：引用的本质是什么？
 
一般教科书上说：引用就是“别名”。确实这个说法没有大问题。但这并不是本质。
 
引用不占据内存空间这种说法是错的，如果反编译看汇编代码，会发现引用实际上被解释为一个指针常量，而这也恰好符合引用本身不能更改的原则。
 
这样看引用常量不存在的原因很明显了：引用本身就被解释为指针常量，再用const修饰完全没有意义。