引用与指针

1.引用的几个错误用法：

#include<iostream>
using namespace std;
int main() {
    int sum = 0, val = 1;
    int &ref;//错误引用必须初始化
    int &ref = 10;//错误引用必须与一个对象绑定，不能与字面值绑定
    int &ref = sum+val;//错误引用不能与表达式的结果绑定在一起
    &ref = val;//错误引用绑定了另外一个对象
    ref = val;//正确这只是一个赋值
    return 0;
}

其他注意事项：

1.对引用的任何操作都是对对象进行操作

2.不能定义引用的引用（不过好像也没法写出来）

2.引用VS指针

1.引用不是对象，而指针是。（对象是具有某种数据类型的内存空间，它有实际的地址和存储空间）。引用就像一个贴贴纸，这个贴贴纸贴到盒子（变量）上，为盒子起了一个别名，并且无法撕下来了；指针就像一个盒子（对象都可以认为是一个盒子）装了变量的地址，你也可以将盒子里的东西拿出来再装其他地址。

 

int a = 10;
int& r1 = a;
int& r2 = r1;//这样做是可以的，就像a这个盒子多了一个贴贴纸，多了一个别名

 

2.普通的引用（常量的引用除外）和指针必须绑定或则指向与自身类型相同的变量

 

double dval = 3.14;
int& r1 = dval;//错误
int* p1 = dval;//错误

 

3.引用必须要初始化，而指针不用（野指针，此时指针指向一个不确定的值），因此，不存在指向空值的引用这个事实意味着使用引用的代码效率比使用指针的要高。因为在使用之前不需要测试它的合法性。

void printInt(const int& ri)
{
    cout<<ri<<endl;//不需要测试ri，它肯定指向一个int值
}
//vs
void printInt(const int *pi)
{
    if(pi)  return；    
}

4.引用不可以先后指向不同的值（绑定），指针可以（拷贝）。

5.引用没有实际的地址，指针有，因此不能定义指向引用的指针。

6.sizeof指针永远是8个字节（64位操作系统），sizeof引用结果是引用的变量的类型大小。

7.能用引用的地方尽量用引用。

8.只有指针的引用（相当于该指针的别名），没有引用的指针，因为引用本身不是一个对象，没有实际地址。

int i = 42;
int* p;//p是一个int类型的指针
int*& r = p;//r是一个引用，是一个对指针p的引用
r = &i;//r引用了一个指针，因此给r赋值&i就是令p指向i
*r = 0;//相当于将i的值改成0

9.想理解r的类型到底是什么，办法是从右向左读r的定义。离变量名最近的符号（&）对变量有直接的影响，因此r是一个引用，其余的部分用来确定r引用的类型是什么，此例中*说明r引用的是一个指针。

 

int a = 10;
int* const ai = &a;
const int* aj = &a;
const int* const ak = &a;

//aii是一个指针，它是一个指向“int* const”的指针
int* const* aii = &ai;
//ajj是一个指针，它是一个指向“const int*”的指针
const int** ajj = &aj;
//akk是一个指针，它是一个指向“const int* const”的指针
//注意akk同样可以指向“const int*”“int* const”，但其他两个只能指向自己类型
const int* const* akk = &ak;

cout << "&a=" << &a << endl;
cout << "&ai=" << &ai << endl;
cout << "&aj=" << &aj << endl;
cout << "&ak=" << &ak << endl;

cout << "aii=" << aii << endl;
cout << "ajj=" << ajj << endl;
cout << "akk=" << akk << endl;

cout << "*aii=" << *aii << endl;
cout << "*ajj=" << *ajj << endl;
cout << "*akk=" << *akk << endl;

cout << "**aii=" << **aii << endl;
cout << "**ajj=" << **ajj << endl;
cout << "**akk=" << **akk << endl;

 

10.实参是指针它指向了一块内存，形参也是同级指针，即便形参在其所在的函数中指向了另一块内存，实参的指针指向依然不变，相当于值传递

 

void test(int* p)
{
    int a = 1;
    p = &a;
    cout << p << " " << *p << endl;
}
int main(void)
{
    int* pt = NULL;
    test(pt);
    if (pt == NULL)
        cout << "指针pt为NULL" << endl;
    return 0;
}

 

地址传递时，形参指针在其所在函数内没有实现对*p的赋值，实参就不会改变

void testPTR(int* p) {
    int a = 12;
    p = &a;

}

void main()
{
    int aa = 10;
    testPTR(&aa);
    cout << aa << endl;
}

 

结果是10

实参是引用它指向了一个变量，形参也是引用，形参在其所在的函数中指向了另一个变量，实参的指针指向虽然依然不变，但实参的值以及实参所指向的变量的值发生了改变

void test(int& p)
{
    int a = 1;
    p = a;
    cout << "a:" << a << endl;
    cout << "p:" << p << endl;
}
int main()
{
    int aa = 10;
    int& pp = aa;
    cout << "aa:" << aa << endl;
    cout << "pp:" << pp << endl;
    test(pp);
    cout << "aa:" << aa << endl;
    cout << "pp:" << pp << endl;
    return 0;
}