C++ Primer课后习题解答（第二章）

Exercise Section 2.1.1

Ex2.1

一个 long long 类型至少和 一个 long 类型一样大；一个 long 类型至少和一个 int 类型一样大；一个 int 类型至少和一个 short 类型一样大。

unsigned 类型不存在负数；signed 类型存在负数。

一个 double 类型至少和一个 float 类型一样大。

Exercises Section 2.1.2

Ex2.3 2.4

Exercises Section 2.1.3

Ex2.5

a) 'a' 		// 一个字符 a
   L'a' 	// wchar_t 类型字符 a
   "a"		// 字符串 a
   L"a"		// wchar_t 类型字符串 a
   
b) 10  		// 十进制 int 整数值 10
   10u 		// 十进制 unsigned 类型整数值 10
   10L		// 十进制 long 类型整数值 10
   10uL		// 十进制 unsigend long 类型整数值 10
   012		// 八进制整数值 10
   0xC 		// 十六进制整数值 12
 
c) 3.14		// 浮点数3.14
   3.14f	// float 类型浮点数 3.14
   3.14L	// long double 类型浮点数 3.14
   
d) 10		// 十进制整数值 10
   10u		// 十进制 unsigned 类型整数值 10
   10.		// 浮点数 10.0
   10e-2	// 科学计数法浮点数 0.01

Ex2.6

// month 和 day 都是十进制
int month = 9, day = 7;
// month 为无效的八进制，day 为八进制
int month = 09, day = 07;

Ex2.7

b) 3.14e1L		// 科学计数法表示的 long double 类型浮点数 31.4
c) 1024f		// float 类型浮点数 1024.0
d) 3.14L		// long double 类型浮点数 3.14

Exercises Section 2.2.1

Ex2.9

a) std::cin >> int inut_value;	// 非法，需要输入变量前定义变量
// 修正如下
int value;
std::cin >> value;

b) int i = { 3.14 };	// 非法，花括号初始化不能转换类型
// 修正如下
int i = 3;

c) double salary = wage = 9999.99;	// 非法，wage 未定义
// 修正如下
double salaty = 9999.99, wage = 9999.99;

d) int i = 3.14	// 合法，只是会将浮点数转换为 int 类型，i 的值为 3

Ex2.10

std::string global_str;		// 空字符串
int global_int;				// 值为 0
int main()
{
	int local_int;			// 取决于编译器
    std::string local_str;	// 取决于编译器
}

Exercises Section 2.2.2

Ex2.11

a) extern int ix = 1024;		// 声明并定义
b) int iy;					// 声明
c) extern int iz;			// 声明

Exercises Section 2.2.3

Ex2.12

a) int double = 3.14;		// 非法，变量名不能和关键字名一样
b) int _;					// 合法
c) int catch-22;			// 非法，变量中不能有 - 符号
d) int 1_or_2 = 1;			// 非法，变量不能以数字开头
e) double Double = 3.14;	// 合法

Exercises Section 2.2.4

Ex2.13

j = 100

Ex2.14

合法，输出结果：100 45

Exercises Section 2.3.1

Ex2.15

a) int ival = 1.01;	// 合法
b) int &rvall = 1.01;	// 非法，引用绑定的对象不能是字面值
c) int &rval2 = ival;	// 合法
d) int &rval3;		// 非法，引用必须绑定在一个对象上

Ex2.16

int i = 0, &r1 = i; double d = 0, &r2 = d;
a) r2 = 3.14159;	// 合法
b) r2 = r1;			// 合法
c) i = r2;			// 合法
d) r1 = d;			// 合法

Ex2.17

输出结果：10 10

Exercises Section 2.3.2

Ex2.18

#include<iostream>

int main()
{
	int i = 0, j = 1;
	int *p = &i;
	std::cout << p << " " << *p << std::endl;
	p = &j;
	*p = j;
	std::cout << p << " " << *p << std::endl;
	system("pause");
	return 0;
}

Ex2.19

1. 指针是一个对象，而引用不是。
2. 指针可以为空，而引用不能。

Ex2.20

int i = 42;
int *p1 = &i;
*p1 = *p1 * *p1;	// 将初始变量 i 的值平方然后赋给变量 i

Ex2.21

int i = 0;
a) double *dp = &i;		// 非法，指针与变量类型不匹配
b) int *ip = i;			// 非法，指针绑定的对象前应该加 & 符号
c) int *p = &i;			// 合法

Ex2.22

if(p)	// 指针指向的变量的地址不为0，条件成立
if (*p)	// 指针指向的变量的值不为0，条件成立

Ex2.24

void 类型指针可以指向绑定任何类型对象，但是其他类型指针只能绑定同类对象。

Exercises Section 2.3.3

Ex2.25

a) ip 为 int 类型指针，值不确定(编译器决定)；i 为 int 类型变量，值不确定(同前)；r 为 int 类型引用绑定到变量 i 上，值和 i 的值一样。
b) 变量 i 为 int 类型，值不确定； ip 为 int 类型指针，值为 0。
c) ip 为 int 类型指针，值不确定；ip2 为 int 类型变量，值不确定。

Exercises Section 2.4

Ex2.26

a) const int buf;	// 非法，const 修饰的变量必须初始化
b) int cnt = 0;		// 合法
c) const in sz = cnt;	// 合法
d) ++cnt; 	// 合法   
   ++sz;	// 非法，被 const 修饰的对象的值不能更改

Exercises Section 2.4.2

EX2.27

a) int i = -1, &r = 0;	// 变量 i 合法，引用 r 非法，引用不能绑定到字面值上
b) int *const p2 = &i2;	// 合法
c) const int i = -1, &r = 0;	// 变量 i 合法，引用 r 非法，引用不能绑定到字面值上
d) cnost int *const p3 = &i2;	// 合法
e) const int *p1 = &i2;		// 合法
f) const int &const r2;		// 非法，引用 r2 必须绑定一个对象
g) const int i2 = i, &r = i;	//	合法

Ex2.28

a) int i, *const cp;	// 指针 cp 非法，必须初始化
b) int *p1, *const p2;	// 指针 p2 非法，必须初始化
c) const int ic, &r = ic;	// 变量 ic 非法，必须初始化
d) const int *const p3;	// 指针 p3 非法，必须初始化
e) const int *p;	// 合法

Ex2.29

a) i = ic;		// 合法
b) p1 = p3;		// 非法，普通指针不能绑定 const 修饰的对象
c) p1 = ⁣	// 非法，普通指针不能绑定 const 修饰的对象
d) p3 = ⁣	// 合法
e) p2 = p1;		// 合法
f) ic = *p3;	// 非法，被 const 修饰的对象的值不能更改

Exercises Section 2.4.3

Ex2.30

const int v2 = 0;	// top-level
int v1 = v2;
int *p1 = &v1, &r1 = v1;
const int *p2 = &v2, *const p3 = &i, &r2 = v2;	// p2 -> low-level  p3 -> top-level and low-level     r2 -> low-level

Ex2.31

r1 = v2;	// 非法，普通引用不能绑定被 const 修饰的对象
p1 = p2;	// 非法，p2 有 low-level const 而 p1 没有
p2 = p1;	// 合法
p1 = p3;	// 非法，p3 有 low-level const 而 p1 没有
p2 = p3;	// 合法

Exercises Section 2.4.4

Ex2.32

int null = 0, *p = null;	// 非法
// 修改如下
int null = 0, *p = &null;

Exercises Section 2.5.2

Ex2.35

const int i = 42;
auto j = i; // j 为 int 类型
const auto &k = i; // k 为 const int& 类型
auto *p = &i;	// p 为 const int* 类型
const auto j2 = i, &k2 = i;	// j2 为 const int 类型， k2 为 const int& 类型

Exercises Section 2.5.3

Ex2.36

int a = 3, b = 4;
decltype (a) c = a;	// c 为 int 类型
decltype ((b)) d = a;	// d 为 int& 类型
++c; // c = 4	
++d;	// d = 4

Ex2.37

int a = 3, b = 4;
decltype (a) c = a;		// c 为 int 类型，值为 3
decltype （a = b) d = a;	// d 为 int& 类型，值为 3