2.1

int,long long ,short 可表示范围和占用内存空间不同。具体与计算机有关。

无符号类型只能表示0和正数，带符号类型可以表示负数，0，正数。

float是单精度，一般占用4个字节，double是双精度，一般占用8个字节，它们可表示的数据范围也不相同。

2.2

利率用double，本金和付款用int

2.3

    unsigned u=10,u2=42;    cout<<u2-u<<endl;    cout<<u-u2<<endl;    int i=10,i2=42;    cout<<i2-i<<endl;    cout<<i-i2<<endl;    cout<<i-u<<endl;    cout<<u-i<<endl;

输出

32
4294967264
32
-32
0
0

但凡unsigned类型涉及负数运算都会出现意外的情况（具体查询整数在计算机内的表示方法），比如上面第2个。int与unsigned计算会将int转化为unsigned。

2.4

略

2.5

（a）。

‘a‘ 是单字符字面值，char

L‘a‘是宽字符字面值，wchar_t

"a"是字符串字面值

L"a"宽字符型字符串字面值

wchar_t占16位，char占8位

（b）。

10是int字面值

10u是unsigned字面值

10L是long字面值

10LL是longlong字面值

012是八进制，等于十进制下的10

0xC是十六进制，等于十进制下的12

（c）。

3.14浮点数字面值

3.14f是float字面值

3.14L是longdouble字面值

（d）。

10是int字面值

10u是unsigned字面值

10.浮点数字面值

10e-2浮点数字面值，等于0.01

2.6

上面一行定义的是十进制整型，下面一行定义的是八进制整型，因此int month=09的写法是错的。

2.7

（1）字符串常量

cout<<"Who goes with F\145rgus?\012";

输出Who goes with Fergus?

其中\145是‘e‘，\012是’\n‘

（2）longdouble常量

（3）float常量

（4）longdouble常量

2.8略

2.9

    cin>>int inpu_value;//error：不能在读入的时候定义，只能读已经定义好的变量    int i={3.14};//虽然编译通过，但是给了一warning，因为损失了精度！可能与编译器有关，有的可能会报错。    double salary=wage=9999.99;//errer:wage未定义，不能连续定义！    int j=3.14;//正确，虽然也损失了精度，但没有提示

2.10

local_int初值未知

global_int初值为0

global_str和local_str初值为空

2.11

（a）错误，既有extern又有初始值

（b）定义

（c）声明

 2.12

（a）非法，double是c++关键字

（c）-不能出现在变量名中

2.13

j等于100

因为局部变量i隐藏了全局变量i

2.14

输出100 45。

 2.15

（a）正确，发生隐式转化double转int

（b）错。普通引用不能绑定常量，而且数据类型也不符。

（c）正确

（d）错，引用未初始化。

2.16

（a）合法，double赋给double

（b）合法，int隐式转化成double

（c）合法，double隐式转化成int

（d）合法，double隐式转化成int

2.17

输出10 10.

因为ri是i的引用，改了i的值

2.18略

2.19

指针是对象，它指向的也是一个对象。

而引用不是对象，它绑定一个对象，是对象的一个别名，定义时必须初始化。

很多区别。。。

2.20

第一行：定义变量i=42

第二行：定义int指针指向i

第三行：通过指针修改i，使其等于42*42

2.21

（a）指向double的指针不能指向int变量

（b）错误。等号右侧缺少&。

（c）正确

2.22

如果p不是空指针。。

如果p指向的对象非空。。

2.23

在不用智能指针的前提下，定义的时候指针要初始化，释放内存后指针要置NULL。这样就可以通过检查指针是否为NULL来判断是否指向合法对象了。

2.24

void*p是一种特殊的指针类型，可以存放任意对象的地址。

*lp是指向long的指针而i是int，数据类型不符。

2.25

（a）ip是野指针，i的值是随机的，r绑定i。

（b）i的值是随机的，ip是空指针

（c）ip是野指针，ip2是int数据类型，值是随机的

2.26

（a）错，const变量必须初始化

（b）正确

（c）正确

（d）错。sz是指向常量对象的引用，不能修改对象的内容。

2.27

 (a)&r=0,错误，普通引用不能绑定常量

（f）错误，不存在常量引用，而且也没用初始化

2.28

（a）不合法，*const需要初始化。

（b）不合法，*const需要初始化。

（c）不合法，ic是常量需要初始化。

（d）不合法，常量指针需要初始化

（e）不合法，常量指针对象初始化。

2.29

这里要注意const修饰的是数据类型还是声明符。

如*、&（类型修饰符）都只是声明符的一部分，不属于数据类型的部分。类型修饰符不作用于本次定义的全部变量，只作用于修饰的变量。

（a）合法，常量可以拷贝给非常量

（b）不合法，p3有底层const，不能赋给p1

（c）不合法，ic是常量，而p1是普通指针，不能指向它

（d）不合法，p3是常量指针，不能再指向其他对象

（e）不合法，p2是常量指针，不能再修改它指向的地址

（f）不合法，ic是常量，不能修改

2.30

    const int v2=0;//顶层const    int v1=v2;    int *p=&v1,&r1=v1;    const int *p2=&v2,*const p3=&v1,&r2=v2;    //p2是底层const，p3是顶层、底层const，r2底层const

2.31

（1）。合法

（2）。p1=p2不合法，p2具有底层const不能赋给p1；p2=p1，合法，没有const的指针可以赋给有底层const的指针

（3）。p1=p3不合法，p3具有底层const；p2=p3合法，两个指针都有底层const

2.32

不合法。不能将非地址的数据类型赋给指针，即使该变量值等于0也不行。

*p=NULL;

2.33

 a是int，赋值合法。

b是int，赋值合法。auto会忽略顶层const而保留底层const

c是int，赋值合法。从引用中得到的是int。

d是一个int*，赋值不合法。

e是一个指向常量的指针，具有底层const，赋值不合法

g是常量int引用，赋值不合法。

auto可以从指针中得到指针变量，但是不能从引用中得到引用。所以我们可以使用auto&来定义引用。

2.34略

2.35

auto &k=10;这样是不行的

但是const auto &k=10;就可以

j是const int。

k是指向常量对象的引用。（前面不加const效果是一样的）

p是指向常量对象的指针

j2是常量int。

k2是指向常量对象的引用。

2.36

    int a=3,b=4;    decltype(a) c=a;//c是int    decltype((b)) d=a;//d是a的引用    ++c;    ++d;    cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl

2.37

对表达式使用decltype会得到普通引用

    int a=3,b=4;    decltype(a) c=a;//c是int    decltype((a=b)) d=a;//d是a的引用    c=5;    d=10;    cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl;

2.38

auto根据定义时的表达式决定变量类型同时初始化变量

decltype根据表达式决定变量类型但不同时初始化变量

等等。。