c++ Primer 第五版习题答案第二章
Q: 类型int、long、long long和short的区别是什么，无符号和带符号类型的区别是什么？float和double的区别是什么？
int、 long、 long long和short尺寸不同，表示的数据范围不同。无符号只能表示0和正数，无符号还可以表示负数。float为单精度浮点数，double为双精度，一般来说，float占4字节，double占8字节。
练习2.2
Q: 计算按揭贷款时，对于利率、本金和付款分别应选择何种数据类型？说明你的理由。
利率应该用unsigned double表示，本金和付款应使用unsigned float表示。因为利率一般小数位数较多，且没有负数，本金和付款小数位数少，也没有负数。
练习2.3
Q: 读程序，写结果
unsigned u = 10, u2 = 42;
std::cout << u2 - u << std::endl; //32
std::cout << u - u2 << std::endl; // -32的补码 4294967264
int i = 10, i2 = 42;
std::cout << i2 - i << std::endl; // 32
std::cout << i - i2 << std::endl; // -32
std::cout << i - u << std::endl; // 0
std::cout << u - i << std::endl; // 0
练习2.5
Q：指出下面字面值的数据类型
（1）'a'<字符字面值>, L'a'<宽字符字面值，类型是wchar_t>, "a"<字符串字面值>, L"a"<宽字符字符串字面值（2）10<十进制>, 10u<无符号整型>, 10L<长整型>, 10uL<无符号长整型>, 012<八进制>, 0xC<十六进制（3）3.14,<浮点数> 3.14f<单精度浮点型字面值，类型是float>, 3.14L<扩展精度浮点型字面值，类型是long double>
（4）10<十进制>, 10u<无符号整型>, 10.<浮点型>, 10e-2<浮点型字面值>
练习2.6
Q：下面两组定义是否有区别？
int month = 9, day = 7; //定义的month和day均为10进制
int month = 09, day = 07; // 定义的month和day为八进制，month会报错，因为09超出范围了。error: invalid digit '9' in octal constant
练习2.7
Q：下述字面值表示什么含义？各自的数据类型是什么？
(1)"who goes with F\145rgus?\012"
// \145表示小写字母“e”， \012表示换行符。 输出：who goes with Fergus?
(2) 3.14e1L // 表示扩展的浮点型，类型是long double
(3) 1024f // 单精度浮点型字面值，类型是float
(4) 3.14L // 表示扩展的浮点型，类型是long double
练习2.8
Q：使用转义写一段程序，先输出2M，然后转到新的一行，修改程序使其先输出2， 然后输出制表符，再输出M，最后转到新的一行。
cout << "\62\115\012" ;
cout << "\62\t\115\012" ;
练习2.9
Q：解释下列定义的含义。对于非法的定义，说明错在何处
(1）std::cin >> int input_value // 错误，不能在输入输出语句中定义变量。
（2）int i = { 3.14 }; // 错误，在初始化列表中使用浮点型初始化int变量可能会丢失数据，编译器会拒绝执行
（3）double salary = wage = 9999.99; // wage未定义，如果wage定义了，则该语句可以正常执行，最终wage和salary相等
（4）int i = 3.14; // 警告，有隐式转化，i值为3。
练习2.10
Q：下列变量的初始值是什么？
std::string g_str; //初始化为一个空串
int g_int; // 初始化为0
void test210 ()
{
int local_int; //按标准局部变量不初始化，g++编译器下可能也会初始化为空
std::string local_str;
}
练习2.11
Q：指出下面的语句是被声明还是定义。
（1）extern int ix = 1024; // 定义 （任何包含了显式初始化的声明即成为定义）
（2）int iy; // 声明并定义 （想声明而不定义，就在变量名前家extern）
（3）extern int iz; // 声明
练习2.12
Q：请指出下面的名字中哪些是非法的？
（1）int doube = 3.14; //非法，double为关键字，不能作为变量名
（2）int _; //合法
（3）int catch-22; //非法，变量名只能包含字母、数字、下划线
（4）int 1_or_2 = 1; //非法，不能以数字开头
（5）double Double = 3.14; //合法
练习2.13
Q：下面程序中j的值是多少？
int i =42;
void test213 ()
{
int i = 100;
int j = i;
cout << "j = " << j << endl; //j =100 ,使用局部变量j。
}
练习2.14
Q：下面的程序合法吗？输出什么？
int i =100, sum =0;
for (int i =0; i != 10; ++i) {
sum += i;
}
cout << i << " " << sum << endl;
// i = 100, sum = 45，for循环中的i，只在循环体内起作用，因此输出的是全局变量i= 100， 局部变量sum依旧在作用域内，因此输出局部变量sum=45。
练习2.15
Q：下面哪个定义是不合法的，为什么？
（1）int ival = 1.01; //用float初始化int，不合法，会有警告
（2）int &rval1 = 1.01; //非法，引用的初始值必须是一个对象
（3）int &rval2 = ival; //合法
（4）int &rval3; //非法，引用必须被初始化。
练习2.16
Q：下面哪些赋值不合法，为什么？
int i = 0, &rl = i;
double d = 0, &r2 = d;
（1）r2 = 3.14159; //合法,d的值也变为3.14159
（2）r2 = r1; //合法，但隐式转化
（3）i = r2; //合法，但隐式转化
（4）r1 = d; //合法，但隐式转化
练习2.17
Q：下面的代码会输出什么结果？
int i, &ri = i;
i = 5;
ri = 10;
cout << "i = " << i << " ri = " << ri << endl;
//i = 10, ri = 10 --- 改变ri的值也会改变i的值。
练习2.18
Q：编写代码分别更改指针的值以及指针所指对象的值。
int i =20;
int j = 10;
int* p = &i;
cout << "p = " << p << endl; // p = 0x7ffee3a3ea3c
p = &j;
cout << "p = " << p << endl; // p = 0x7ffee3a3ea38
*p = 5;
cout << "*p = " << *p << " i = " << i << " j = " << j << endl;
// *p = 5 i = 20 j = 5
练习2.19
Q：说明指针和引用的主要区别。
(1) 引用在定义时必须初始化，而指针可不初始化
（2）引用在其生命周期内，只能指向一个对象，而指针可以先后指向不同的对象
（3）指针本身就是一个对象，允许对指针进行赋值和拷贝。
练习2.20
Q：叙述下面代码的作用
int i = 42;
int * p = &i;
*p = *p * p; // 4242, 求i的平方。
练习2.21
Q: 解释下述定义是否非法。
int i = 0;
(1）double* dp = &i; //非法，不能用int型的变量初始化doube指针
(2）int* ip = i; //非法， 不能用int值初始化指针
(3）int* p = &i; //合法•
练习2.22
Q: 假设p是一个int型指针，说明下面代码的含义
if (p) //如果地址不为0
if (*p) //如果所指的值为真
练习2.23
Q: 给定指针p，能否知道它指向了一个合法的对象？
不行，如果你把指针理解为一个信封上的地址，那么没有任何手段能保证你填写的地址必然有人住。(别人的回答)
我的理解，给定一个指针，首先要判断这个指针是否有效（不为NULL，地址合法等），好像没什么办法判断指向了合法对象，有可能在使用过程中发现。
练习2.24
Q: 下面的代码中，为什么p合法而lp非法？
int i = 42;
void *p = &i; //因为void指针类型可以存放任意对象的地址
long *lp = &i; //但是long指针，就只能存放long对象的地址
练习2.25
Q: 说明下列变量的类型和值。
A:
(1) int* ip, i, &r = i; // ip 为int指针类型，i为int型，r为引用类型，初始化为i。
(2) int i, *p =0; // i为int型， p为int指针类型，初始化为0，并未指向任何对象
(3) int* ip, ip2; // ip为int指针类型，ip2为int型
练习2.26
Q: 下面哪些句子是合法的，说明原因。
A:
（1）const int buf; // 不合法，声明一个const常量的同时必须初始化
（2）int cnt = 0; // 合法，声明并初始化一个int变量
（3）const int sz = cnt; // 合法，声明一个int const常量，并初始化。
（4）++ cnt; ++sz; // 不合法，sz为常量，不能进行++操作。
练习2.27
Q: 下面哪些初始化是合法的，说明原因。
A:
（1）int i = -1, &r = 0; // 不合法， r为引用，初始化只能指向一个对象。
（2）int *const p2 = &i2; // 合法，定义一个int型的常量指针，初始化为i2的地址，之后指针的值不能再改变
（3）const int i = -1, &r = 0; // 合法， r为引用，const int &r = 0; 是合法的。（感谢评论去指正）
（4）const int* const p3 = &i2; // 合法，p3的值不能改变，*p3也不能改变
（5）const int* p1 = &i2; // 合法，指针常量，p1指向的值不能被改变
（6）const int& const r2; // 不合法，引用不能是const
（7）const int i2 = i, &r = i; // 合法
练习2.28
Q: 下面哪些是合法的，请说明。
A:
（1） int i, *const cp; // 不合法，定义const类型指针要初始化，cp
（2） int *p1, *const p2; // 不合法，同上，p2应该初始化。
（3） const int ic, &r = ic; // 不合法，ic为const类型，必须要初始化
（4） const int *const p3; // 不合法，p3需要初始化
（5） const int *p; // 合法，指向是常量，但指针的值可变。
练习2.29
Q: 假设已有上题中所定义的变量，则下面哪些是合法的？
A:
（1） i = ic; // 合法
（2） p1 = p3; // 不合法，int* 不能用const int* 初始化
（3） p1 = // 不合法，p1是一个普通指针，不能指向const int类型的值。
（4） p3 = // 不合法，p3的值和p3指向的值都不能改变
（5） p2 = p1; // 不合法，p2的值不能被改变
（6） ic = *p3; // 不合法，ic是常量，不能被改变
练习2.30
Q: 对于下面的语句，请说明对象被声明为顶层const还是底层const。
A:
（1） const int v2 = 0; int v1 = v2; // v2是顶层const
（2） int *p1 = &v1, &r1 = v1; // 非const
（3） const int *p2 = &v2, *const p3 = &i, &r2 = v2; // p2是底层const，p3最左是底层，p3前面是顶层const， r2是底层const。
练习2.31
Q: 假设上题中的变量已定义，判断下面语句哪些合法。
A:
（1） r1 = v2; // 合法，引用改变值
（2） p1 = p2; p2 = p1; // 不合法，p2是底层const，赋值对象必须同样有底层const才行，p2 = p1合法
（3） p1 = p3; p2 = p3; // 不合法，p3是底层const， p2 = p3合法。
总结：顶层const可以进行赋值操作。但底层const有限制，拷入拷出的对象也必须具有相同的底层const。
练习2.32
Q: 下面的代码是否合法？说明原因。
A:
int null = 0, *p = null;
// int *p不能用int型来初始化。 应为 int null = 0, *p = &null / int *p = nullptr
练习2.33
Q: 利用本节已定义的变量，判断下列语句的运行结果。
A:
（1） a = 42; b = 42; c = 42; // a, b, c的值均为42
（2） d = 42; e = 42; g = 42; // d:error, d为int *类型
// e:error, e为int*类型
// g:error, g为const int类型，不能再赋值
练习2.34
Q: 证明上述推断是否正确，写一段程序。
A:
int i = 0, &r = i;
auto a = r;
const int ci = i, &cr = ci;
auto b = ci;
auto c = cr;
auto d = &i;
auto e = &ci;
auto &g = ci;
a = 42;
b = 42;
c = 42;
std::cout << a << b << c << std::endl;
>> d = 42;
>> e = 42;
>> g = 42;
练习2.35
Q: 判断下面定义的类型，编写程序验证。
A:
const int i = 42； // i为const int类型
auto j = i; // j为int类型
auto &k = i; // k为const int& 类型
auto p = &i; // p为const int 类型
const auto j2 = i, &k2 = i; // j2为const int类型，k2为const int& 类型。
练习2.36
Q: 关于下列代码，指出每个变量的值及程序结束后的值。
A:
int a = 3, b = 4; //
decltype(a) c = a; // c为int类型，a为c的初值
decltype((b)) d = a; // d为int& 类型，是a的引用
++c; // ++c之后的值为4；
++d; // ++d之后的值为4
练习2.37
Q: 赋值是会产生引用的一类典型表达式，引用的类型就是左值的类型。也就是说，如果i是int，则表达式i=x的类型是int&。根据该特点指出下面变量的类型。
A:
int a = 3, b = 4; // a, b均为int
decltype (a) c = a; // c为int
decltype (a = b) d = a; // d为int&，是a的引用。
练习2.38
Q: 举例说明decltype指定类型和auto有何区别。
A:
相同点：都通过已知变量或表达式的类型来指定类型。如：int i = 2； auto j = i; decltype(i) j = i; 两者相同。不同点：（1）auto会忽略顶层const，但decltype不会。
（2）auto定义变量必须有初始值，但decltyple不一定
练习2.39
Q: 编译下面程序观察其运行结果，注意，如果忘记写类定义体后面的分号会发生什么情况？记录下相关信息，以后可能会有用。
struct Foo {/*此处为空*/} //注意：没有分号
int main()
{
return 0;
}
报错：error: expected ';' after struct definition
练习2.40
Q: 根据自己的理解写出Sales_data类，最好与书中的例子有所区别。
struct Sales_data
{
string bookNo;
unsigned units_sold = 0;
double revenue = 0.0;
};
练习2.41
Q: 使用你自己的Sales_data类重写1.5.1节、1.5.2节和1.6节的练习。眼下先把Sales_data类的定义和main函数放在同一个文件里。
A:
练习2.42
Q:根据自己的理解重写一个Sales_data.h头文件，并以此为基础重做2.6.2节的联系。
A:
