C++ const限定符和auto类型说明符讲解

only1

const限定符
* j8 _( s( f) L- z8 ?% w& L
" M9 c! i! o2 @7 N% L0 t
# 1.限定常量

" ?1 T6 B6 y* J+ g; `

有时我们希望定义这样的变量：它的值不能被改变。为了满足这一要求，我们使用const对变量的类型加以限定：

. ?4 r1 M9 Y- |- S+ V; f+ U8 r
const int bufSize = 512;
# H3 d* {9 _$ d& n6 l

这样就把bufSize定义成了一个常量，它的值不能再发生变化。所以这也就意味着const对象必须要初始化。那么初始化操作对于const对象来说意味着什么呢？如果利用一个对象去初始化另外一个对象，则它们是不是const都无关紧要：

" t1 c. E6 }' k* B/ b
int i = 42;# Y" K/ _, H- Q& {! \& `$ P0 d; d
const int ci = i;  //正确5 }1 W2 G3 K9 w, C
# g5 h# r( c6 i  u/ ?* K$ eint j = ci;  //正确1 m$ o: w/ [( v3 B

这里要注意的是，虽然使用常量ci去初始化j，但是拷贝一个对象的值并不会改变它，一旦完成拷贝，新的对象就和原来的对象没有什么关系了。

# 2.const对象仅在文件内有效8 i# N2 h, K- v
6 s1 L/ B3 J2 N

默认情况下，const对象被限定仅在文件内有效。当多个文件中出现了同名的const变量时，其实等同于在不同文件中分别定义了独立的变量。但是，如果需要将const变量在多个文件中实现共享该怎么办呢？要做到在一个文件中定义const，而在其它多个文件中声明并且使用它，解决的办法就是：对于const变量不管是声明还是定义都添加extern关键字，这样只需要定义一次就够了。

0 R0 W- _4 V* [//第一个文件file14 B# O& h8 K! \) o/ r
extern const int bufSize = fcn();
//第二个文件file2# p' ]. `+ t0 p) h$ C. j# p$ |% Z
extern const int bufSize;  //与file1里面的是同一个
, `7 s) ?- Q- Mconst的引用

9 B8 y  l' \% B1 Q( D7 e+ c

对常量的引用不能被用作修改它所绑定的对象：

, A" M8 b) g8 ~+ W# V) G0 }! Y( kconst int ci = 1024;8 O7 ~1 o+ r- p6 [7 l7 w$ L
const int &r1 = ci;  //正确，引用及其对应的对象都是常量7 m* H! l, G0 U; g1 D  u8 A0 c
r1 = 42;    //错误，r1是对常量的引用
' }) C1 p' c* p% qint &r2 = ci;    //错误，r2是非常量引用，ci是一个常量

我们知道，引用的类型必须与其所引用的对象的类型一致，但是有两个特殊情况：（1）初始化常量引用时允许用任意表达式作为初始值，只要该表达式的结果能转换成引用的类型即可。

+ v+ t' y! f* @( n
2 G/ D6 B6 R* \, z$ Idouble dval = 3.14;4 S. ?- z& M* a, N7 R8 i! T+ P4 ~
const int &ri = dval;( R" \' c4 B& I4 h8 S
1 Q5 c/ d" j7 ?( M8 j+ l) r

ri引用了一个int型的数，但是dval确实一个双精度浮点数，编译器会将其变成如下形式：

8 }! X% ^5 s  S, s
const int temp = dval;5 v2 g& o/ M& H  c1 P& ~9 @1 s: t
5 v: q8 ]4 ^( H0 h3 y' n; v; s9 B9 zconst int &ri = temp;

（2）对const的引用可能引用一个并非const的对象

- K3 }( _4 A% U
2 H/ k- y) h7 v# ]int i = 42;
const int &ri = i;9 ^6 G0 t7 l3 z/ m2 q
, L* ?1 ^6 U$ `: `6 ]

这种方式是允许的。

( Z" c+ m9 t9 q( d1 b2 k
! d) s2 B" x$ r: Y2 r' C1 V# const与指针* g! q5 _- o+ d' Z% d. Y. ?
6 A" q3 E3 ^- _* }1 G2 |- r
9 b1 @( M8 U! u9 |/ L

顶层const

顶层const表示指针本身是一个常量，不能改变它的指向。

% k+ y* U6 p5 U; d, |
% m2 z: c, O/ `) @% R8 Xint i = 43;& [1 K' f" S  Z; [4 C( G
int * const p1 = &i;
) Y4 Y; v6 \" p; h4 R8 Y5 _4 E

底层const表示指针所指的对象是一个常量。

int i = 43;
2 B/ g# ?( P7 {# d. xconst int * p1 = &i;6 r- `- [" Z* o1 d* C- q# M
+ A! S4 D0 O, qint const * p2 = &i;
# 常量表达式与constexpr
% b: }- ?4 h/ m2 L/ w- D* J3 j1 ~
; O* Q( v8 ~* R+ I

常量表达式指的是值不会改变且在编译过程中就能得到计算结果的表达式：

! Y6 l' q8 u2 X, l$ t( l8 ~
const int max_file = 20;    //是常量表达式( Z1 h2 y" z5 q" u
const int limit = max_file + 1    //limit是常量表达式
% j* d- w  N4 k9 \4 sint stuff_size = 10;      //stuff_size不是常量表达式
2 ~* ~0 o, q' Cconst int sz = getSize();     //sz不是常量表达式

C++11标准规定，允许将变量声明为constexpr类型以便由编译器来验证变量的值是否是一个常量表达式。声明为constexpr的变量一定是一个常量，而且必须用常量表达式初始化：

$ L8 Z2 w& A$ c
constexpr int mf = 20;  //  正确
constexpr int limit = mf + 1;    //mf+1是常量表达式
) ?- U7 |  ^* A$ f0 E" h& @4 pconstexpr int sz = size();      //只有当size()是一个constexpr函数时才是一条正确的语句4 B; Q# B: S2 V3 ]2 l8 f$ \; W
% B7 ^; g8 I6 P% A

需要注意的是，在constexpr声明中如果定义了一个指针，限定符constexpr仅针对指针有效，与所指的对象无关。

# auto类型说明符

C++11引入auto类型说明符，它可以让编译器通过初始值来推断变量的类型。显然，auto定义的变量必须有初始值。但是，auto会忽略掉顶层const，：

- H% k; s2 _1 D. g/ r
const int ci = i, &cr = ci;
' B& d: B- D9 ]8 q' aauto b = ci;     //b是一个整数* ~! J9 O0 ^1 H! O/ K, W( W" n
) \! H2 O! M6 j' Eauto c = cr;    //c是一个整数
, z& |. u3 r) c! x( X- U$ u. N, mauto d = &i； //d是一个整型指针
! e9 h! {& ?7 J" h! l8 xauto e = &ci；  //e是一个指向整型常量的指针（这是底层const）
+ G$ i2 G( a, w7 \

但是，有时会遇到一种情况：我想知道这个表达式结果的类型，但是我又不想真的用这个表达式的结果来初始化变量。这个时候就要用到另外一个类型指示符decltype

5 c& p- X  {6 w% R
decltype(f()) sum = x;    //sum的类型就是f()函数的返回类型, o$ y" `! V+ R  i% j) E7 o0 k
9 t6 K' u: N& e% B4 p+ y

编译器并不会实际调用函数f()，而是使用当调用发生时f的返回值类型作为sum的类型。decltype的一个坑：对于decltype所用的表达式来说，如果decltype给变量加上括号，则返回的是引用类型：

( A8 K+ ~6 f! s' b: e/ m
5 |' n: w' G1 h7 ]5 x( j  A2 eint i = 42;$ f8 s* k, {; I
& q4 k5 p0 p- v% l7 b. T! M* Udecltype((i)) d;    //错误，d是int&，必须初始化