c++primer表达式

学习目标

1.表达式基础
2.算术运算符
3.逻辑运算符与关系运算符
4.赋值运算符

一.学习内容

1.基础概念
2.优先级与结合律
3.求值顺序

习题解析

4.1
105

4.2

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

4.3
我还不知道

4.4
(12 / 3 * 4 ) + (5 * 15) + (24 % 4 / 2)
分成三个单元分别求值，之后再从左到右相加，最后值是

int main()
{
    short i = 12 / 3 * 4 + 5 * 15 + 24 % 4 / 2;
    cout << i; 
    //最终值是91
    
        return 0;
}

4.5
（a）-86
（b）-18
（c）0
（d）-2

4.6

int main()
{
    int i1;
    std::cin >> i1;
    if (!(i1 % 2))
        cout << "偶数";
    else
        cout << "奇数";

    return 0;
}

4.7
超出指定范围的内存空间

short sval = 32767;
    ++sval;
    unsigned ival = 4394967295;
    ++ival;
    unsigned short suval = 65535;
    ++suval;
    cout << ival;

4.8
首先看优先级按照高到低是相等运算符，逻辑与运算符，逻辑或运算符，且三个运算符都是左结合律
所以按优先级从高到低两两结合再从左到右两两结合就可以了

4.9
先解引用右对象这个指针，再从左到右因为是逻辑与运算符左边只有个指针cp看他是不是0,0为假非零为真，显然这个指针(地址）不为零，左侧为真判断右侧解引用cp是字符，类型转换到整型显然也不会为0，既两边为真整体为真。

4.10

int i;
while (cin >> i && i != 42)
{...}

4.11

if (a > b && b > c && c > d)

4.12
按照优先级，判断j是否小于k，结果是0或1，再判断i是否不等于结果值

4.13
（a）i = 3，d = 3
（b）d = 3.5，i = 3

4.14

if (42 = i) // 语句非法
if (i = 42) // i赋值为42，if判断i，i类型转换为bool值1（true），if判断为真

4.15
指针pi不能被赋值，如果需要赋值可以解引用*ip，这样间接的指向的是对象而不是地址了

dava = ival = *pi = 0;

4.16
（a）不等于运算符的优先级比赋值运算符的高，函数和0比较等到一个bool值再将bool值赋值给变量，这样的结果可能和真实意图不符

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

（b）真实的意图可能想知道i是否等于1024

if (i == 1024);

4.17
前置递增运算符返回递增后的对象本身，后置递增运算符返回递增后对象在递增前储存下来的副本。

4.18
指向下一个地址再解引用，一开始循环会指向第二个地址，最后一个循环会指向尾元素的下一个地址，但条件判断不通过不会解引用这个迭代器。

4.19
（a）如果ptr不是空指针，则ptr指向下一个地址并解引用递增前的指针判断是否为0
（b）非法，无法确定求值循序
（c） true，一直等于

4.20
（a）合法，求iter的解引用，并把iter指向下一个位置
（b）非法法，*iter为字符串，不能++
（c）非法，iter是迭代器没有empty成员
（d）合法，等价于(*iter).empty()，所指向的值是否为空
（e）非法，字符串不能++
（f） 合法，先判断是否为空，再iter++

4.21

int main()
{
   
    vector<int> vi1 = { 1,2,3,4,5,6 };
    for (auto &vi2 : vi1)
    {
        (vi2 % 2) ? (cout << (vi2 *= vi2) << " ") : (cout << vi2 << " ");
    }
    return 0;
}

4.22

#include <iostream>
#include <string>
#include <vector>
using std::cout; using std::endl;
using std::string; using std::vector;
using std::begin; using std::end;

int main()
{
   
    /*int gra;
    string fin;
    std::cin >> gra;
    fin = (gra >= 90) ? "优秀" : (gra >= 60) ? (gra >= 75) ? " 良好 " : " 合格" : "不合格";
    cout << fin << " ";
    return 0;*/

    int gra;
    string fin;
    std::cin >> gra;
    if (gra >= 90)
        cout << "优秀";
    else
    {
        if (gra >= 75)
            cout << "良好";
        else
        {
            if (gra >= 60)
                cout << "及格";
            else
                cout << "不合格";
        }
    }
}

条件运算符使用的代码量更少，但阅读起来有难度
if判断语句使用的代码量很大，但阅读起来轻松
在判断条件少的情况条件运算符更好理解，在判断多的情况if语句更好理解。

4.23

//在其中加了一个括号
s + (s[s.size() - 1] == 's' ? "" : "s");
//步骤是 先这样(s[s.size() - 1] == 's' 再这样s + (0 ? "" : "s");再这样s + s；

4.24

//位运算作用于整数类型的运算对象，并把运算对象当成是二进制位的集合

4.25
11111111111111111110001110000000

4.26
会自动提升为unsigned long型

4.27
（a）3
（b）7
（c）true
（d）true

sizeof运算符返回一条表达式或一个类型所占的字节数
4.28

int main()
{
    constexpr size_t i = sizeof(int);
    constexpr size_t c = sizeof(char);
    constexpr size_t d = sizeof(double);
    constexpr size_t f = sizeof(float);
    constexpr size_t b = sizeof(bool);
    constexpr size_t s = sizeof(short);
    constexpr size_t l = sizeof(long);

    cout << i << " " << c << " " << d << " "
        << f << " " << b << " " << "s" << " "
        << "l" << endl; 
}

4.29
40/4=10,数组所占字节数/数组类型int所占字节数等于数组的个数
4/4=1,指针所指字节数/int类型所占字节数

4.30

（a）(sizeof x) + y
（b）sizeof (p->mem[i])
（c）(sizeof a) < b
（d）sizeof (f())

4.31

int main()
{
    string ivce = "etete";
    vector<int>::size_type cnt = ivce.size();
    for (vector<int>::size_type ix = 0;
        ix != (ivce.size()); ix++, cnt--)
        ivce[ix] = cnt;    
}

不需要用到递增和递减前的副本

4.32
两种遍历数组的方式，ptr是用指针遍历数组，ix使用索引遍历数组。

4.33
++和-- x和y完成后执行条件运算符

4.34
（a）fval最后转换成bool型
（b）ival转换成float，fval+ival相加的结果转换为double型
（c）cval转换成int型，cval加ival的结果转换成double型

4.35
（a）字符a转换成int型，结果转换为char赋值给cval
（b）ui转换为float，ival转换为float，三者做完算数运算后赋值给fval //乱做的
（c）ui转换为float，结果再转换为double
（d）inval->float,与fval相加结果转换为double，最后相加的结果转换为char类型

4.36

in *= (static_cast<int>d)

4.37

(a) pv = const_cast<void*>(ps)
(b) i = reinterpret_cast<int>(*pc)
(c) pv = static_cast<double>(d)
(d) pc = static_cast<char*>(pv)
//全错

4.38
j和i强制转换为double，相除的结果赋值给slope。