c++ Primer 第五版习题答案第二章

练习2.1

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 F145rgus?12"   
    // 145表示小写字母“e”， 12表示换行符。 输出：who goes with Fergus?
(2) 3.14e1L   // 表示扩展的浮点型，类型是long double
(3) 1024f     // 单精度浮点型字面值，类型是float
(4) 3.14L     // 表示扩展的浮点型，类型是long double

练习2.8

Q：使用转义写一段程序，先输出2M，然后转到新的一行，修改程序使其先输出2， 然后输出制表符，再输出M，最后转到新的一行。

cout << "6211512" ;
cout << "62	11512" ;

练习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: