c++之指针&&引用

指针：指向一块内存地址的标识。

引用：给已经定义的变量起的别名。

格式：

类型 &引用变量名 = 已定义的变量名（引用变量名和已定义的变量名可以看成是同一个实体，一个改变，另一个也随之改变）

引用的特点：

（1）引用必须初始化

int a = 10;
int &ra = a;

（2）一个变量可以有多个引用

int a = 10;
int &ra = a;
int &qa = a;

（3）当一个引用确定后，不可以引用其他变量

int a = 10;
int &ra = a;
int b = 20;

在这里，ra是不可以再作为变量b的别名的。引用确定后，第一次是哪个实体，后边是不可修改的。

（4）你可能还会碰到类似这样的：

int a = 10;
double &qa = a;       //error

如果这里不使用引用的话，可以直接隐式的强制类型转换，编译器不会报错。而这里使用了引用之后，会产生一个临时变量，这个临时变量是常量，其具有常属性（一个常属性的变量赋给另一个变量时，为了保证不修改原变量，应在另一变量前加关键字const），所以应该这样定义：

int a = 10;
const double qa = a;     //OK

（5）数组的引用

int a[10];
int (&b)[10]= a;

（6）引用--函数

#include<iostream>
using namespace std;
int& Fun(int a)
{
return a;
}
int main()
{
int &b = Fun(10);
printf("%d\n",b);      //b压栈，输出10，销毁
printf("%d\n",20);
printf("%d\n",b);
system("pause");
return 0;
}

结果：



 明明把b和Fun()函数是同一实体，为什么输出第二个b时会出现随机值呢？

对于引用来说，b和Fun()函数是同一实体，所以呢，在Fun()函数里的a，是一个临时变量，出了作用域后就会自动销毁，所以在第一次的printf函数中，先将b压栈，然后可以输出10，当printf函数完成后，将销毁掉那块内存；因此下次再访问b时，就会出现随机值。

那么在这里怎么避免这种情况呢？

**解决方法：返回比int&的生命周期长的变量

#include<iostream>
using namespace std;
int& Fun(int& a)
{
return a;
}

int main()
{
int a = 10;
int &b = Fun(a);
printf("%d\n",b);
printf("%d\n",20);
printf("%d\n",b);
system("pause");
return 0;
}结果：



说完引用的几大特性后，再看看区别吧~~

值传递和引用传递的区别：引用传递不需要创建临时变量，而值传递则需要。

指针和引用的区别和联系：

（通过汇编看）底层的处理方式是一样的。

区别：

（1）指针不用初始化，而引用则需要。

int a = 10;
int *p;
int &ra = a;

（2）指针的指向不唯一，引用只能指向一个。（引用：一夫一妻制）

int a = 10;
int b = 20;
int *p = &a;
int &ra = a;
p = &b;

（3）对于自加减的意义。

指针自加减：偏移指针类型个位；

引用自加减：给引用的实体加1或减1；#include<iostream>
using namespace std;
int main()
{
int a[10] = {1,2,3};
int b = 20;
int *p = a;
int &ra = b;
p++;
ra++;
cout<<*p<<endl;
cout<<ra<<endl;
system("pause");
return 0;
}结果：



（4）关于sizeof()

#include<iostream>
using namespace std;
int main()
{
char b = 20;
char *p = &b;
char &ra = b;
cout<<sizeof(p)<<endl;
cout<<sizeof(ra)<<endl;
system("pause");
return 0;
}结果：



指针表示的是指针类型的大小；

引用表示的是已定义的变量的类型。

（5）有多级指针，无多级引用。

多级指针：int **p;   二级指针

int &&p = a;这里指的是右值的引用，而并非二级引用哦。这里没有多级引用。

（6）引用比指针更安全。

指针每次使用时，都需判空。引用则不需要。

**测试值传递和引用传递的效率：

（1）值传递

<span style="font-size:18px;">#include<iostream>
using namespace std;
#include<Windows.h>
struct BigData
{
int array[10000];
};

void setBigData(BigData data)
{
data.array[0] = 0;
data.array[1] = 1;
data.array[2] = 2;
}
int main()
{
BigData data;
int begin = GetTickCount();
for(long long int i = 0; i < 1000000; i++)
{
setBigData(data);
}
int end = GetTickCount();
cout<<"cost time:"<<end-begin<<endl;
system("pause");
return 0;
}</span>结果：



（2）引用传递

#include<iostream>
using namespace std;
#include<Windows.h>
struct BigData
{
int array[10000];
};

void setBigData(BigData& data)
{
data.array[0] = 0;
data.array[1] = 1;
data.array[2] = 2;
}
int main()
{
BigData data;
int begin = GetTickCount();
for(long long int i = 0; i < 1000000; i++)
{
setBigData(data);
}
int end = GetTickCount();
cout<<"cost time:"<<end-begin<<endl;
system("pause");
return 0;
}结果：



所以一般情况下会使用引用传参，引用的效率明显比传值的效率要高。

如果不希望传的参被修改的话，还可用常引用的方式，即const BigData& data。