C++ Primer学习心得第四章

4.1 基础

4.2 算术运算符

4.3 逻辑与关系运算符

4.4 赋值运算符

4.5 递增和递减运算符

4.6 成员访问运算符

4.7 条件运算符

4.8 位运算符

4.9 sizeof运算符

4.10 逗号运算符

4.11 类型转换

4.12 运算符优先级表

 4.1 基础

左值和右值：

书中简单做了个归纳：

      当一个对象被用作为右值的时候，用的是对象的值(内容);当对象被用作左值的时候，用的是对象的身份(在内存中的位置).

最简单的解释：
如果一个对象满足以下两个条件之一，即可称为左值：
1. 能取到它的地址
2. 有名字

否则就是右值

如果表达式的求值结果是左值，decltype作用于该表达式得到的是一个引用类型。举个例子，假设p的类型是int* ，因为解引用运算符生成左值，所以decltype(*p)的结果是int&.

另一方面，因为取地址运算符生成右值，所以decltype(&p)的结果是int** ,也就是说，结果是一个指向整型指针的指针。

int a,b=10;a=5;//a是左值，5是右值a=b; //a是左值，b是左值(转换为右值10)decltype(a) c;//c为int类型decltype((a)) d;//d是int&类型，因为(a)是一个表达式，返回a的左值

++x 与 x++ 假定x的定义为 int x=0;,那么前者是 lvalue，后者是rvalue。前者修改自身值，并返回自身；后者先创建一个临时对像，为其赋值，而后修改x的值，最后返回临时对像。

区分表达式的左右值属性还有一个简便方法：若可对表达式用 & 符取址，则为左值，否则为右值。

4.2 算术运算符

bool b=true;bool b2 =-b;//b2为true;

我们指出布尔值不参与运算，-b就是一个很好的例子

short类型占16为，则最大的short数值是32767，int类型最大值是2147483647 。注意溢出

4.3 逻辑和关系运算符

C++提供3种逻辑运算符:
(1) &&  逻辑与(相当于其他语言中的AND)
(2) ||  逻辑或(相当于其他语言中的OR)
(3) !逻辑非(相当于其他语言中的NOT)

C++的关系运算符有：
    <    (小于)
    <=        (小于或等于)           优先级相同 (高)
    >    (大于)
    >=        (大于或等于)  
    ==        (等于)
    !=       (不等于)           优先级相同 (低)

4.4赋值运算符

因为赋值运算符的优先级低于关系运算符的优先级，所以在条件语句中，赋值部分通常应该加上括号。

赋值操作符是右结合的，而算术运算符是左结合的。例如：

[cpp] view plain copy

1. a+b+c  
2. 就是(a+b)+c  
3. 而a=b=c  
4. 就是a=(b=c)  

4.5递增和递减运算符

对于内置类型来说，前置递增++递减--，与后置递增++递减--，在只执行变量自增1或者自减1的运行效率上是一致的。但要注意在对复杂迭代器的处理上，后置++或者--效率要比前置版本低很多。所以，如非必要，在使用迭代器时，推荐使用前置版本。

4.6成员访问运算符

string s1 ="a string",*p=&s1;auto n =s1.size(); //运行string 对象s1的size成员n =(*p).size(); //运行p所指对象的size成员n =p->size();//等价于(*p).size();

4.7 条件运算符

string finalgrade =(grade<60)?"fail":"pass";

小于60，则fail，大于则pass

嵌套条件运算符;

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

随着条件运算符嵌套层数的增加，代码的可读性急剧下降。因此，条件运算的嵌套最好别超过两到三层。

4.8位运算符

位运算符强烈建议只用于处理无符号数或正数,因为符号位如何处理是与机器有关的.

 以下是摘取一段博客的内容，总结的比较好。侵留言删   

老实说，我对+ = * / % && || ==一些比较简单的运算符比较熟悉。对位运算就陌生了，主要用的少。我觉得高手用的会比较多，因为位运算速度比较快。位运算应该适用于大多数的语言，不限于c++

1.& 

如果两个相应的二进制位都为１，则该位的结果值为1；否则为0。

注：下面都用8位的 unsigned char 来做例子。

目录 [隐藏]

&简单举例：
&比较实用的例子：
2. |
| 简单例子：
| 比较实用的例子
3. << 向左移位移
4. >> 向右位移
5. ^ 异或
6 ~
7 再扯下%
8.位运算优先级

&简单举例：

11&3  = 3

    00001011

&  00000011

=  00000011 = 3

 

&比较实用的例子：
比如我们经常要用的是否被2整除，一般都写成  if(n % 2 == 0)

可以换成 if((n&1) == 0)

 

2. |
 

如果两个相应的二进制位只要有一个是1，结果就是1；否则为0。

 

| 简单例子：
 

11 | 3 = 11

    00001011

|    00000011

=  00001011 = 11

 

| 比较实用的例子
可以用一个unsigned int 来存储多个布尔值。比如一个文件有读权限，写权限，执行权限。看起来要记录3个布尔值。我们可以用一个unsigned int也可以完成任务。

 

一个数r来表示读权限，它只更改个位来记录读权限的布尔值

00000001  (表示有读权限)

00000000  (表示没有读权限)

 

一个数w表示写权限，它只用二进制的倒数第二位来记录布尔值

00000010 (表示有写权限)

00000000 (表示没有写权限)

 

一个数x表示执行权限，它只用倒数第三位来记录布尔值

00000100 (表示有执行权限)

00000000 (表示没有执行权限)

 

那么一个文件同时没有3种权限就是

~r | ~ w | ~ x 即为 00000000，就是0

 

只有读的权限就是

r | ~w | ~x 即为 00000001，就是1

只有写的权限就是

~r | w | ~x 即为 00000010，就是2

…

一个文件同时有3种权限就是

r | w | x 即为 00000111，就是7

 

3. << 向左移位移
 

<<简单例子(向左移一位，右边自动补0)

11 << 1 = 22

  00001011 << 1

  00010110 = 22

相当于二进制的每个数都变成当前值的两倍，结果就是变成当前值的两倍。

n * 2 == (n << 1)

推广下就是(注意可能会溢出)

 

 

4. >> 向右位移
 

>>简单例子(向右移一位，左边自动补0)

11 >> 1 =  5

00001011 >> 1

00000101 = 5

注意到最后一位的1被干掉了。

比较实用的例子是:

int n = n / 2    等价于  int n = n >> 1  等价于 int n >>= 1

 

 

5. ^ 异或
 

两个相同的数会变成0，反之是1

例子：

11^3 = 8

    00001011

^  00000011

=  00001000 = 8

 

我觉得理解异或，一定要用异或来解下面的题目：

Given an array of integers, every element appearstwice except for one. Find that single one.

就是一个数组中，所有数字都出现了两次，只有一个没有

比如 int t = {1,2,3,3,2,1,5} 要找到5。

用异或就完美了，所有相同的都会消失，留下来的就是5了。我发现异或是嫉妒成双成对的。

int singleNumber(int A[], int n) {

for(int i = 1; i < n; ++i){

A[0] ^= A[i];

}

return A[0];

}

还有就是用不tmp值来交换两个数

//不用temp交换两个整数

void swap(int& x , int& y)

{

x ^= y;

y ^= x;

x ^= y;

}

扯点别的，^在lua中表示pow的意思，这是要逆天。

 

6 ~
 

这个在加法中用到

x-y = x + ~y + 1

所以~y = – y  -1

 

比如 ~11 = -11 -1 = -12

 

7 再扯下%
 

居然有道题目是这样的: 求 100 % 8的 优化解法。我们知道：

8刚好是2的3次方

所以 100 % 8 == 100 – math.floor(100 / 8) * 8 == 100 -  ((100 >> 3) << 3)

 

8.位运算优先级
 

总的来说比较低，一定要加括号

4.9 sizeof运算符

类型
　　对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量）

　　Char
　　偏移量必须为sizeof(char)即1的倍数

　　int
　　偏移量必须为sizeof(int)即4的倍数

　　float
　　偏移量必须为sizeof(float)即4的倍数

　　double
　　偏移量必须为sizeof(double)即8的倍数

　　Short
　　偏移量必须为sizeof(short)即2的倍数

　　各成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边界数（即该结构中占用最大空间的类型所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会根据需要自动填充空缺的字节。

　　下面用前面的例子来说明VC到底怎么样来存放结构的。

struct MyStruct
{
double dda1;
char dda;
int type
}；

　　为上面的结构分配空间的时候，VC根据成员变量出现的顺序和对齐方式，先为第一个成员dda1分配空间，其起始地址跟结构的起始地址相同（刚好偏移量0 刚好为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；接下来为第二个成员dda分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为8，是sizeof(char)的倍数，所以把dda存放在偏移量为8的地方满足对齐方式，该成员变量占用 sizeof(char)=1个字节；接下来为第三个成员type分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为9，不是sizeof (int)=4的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址对于结构的起始地址的偏移量为12，刚好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个字节；这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为：8+1+3+4=16，刚好为结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以没有空缺的字节需要填充。所以整个结构的大小为：sizeof(MyStruct)=8+1+ 3+4=16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。

　　下面再举个例子，交换一下上面的MyStruct的成员变量的位置，使它变成下面的情况：

struct MyStruct
{
char dda;
double dda1;
int type
}；

　　这个结构占用的空间为多大呢？在VC6.0环境下，可以得到sizeof(MyStruc)为24。结合上面提到的分配空间的一些原则，分析下VC怎么样为上面的结构分配空间的。（简单说明）

struct MyStruct
{
char dda;//偏移量为0，满足对齐方式，dda占用1个字节；
double dda1;//下一个可用的地址的偏移量为1，不是sizeof(double)=8
//的倍数，需要补足7个字节才能使偏移量变为8（满足对齐
//方式），因此VC自动填充7个字节，dda1存放在偏移量为8
//的地址上，它占用8个字节。
int type；//下一个可用的地址的偏移量为16，是sizeof(int)=4的倍
//数，满足int的对齐方式，所以不需要VC自动填充，type存
//放在偏移量为16的地址上，它占用4个字节。
}；//所有成员变量都分配了空间，空间总的大小为1+7+8+4=20，不是结构
//的节边界数（即结构中占用最大空间的类型所占用的字节数sizeof
//(double)=8）的倍数，所以需要填充4个字节，以满足结构的大小为
//sizeof(double)=8的倍数。

　　所以该结构总的大小为：sizeof(MyStruc)为1+7+8+4+4=24。其中总的有7+4=11个字节是VC自动填充的，没有放任何有意义的东西。

　　VC对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。

　　VC中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况：第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；

　　否则必须为n的倍数。下面举例说明其用法。

#pragma pack(push) //保存对齐状态
#pragma pack(4)//设定为4字节对齐
struct test
{
char m1;
double m4;
int m3;
};
#pragma pack(pop)//恢复对齐状态

　　以上结构的大小为16，下面分析其存储情况，首先为m1分配空间，其偏移量为0，满足我们自己设定的对齐方式（4字节对齐），m1占用1个字节。接着开始为m4分配空间，这时其偏移量为1，需要补足3个字节，这样使偏移量满足为n=4的倍数（因为sizeof(double)大于n）,m4占用8个字节。接着为m3分配空间，这时其偏移量为12，满足为4的倍数，m3占用4个字节。这时已经为所有成员变量分配了空间，共分配了16个字节，满足为n的倍数。如果把上面的#pragma pack(4)改为#pragma pack(16)，那么我们可以得到结构的大小为24。

4.11.3显示转换

显示转换四个操作符的区别：

• static_cast：静态转换，相当于c中的类型转换，编译过程中转换不成功将报错
• dynamic_cast：动态转换，具有运行时类型检查的特性，只能被使用在将变量转化为类的指针/类的引用/void*时，进行父类子类之间的现实转换时更加安全
• const_cast：去掉变量的const/volatile属性
• reinterpret_cast：重解释转换，可以在任何两种类型之间进行转换，而不必担心编译器的检查，由程序员自己负起转换后正确使用的责任

4.12 运算符优先级表

 

优先级操作符描述例子结合性1()
[]
->
.
::
++
--调节优先级的括号操作符
数组下标访问操作符
通过指向对象的指针访问成员的操作符
通过对象本身访问成员的操作符
作用域操作符
后置自增操作符
后置自减操作符(a + b) / 4;
array[4] = 2;
ptr->age = 34;
obj.age = 34;
Class::age = 2;
for( i = 0; i < 10; i++ ) ...
for( i = 10; i > 0; i-- ) ...从左到右2!
~
++
--
-
+
*
&
(type)
sizeof逻辑取反操作符
按位取反(按位取补) 
前置自增操作符
前置自减操作符
一元取负操作符
一元取正操作符
解引用操作符
取地址操作符
类型转换操作符
返回对象占用的字节数操作符if( !done ) ...
flags = ~flags;
for( i = 0; i < 10; ++i ) ...
for( i = 10; i > 0; --i ) ...
int i = -1;
int i = +1;
data = *ptr;
address = &obj;
int i = (int) floatNum;
int size = sizeof(floatNum);从右到左3->*
.*在指针上通过指向成员的指针访问成员的操作符
在对象上通过指向成员的指针访问成员的操作符ptr->*var = 24;
obj.*var = 24;从左到右4*
/
%乘法操作符
除法操作符
取余数操作符int i = 2 * 4;
float f = 10 / 3;
int rem = 4 % 3;从左到右5+
-加法操作符
减法操作符int i = 2 + 3;
int i = 5 - 1;从左到右6<<
>>按位左移操作符
按位右移操作符int flags = 33 << 1;
int flags = 33 >> 1;从左到右7<
<=
>
>=小于比较操作符
小于或等于比较操作符
大于比较操作符
大于或等于比较操作符if( i < 42 ) ...
if( i <= 42 ) ...
if( i > 42 ) ...
if( i >= 42 ) ...从左到右8==
!=等于比较操作符
不等于比较操作符if( i == 42 ) ...
if( i != 42 ) ...从左到右9&按位与操作符flags = flags & 42;从左到右10^按位异或操作符flags = flags ^ 42;从左到右11|按位或操作符flags = flags | 42;从左到右12&&逻辑与操作符if( conditionA && conditionB ) ...从左到右13||逻辑或操作符if( conditionA || conditionB ) ...从左到右14? :三元条件操作符int i = (a > b) ? a : b;从右到左15=
+=
-=
*=
/=
%=
&=
^=
|=
<<=
>>=赋值操作符
复合赋值操作符(加法)
复合赋值操作符(减法)
复合赋值操作符(乘法)
复合赋值操作符(除法)
复合赋值操作符(取余)
复合赋值操作符(按位与)
复合赋值操作符(按位异或)
复合赋值操作符(按位或)
复合赋值操作符(按位左移)
复合赋值操作符(按位右移)int a = b;
a += 3;
b -= 4;
a *= 5;
a /= 2;
a %= 3;
flags &= new_flags;
flags ^= new_flags;
flags |= new_flags;
flags <<= 2;
flags >>= 2;从右到左16,逗号操作符for( i = 0, j = 0; i < 10; i++, j++ ) ...从左到右

 

记忆方法：

--摘自《C语言程序设计实用问答》       
    问题：如何记住运算符的15种优先级和结合性？    
    解答：C语言中运算符种类比较繁多，优先级有15种，结合性有两种。    
    如何记忆两种结合性和15种优先级？下面讲述一种记忆方法。    
    结合性有两种，一种是自左至右，另一种是自右至左，大部分运算符的结合性是自左至右，只有单目运算符、三目运算符的赋值运算符的结合性自右至左。    
    优先级有15种。记忆方法如下：    
    记住一个最高的：构造类型的元素或成员以及小括号。    
    记住一个最低的：逗号运算符。    
    剩余的是一、二、三、赋值。    
    意思是单目、双目、三目和赋值运算符。    
    在诸多运算符中，又分为：    
    算术、关系、逻辑。    
    两种位操作运算符中，移位运算符在算术运算符后边，逻辑位运算符在逻辑运算符的前面。再细分如下：    
    算术运算符分     *，/，%高于+，-。    
    关系运算符中，〉，〉=，<，<=高于==，！=。    
    逻辑运算符中，除了逻辑求反（！）是单目外，逻辑与（&&）高于逻辑或（||）。    
    逻辑位运算符中，除了逻辑按位求反（~）外，按位与（&)高于按位半加（^)，高于按位或（|）。    
    这样就将15种优先级都记住了，再将记忆方法总结如下：    
    去掉一个最高的，去掉一个最低的，剩下的是一、二、三、赋值。双目运算符中，顺序为算术、关系和逻辑，移位和逻辑位插入其中。