第2章练习题

2.9、

　　(a) 不合法，变量要在输入前定义

　　(b) 不合法，存在丢失信息的风险

　　(d) 会被转换为整型

2.10

　　global_str : 空字符串

　　global_int : 0

　　local_int : 垃圾值

　　local_str : 垃圾值

2.11

(a) 声明+定义

(b) 声明+定义

2.12

(a) double 是关键字

(b) 合法

(d) 不能以数字开头

(e) 合法但不符合命名规范

2.13

100

2.14

合法：100 45

2.15

a 合法，会转换

b 不合法，引用不能绑定字面值

c 合法

d 不合法，引用必须初始化

2.16

a 合法，赋值给d

b 合法，把i赋值给d

c 合法，把d赋值给i,会发生转换

d 合法，把d赋值给i,会发出警告

2.17

10 10

2.18

#include <iostream>

int main()
{
int value1 = 5, value2 = 10;
int* pvalue1 = &value1;
std::cout << "pvalue1 = " << pvalue1 << std::endl;
std::cout << "*pvalue1 = " << *pvalue1 << std::endl;
std::cout << "value1 = " << value1 << std::endl;
*pvalue1 = 6;
std::cout << "*pvalue1 = 6 : " << std::endl;
std::cout << "pvalue1 = " << pvalue1 << std::endl;
std::cout << "*pvalue1 = " << *pvalue1 << std::endl;
std::cout << "value1 = " << value1 << std::endl;
pvalue1 = &value2;
std::cout << "pvalue1 = &value2 : " << std::endl;
std::cout << "pvalue1 = " << pvalue1 << std::endl;
std::cout << "*pvalue1 = " << *pvalue1 << std::endl;
std::cout << "value1 = " << value1 << std::endl;

return 0;

}

2.19、

1）引用本身不是一个对象，指针本身是一个对象

2）引用定义必须赋初值，之后无法解绑。指针可以不赋初值，程序运行过程中可以更改指针指向的位置

2.20、

定义int类型变量i并初始化为42；

定义指向int类型指针p并指向变量i;

使用解引用符访问指向的对象并对对象进行乘法运算；

2.21、

a) 不合法，类型不匹配 b)不合法，类型不匹配　　c) 合法

2.22、

如果指针不为空指针则为真，否则为假

如果指针p指向的对象不为0则为真，指向的对象值为0则为假

2.23、

不能，

2.24

类型不匹配

2.25

a) ip: int类型的指针 i: int 类型的变量（对象）；b) i: int类型的对象 ip: int类型的指针并初始化为空指针　　c) ip是int类型的指针 ip2是int类型的对象

2.26

a) 不合法：const对象必须在声明的时候初始化

b) 合法

c) 合法

d) 不合法；sz是const对象无法进行改变其自身值的运算

2.27

a) 不合法：引用类型的初始值必须是一个对象

b) 如果i2是一个int类型的对象则合法

c) 合法，初始化常量引用可以用用任意表达式作为初始值

d) 同b)；

e) 同b);

f) 不合法，引用本身不是对象不能用const限定

g) 如果i可以转化为int类型则合法

2.28、

a) 不合法，定义const对象必须初始化

b) 不合法，同a)

c) 不合法，同a)

d) 不合法，同a)

e) 声明一个int类型的指针

2.29

a) 合法，常量赋值给非常量合法

b) 不合法，p3不仅自己是常量而且指向常量

c) 不合法，ic是常量

d) 不合法，p3本身是const对象只能初始化的时候赋值

e) 不合法，p2本身是const对象只能初始化的时候赋值

f) 不合法，ic是常量

2.30

v2顶层const,v1没有const, p1没有const &r1没有const,

p2底层const,p3 既是顶层const又是底层const ,&r2是底层const

2.31

r1 = v2; 合法

p1 = p2; 不合法，

p2 = p1;合法，

p1 = p3; 不合法

p2 = p3;合法

2.32

不合法： *p = nullptr，(不能把int类型的值赋给指针）

2.33

a = 42；//a 是int 类型结果42赋值给a

b = 42; //b 是Int 类型结果42赋值给b

c = 42; 　//同上

d = 42; 　//非法，d是一个整型指针

e = 42;　//非法，e是一个指向整型常量的指针

g = 42; 　//非法，g是一个整型常量的引用

2.34

#include <iostream>

using namespace std;

int main()

{

int i = 0, &r = i;

auto a = r; //a是一个整数（r是i的别名，而i是一个整数）

const int ci = i, &cr = ci;

auto b = ci; //b是一个整数（ci的顶层const特性被忽略掉了）

auto c = cr; //c是一个整数（cr是ci的别名，ci本身是一个顶层的const）

auto d = &i; //d是一个整型指针（整数的地址就是指向整数的指针）

auto e = &ci; //e是一个指向整型常量的指针（对常量对象取地址是一种底层const）

const auto f = ci; //ci的推演类型是int,f是const int

auto &g = ci; //g是一个整型常量引用，绑定到ci

a = 42;

cout << "a = " << a << endl;

b = 42;

cout << "b = " << b << endl;

c = 42;

cout << "c = " << c << endl;

d = 42;//报错：不能将 "int" 类型的值分配到 "int *" 类型的实体

cout << "d = " << d << endl;

e = 42;//报错：不能将 "int" 类型的值分配到 "const int *" 类型的实体

cout << "e = " << e << endl;

g = 42;//报错：g是一个整型常量引用，绑定到ci表达式必须是可修改的左值

cout << "g = " << g << endl;

return 0;

}

2.35

const int i = 42;

auto j = i;　　　　//j是一个整数（i的顶层const被忽略）

const auto &k = i;　　//k是对整型常量的引用，绑定到i

auto *p = &i 　　　　//p是指向整型常量的指针

const auto j2 = i, &k2 = i;//j2是整型常量，k2是对整型常量的引用

代码：

#include <iostream>

using namespace std;

int main()

{

const int i = 42;

auto j = i;

const auto &k = i;

auto *p = &i;

const auto j2 = i, &k2 = i;

cout << "i = " << i << endl;

cout << "j = " << j << endl;

cout << "k = " << k << endl;

cout << "p = " << p << endl;

cout << "j2 = " << j2 << endl;

cout << "k2 = " << k2 << endl;

return 0;

}

运行结果：

2.36

a 是int 类型

b 是int类型

c 是int类型

d是int类型的引用

值：a==4　　b == 4　　c == 4　　d == 4

2.37

a int类型 3

b int类型 4

c int类型 3

d int类型引用 3　　//decltype(a = b)不作运算,所以a 的值不变

2.38

//没太搞懂这两个东西

2.39

提示缺;

2.40

struct Sales_data

{

　　std::string bookNo;

　　std::string author;

　　int sold = 0;

　　double revenue = 0.0;

};

第2章 练习题

猜你喜欢