码迷,mamicode.com
首页 > 编程语言 > 详细

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

时间:2018-05-24 11:49:33      阅读:243      评论:0      收藏:0      [点我收藏+]

标签:结束   指定   利用   day   也会   err   答案   计算   贷款   

练习2.1

Q: 类型int、long、long long和short的区别是什么,无符号和带符号类型的区别是什么?float和double的区别是什么?

A:int、 long、 long long和short尺寸不同,表示的数据范围不同。无符号只能表示0和正数,无符号还可以表示负数。float为单精度浮点数,double为双精度,一般来说,float占4字节,double占8字节。

 

练习2.2

Q: 计算按揭贷款时,对于利率、本金和付款分别应选择何种数据类型?说明你的理由。

A: 利率应该用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:指出下面字面值的数据类型

A:(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:下面两组定义是否有区别?

A:

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:下述字面值表示什么含义?各自的数据类型是什么?

A:(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,最后转到新的一行。

A: cout << "\62\115\012" ;

cout << "\62\t\115\012" ;

 

练习2.9

Q:解释下列定义的含义。对于非法的定义,说明错在何处

A:(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:下列变量的初始值是什么?

A:std::string g_str; //初始化为一个空串

int g_int; // 初始化为0

 

void test210 ()

{

int local_int; //按标准局部变量不初始化,g++编译器下可能也会初始化为空

std::string local_str;

}

 

练习2.11

Q:指出下面的语句是被声明还是定义。

A: (1)extern int ix = 1024; // 定义 (任何包含了显式初始化的声明即成为定义)

(2)int iy; // 声明并定义 (想声明而不定义,就在变量名前家extern)

(3)extern int iz; // 声明

 

练习2.12

Q:请指出下面的名字中哪些是非法的?

A: (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的值是多少?

A:int i =42;

void test213 ()

{

int i = 100;

int j = i;

 

cout << "j = " << j << endl; //j =100 ,使用局部变量j。

}

 

练习2.14

Q:下面的程序合法吗?输出什么?

A: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:下面哪个定义是不合法的,为什么?

A: (1)int ival = 1.01; //用float初始化int,不合法,会有警告

(2)int &rval1 = 1.01; //非法,引用的初始值必须是一个对象

(3)int &rval2 = ival; //合法

(4)int &rval3; //非法,引用必须被初始化。

 

练习2.16

Q:下面哪些赋值不合法,为什么?

A: 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:下面的代码会输出什么结果?

A: int i, &ri = i;

 

i = 5;

ri = 10;

 

cout << "i = " << i << " ri = " << ri << endl; //i = 10, ri = 10 --- 改变ri的值也会改变i的值。

 

练习2.18

Q:编写代码分别更改指针的值以及指针所指对象的值。

A: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:说明指针和引用的主要区别。

A:(1) 引用在定义时必须初始化,而指针可不初始化

(2)引用在其生命周期内,只能指向一个对象,而指针可以先后指向不同的对象

(3)指针本身就是一个对象,允许对指针进行赋值和拷贝。

 

练习2.20

Q:叙述下面代码的作用

A:int i = 42;

int * p = &i;

 

*p = *p * *p; // 42*42, 求i的平方。

 

练习2.21

Q: 解释下述定义是否非法。

A: int i = 0;

(1)double* dp = &i; //非法,不能用int型的变量初始化doube指针

(2)int* ip = i; //非法, 不能用int值初始化指针

(3)int* p = &i; //合法

 

练习2.22

Q: 假设p是一个int型指针,说明下面代码的含义

A: if (p) //如果地址不为0

if (*p) //如果所指的值为真

 

练习2.23

Q: 给定指针p,能否知道它指向了一个合法的对象?

A: 不行,如果你把指针理解为一个信封上的地址,那么没有任何手段能保证你填写的地址必然有人住。(别人的回答)

我的理解,给定一个指针,首先要判断这个指针是否有效(不为NULL,地址合法等),好像没什么办法判断指向了合法对象,有可能在使用过程中发现。

 

练习2.24

Q: 下面的代码中,为什么p合法而lp非法?

A: 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 = &ic; // 合法

(4) p3 = &ic; // 不合法,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:

A:

 

练习2.40

Q:

A:

 

练习2.41

Q:

A:

 

练习2.42

Q:

A:

 

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

标签:结束   指定   利用   day   也会   err   答案   计算   贷款   

原文地址:https://www.cnblogs.com/songshuguiyu/p/9081462.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!