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

c++-

[复制链接]
gaosmile 发布时间:2020-8-20 20:31
关于const的用法,现在大概前前后后应该写了有两篇文章,以前学习的时候,用法体会不是那么深刻,为啥这么说呢,因为在学习c++的时候,会发现const关键字有新的玩法,关于这个新的玩法,大家可以去看最近学习总结写的c++文章专辑。
一、const的用法:
1、const只读变量:
  • const修饰的变量是只读的,本质上还是变量
  • const修饰的局部变量在栈上分配空间
  • const修饰的全局变量在全局数据区分配空间
  • const只在编译期有用,在运行期没有用

    : o0 o; S0 \: a. ^) w3 {
注:const修饰的变量不是真的常量,它只是告诉编译器该变量不能出现在赋值符号的左边
2、const全局变量的分歧:
  • 在现代c语言编译器中,修改const全局变量将导致程序崩溃
  • 标准c语言编译器不会将const修饰的全局变量存储于只读存储区中,而是存储于可修改的全局数据区,其值依然可以改变

    : _5 i+ C( V$ d  `0 j0 {6 f
3、代码示例:
(1)只读变量代码示例:
#include <stdio.h>
0 n) z, A. ]9 n2 }7 q6 b
$ Z9 A+ y; a9 @. }int main()4 t" x8 p$ @" C
{$ D9 b, r6 ]5 ^5 |3 M! v6 J& s- C
   const int a =10;1 |! w* w2 U5 H( z/ z! [' H! ^2 I9 L
   printf("a = %d\n",a);
% G$ i8 H1 ]! L  o, j% {9 A6 n5 h+ `# ^  P9 V0 A& s3 a, }4 G% U( o% V
   a=20;
; _8 t- e2 [. h   printf("a = %d\n",a);6 P0 q3 V9 C+ u4 k' `8 {
  
' z+ |3 A% Q5 H" f- H. {  V0 Y: [0 f  return 0;
& v! v6 }2 W, c" e* o/ P  _# `9 l1 ^}/ V; U) a# s! w  ^# a% X

8 B& [& |- K6 H/ D( M3 Q
运行结果:
test.c: In function ‘main’:
# m7 [1 w# b( p- e4 ptest.c:8:4: error: assignment of read-only variable ‘a’* {( h* a4 u  D2 `1 d3 G/ M* `; V
    a=20;. g8 O0 \; Z) f% S% }* M
    ^
8 {- X) A9 I9 _8 I7 _0 H: b1 `+ R8 W# W* D3 ?
注解:显示这个结果很正常,变量a被const修饰了,它就成了只读的。
(2)如果对变量a的值进行修改:
#include <stdio.h>
" i6 ]0 C0 I1 o( U7 Q3 k/ c% g) P& W! J+ T
int main()
/ B! m! p3 `; m& _$ V7 L( ~9 F{9 V  C" j& s7 ^; K, X+ Z# t7 o
   const int a =10;/ P) I  z( ^2 j" Y: Z8 U
   int *p =(int *) &a;8 i, S+ S! l' i/ t" C7 t
   printf("a = %d\n",a);3 e( i/ m0 @# l* N8 p
) g7 f/ o7 _2 w0 c: q4 ~
   *p=20;& s3 o) |# ]% Z' t- I& B7 y
   printf("a = %d\n",a);
. i+ j+ A8 ]/ S! l# A; }
: m& A% q5 U$ |. \/ A8 Z( i  O2 h+ y) M6 p1 y
  return 0;$ z" h2 F* e1 h- A
}. r" x' K2 v4 G0 O+ ~! w8 V$ w
* g7 B) q1 r/ a, p5 U

3 G. R$ T( h, a( ^
运行结果:
root@txp-virtual-machine:/home/txp# ./a.out; ~8 Y( y" a5 Z/ O) ?
a = 10
( {7 \% {* F/ k3 ^7 R) n$ b9 \a = 202 ?4 [1 X' ?! N* `! X9 k5 r

8 x8 f  `  x4 e, d
注解:通过指针的方式,就能够把a的值进行修改,这也论证了“const修饰的变量是只读的,本质上还是变量”这句话
(3)const修饰全局变量:
代码版本一
#include <stdio.h>1 H- G8 i3 D- b. d* a# O$ C
const int b = 40;$ _$ Q# ]# c7 Z7 P! J0 c
2 N1 f* {' {6 }# F% h* _
int main()
( g/ S( |! d5 r* A/ K6 }{
" [+ x& A' c- M! k" ~1 i   
7 A/ O5 I) [: Y  h 7 a, m% |) d+ a' S6 R) r/ t
   printf("b = %d\n",b);
- W  o' L" H6 I, w9 u   b=20;/ L7 Y8 D$ X- I" n! k% X
   printf("b = %d\n",b);0 l  @6 W5 I7 h+ c5 R  c- X8 T4 T
1 v* }  G! \. V3 I% q9 V2 l

4 E  G) J: w) @5 o7 n  return 0;
( Q5 i# z$ u; k2 k/ B/ m}( o9 ]/ a' z. ^! B' i  L

3 G. V& Y/ K3 F1 q; a) x
输出结果:
root@txp-virtual-machine:/home/txp# gcc test.c
" K3 i# y. F) m) C7 f' Htest.c: In function ‘main’:
# Q/ @& @* E. Y3 `& ~; Ltest.c:10:4: error: assignment of read-only variable ‘b’
  f" j/ a& w7 ?7 b# [% ~) y    b=20;
( Z0 M* q4 _' O) i( v    ^
, [- O0 |- c6 \" {/ W* S$ y2 y6 c' s3 Q
注解:跟const修饰栈上的变量用法一样
代码版本二
#include <stdio.h>  k, j& U5 v5 v* ]
const int b = 40;/ s# e( @* @+ C  X0 K
# s% q5 w5 m8 s. f% t# E
int main()& I/ H3 p2 ^. G9 F5 V  x
{
8 F+ W. j- Q# j5 Z$ J7 G; o7 i. G/ a
   int *p =(int *) &b;6 Y' o- ^( }; q4 L  B
   printf("b = %d\n",b);: e( u) r8 i' O" a: x

8 K* J# O9 V8 u0 n! w6 Z   *p=20;
$ h/ Q6 o% A0 E) Q. J6 v   printf("b = %d\n",b);' n; C* E4 h; l5 U2 x1 E$ |/ u1 t
, i' l% {, Q/ H

. T, z6 H5 ?* S# u. S  return 0;
0 M& S/ A# a% x4 S}- c/ D. D! T) F% @$ X% s1 T6 ]
& D) ]/ o& w  M+ j8 T) k. q
运行结果:
root@txp-virtual-machine:/home/txp# ./a.out9 ^( c, O3 q" O* M& O! I
b = 400 P, ^- ?# P$ H0 X
Segmentation fault (core dumped)' |- d  d4 E: R- U
1 ^) u! W, M8 S2 M* o
注解:这里出现了段错误,这也验证了我们上面所说的“修改const全局变量将导致程序崩溃”。
同时为了验证“标准c语言编译器不会将const修饰的全局变量存储于只读存储区中,而是存储于可修改的全局数据区,其值依然可以改变”这句话,我把这段代码放到dev c++上进行试验:
微信图片_20200820202426.png
说明:我这个版本的编译器支持标准c语言,所以没导致程序崩溃,能够正常运行
4、const的本质
  • c语言中的const使得变量具有只读属性
  • 现代c编译器中的const将具有全局生命周期的变量存储于只读存储区,不是放在全局数据区
    . e* j4 B  u0 ^# Q! m% _, Q
注:const不能定义真正意义上的常量;同时这里注意static关键字修饰的变量,它的生命周期和全局变量一样。
代码示例:
#include <stdio.h>. H/ p. v  n$ F1 e% z$ S: Q+ }+ w

1 j9 D/ J* }# c  ~const int Array[5] = {0};
" B! j  l6 V1 L( F3 F, N" |
# _6 R$ o8 W) A8 B1 J; N+ Hvoid fun(int *p,int v)
, }  |+ c1 E/ n4 c4 V. L3 U2 B) _{
8 X& ^2 P2 R: f   *p=v;% I9 ^1 |" z, s4 ~) [6 D0 N6 ?. e/ U
}
+ {. P* @! n. _/ Hint main()
# V0 F$ \1 w" b; o. u{
0 ~2 Z$ \3 e2 o1 Z. H& T    int const i =1;
# [( j0 O. i9 R0 X5 f& ]    const static int j =2;6 @  m) a2 @# l( U+ ~+ r* Z+ T
    int const array[5] = {0};
! K8 d" y5 ]* e8 H; s7 @
+ j" l9 {$ M1 T0 C    fun((int *)&i,1);7 S/ Q$ O8 t) b" i6 b6 u
    fun((int *)&j,2);" b9 B) d! I, [
    fun((int *)&array[2],3);
5 W8 V8 `: Y7 a/ {; _, h    fun((int *)&Array[1],4);
4 }' j: l- _' ]% Y3 x. [/ O5 v4 L% }8 n) P& G7 L
   return 0;
& n5 t1 {6 M: e6 N. l! Q4 E* A: d' f; T9 P) f; W! `' H' ?
}! l+ N' K, k) [9 o

. M7 `+ ?5 B7 p
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out8 ?. c. F, |1 s5 r+ R
Segmentation fault (core dumped)
5 s( P8 m* W! V- a) {7 i4 v0 r: n/ ~/ F7 b4 t: ]
注解:这里会有段错误,错误出现在const+static修饰的j变量对其进行修改,还有const修饰的全局数组。
5、const修饰函数参数和返回值
  • const修饰函数参数表示在函数体内不希望改变参数的值
  • const修饰函数返回值表示返回值不可改变,多用于返回指针的情形

      L1 {: `9 p% H7 X* j0 M3 E
在c语言中的字符串字面量存储于只读存储区中,在程序中需要使用const char* 指针,例如:
const char * s = "TXP嵌入式";//字符串字面量
& ]+ E$ X' Y/ f; v3 u8 C8 }7 w
代码示例:
#include <stdio.h>* u9 T0 K) |4 O6 L$ k) S, K6 g

) q' J5 O9 a# G( E$ {const char*fun(const int i)* o2 r  u+ _; j$ p( a# @0 p
{
! C& z8 C8 C  X# K! A3 |9 x   i=8;  V1 A0 s6 A; J' Y, D# v9 L7 k
    return "TXP";
# i% ^2 t7 y# c! y}+ ]! l" B5 M6 P- {4 \' [, {1 G
int main()
. E7 y  o( {* I* k8 T+ N{, i& P, z; |- }
   const char * p=fun(0);2 _) `2 }. m2 a3 m- S
    printf("%s\n",p);5 T  m+ r0 I( {6 N
    p[1]='_';! T- a' R6 Y# [4 f6 j( L, u
    printf("%s\n",p);# d' Y* s0 T: M0 I7 H7 N

; q! [: H+ i3 f- ^    return 0;& M6 x! u* d+ J
+ b3 E' P1 W1 z& E8 J7 b

7 N; B: a- Q! c6 ^$ Q( `}
" ~  `0 p1 Y$ ?5 b, ~
6 Q- q' b6 Y0 e9 ]+ T. W- c' b6 d4 }  {/ ?9 U9 f* j) g
输出结果:
root@txp-virtual-machine:/home/txp# gcc test.c
/ F* @$ k2 f* `) h8 z& W. R: xtest.c: In function ‘fun’:
* _3 F: U( V( @+ x8 Y) b  ttest.c:5:4: error: assignment of read-only parameter ‘i’; O0 {8 P! \, ?) f- I- E/ @
    i=8;/ V3 j7 A) A4 q9 c9 c! q6 ^
    ^: d% x2 S/ S" Y; X/ j  `0 p
test.c: In function ‘main’:! b  n4 y; }6 |- n3 E
test.c:12:5: error: assignment of read-only location ‘*(p + 1u)’
. G5 |; P$ d6 H9 ~4 v3 t3 y     p[1]='_';2 w! b& m2 o1 b3 U0 D5 a: k1 W/ P
     ^9 O1 y7 X# a2 h  X5 a7 `

. }- n. i8 Q0 ^9 |7 T9 F
注解:上面这样写,肯定有问题。
代码进化:
#include <stdio.h>
; g8 x# `# I7 s) p% \$ _; C3 |& T( Z. a2 T4 C1 I
const char*fun(const int i)
$ b; c, Z6 t4 t6 S{
# R/ e) q) U" L$ B0 d2 t' ^, f9 F//   i=8;
3 O/ q# ^( v5 [% ?    return "TXP";1 {5 J; W! ?7 k6 u3 y* T8 x% M
}4 O) m2 L* ?6 v& q- V
int main()0 P# @2 U' H$ i( U  c
{3 J. B: ~4 Z5 h. S! \7 {; Q
   const char * p=fun(0);  V( h" }2 V! z; E' \& S8 n- J! E
    printf("%s\n",p);+ y" R! x& z  p6 A2 x- v
  //  p[1]='_';7 j9 y* _  _" ?. h0 c. q0 A' r
   // printf("%s\n",p);* Q2 g( b# b- ]0 N8 A

5 {7 m8 ]' J& L4 B% r    return 0;8 Z% W0 L- e# ^: o

8 z+ L+ [" D% V) V! }* W5 Q5 v0 r' ?. b1 C' U
}
; H' u$ c' S7 Z; y
3 N3 N( m& _. j/ m; u5 D
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out
2 S4 N; ^/ ?, ?, K: ~+ PTXP0 s; p( n6 L& n  f, L8 I! W

7 G$ T+ R. w8 w. s  {' f
二、volatile的用法
老实说,这个关键字在面试题目里面经常会出现,但是平时学习的时候,如果你没有真正理解这其中的含义,在笔试的时候,脑袋里面可能依稀是记得有那么几个结论,但是有时候吧,一紧张就把结论给忘了,也不是不可能,所以说,咋们还是老实一点,得真正把它原理搞明白才行,这样上来战场就不怕了,以后写代码也就少一点bug。
1、volatile的常用结论(volatile英文本意就是易变的意思)
这里我先给结论,然后再给一个例子,把这个例子的讲明白,所有结论就都明白了。
  • volatile可理解为“编译器警告指示字”
  • volatile告诉编译器必须每次去内存中取变量值
  • volatile主要修饰可能被多个线程访问的变量
  • volatile也可以修饰可能被未知因素更改的变量
  • volatile可以修饰一个中断子程序中会访问到的非自动变量
    ; C( b. r: J8 x
2、分析原理
大家可能平时在博客学习,都会发现讲解编译器优化的,然后加了volatile关键来修饰变量,就告诉编译器不要去优化这个变量了,那么这里的优化到底是什么意思呢?
从字面上来理解优化两个字,意思就是最优值(变量的值不会改变),这里我用一个简单代码来说明一下:
#include <stdio.h>
4 g+ t+ ^5 l9 X6 S+ q( n- O9 j5 }2 k: }- |6 l2 c
int main()
, F" H/ r* m# p, y. [! s9 l! N3 |{8 M: q( f# s2 V( v9 z: K
    int a =1;//volatile int a =0;
$ {! b$ g2 Y+ u     6 W' O0 K4 X  `
    while(a)
' k3 D! G- z3 ?# g    {
0 G( x# A* J8 ^4 e! x, p    $ n* Z: V( _* v1 _& |9 v
    }% m9 X- {# n) x+ v, o0 i' ~
}
) S: f0 T7 Y7 A' P" y0 q& h
说明:上面的代码,如果变量a没有加volatile修饰的话,编译器就会优化它(也就是a的值一直不变),所以while就一直死循环;然后我如果加了volatile来修饰的话,编译器就不会去优化变量a,不优化的意思就是说,变量a的值可能就会改变,while就不会一直死循环。
当然这里为了好理解,我说的不是很专业,没有从寄存器和内存的角度去说。(我也不想那么去讲解,简单理解了就行)
总之一句话:上面的结论中,volatile修饰的都是变量,变量就可能改变,不会被编译器优化;只是说我们上面的结论应用场景不同而已。
三、总结
  • const使得变量具有只读属性
  • const不能定义真正意义上的常量
  • const将具有全局生命周期的变量存储于只读存储区
  • volatile强制编译器减少优化,必须每次从内存中取值
    + r! n! ~' @' Y( i8 q
微信图片_20200820202430.png
1 r/ ^  D4 e/ `" ~, H! ^
好了,今天的分享就到这里,如果文章中有错误或者不理解的地方,可以交流互动,一起进步。
1 C7 |+ i" ?; Q# ]
赞 收藏 评论0 发布时间:2020-8-20 20:31

举报

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