4.1

105

4.2

*vec.begin()=*（vec.begin()）//先调用点运算符，再解引用

*vec.begin()+1=(*vec.begin())+1//先解引用，再加一

4.3略？

4.4

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

4.5

（a）-86（b）-16

（c）0 （d）0

4.6

n%2

4.7

溢出：计算结果超出该数据类型所能表示的范围

2147483647+1

1U-2

...

4.8

比较低。。

4.9

首先判断cp是否为空指针，若非空指针则判断cp指向的是否是空字符串

4.10

    int val;    while(cin>>val&&val!=42);

4.11

int main(){    int a,b,c,d;    cin>>a>>b>>c>>d;    if(a>b&&b>c&&c>d)        cout<<"Yes"<<endl;    else        cout<<"No"<<endl;    return 0;}

4.12

由于<优先级高于！=，所以先执行j<k返回一个bool类型，可能是0或1，再执行!=运算。最终返回一个bool运算结果，可能是0或1。

4.13

（a）d=3，i=3 因为是从右往左执行的

（b）i=3，d=3.5

4.14

第一种将报错，42是常量，不能被赋值

第二种，该表达式返回42，为真，但是可能并非设计者原意

4.15

指针数据类型与int和double都是不相容的，不能这样赋值。

正确答案：dval=ival=*pi=0;

4.16

（a）将先执行 !=，再执行=。

正解：if((p=getPtr())!=0)

（b）=是赋值，不是判断是否相等

正解：if(i==1024)

4.17

前置运算符，先求值再返回该对象用于左值运算对象

后置运算符，返回该对象的一个副本作为右值运算对象，再求值

4.18

使用前置运算符将不能输出第一个元素，而且会访问越界

另外，经测试，++*it和*++it是不一样的。前置可能导致死循环，因为只是给数值自加了。

4.19

（a）如果ptr不是空指针，那么判断ptr指向的是否是0，再将ptr指向下一个位置

（b）先判断ival是为是0，再将ival自加1，再判断ival是否为0。

（c）等价于vec[ival]<=vec[ival+1],++ival;

4.20

（a）合法。等价于*iter,iter++;

（b）非法。string类型不支持++运算。

（c）非法。先执行成员访问运算符，而iter没有empty这个成员，所以将报错。

（d）正确。等价于(*iter).empty()

（e）正确。等价于++(*iter)

（f）正确。等价于iter->empty(),iter++;

4.21

int main(){    vector<int> vec;    int val;    while(cin>>val)        vec.push_back(val);    for(auto &i:vec)        if(i%2)            i=i*2;    for(auto i:vec)        cout<<i<<endl;    return 0;}

4.22

int main(){    int val;    while(cin>>val)    {        string grade=(val>90)?"high pass":(60<=val&&val<=75)?"low pass":(val<60)?"fail":"pass";        cout<<grade<<endl;    }    return 0;}

明显if语句更好懂

int main(){    int val;    while(cin>>val)    {        if(val>90) cout<<"high pass"<<endl;        else if(val<60) cout<<"fail"<<endl;        else        {            if(60<=val&&val<=75) cout<<"low pass"<<endl;            else cout<<"pass"<<endl;        }    }    return 0;}

4.23

由于加法运算优先级高于条件运算符，因此会先执行加法，得到一个string类型，而string与字符比较，会报错。

正解： string p=s+(s[s.size()-1]==‘s‘?"":"s");

4.24？

不是很懂结合律这块。留着以后研究。

4.25

不懂Latin-1字符集是什么。。

该表达式，第一步取反得到10001110

第二步左移6位得到10000000

4.26

unsigned int在不同机器上位数不同，不能确保一定可以表示30个学生

4.27

ul1=011

ul2=111

（a）011=3

（b）111=7

（c）1

（d）1

4.28

    cout<<"short:"<<sizeof(short)<<endl;    cout<<"int:"<<sizeof(int)<<endl;    cout<<"long:"<<sizeof(long)<<endl;    cout<<"long long:"<<sizeof(long long)<<endl;    cout<<"float:"<<sizeof(float)<<endl;    cout<<"double:"<<sizeof(double)<<endl;    cout<<"char:"<<sizeof(char)<<endl;

这是在我的机器上的输出：

short:2int:4long:4long long:8float:4double:8char:1

4.29

int main(){    int x[10];    int *p=x;    cout<<sizeof(x)<<" "<<sizeof(*x)<<" "<<sizeof(x)/sizeof(*x)<<endl;    cout<<sizeof(p)<<" "<<sizeof(*p)<<" "<<sizeof(p)/sizeof(*p)<<endl;    return 0;}

sizeof(x)是一个大小为10的int数组的空间

sizeof(*x)是一个指向int的指针的空间

sizeof(p)是一个指向int的指针的空间

sizeof(*p)是一个int元素的空间

40 4 104 4 1

以上是输出

4.30

（a）sizeof (a+b)

（b）sizeof (p->mem[i])

（c）sizeof (a<b)  注意小于优先级比sizeof低

（d）sizeof (f())

4.31

后置会额外返回一个对象的副本，使用前置运算符更符合编程的初衷，效率也更高

4.32

遍历ia数组。

4.33

如果someValue为真，则++x，++y并返回自加以后的y。如果为假，则--x，--y并返回自减以后的y。

注意逗号运算符从左向右依次求值，最终返回右侧表达式的值

4.34

（a）float转为bool

（b）+：int转float，=float转double

（c）*：char转int，+int转double

4.35

（a）char转int，再转char？

（b）*int转double，-unsignedint转double，=double转float

（c）*unsignedint转float，float转double

（d）int转float，float转double，double转char

为避免精度损失，整型与浮点型计算，整型会被转化成浮点型

4.36

i*=(int)d;

4.37

（a）pv=static_cast<void*>(ps);

（b）i=static_cast<int*>(pc);

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

（d）pc=static_cast<char*>(pv);

注意强转的数据类型要用<>扩起来，变量要用()括起来。

4.38

把j/i的结果强转成double赋值给slope

int main(){    int i=3,j=5;    double slope=static_cast<double>(j/i);    cout<<slope<<endl;    return 0;}

比如上面的结果，输出1