C++ primer 第二章习题答案

2.1

int、long、long long、short的区别：表示的范围不同，一般short16位，int32位，long32位，long long64位；

无符号类型只能表示不小于0的数，带符号类型既可以表示整数也可以表示负数；

float与double的区别：内存中所占的比特数不同，有效数位也不同

 

2.2

double或者float都可以，最好选择double。因为float的精度可能不够，long double的计算代价比较大。

2.3/2.4

32;  2^32-32=4294967274 ;32 ;-32 ;0; 0;

 

2.5

(a)字符字面量，宽字符字面量，字符串字面值，宽字符串字面值

（b）十进制，无符号十进制，长十进制整型，无符号长十进制整型，八进制整型，十六进制整型

（c）double，float，long double

（d）十进制，无符号十进制，double，double

 

2.6

第一个式子正确，两者都是十进制。

第二个式子错误，八进制，09超出范围

 

2.7

(a): Who goes with Fergus?(new line) "string"

(b): 31.4 "long double"

(c): 1024 "float"

(d): 3.14 "long double"

 

2.8

#include 
int main()
{
  std::cout<<"2M\n";
  std::cout<<"2\t\n";
}

2.9

（a）错误。

int input_value;
std::cin>>input_value;

(b）错误。存在丢失信息的风险

（c）错误，使用未定义的对象wage

double salary,wage;
salary=wage=9999.99;

(d)正确，转换执行，但丢失部分值

 

2.10

global_str初始值为空串

global_int初始值为0

local_int不被初始化

local_str初始值为空串

注：因为string类型本身接受无参数的初始化方式，不论变量定义在函数内还是函数外都默认初始化为空串

 

2.11

（a）定义

（b）定义

（c）声明

 

2.12

（a）非法，不能出现double

（b）合法

（c）非法，不能出现-

（d）非法，不能以数字开头

（e）合法

 

2.13

外层i被内层i覆盖，故j的值为100

 

2.14

合法；

100  45

 

2.15

（a）合法

（b）不合法，因为引用只能绑定到对象上，而不能与字面值或某个表达式的计算结果绑定在一起

（c）合法

（d）不合法，因为无法令引用重新绑定在另外一个对象，因此引用必须初始化

 

2.16

（a）合法，令d等于3.14159

（b）合法，将i赋给d

（c）合法，将d赋给i，数据丢失一部分

（d）合法，将d赋给i，数据丢失一部分

 

2.17

10  10

 

2.18

int a = 0, b = 1;
int *p1 = &a, *p2 = p1;

// change the value of a pointer.
p1 = &b;
// change the value to which the pointer points
*p2 = b;

 

2.19

两者不同点：

①指针本身就是一个对象，允许对指针赋值和拷贝，而且在指针的声明周期内它可以先后指向几个不同的对象。

引用不是一个对象，无法令引用重新绑定到另外一个对象。

②指针无需在定义时赋初值，而引用必须在定义时赋初值。

 

2.20

等价于i=42*42=1764

 

2.21

（a）非法。指针的类型与对象不匹配

（b）非法。指针的类型与对象不匹配

（c）合法

 

2.22

第一个判断p是否是nullptr；

第二个判断p指向的对象值是否是0

 

2.23

不可以，首先要判断p是不是合法

 

2.24

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

lp的类型（long）与对象（int）不匹配。

 

2.25

（a）ip是int型指针，i为int类型，r是int类型的引用

（b）i为int类型，ip为空的int型指针

（c）ip为int型指针，ip2为int型

 

2.26

（a）不合法，const对象必须初始化

(b)合法

（c）合法

（d）++cnt合法；

        ++sz不合法，const对象不可改变。

 

2.27

（a）r为非常量引用，非常量引用不能引用字面值常量

（b）合法

（c）合法

（d）合法

（e）合法

（f）不合法，引用本身不是对象，因此不能让引用恒定不变

（g）合法

 

2.28

（a）不合法，cp为常量指针，必须初始化

（b）不合法，p2为常量指针，必须初始化

（c）不合法，ic为常量，必须初始化

（d）不合法，p3为指向int常量的常量指针，必须初始化

（c）合法，p为指向常量的指针

 

2.29

（a）合法

（b）不合法，指针p3和p1的类型不同，一个是const int，一个是int

（c）不合法，两者类型不匹配，前者是int，后者是const int

（d）不合法，p3是一个常量指针，不能被赋值

（e）不合法，p2是一个常量指针，不能被赋值

（f）不合法，ic是一个常量，不能被赋值

总结：

①指向常量的指针或常量引用前必须加const；

②const引用绑定的对象、指向常量的指针的对象也可以非常量对象，但不允许通过其改变所指对象的值；

③允许为一个常量引用绑定非常量的对象、字面值，甚至是个一般表达式，而非常量引用只能绑定到对象上，而不能与字面值或某个表达式的计算结果绑定在一起

④常量指针也可以指向非常量，不变的是指针本身的值而不是指向的那个值

⑤常量指针和常量必须初始化，且不能被赋值只能初始化

 

2.30

v2:顶层const

p2：底层const

p3：既是顶层const又是底层const

r2:底层const

 

2.31

r1 = v2; // 合法，顶层const不受影响
p1 = p2; // 不合法，p2为底层const而p1不是
p2 = p1; // 合法，变量可以转换成常量
p1 = p3; // 不合法，p3有底层const特性，而p1没有
p2 = p3; // 合法，p2和p3都是底层const

2.32

不合法，修改为：

int null = 0, *p = nullptr;

2.33

a = 42; // 正确
b = 42; // 正确
c = 42; // 正确
d = 42; // 错误，d的类型为int*,应改为*d=42;
e = 42; // 错误，e的类型为const int*，应改为 e = &c;
g = 42; // 错误，g的类型为const int& ，绑定到 ci，不可改变

2.34

如不理解请好好理解课本

 

2.35

j为int，忽略了顶层const；

k为const int&

p为const int*

j2为const int

k2为const int&

 

2.36

a为int，b为int，c为int，d为int&

a=b=c=d=4;

 

2.37

c为int，d为int&

a=3，b=4,c=d=3;

 

2.38

decltype与auto的区别：

①decltype并不实际计算表达式的值

②处理顶层const和引用的方式不同，decltype返回该变量的类型，包括顶层const和引用在内

③decltype的结果类型与表达式形式密切相关

int i = 0, &r = i;
// same
auto a = i;
decltype(i) b = i;
// different
auto c = r;
decltype(r) d = r;

2.39

报错: [Error] expected ';' after struct definition

 

2.40

struct Sale_data {
    std::string bookNo;
    std::string bookName;
    unsigned units_sold = 0;
    double revenue = 0.0;
    double price = 0.0;
    //...
};