1. 指针有const，引用没有const
1）为了限制指针更改指向，引入了const指针（int* const ptr）。
2）引用本身就不能更改，所以不存在const引用（int& const ref是错误的）。
引用可以指向常量，也可以指向变量。所谓“常量引用”是缩写，全称是对常量的引用，是底层const。引用本身不是对象，是在语法上的绑定。指针是对象，指针本身可以是常量 T *const。所以就有 const T *const p = &var;兼具顶层和底层const。顶层const限制的是对象本身。底层const限制的是通过该对象间接访问的那个对象。
例如int &a=b，使引用a指向变量b。而为了让引用指向常量，必须使用常量引用，如const int &a=1; 它代表的是
引用a指向一个
const int型，这个int型的值不能被改变，而不是引用a的指向不能被改变，因为引用的指向本来就是不可变的，无需加const声明。
即指针存在常量指针int const *p和指针常量int *const p，而引用只存在常量引用int const &a，不存在引用常量int& const a。
为什么引用没有const？
“const变量”一旦赋值，就不能更改变量，如下：
int const i = 1;
i = 2;
上面的程序将无法编译; gcc提示错误：
assignment of read-only variable 'i'
或
$ g++ test.cpp test.cpp:6:7: error: 'const' qualifier may not be applied to a reference int& const b = a; ^1 error generated.
我们通过 std::is_const 来检查类型是否是const限定的。
如果T是一个const限定类型（即const或const volatile），则提供等于true的成员常数值。对于任何其他类型，值都是错误的。
但是引用不能是const限定的。$ 8.3.2 / 1参考文献[dcl.ref]
除非通过使用typedef-name（[dcl.typedef]，[temp.param]）或decltype-specifier（[dcl.type.simple]）引入cv限定符，否则cv限定的引用不合法，在这种情况下，cv-qualifiers被忽略。示例如下
int main()
{
boolalpha(cout);
int const i = 1;
cout << is_const<decltype(i)>::value << endl;//true
int const* ri = &i;
cout << is_const<decltype(ri)>::value << endl;//false.它不是指向 const 的指针对象（它可以指向别处），它是指向的对象。所以，我们看到正确的常量性的的指针本身返回false。
return 0;
}
2. 指针(*)和引用(&) 对比
相同点
- 都是地址的概念；
- 指针指向一块内存，它的内容是所指内存的地址；引用是某块内存的别名。
不同点
- 指针是一个实体，而引用仅是个别名；
- 引用使用时无需解引用()，指针需要解引用；指针与引用看上去完全不同（指针用操作符’’和’->’，引用使用操作符’.’）
- 引用只能在定义时被初始化一次，之后不可变；指针可变；
引用“从一而终” _- 引用没有 const，指针有 const，const 的指针不可变；
- 引用不能为空，指针可以为空；
- “sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身(所指向的变量或对象的地址)的大小；
typeid(T) == typeid(T&) 恒为真，sizeof(T) == sizeof(T&) 恒为真，
但是当引用作为成员时，其占用空间与指针相同（没找到标准的规定）。- 指针和引用的
自增(++)运算意义不一样；
联系
- 引用在语言内部用指针实现（感兴趣的可以通过vs里面的反汇编可以研究下具体实现）。
- 对一般应用而言，把引用理解为指针，不会犯严重语义错误。引用是操作受限了的指针（仅容许取内容操作）。指针与引用都是让你间接引用其他对象。
引用是C++中的概念，初学者容易把引用和指针混淆一起。一下程序中，n 是m 的一
个引用（reference），m 是被引用物（referent）。
int m;
int &n = m;
n 相当于m 的别名（绰号），对n 的任何操作就是对m 的操作。例如有人名叫王小毛，
他的绰号是“三毛”。说“三毛”怎么怎么的，其实就是对王小毛说三道四。所以n 既不
是m 的拷贝，也不是指向m 的指针，其实n 就是m 它自己。
引用的一些规则如下：
（1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。
（2）不能有NULL 引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
（3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。
以下示例程序中，k 被初始化为i 的引用。语句k = j 并不能将k 修改成为j 的引
用，只是把k 的值改变成为6。由于k 是i 的引用，所以i 的值也变成了6。
int i = 5;
int j = 6;
int &k = i;
k = j; // k 和i 的值都变成了6;
上面的程序看起来象在玩文字游戏，没有体现出引用的价值。引用的主要功能是传
递函数的参数和返回值。C++语言中，函数的参数和返回值的传递方式有三种：值传递、
指针传递和引用传递。
以下是“值传递”的示例程序。由于Func1 函数体内的x 是外部变量n 的一份拷贝，
改变x 的值不会影响n, 所以n 的值仍然是0。
void Func1(int x)
{
x = x + 10;
}
int n = 0;
Func1(n);
cout << “n = ” << n << endl;// n = 0
以下是“指针传递”的示例程序。由于Func2 函数体内的x 是指向外部变量n 的指
针，改变该指针的内容将导致n 的值改变，所以n 的值成为10。
void Func2(int *x)
{
(* x) = (* x) + 10;
}
⋯
int n = 0;
Func2(&n);
cout << “n = ” << n << endl; // n = 10
以下是“引用传递”的示例程序。由于Func3 函数体内的x 是外部变量n 的引用，x
和n 是同一个东西，改变x 等于改变n，所以n 的值成为10。
void Func3(int &x)
{
x = x + 10;
}
⋯
int n = 0;
Func3(n);
cout << “n = ” << n << endl; // n = 10
对比上述三个示例程序，会发现“引用传递”的性质象“指针传递”，而书写方式象
“值传递”。实际上“引用”可以做的任何事情“指针”也都能够做，为什么还要“引用”
这东西？
答案是“用适当的工具做恰如其分的工作”。
指针能够毫无约束地操作内存中的如何东西，尽管指针功能强大，但是非常危险。
string& rs; // 错误，引用必须被初始化
string s("xyzzy");
string& rs = s; // 正确，rs指向s
指针没有这样的限制。
string *ps; // 未初始化的指针
// 合法但危险
总的来说，在以下情况下你应该使用指针:
一是你考虑到存在不指向任何对象的可能（在这种情况下，你能够设置指针为空）;
二是你需要能够在不同的时刻指向不同的对象（在这种情况下，你能改变指针的指向）。如果总是指向一个对象并且一旦指向一个对象后就不会改变指向，那么你应该使用引用。
还有第三种情况，就是当你重载某个操作符时，你应该使用引用。最普通的例子是操作符[]，Operator[] 操作符 由于该操作符很特别地必须返回 [能够被当做assignment 赋值对象] 的东西,所以需要给他返回一个 reference.。这个操作符典型的用法是返回一个目标对象，其能被赋值。
vector<int> v(10); // 建立整形向量（vector），大小为10;
// 向量是一个在标准C库中的一个模板(见条款35)
v[5] = 10; // 这个被赋值的目标对象就是操作符[]返回的值
如果操作符[]返回一个指针，那么后一个语句就得这样写：
*v[5] = 10;
但是这样会使得v看上去象是一个向量指针。因此你会选择让操作符返回一个引用。（这有一个有趣的例外，参见条款30）
当你知道你必须指向一个对象并且不想改变其指向时，或者在重载操作符并为防止不必要的语义误解时，你不应该使用指针。而在除此之外的其他情况下，则应使用指针
假设你有
void func(int* p, int&r);
int a = 1;
int b = 1;
func(&a,b);
指针本身的值(地址值)是以pass by value进行的，你能改变地址值，但这并不会改变指针所指向的变量的值，
p = someotherpointer; //a is still 1
但能用指针来改变指针所指向的变量的值，
*p = 123131; // a now is 123131
但引用本身是以pass by reference进行的，改变其值即改变引用所对应的变量的值
r = 1231; // b now is 1231
网友评论