文章目录
- 1. 引用
- 1.1 引用不是对象或变量
- 1.2 引用必须初始化
- 1.3 不能定义引用的引用
- 1.4 引用类型要适配
- 1.5 非const引用不能绑定字面值
- 2. 指针
- 2.1 指针和引用的区别
- 2.2 指针的指针
- 2.3 类型一致
- 2.4 指针的引用
- 2.5 void 型指针
- 3. const
- 3.1 const的基本作用
- 3.2 对const变量的引用
- 3.3 不能把一般引用与const变量进行绑定
- 3.4 const变量的引用可以绑定字面值
- 3.5 不存在const引用
- 4. const与指针
- 4.1 const变量的值不能改变
- 4.2 const变量的指针可以存储非常量的地址
- 4.3 const常量的存储地址
- 4.4 const指针
1. 引用
1.1 引用不是对象或变量
引用就是对象或变量的别名
,但引用不是对象或变量
int a=10;
int&
b=a;
这里面,b就是变量a的另一个名字,对b操作就是对a操作,对a操作,b也会变化
void testreference()
{
int a=10;
int &b=a;
b=5;
cout<<a<<b<<endl;
a=4;
cout<<a<<b<<endl;
}
1.2 引用必须初始化
因为引用一定是某个变量的别名,引用一定是和变量绑定在一起的,所以引用必须初始化
int a=10;
int &b; <---错误
1.3 不能定义引用的引用
因为引用不是对象,但是引用又要绑定一个对象,所以不能
定义引用的引用
int a=10;
int &b=a;
int &(&c)=a; <---错误
1.4 引用类型要适配
因为操作引用就是操作变量或者对象本身,所以对于内置类型,变量和其引用之间的类型要适配。
int a=10;
float &b=a; <---错误
1.5 非const引用不能绑定字面值
因为引用必须和变量进行绑定,所以非const引用不能绑定字面值
int a=10;
int &b=20; <---错误
所以,引用的基本特性就五个:
1.不是对象;
2.必须初始化;
3.不能定义引用的引用;
4.类型适配;
5.不能绑定字面值.
2. 指针
2.1 指针和引用的区别
指针就是变量的地址
,可以通过引用
访问变量,也可以通过指针
访问变量,但是指针是对象
,而引用不是,这是二者的根本区别
void testpointer()
{
int a=10;
int *p=&a;
int *q;
cout<<p<<endl<<q<<endl;
}
通过上述代码,可以知道,指针可以不初始化
(只是为了演示,不要这样做),但是引用必须初始化
。
另外,&
符号既能表示引用
,也是取地址
符号,当&
出现在=左侧
时,是引用
,在=右边
就是取地址
。
2.2 指针的指针
因为指针是一个对象,所以可以定义指针的指针
,但是不能定义引用的引用
void testpointer()
{
int a=10;;
int *p=&a;
int *q;
int **pp = &p;
cout<<p<<endl<<q<<endl;
cout<<pp<<endl;
}
所以,指针的引用的不同点就是:
1.引用必须初始化,指针不用,
2.可以定义指针的指针,但是不能定义引用的引用,这两点的原因就是指针是变量,而引用不是(只是个别名)
2.3 类型一致
指针所指向的数据的类型要和指针的类型一致
float a=10;
int *p=&a;
2.4 指针的引用
因为指针是对象,引用不是,所以可以定义指针的引用
,但是不能
定义引用的指针
。
void testpr()
{
int i=0;
int *pi=&i;
int *&pr=pi;
cout<<pr<<endl<<pi<<endl;
*pr=4;
cout<<i<<endl;
}
int *&pr=pi;
说明了如何定义一个指针的引用
,可以从右向左读。
先看pr
部分,我们知道有个对象叫pr
;接着看到&pr
,我们知道pr是一个引用
;
最后看到int *
,就知道这个引用和一个int类型的指针绑定,这个指针
就是pi
。
因为pr是pi的别名
,所以对可以通过pr改变i。
2.5 void 型指针
void型指针可以存放任意类型的指针(包括二级指针),但是不能
对void型指针解引用
,所以void*指针可以保护数据所在的内存不被修改
void testvoidp()
{
double d=1.2;
double *pd=&d;
int i=11;
int *pi=&i;
void *vp=pi;
vp=pd;
cout<<__func__<<endl;
cout<<*vp;
}
3. const
3.1 const的基本作用
之前所讲的C++中的变量值,都是可以赋值的,如果我们不允许对变量赋值,那么就要将变量设置为const。
void testconst()
{
const int c=10;
c=20;
}
可见,只能对const变量进行初始化,不能对其赋值,因为const变量的值不能被改变
3.2 对const变量的引用
可以用const来修饰一个引用,称为对const变量的引用
,对const变量的引用不能直接修改所绑定的对象(这个性质通常用于函数传参,使传的参数在函数中不能被改变)
void testconst()
{
int i=2;
const int &ri=i;
ri=3;
}
也就是说,无法通过ri来修改i的值
3.3 不能把一般引用与const变量进行绑定
因为const的变量无法修改,所以不能把一般引用
与const
变量进行绑定
void testconst()
{
const int c=10;
int &ri=c;
}
如果可以通过一般引用
来绑定const的变量
,那么就可以通过该引用修改
const变量,与const的属性相冲突
,所以,不能用一般引用与const变量进行绑定。
3.4 const变量的引用可以绑定字面值
一般的引用不能与字面值
进行绑定,但是const变量的引用可以绑定字面值
(因为有const修饰)。而且,const变量的引用不仅可以绑定字面值,还可以绑定一般的对象(允许类型不匹配)
void testconst()
{
double d=1.2;
const int &rc=10;
const int &rc1=d;
cout<<rc<<endl<<rc1<<endl;
}
正是因为const变量的引用几乎可以绑定任何对象,所以函数的参数
一般都设定为const变量的引用
,扩大了函数可传参数的范围
此外,由于是按引用传参
,所以避免了拷贝,加快了代码的执行速度。
当执行const int &rc1=d;
时,rc1并不是真正的和d绑定,而是绑定了一个临时变量
,编译器会把这句代码转化成下面这样
const int tmp=d; //类型转换 double to int
const int &rc1=tmp;
在这种情况下,引用绑定的是一个临时量对象
而不是
d本身,而是临时变量tmp
。
c++认为,常量引用可以绑定这个临时量,而普通引用就不能绑定这个临时量。因为c++认为,使用普通引用绑定一个对象,就是为了能通过引用对这个对象做改变。如果普通引用绑定的是一个临时量而不是对象本身,那么改变的是临时量而不是希望改变的那个对象,这种改变是无意义的。所以规定普通引用不能绑定到临时量上。
那么为什么常量引用就可以呢,因为常量是不能改变的
。也就是说,不能通过常量引用去改变对象,那么绑定的是临时量
还是对象
都无所谓了,反正都不能做改变,也就不存在改变无意义的情况。
所以,常量引用可以绑定临时量,也就可以绑定非常量的对象、字面值,甚至是一般表达式,并且不用必须类型一致。
3.5 不存在const引用
4.因为引用并不是对象,所以不存在const引用(注意理解const变量的引用
和const引用
的区别)
void testconstreference()
{
double d=1.2;
int &const rc=10; //const的引用
const int &rc1=d;
cout<<rc<<endl<<rc1<<endl;
}
const变量的引用与一般引用(见C++知识点——指针、引用基础)的区别
1.一般引用不能绑定字面值。但是const变量的引用就可以
2.一般引用要与绑定的数据的类型一致,但是const变量的引用是个例外
4. const与指针
4.1 const变量的值不能改变
const变量的值不能改变,所以想要存放const变量的地址,就需要使用指向const变量的指针。
void testconstpointer()
{
const int i=0;
const int *pi=&i;
cout<<pi<<endl;
}
4.2 const变量的指针可以存储非常量的地址
所以指向const变量的指针的基本作用就是存储const变量的地址,而且const变量的指针也可以存储非常量的地址(类型要匹配),因为pi
本身是变量
,pi
本身并不是const
void testconstpointer()
{
int i=0;
const int *pi=&i;
cout<<pi<<endl;
}
4.3 const常量的存储地址
const变量i
的地址不能使用指向非常量的指针
来存储,而且非常量的指针
也不能指向常量的指针
,否则可以通过指针修改const变量。
void testconstpointer()
{
const int i=0;
const int *pi=&i; //对
int *p=&i; //错,p不是常量指针
cout<<pi<<endl;
}
=======================================
void testconstpointer()
{
const int i=0;
const int *pi=&i;
int *p=π
cout<<pi<<endl;
}
4.4 const指针
因为引用不是对象,但是指针是对象,所以存在const指针
void testconstpointer()
{
int i=0;
const int *const pi=&i;
cout<<pi<<endl;
}
const int *const pi;
的读法依然采用从右向左的读法
先看到pi
,我们知道这是一个变量,接着看到const
,我们知道他是一个const变量
,然后看到*
,我们知道这个是const的指针变量
,看到const int
我们知道这个const指针指向一个const int
。
因为pi用const修饰
,所以pi中存储的地址值不能改变
,也就是说,pi本身不能改变
void testconstpointer()
{
int i=0;
int j=0;
const int *const pi=&i;
pi=&j;
cout<<pi<<endl;
}
因为pi
指向const int
,所以不能通过pi来改变指向的对象的值。
void testconstpointer()
{
int i=0;
int j=0;
const int *pi=&i;
*pi=10;
cout<<pi<<endl;
}