你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

c++里面的const关键字和引用

[复制链接]
gaosmile 发布时间:2020-8-28 20:54
今天给大家分享一下这段时间学习c++的总结学习:c++里面的const关键字和引用。
一、const关键字的总结
1、const什么时候为只读变量,什么时候又是常量呢?
(1)const常量的判别规则:
  • 只用字面量初始化的const常量才会进入符号表
  • 使用其它变量初始化的const常量仍然是只读变量
  • 被volatile修饰的const常量不会进入符号表
  • 在编译期间不能直接确定初始值的const标识符,都被作为只读变量处理

    : t/ F4 k% f5 K1 D
(2)const引用的类型与初始化变量的类型
  • 相同:初始化变量成为只读变量
  • 不同:生成一个新的只读变量

    . ?9 I$ Q' O* s$ K' f: W
代码版本一:
#include <stdio.h>
: |6 \+ c7 |) K! j8 f+ ?. I- A8 f, n6 r* W% G4 n
int main()
9 x6 U/ J/ _# X) `7 v1 `{
  g% I! t9 ~* I% ^" k( e   const int x = 1;//直接得到值,进入符号表,但是还是会为 x 分配空间,只不过这个空间 x 没有用而已& l( l8 G$ [$ Z% U  C
   const int& rx = x;//rx代表只读变量,这个变量是编译器为x分配而没有使用的空间;引用代表变量的别名,而变量代表一段内存空间的别名,所以引用代表一段内存空间的别名
; b! H& B$ f( ?' f, q' Z6 r: a' w3 @5 m- k& {8 T% I4 t5 ~
   int& nrx = const_cast<int&>(rx); //消除 rx只读属性,和rx 代表的内存空间相同,同时c++里面的几种类型转换要掌握) D% D7 Z0 F1 r1 d- E3 w8 K5 ~9 E+ j
   nrx=5;
" N: ]' L4 t( _: H9 \" M. u4 _3 v3 d2 K# w& r3 Y( o
   printf("x = %d\n",x);
- b0 k7 x; |) x7 [2 V6 K+ u   printf("rx = %d\n",rx);6 L' u" [2 T7 g) A- \8 x9 a( j8 C
   printf("nrx = %d\n",nrx);: x# A( s9 ?) m" K1 w

  Q0 `# R% n- F, B* Y   printf("&x = %p\n",&x);% }( L6 P& b1 t
   printf("&rx = %p\n",&rx);
( L' y) T; h" s6 k; Y! {8 @9 x   printf("&nrx = %p\n",&nrx);
$ [7 e% c! ]; X/ w   6 Y  x/ y, P. L0 \- L  o5 u, @
) S9 Y* g/ }6 d
   return 0;4 S7 Y1 j6 F1 D
}7 P/ k# m& y% p- [- I

7 `6 [2 m% r5 x0 ?
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out0 _9 P( b& K) _5 x( X/ @
x = 1
( ~3 ]$ b: L  w+ Rrx = 55 Y1 R( e, J' l( M  a
nrx = 57 o0 i; ~3 L. k! v7 B; D
&x = 0x7ffcc5fa8abc) i9 s1 ~- T# p) Z' B+ c+ U
&rx = 0x7ffcc5fa8abc
& T0 F) J; z+ o5 l&nrx = 0x7ffcc5fa8abc
; X, \) ?- c0 r& \( n7 S" `1 v0 q, h; d( l3 b& m3 _
代码版本二:
#include <stdio.h>2 J! i8 b4 x' ?5 H+ ~
' w$ F1 F: x& v  J
int main(); P, m2 e2 i- k; J
{0 i$ H* m" K6 s" H  y1 F
     volatile const int y = 2;// 只读变量,不会进入符号表) x! H" }( j: Y% V7 o- ^
     int *p = const_cast<int*>(&y);//y被 const修饰,取到的地址也有 const 属性,这里将地址只读属性去掉
+ Y" U/ _* {9 X3 ~# A; A. c) I0 V3 O7 H% u# ^
      *p = 8;# c  E: a/ l% f0 O

  X9 `( u3 a2 ~8 H" V8 a  h1 B  G       printf("y = %d\n",y);
" [, x7 X6 D# X0 M6 G0 G       printf("p = %p\n",p);
( K; O. t! C, f5 ~& W! Y
: L2 O: d; c. b2 w. @0 i       return 0;
4 i- o7 |7 M- O; U/ I% k/ ^
$ N  Y6 S7 B/ E2 H}
) l( r3 M% V7 U9 U* v
$ V6 z1 |4 p; L; A% m
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out
5 T* j  h* X% v% @y = 8
. f3 e# v, F, D/ O& y0 X* I; fp = 0x7ffd78559684$ x2 Y& n- _; N. @$ Y: E& v
* j8 W" a" Z  N( S1 c. @( Y: l
代码版本三:
#include <stdio.h>
8 g, @2 K; D! m4 X
# ~* u" v0 Z) g- q" Sint main()
$ I# h% K. R! |{
% k" K! F* I% F3 |* \     volatile const int y = 2;- n. R* S* ~4 d3 r/ }$ e; t! _
     int *p = const_cast<int*>(&y);5 U/ D: W% Z$ p) Q8 A9 Y
2 @* ?) M8 `, e" B; r+ n
     *p = 8;1 M, ~! K! `+ W7 B5 _+ Y
, Y7 G! P1 t- L8 h) [/ S
      printf("y = %d\n",y);
/ x0 k& [: k( ?. W7 k% ]7 j1 [      printf("p = %p\n",p);' ^  S" E4 C3 T2 @9 `
- }6 M+ Y) `+ E
      const int z = y ;//只读变量0 \$ K# S8 `; }/ q  u, L
, A. P/ Q& N( A& u2 s+ x7 T+ h
      p = const_cast<int*>(&z);
/ F7 f, h9 P5 s% t' [0 w' j5 `6 B% _7 J# t+ F
      *p= 9;$ Q( X" M: G, C$ Z

% K: n( m" w4 k* q      printf("z = %d\n",z);
  i( r5 @; }% `. z& L9 }: u. Q" a      printf("p = %p\n",p);# d7 H8 {9 b7 Y6 N" w' B* p- z- l+ q
6 e3 n9 r4 D1 L0 V3 U' O% o
       return 0;+ P( K3 p' V, \  {7 b9 j
5 G7 ]' B, @4 X$ D' a
}
; X& u. N5 V0 D1 D) i1 O, }* c' R
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out; P! z7 m% ~% h8 J1 I
y = 8$ ^8 l9 B& r9 j2 B7 J: y, l6 E0 t. D
p = 0x7ffc5d651250
' ~! A9 D0 V' |: G3 Pz = 94 `4 p. t( M) E8 K3 Z8 K
p = 0x7ffc5d651254
1 \8 k. S9 \% f4 y# s  ^, G# `
  C1 b9 C$ p/ L3 E, `
代码版本四:
#include <stdio.h>9 }  j  z6 T. v7 J

4 o0 H) k$ F9 g6 m, qint main(); o+ H2 i% g6 s- w* p/ n$ g
{
) \' M! Q# E, h2 b0 I1 k     char c = 'c';* y7 q$ A3 p  j# F2 p
     char& rc = c;+ Q; R. B5 U0 U& y% h' H. ]
     const int& trc = c; // char 类型默认转换为 int;const 引用初始化类型不同,将得到新的只读变量,所以改变 rc 和 trc 没有丝毫关系,从我们的输出结果可以看出来
& n$ l/ y, y4 L; F. t8 f& S/ M; r" \4 v/ ~/ `; q, D3 x
     rc = 'a';# z/ K* v* o- z, \9 R2 _" S% s9 J
, C; s2 |1 A9 O6 ~. t8 ~, }
     printf("c = %c\n",c);
$ v) G& u0 V( E( Y( \  U     printf("rc = %c\n",rc);
% N$ }, ~7 N# E' e     printf("trc = %c\n",trc);
, Q+ ^! P2 [  _$ U) i
, E6 }9 b' m& l& Y+ e  m5 H     return 0;
. i/ m$ v* C5 @  v7 ~
5 B% U0 w% t) j6 G}1 O, l) c. `% U
结果输出:
root@txp-virtual-machine:/home/txp# ./a.out% n6 ?7 b* N# b8 n! G% n  p+ t
c = a7 [8 G/ c! N; T1 J1 }0 W
rc = a
& V& ^- @- U# }- Utrc = c, V7 w8 u0 [; h' {& Q  a# ]
$ z, V4 F. M. M" d7 F  Z5 P7 j
二、引用的总结:
1、引用与指针有什么关系,以及如何理解"引用的本质就是指针常量"?
(1)指针是一个常量:
  • 值为一个内存地址,不需要初始化,可以保存不同的地址
  • 通过指针可以访问对应内存地址中的值
  • 指针可以被const修饰成为常量或者只读变量
    " e. v0 B! {! m, t
(2)引用只是一个变量的新名字:
  • 对引用的操作(赋值、取地址等)都会传递到代表的变量上
  • const引用使其代表的变量具有只读属性
  • 引用必须在定义时初始化,之后无法代表其它变量

    6 D% Z1 T, ^6 ]5 Q" A% W
(3)从使用c++语言的角度来看:
  • 引用与指针没有任何的关系
  • 引用是变量的新名字,操作引用就是操作对应的变量

    - G- y2 v9 S5 `) U
(4)从c++编译器的角度来看:
  • 为了支持新概念"引用"必须要一个有效的解决方案
  • 在编译器内部,使用指针常量来实现"引用"
  • 因此"引用"在定义时必须初始化
    8 F1 f3 {" E: Y& Y/ Z
(5)在工程项目开发中:
  • 当进行c++编程时,直接站在使用的角度来看待引用,与指针毫无关系,引用就是变量的别名
  • 当对C++代码进行调试分析时,一些特殊情况,可以考虑站在C++编译器的角度来看待引用

    - h& V: Q' J& r" i5 K# H
代码实践:
版本一:
#include <stdio.h># L' t" \+ B+ @5 G4 A; V* L/ U) n

1 \4 W0 f/ Y5 w. Aint a = 2;% Q. p# v" g3 F2 T- o3 e& _

$ \. r; ]+ k& Ystruct SV{
; \. I" ]; b- g) j+ G- R   int& x;
( [7 H3 P5 p% O: Z( Y: ~: l- m   int& y;
# v) A/ v8 L: G# M   int& z;
, i4 q. P3 y0 Z2 M};& I8 m9 T! b$ ~3 t2 M% r" ]
int main()* \0 {1 g5 C; Y: g7 b% p
{  n& S0 x( f- U9 e7 l) T
  int b =4;
( k9 i1 ?. _/ T) _1 p5 K7 o! x7 p  int* pc = new int(3) ;
6 A" Z& H: M9 o" z% [2 {
) Y, Q; e5 y; u  SV sv = {a,b,*pc};5 j" `2 p1 g. I& b; ~6 n! v$ v9 U: D

1 Z! y/ z  k$ R  printf("&sv.x = %p\n",&sv.x);
" m% }; }2 O: A. L4 a& Q- I$ a) D$ J0 H  printf("&sv.y = %p\n",&sv.y);2 n4 _: M+ S. i$ {; J: v
  printf("&sv.z = %p\n",&sv.z);% n5 M. \, i: {! R" o- H$ ?

+ L; O# ?5 m% r( G+ A8 j: v  delete pc;; n2 x: I0 u: Q# N0 `

' m' @2 a/ d$ i! }7 f8 N' R  return 0;$ U" k3 F, _* [) B# d4 m- {, e

( m2 J) b$ a/ L" m& Y6 H2 K}
6 x4 M% G3 q: r( {+ x' O" C& ^6 |
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out
) O( R; f( h, Y& ^- u&sv.x = 0x601050
# Z. u, M" d8 o&sv.y = 0x7ffee11ba794
" `9 j0 {& s5 V+ ?  Y0 H$ [' M&sv.z = 0x1cfd0101 E9 x& s8 w) ~# w- q9 u% {! ?
, g: a' B& N" x
版本二:
#include <stdio.h># j. q+ ~( [8 S" y" ~
& F2 l% R8 o* Y
int a = 2;- f+ g1 x7 k+ a( N9 W0 z, J
; ^  p; |6 P6 @( [6 Y
struct SV{
- u% S! ~: E" i2 U4 @: S$ w" G, W   int& x;
( [( |# Z+ J7 P# \/ v1 J! X   int& y;; d' @4 b+ S$ N$ m2 n. g( J- K- a. r4 G
   int& z;
9 \- \) S7 G" s' l% J};3 x, F( _$ p+ ]+ k$ A
int main()
1 h( x3 u! G/ l$ J) H% z5 p{  L: y" f* G" e2 M% O7 |) @& {
  int b =4;
4 T+ S0 d- ^9 e& W2 v* U) w  int* pc = new int(3) ;2 Z- D! c0 N/ R1 x+ u# \

: j8 K: ?5 G) w9 `/ x) j8 {  SV sv = {a,b,*pc};5 P$ X9 j  S* G
  int& array[] = {a,b,*pc};//数组中的每个元素是引用就不可以;error: declaration of ‘array’ as array of references;C++ 天生要支持 C 语言,C 语言中数组中的每个元素在内存中是顺序存放的,地址是递增的,所以在 C++ 中也要兼容这个特性,而在 C++ 中唯有引用数组破快了这个特性,所以说 C++ 中不支持引用数组;&array[1] - &array[0] !=  Expected ==> 4
* s: x! ]# i2 d" D
- _8 @( w3 i4 h5 c4 p
% o" g( f$ ]) E, m+ s  printf("&sv.x = %p\n",&sv.x);5 [* y! {$ f! U
  printf("&sv.y = %p\n",&sv.y);
& Q3 n  h2 z" q0 q& Z4 b  printf("&sv.z = %p\n",&sv.z);% N3 V# R* ^, M( h; e$ |5 e
+ D7 g6 {. r7 _3 X
  delete pc;
' F& e* F" U2 e- P/ G4 w3 @( ]8 ]% H/ J  @3 P0 ]
  return 0;5 l. t# l: J( K; {3 j1 N6 @7 c

- O$ i- O( a9 C% E2 A}$ R9 }# u  c  k. H  `8 v( R
; E. ]; P$ X+ b
输出结果:
root@txp-virtual-machine:/home/txp# g++ test.cpp
0 Y/ N  S* O/ ptest.cpp: In function ‘int main()’:
; [9 D# _; O. `# U2 utest.cpp:16:14: error: declaration of ‘array’ as array of references5 t/ h$ y0 i8 M+ Z+ Q5 z
   int& array[] = {a,b,*pc};6 e( @0 S- b1 \; t& a# N! Q. [
5 c: `( U" Q6 v) o7 \. V
三、总结:
  • 指针是一个变量
  • 引用是一个变量的新名字
  • const引用能够生成新的只读变量
  • 在编译器内部使用指针常量实现"引用"
  • 编译时不能直接确定初始值的const标识符都是只读变量

    0 g8 C! `7 p# v
好了,今天的分享就到这里,如果文章中有错误或者不理解的地方,可以交流互动,一起进步。
# ^6 d2 a* q6 V- @
赞 收藏 评论0 发布时间:2020-8-28 20:54

举报

0个回答
关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版