=======================================================
4.1 什么是表达式
=======================================================
表达式由一个或多个 操作数（aperand） 、以及应用在这些操作数上的操作构成。
应用在操作数上的操作由 操作符（operator） 表示。分：一元操作符和二元操作符。
=======================================================
4.2 算术操作符
=======================================================
操作符 功能 用法 说明
* 乘 expr * expr
/ 除 expr / expr
% 求余（取模） expr % expr 只能用于整数，若有一个或两个数为负，余数的是否为负则取决于机器
+ 加 expr + expr
- 减 expr - expr
标准C++头文件limits提供了与内置类型表示有关的信息，如一个类型能表示的{zd0}值和最小值。
标准C头文件climits和cfloat定义了提供类似信息的预处理器宏。
=======================================================
4.3 等于、关系和逻辑操作符
=======================================================
操作符 功能 用法
! 逻辑非 !expr
< 小于 expr < expr
<= 小于等于 expr <= expr
> 大于 expr > expr
>= 大于等于 expr >= expr
== 等于 expr == expr
!= 不等于 expr != expr
&& 逻辑与 expr && expr
|| 逻辑或 expr || expr
注：这些操作符的结果是bool类型（true或false）。
int elem_cnt = 0;
vector<int>::iterator iter = ivec.begin();
while( iter != ivec.end() )
{
elem_cnt += *iter < some_value;
++iter;
}
二元操作符存在潜在的缺点：左右操作数的计算顺序是未定义的，因此计算过程必须是与顺序无关的：
if( ia[index++] < ia[index] ) ... //目的是ia[0]与ia[1]，但实际上很可能是ia[0]与它自己
所以应该写成：
if( ia[index] < ia[index+1] ) ...
=======================================================
4.4 赋值操作符
=======================================================
int ival = 1024;//初始化操作，只可以被初始化一次
ival = 2048; //赋值操作，可以被重复多次
当我们把不同类型的表达式赋值给一个对象时，编译器会试着隐式将右操作数转换成被赋值对象的类型，如果可能的话。若不能则编译出错。
ival= 3.1415926; //3
int *pi;
pi = ival; //错误
赋值表达式可以被当作一个子表达式：
while( (ch=next_char()) != '\n' ) ... //外加的小括号是必需的
赋值操作符也可以被连接在一起，只要操作数都是相同的类型：
int ival, jval, *pval;
ival = jval = 0; //ok
ival = pval = 0; //错误，即使单独赋值都是正确的
int ival = jval = 0; // 可能合法，也可能不合法，因为jval必须实现定义成适当的类型
应该写成：
int ival=0, jval=0;
复合赋值操作符:
+= -= *= /= %=
<<= >>= &= ^= |=
=======================================================
4.5 递增和递减操作符
=======================================================
递增（++）、递减（--）
为什么C++不叫++C？
转自：
C++的C说明了它本质上是从C语言演化过来的，C++语言是C语言的超集，是在C语言基础上进行的扩展(引入了new、delete等C语言中没有的操作符，增加了面向对象程序设计的支持，等等)，是先有C语言，在进行C++。根据自增操作符前、后置形式的差别，C++表示对C语言进行扩展之后，还可以使用C语言的内容，而写成++C则表示无法再使用C的原始值了，也就是说C++不能向下兼容C了，这与实际情况不符。
=======================================================
4.6 复数操作
=======================================================
C++不但支持一般的算术操作符，如加、减、乘、除，而且还支持复数类型与内置类型的混合运算。如：
#include <complex>
complex<double> a;
complex<double> b;
//...
complex<double> c = a*b + a/b;
complex<double> complex_obj = a + 3.14159;
或：
double dval = 3.14159;
complex_obj = dval;
但是反过来则不行：
dval = complex_obj; //错误
可以显示的知名我们要用复数对象的哪部分来赋值：
double re = complex_obj.real();
double im = complex_obj.imag();
或
double re = real(complex_obj);
double im = imag(complex_obj);
支持四种复合赋值：+=、-=、*=、/=
复数的输出：
complex<double> complex0(3.14159, -2.171);
cout << complex0 << endl;
输出：
(3.14159, -2.171)
复数的输入，下面任意格式都可以：
cin >> a >> b >> c;
3.14159 (3.14159) (3.14, -1.0)
复数类支持的其他操作包括：sqrt()、abs()、polar()、sin()、cos()、tan()、exp()、log()、log10()，以及pow()。
=======================================================
4.7 条件操作符
=======================================================
expr1 ? expr2 : expr3;
使用：
int i=10, j=20, k=30;
cout << "the larger value of " << i << " and " << j << " is " << (i>j ? i:j) << endl;
条件操作符可以被嵌套，但是深度的嵌套比较难读：
//max被设置为3个变量中的{zd0}值
int max = ( (i>j) ? ((i>k) ? i : k) : (j<k) ? j : k );
=======================================================
4.8 sizeof操作符
=======================================================
sizeof操作符的作用是返回一个对象或类型名的 字节长度 。它有三种形式：
sizeof(type name);
sizeof( object );
sizeof object;
返回值的类型是size_t，这时一种与机器相关的typedef定义，我们可以在cstddef头文件中找到它的定义。
使用：
#include <cstddef>
int ia[] = {1, 2, 3};
size_t array_size = sizeof ia; //整个数组占的字节长度：12
size_t element_size = array_size / sizeof(int); //int类型的大小
int *pi = new int[3];
size_t pointer_size = sizeof(pi); //返回指向int型的指针的字节长度，而不是pi指向的数组的长度
sizeof操作符在编译时刻计算，因此被看作是常量表达式。它可以用在任何需要常量表达式的地方：
int array[sizeof(some_type_T)]; //数组的维数
例子：
#include <string>
#include <iostream>
#include <cstddef>
int main()
{
size_t ia;
ia = sizeof( ia ); // ok
ia = sizeof ia; // ok
// ia = sizeof int; // 错误
ia = sizeof( int ); // ok
int *pi = new int[ 12 ];
cout << "pi: " << sizeof( pi )
<< " *pi: " << sizeof( *pi )
<< endl;
// 一个 string的大小与它所指的字符串的长度无关
string st1( "foobar" );
string st2( "a mighty oak" );
string *ps = &st1;
cout << "st1: " << sizeof( st1 )
<< " st2: " << sizeof( st2 )
<< " ps: " << sizeof( ps )
<< " *ps: " << sizeof( *ps )
<< endl;
cout << "short :\t" << sizeof(short) << endl;
cout << "short* :\t"<< sizeof(short*) << endl;
cout << "short& :\t"<< sizeof(short&) << endl;
cout << "short[3] :\t" << sizeof(short[3]) << endl;
cout << "char :\t" << sizeof(char) << endl;
}
编译并运行它 产生如下结果：
pi: 4 *pi: 4
st1: 12 st2: 12 ps: 4 *ps: 12 //试验得出的结果是：st1: 4 st2: 4 ps: 4 *ps: 4
short : 2
short* : 4
short& : 2
short[3] : 6
char : 1
=======================================================
4.9 new和delete表达式
=======================================================
系统为每个程序都提供了一个在程序执行时可用的内存池，成为 程序的空闲存储区 或 堆。
运行时刻的内存分配被称为 动态内存分配。在空闲存储区里分配。
动态分配有new完成。
int *pi = new int; //没有被初始化
int *pi = new int(1024);//初始化为1024
int *pia = new int[10]; //定义数组，同样没有初始化，若是类对象数组且有缺省构造函数，则依次应用在每个元素上
当对象完成了使命时，我们必须显示地把对象的内存返还给空闲存储区。用delete。但是它应该用在new分配的指针上（成对出现）。
在类对象上使用delete时，会应用其析构函数释放存储区，并还给空闲存储区。
delete pi;
delete [] pia; //释放数组
=======================================================
4.10 逗号操作符
=======================================================
逗号表达式是一系列由逗号分开的表达式。这些表达式从左向右计算。逗号表达式的结束是最右边表达式的值。
例子，{dy}个逗号表达式的值是ix，第二个是0：
int ival = (ia!=0) ? ix=get_value(), ia[index]=ix : ia=new int[sz], ia[index]=0;
=======================================================
4.11 位操作符
=======================================================
操作符 功能 用法
~ 按位非 ~expr
<< 左移 expr1 << expr2
>> 右移 expr1 >> expr2
& 按位与 expr1 & expr2
^ 按位异或 expr1 ^ expr2
| 按位或 expr1 | expr2
&= 按位与赋值 expr1 &= expr2
^= 按位异或赋值 expr1 ^= expr2
|= 按位或赋值 expr1 |= expr2
位操作符允许程序员设置或测试独立的位或位域。
如果一个对象被用作一组位或位域的离散集合，那么这样的对象成为 位向量。
C++有两种方式支持位向量：
1. 用内置整值类型来表示，如：unsigned int；
2. 标准库提供了一个bitset类，它支持位向量的类抽象。
用内置整值类型来表示：
类型可以是有符号的，也可以是无符号的，建议使用无符号类型。
操作符 功能
~ 翻转操作数的每一位
<<, >> 将其左边操作数的位想左或右移动某些位。左移符从右边开始补0；右移，无符号数则补0，有符号数补0或符号位的拷贝视具体实现定义
& 两个整值操作数。在每个位所在处与
| 两个整值操作数。在每个位所在处或
^ 两个整值操作数。在每个位所在处非，两个数只有一个含有1，则结果该位为1，否则为0
例子：
unsigned int quiz1 = 0;
quiz1 |= 1 << 27; //将第28位置成1
quiz1 &= ~(1 << 27); //将第28位置成0
bool hasPassed = quiz1 & (1<<27); //判断第28位是1还是0
=======================================================
4.12 bitset操作
=======================================================
继续上节，用bitset类进行位操作。
操作 功能 用法 说明
test( pos ) pos 位是否为1 a.test( 4 )
any() 任意位是否为1 a.any() 有一位或多位为1时，返回true，否则false
none() 是否没有位为1 a.none() 与any()相反，都为0才返回true
count() 值是1 的位的个数 a.count()
size() 位元素的个数 a.size()
[pos] 访问pos 位 a[ 4 ]
flip() 翻转所有的位 a.flip()
flip( pos ) 翻转pos 位 a.flip( 4 )
set() 将所有位置1 a.set()
set( pos ) 将pos 位置1 a.set( 4 )
reset() 将所有位置0 a.reset()
reset(pos) 将pos 位置0 a.reset( 4 )
头文件：<bitset>
定义和初始化：
bitset<32> bitvec; //缺省定义，指名位向量的长度是32，所有为被初始化为0
bitset< 32 > bitvec2( 0xffff ); //前N位被初始化为参数的相应位值
bitset< 32 > bitvec3( 012 ); //012为8进制数，将第1 和3 位的值设置为1，其它为0，同样可以用10进制数
string bitval( "1010" );
bitset< 32 > bitvec4( bitval ); //同上
我们还可以标记用来初始化bitset 的字符串的范围：
string bitval( "1111110101100011010101" );
bitset< 32 > bitvec5( bitval, 6, 4 ); //从低位开始数，从位置6开始, 长度为4: 1010
bitset< 32 > bitvec6( bitval, 6 ); //从低位开始数，从位置6开始直到{zh1}: 1010101
bitset类还支持位操作符：
bitset<32> bitvec7 = bitvec2 | bitvec3;
针对上节的例子，现在可以写成：
bitset<30> quiz1;
quiz1.set(27); //quiz1 |= 1 << 27;将第28位置成1
或：quiz1[27] = 1;
quiz1.reset(27); //quiz1 &= ~(1 << 27);将第28位置成0
或：quiz1[27] = 0;
if(quiz1[27]); //判断第28位是1还是0
或：if(quiz1.test(27))
还包括两个类型转换函数：
to_string(); //转换成string
to_ulong(); //转换成 unsigned long
=======================================================
4.13 优先级
=======================================================
操作符优先级是指复合表达式中操作符计算的顺序。
用括号把一些子表达式括起来，可以改变优先级。
结合性：
赋值操作是右结合的：
ival = jval = kval = lval
算术操作符是左结合的：
ival + jval + kval + lval
C++操作符的全集，每段中优先级相同，上段优先级高于下段：
操作符 功能 用法
:: 全局域 ::name
:: 类域 ::name
:: 名字空间域 namespace::name
. 成员选择 object.member
-> 成员选择 pointer->member
[] 下标 variable[ expr ]
() 函数调用 name(expr_list)
() 类型构造 type(expr_list)
++ 后置递增 lvalue++
-- 后置递减 lvalue--
typeid 类型ID typeid(type)
typeid 运行时刻类型 ID typeid(expr)
const_cast 类型转换 const_cast<type>(expr)
dynamic_cast 类型转换 dynamic_cast<type>(expr)
reinterpret_cast 类型转换 reinterpret_cast<type>(expr)
static_cast 类型转换 static_cast<type>(expr)
sizeof 对象的大小 sizeof object
sizeof 类型的大小 sizeof( type )
++ 前置递增 ++lvalue
-- 前置递减 --lvalue
~ 按位非 ~expr
! 逻辑非 !expr
- 一元减 -expr
+ 一元加 +expr
* 解引用 &expr
& 取地址 &expr
() 类型转换 (type)expr
new 分配对象 new type
new 分配/初始化对象 new type(expr_list)
new 分配/替换对象 new(expr_list)type(expr_list)
new 分配数组 所有的形式
delete 释放对象 所有的形式
delete 释放数组 所有的形式
->* 指向成员选择 pointer->*pointer_to_member
.* 指向成员选择 object.*pointer_to_member
* 乘 expr * expr
/ 除 expr / expr
% 取模 求余 expr % expr
+ 加 expr + expr
- 减 expr - expr
<< 按位左移 expr << expr
>> 按位右移 expr >> expr
< 小于 expr < expr
<= 小于等于 expr <= expr
> 大于 expr > expr
>= 大于等于 expr >= expr
== 等于 expr == expr
!= 不等于 expr != expr
& 按位与 expr & expr
^ 按位异或 expr ^ expr
| 按位或 expr | expr
&& 逻辑与 expr && expr
|| 逻辑或 expr || expr
?: 条件表达式 expr ? expr : expr
= 赋值 lvalue = expr
=,*=,/=,%=,+=,-=,<<=,>>=,&=,|=,^= 复合赋值 lvalue += expr 等
throw 抛出异常 throw expr
, 逗号 expr, expr
=======================================================
4.14 类型转换
=======================================================
隐式转换：
int ival = 0;
ival = 3.541 + 3;
这里3.541是double型，3是int型。C++在计算前运用“算术转换”将两个操作数转成同类型。原则是，小类型总是被提升成大类型。
本例3被提升为double型。
所以加法的结果是6.351。
赋值给ival是再转型，右边转到左边，自动按截取而不是舍入进行，小数被抛弃。
所以结果是6。
若想保住小数，使其舍入，则需要自己程序实现：
ival = 3.541 + 3 + 0.5; //保证舍入
也可以显示的先类型转换再计算：
ival = static_cast<int>( 3.541 ) + 3; //结果仍然是6，显示转换也是舍弃小数
1. 隐式类型转换：
在下列情况下会发生隐式转换：
（1）在混合类型的算术表达式中：最宽的数据类型成为目标转换类型，这也被称为 算术转换。
（2）用一种类型的表达式赋值给另一种类型的对象：目标转换类型是被赋值类型。
（3）把一个表达式传递给一个函数调用：转成形式参数的类型。
（4）从一个函数返回一个表达式，表达式的类型与返回类型不同：转成返回类型。
2.算术转换：
算术转换保证了二元操作符的两个操作数被提升为共同的类型，然后再用它表示结果的类型。原则：
（1）为防止精度损失，如果必要的话，类型总是被提升为较宽的类型。
（2）所有含有小于整型的有序类型的算术表达式，在计算之前，其类型都会被转换成整型。包括：char、singed char、unsigned char、short int，及枚举型enum。
如：
3.14159L + 'a'; //3.14159L是long double型，‘a’先被转成long bouble（ASC码为97）再计算
3. 显示转换
也被称为 强制类型转换（cast），包括下列操作符：
static_cast、dynami_cast、const_cast、reinterpret_cast。
显示转换之后，编译器则不会发出提示信息了（否则有警告）。
一般形式：
cast-name<type>(expression);
显示转换存在的原因：
（1）将void*强制转成显示类型的指针
（2）希望改变通常的标准转换
（3）要避免出现多种转换可能的歧义情况
如：
const char *pc_str;
char *pc = pc_str; //编译出错
char *pc = const_cast<char*>(pc_str); //ok
行为不佳的静态转换（即那些有潜在危险的类型转换）：
将void*型的指针强制转换成某种显式指针类型
把一个算术值强制转换成枚举型
把一个基类强制转换成其派生类或者这种类的指针或引用
在引入这些强制转换操作符之前，显式强制转换由一对括号来完成：
char *pc = (char*) pcom; //与reinterpret_cast效果一样
4. 旧式强制类型转换
有两种形式：
type (expr); //C++语言强制转换符号
(type) expr; //C语言强制转换符号
标准C++对旧式强制转换符号的支持，是为了保持 向后兼容性。
如果我们希望自己的代码在C++和C语言中都能编译的话，那么只能使用C语言的强制转换符号。
但是建议使用新式强制转换符号。
=======================================================
4.15 栈类实例
=======================================================
栈是计算机科学的一个基本数据抽象，它允许以 后进先出 的顺序嵌入和获取其中的值。
代码略。
