C++ primer(第五版）第4章习题答案

第四章　表达式

4.1　

105

 

4.2

(a) *(vec.begin())      (b) (*(vec.begin())) + 1

 

4.3

是的，我认为有必要进行权衡。因为速度永远是C++最大的优势。有时，我们需要编译器的特性来进行高效的工作。但如果你不是专家。我必须建议你不要触摸未定义的行为。举个例子，cout << i << ++i << endl 不应该出现在你的代码中。

 

４.4

((12 / 3) * 4) + (5 * 15) + ((24 % 4) / 2)

//  16 + 75 + 0 = 91

 

4.5

(a) -90 + 4 = -86

(b) -30 + 12 = -18

(c) 0

(d) -210 % 4 = -2

 

4.6

i % 2 == 0 ? "even" : "odd"

 

4.7

short svalue = 32767; ++svalue;  //-32768

unsigned uivalue = 0; --uivalue;  //4294967295

unsigned short usvalue = 65535; ++usvalue;  //0

 

4.8

逻辑与运算符，当且仅当左侧运算对象为真时才对右侧运算对象求值。

逻辑或运算符，当且仅当左侧运算对象为假时才对右侧运算对象求值。

相等性运算符，仅当两侧运算对象相等时为真，否则为假。

 

４.9

cp是一个指向常量字符类型的指针，为真。

*cp是常量字符：‘H',为真。

 

4.10

int i = 0;

while (cin >> i && i != 42)

 

4.11

a > b && b > c && c > d

 

4.12

与 i != (j < k)相同, i与布尔类型进行比较。

 

４.13

(a) i = 3, d= 3.0

(b) d=3.5, i = 3

 

4.14

(1) 赋值语句非法，字面值是左值，而赋值运算符的左侧运算对象必须是一个可修改的左值。

(2) 条件判断为真。

 

４.15

int型指针无法转换为int型。

dval = ival = 0;

pi = 0;

 

4.16

(a) if ( (p = getPtr()) != 0)

(b) if (i == 1024)

 

4.17

前置版本运算符首先将运算对象增减，然后将改变后的对象作为求值结果，后置版本也会讲运算对象增减，但是求值结果是运算对象改变之前那个值的副本。前置版本将对象本身作为左值返回，后置版本则将对象原始值的副本作为右值返回。

 

４.18

将会从第二个与元素开始打印，并将解引用尾后迭代器，是未定义的且危险。

 

4.19

(a)检查ptr不是一个空指针，并检查給指针的值。

(b)检查ival和ival+1两者中任一是否为0.

(c)求值顺序未定义。vec[ival] <= vec[ival+1]

 

4.20

(a)返回*iter,然后++iter

(b)非法，*iter是一个字符串，不能自增。

(c)非法，应该用箭头运算符。

(d)指出迭代器所指向的值是否为空。

(e)字符串类型不可以自增。

(f)返回iter->empty(),然后++iter。

 

4.21

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 8, 9};
    for (auto& i : ivec) i = (i % 2) ? (i * 2) : i;

    // Check
    for (auto i : ivec) std::cout << i << " ";
    std::cout << std::endl;

    return 0;
}

 

4.22

#include <iostream>

using std::cout;
using std::cin;
using std::endl;

int main()
{
    unsigned grade;
    while (cin >> grade) {
        // first version(only use conditional operators)
        cout << ((grade > 90) ? "high pass" : (grade < 60)
                                                  ? "fail"
                                                  : (grade < 75) ? "low pass"
                                                                 : "pass");
        cout << endl;
        // second version(only use if statements)
        if (grade > 90)
            cout << "high pass";
        else if (grade < 60)
            cout << "fail";
        else if (grade < 75)
            cout << "low pass";
        else
            cout << "pass";
        cout << endl;
    }

return 0;

 

4.23

加法运算符优先于条件运算符

string p1 = s + (s[s.size() - 1] == 's' ? "" : "s");

 

4.24

左结合率：

finalgrade = ((grade > 90) ? "high pass" : (grade < 60)) ? "fail" : "pass";

 

4.25

'q'    01110001

~'q' ~00000000000000000000000001110001

取反后为负数，左移操作将会产生未定义的行为。

 

4.26

16位，放不下30个学生，结果未定义。

 

4.27

(a) 3

(b) 7

(c) ture

(d) true

 

4.28

#include <iostream>

using std::cout;
using std::endl;

int main()
{
    cout << "bool\t\tis " << sizeof(bool) << "bytes." << endl;
    cout << "char\t\tis " << sizeof(char) << "bytes." << endl;
    cout << "wchar_t\t\tis " << sizeof(wchar_t) << "bytes." << endl;
    cout << "char16_t\tis " << sizeof(char16_t) << "bytes." << endl;
    cout << "char32_t\tis " << sizeof(char32_t) << "bytes." << endl;
    cout << "short\t\tis " << sizeof(short) << "bytes." << endl;
    cout << "int\t\tis " << sizeof(int) << "bytes." << endl;
    cout << "long\t\tis " << sizeof(long) << "bytes." << endl;
    cout << "long long\tis " << sizeof(long long) << "bytes." << endl;
    cout << "float\t\tis " << sizeof(float) << "bytes." << endl;
    cout << "double\t\tis " << sizeof(double) << "bytes." << endl;
    cout << "long double\tis " << sizeof(long double) << "bytes." << endl;
    cout << endl;

    return 0;
}

 

4.29

第一个结果是10,得到的是数组中元素的个数，第二个是　指针所占空间大小/４，64位机器结果是2,32位机器结果是１。

 

4,30

(a) (sizeof x) + y

(b) sizeof (p -> men[i])

(c) sizeof (a) < b

(d) sizeof f() //如果f()返回void,则该语句未定义，否则其他返回其返回类型所占的字节数

 

4.31

　　前置版本可以避免不必要的工作，它递增并返回递增的结果。而后置版本的运算符必须存储原始值，以便它可以返回未递增的值作为其结果。如果不需要未增加的值，则不需要后置版本的运算符完成额外的工作。对于int和指针，编译器可以优化这些额外的工作。 对于更复杂的迭代器类型，这种额外的工作可能会更昂贵。 通过习惯使用前缀版本，我们不必担心性能差异是否重要。 此外，也许更重要的是，我们可以更直接地表达我们的方案的意图。

　　这里不需要改动。

 

4.32

ptr和ix有相同的功能，前者使用指针，后者使用数组的下标，我们使用这个循环遍历数组。

 

4.33

因为逗号优先级最低，所以表达式等同于

(someValue ? ++x, ++y : --x), --y

如果someValue为真，那么y先自增后自减，还是自己。如果someValue为假，那么y仅仅自减，可以发现，最终的输出和ｘ的值一点关系都没有。

 

4.34

(a) fval转化为bool

(b) ival转化为float,相加后的结果转换为double.

(c)cval转化为int,相加后的结果转化为double.

 

4.35

(a) 'a'会提升为int,结果再转换为char.

(b) ival转换为double,ui转换为double,相减后的结果转换为float.

(c) ui提升为flaot,结果转换为double.

(d) ival转换为flaot,和fval相加的结果转换为double,最后的结果转换为char.

 

4.36

i *= static_cast<int>(d);

 

4.37

(a) pv = const_cast<string*>(ps)　或者　pv = static_cast<void*>(const_cast<string*>(ps))  // const_cast只改变常量属性

(b) i = static_cast<int>(*pc)

(c) pv = static_cast<void*>(&d)

(d) pc = reinterpret_cast<char*>(pv)

 

4.38

将　j/i 的结果显式转换为doubl并初始化slope