差别

这里会显示出您选择的修订版和当前版本之间的差别。

--- zh:cpp:cpp_note:cpp_primer:4_expressions [2017/02/20 02:38] – [8.1.sizeof运算符] haregy
+++ zh:cpp:cpp_note:cpp_primer:4_expressions [2017/02/27 12:03] (当前版本) – 移除 haregy
@@ 行 1: / 行 1: @@
-====表达式====
-C++ Primer 笔记 第四章\\
-<wrap em>我的笔记均包含大量个人理解内容，存在一定偏差。如果您发现错误，请留言提出，谢谢！</wrap>
-===== =====
-====1.表达式基础====
-运算符分为一元运算符（unary operator )和二元运算符 （Binary operator）。“元”代表有几个operands。每个运算符的运算优先级（precedence） 和结合律（associativity）由运算符自身决定。
-我们在对包含多个运算符的表达式进行计算的时候，常常会遇到一些需要考虑的问题：比如运算优先级，operands的转化，运算符的重载等等。要讨论这些规则之前，我们必须先明白两个概念：左值（Lvalues）和右值（Rvalues)
-===1.1.左值和右值===
-每个表达式都有至少一个左值或者右值来充当自己的operand。 那什么叫左值？我们可以顾名思义，左值当然是能放到左边的了值了。放到什么左边？放到“=”的左边。不过左值不能这么来定义，因为这么定义会有一些例外。比如 const 对象，这是一个左值，但是不能放到“=”左边。书中讲了一个简单的判定规则：**当使用左值的时候，我们是使用的对象在内存里的位置；当使用右值的时候，我们使用的是对象的值。**看看“=”左边的值，是不是都能取地址，都能赋值？\\
-判断左值的具体方法可以参考：\\
-[[https://www.zhihu.com/question/39846131|关于C++左值和右值区别有没有什么简单明了的规则可以一眼辨别？]] **看轮子哥的解答**。\\
-\\
-了解了定义以后，有几个表达式的规则就根据左右值的区分来制订了：
-  - 在表达式中，左值可以取代右值，反过来不行。
-  - 赋值运算中，“=”号左边如果是一个Nonconst的左值，那么表达式得到的结果类型也是左值。（很好想象，比如 a = 10; 得到的是a）
-  - 取地址操作需要一个左值，而操作结果返回一个指针，是右值。（当然了，左值代表位置，取地址当然是对左值操作。取回的是地址的具体数值，当然是右值。）
-  - 解引用（*）运算，下标运算和迭代器的解引用，都产生左值。
-  - 迭代器的自增 / 自减 也需要左值进行运算，<wrap em>但只有prefix版本返回左值</wrap>（++ / --i）。
-  - 用decltype对表达式进行操作，如果表达式返回左值，那么decltype的返回值是一个引用。
-===1.2.运算符重载 / 转化===
-关于运算符对operand的转化后面会详细说到详细的规则。\\
-对于运算符的重载，要注意的是运算符不管怎么重载，operand的类型都是由重载的定义来决定的。但是，**重载并不能改变运算符本身的运算优先级和结合律。**
-===1.3.表达式判定顺序===
-优先级和结合律并不能保证运算对象的求值顺序，operand的运算顺序在大多数情况下是未知的；而有时候这种未知的操作顺序会带来很严重的后果，比如：
-<code:cpp linenums:1>
-int i = 0;
-cout << i << ++i << endl;
-</code>
-在这里我们根本就不知道i是多少。如果前面的i先运算，那么我们打印的是0, 1;但如果后面的++i先运算，我们打印的就是1,1了，这显然是不合理的。\\
-<wrap em>对于没有指定operand运算顺序的表达式，如果operands的运算牵涉并改变了同一个值，结果将导致undefined.</wrap>\\
-那么问题来了，既然这么危险，为啥C++不直接禁止这么用？\\
-我们再来看一个例子：
-<code:cpp linenums:1>
-f() + g() * h() + j();
-</code>
-我们知道这几个function我们不知道谁先进行运算，因此如果他们改变同一个对象，我们又要得到undefined的值了。但是如果他们操作的是不同的对象呢？\\
-试想一下，如果C++强行规定了运算顺序，那么不管怎么样，我们同时只能进行两个functions的运算。但如果我们不指定顺序，那么这4个functions是可以同时进行运算的。这样的话，不指定顺序比制定顺序快了一倍。当我们明白这些function在操作什么时，我们也不需要害怕上述的危险了，反而能得到性能的提升。这也很符合C++的哲学：让程序员来决定程序的好坏。\\
- \\
-当然如果把握不准，我们还有几个方法来处理这个问题：
-  - 用括号保证优先级。
-  - 如果改变了operand的值，就不要把这个operand再放到同一个表达式的其他任何地方。（有例外，如实际上已经指定了优先级的*iter++，详见[[zh:cpp:cpp_note:cpp_primer:4_expressions#4.1.自增运算符和解引用|section4.1]]）
-==1.3.1.四种确定了operand运算顺序的运算符==
-对于一些运算符，operand运算的顺序是指定了的。比如逻辑运算符(&& / || )，条件运算符(? :)，逗号运算符（，）。
-====2.算术运算符====
-算术运算符的优先级可以同样可以参考P166。有几点需要注意的是：
-  - 一元运算符的优先级 > 乘除 > 加减。
-  - 运算的时候都是从左到右（左结合律）
-  - 算术运算符得到的结果都是右值。
-  - 一元“+”运算符可以应用到指针和算术类型上，返回的值是operand的拷贝。
-  - 整数之间的除法结果是整数。
-===2.1.算术运算异常===
-算术运算的异常通常有几种情况：
-  * 如果我们进行了了一些数学意义上无意义的运算，那么很可能导致算术运算的异常。比如：除0操作
-  * 超出了类型范围算术运算(overflow)，比如：
-     <code:cpp linenums:1>
-     short si = 32767;
-     si += 1; //error, overflows.</code>
-注意：这样的错误编译器很可能不会给出异常，因为在有些系统里是有值得出的，比如上述计算得出si的值为-32768（我的系统）。
-===2.2.余数/商===
-对于整数的除法，现行的新标准已经禁止商像负无穷方向取整了。\\
-对于余数的计算 M%N，有：
-  - M % (-N) = M % N
-  - -(M) % N = - (M % N)
-====3.逻辑运算符====
-逻辑运算符都是先求左边operand的值，根据左边结果来判定是不是要求右边的值，这种求值方式我们称为short-circuit evaluation.
-&& / || / !都是比较常见的运算符，主要用于条件判断。对于默认的条件判断来说，括号里的值只要非负，就为真。比如：
-<code:cpp>
-while(a); // true if a is any non-zero value.
-</code>
-这里牵涉到类型的隐式转换，后面会cover相关内容。
-===3.1.关系运算符===
-关系运算符用于鉴别operand的大小，所以也是返回bool类型的值。\\
-因为关系运算是有结合律的，所以不能进行连续的关系运算，会导致结果错误。一般都与逻辑运算符混用，达到不同的条件判断。\\
-注意：不进行关系运算的时候，不要用true / false来进行运算。（进行比较后会有隐式转换）
-===3.2.赋值运算符===
-赋值运算符有几个要点：
-  - 赋值运算符的左边必须是可以操作的左值。
-  - 赋值结果的类型与左边的operand相同。
-  - 赋值运算中如果左右两个operand的类型不同，右operand会转化成和左operand相同的类型。
-  - C++11中，List初始化不能进行narrow conversion(老版本是可以的，反过来也是可以的，比如用double去装int）,list可以为空（进行默认初始化）。
-==3.2.1.赋值运算的结合律==
-赋值运算的结合律是从右到左的。比如：
-<code:cpp linenums:1>
-int ival, jval;
-ival = jval = 0; // expression will do jval = 0 first; then do ival = jval
-</code>
-**<wrap em>注意：在多重赋值中，所有的对象类型必须一致，或者可以通过类型转换达到一致。</wrap>**
-====4.自增自减运算符====
-假设用自增运算符（自减也是相同的）对变量 i 进行操作，那么我们会得到两种情况：++i 和 i++.\\
-简单的说来：
-  * <wrap em> ++i 是先自增再运算 </wrap>
-  *<wrap em> i++ 是先运算再自增</wrap>
-从结果来说：
-  * **++i 返回的是 i+1的值，返回的值是<wrap em>左值</wrap>**。
-  * i++ 返回的是 i 的值，返回的是一个右值。
-从程序效率上来说：
-  * ++i 做了两步：取值，增加。
-  * i++ 做了三步：取值，增加，再取原来的值。
-对于一些迭代器运算，<wrap em>++i的效率要高于i++的</wrap>。详情可以参考：\\
-[[https://www.zhihu.com/question/19811087|在程序开发中，++i 与 i++的区别在哪里？]] 叶王的回答。
-==4.1.自增运算符和解引用==
-有时候我们会希望使用变量的值，然后再对其加1，这时候我们可以用*iter++这样的表达式。比如我们要遍历打印一个vector：\\
-如果我们用一般的方法，我们需要做两部：
-<code:cpp linenums:1>
-auto pbeg = v.begin();
-while (pbeg != v.end()) {
-    cout << *pbeg << endl; // print current value;
-    ++pbeg; // iterator move to the next position;
-}
-</code>
-但现在有了 *iter++这种形式，语句就可以更简洁了：
-<code:cpp linenums:1>
-auto pbeg = v.begin();
-while (pbeg != v.end())
-    *pbeg++; // print current value then move to the next position. </code>
-而对于 *pbeg++ 来说，解引用运算的优先级高于自增。所以这个表达式也等价于*(pbeg++)。\\
-注意：除非operand的运算顺序明显（如上例），避免用自增 / 自减 运算对同一个数值进行运算，修改（原因见[[zh:cpp:cpp_note:cpp_primer:4_expressions#1.3.表达式判定顺序|section1.3]])
-====5.成员访问运算符====
-成员运算符有 "." 和 "->"两种。 "."(dot)运算符比较常用，一般用于访问成员，比如访问对象a的function(),我们就可以写成：a.function()。\\
-有时候我们知道对象a的指针p，用p来访问function()就要先解引用，再访问，比如：(*p).function()。注意：因为解引用的优先级低于dot成员访问，所以必须用括号强制先行解引用运算。\\
-这种方法比较繁琐，我们可以用"->"运算符来代替，比如如下两种方法都是等价的：
-<code:cpp linenums:1>
-(*p).function();
-p->function();
-</code>
-**对于dot运算，运算结果与参与运算对象的类型相同**（这里指左值/右值）。在(*p).function()里，*p是左值，所以我们可以得知"->"**运算符返回的是左值。
-**
-====6.条件运算符====
-if-else语句可以用条件运算符的形式表达出来：
-<code:cpp >
-condition ? expr1(if_true) : expr2(if_false);
-</code>
-如果两个条件表达式都是左值，那么运算的结果是左值，否则结果是右值。\\
-有几点需要注意的是：
-  * 用条件运算符进行嵌套会大大影响程序的可读性。
-  * 条件运算符的优先级非常低，如果在复杂的表达式中运用，必须要用括号保证优先级，比如：
-    <code:cpp >
-cout << (condition ? expr1(if_true) : expr2(if_false)) << endl;
-</code>
-====7.位运算符====
-位运算符作用于整数运算，并且把运算对象都当作是二进制运算。位运算有几种比较重要的运算符：
-<code:cpp linenums:1 >
-~expr; // bitwase NOT, 按位求反
-expr1 << expr2; //left shift, 左位移
-expr1 >> expr2; //right shift, 右位移
-expr1 & expr2 ;//bitwise AND, 按位与运算，只有位都为1的之后为真
-expr1 ^ expr2; //bitwise XOR, 按位异或运算，位异号的时候为真
-expr1 | expr2; //bitwise OR, 按位或运算，只要位中有一个为1，就为真
-</code>
-对于位移运算符">>, <<" ，我们需要注意的是：
-  - 位移运算符<wrap em>右边的operand必须非负</wrap>，而且<wrap em>值必须小于结果的位数</wrap>，否则会导致undefined。
-  - 对于位运算符，我们最好采用unsigned类型来进行计算。如果位运算符的operand带有符号，那么运算符对operand符号位的处理是根据机器来指定的。换句话说，符号位的处理是没有明确定义的；如果运算导致符号位被修改（比如位移操作），那么这个运算就会导致undefined.
-  - 位移运算的结合律是从左到右的。
-  - 位移运算的优先级高于关系运算符，复合使用的时候必须要用括号确定优先级。
-\\
-位运算因为只进行二进制的条件和位移运算，所以效率是非常高的。我们通常可以把位运算引用到一些比较简单的条件判断上，比如判断奇偶：
-<code:cpp linenums:1>
-int a;
-a % 2; //the way we used to evaluate odd / even
-a & 0x1; // using AND. if the last bit of a is 0, the expression will return 0; then we know a is a even. If the expression returns 1, then a is a add。
-</code>
-还有其他更多高效率的简单位运算应用，详情可以参考Matrix 67的位运算系列：[[http://www.matrix67.com/blog/archives/263|位运算简介及实用技巧]]
-====8.sizeof / 逗号运算符====
-===8.1.sizeof运算符===
-sizeof会按字节返回一个类型所占的空间。sizeof 满足右结合律，返回的值是一个"size_t"的类型。\\
-有几点要注意的是：
-  - sizeof并不会对类型/表达式进行运算，所以即使表达式是无效的（比如无效的指针），sizeof也会计算出值。
-  - sieeof对引用的求值返回的是引用绑定的对象所占空间的大小。
-  - sizeof对指针的求值返回的是指针所占空间的大小。
-  - sizeof对数组的求值返回的是element_space * element_number;因为sizeof不会执行表达式，所以sizeof不会将数组转化成指针处理。
-  - sizeof对vector / string 求值只返回fixed size，比如：
-    <code:cpp linenums:1>
-        string s1 ="a";
-	string s2 ="abcdef";
-	vector<int>vi(10,1);
-	vector<char>vc(20,'c');
-	cout << sizeof(s1) << " " << sizeof(s2) << " " << sizeof(vi) << " " << sizeof(vc) << endl;</code> 返回的值是：32 32 24 24。
-  - 以前用sizeof访问类成员，必须要通过类对象来访问；但是新标准我们可以使用scope运算符来访问，比如：
-     <code:cpp linenums:1>
-     sizeof object.member; // the old way
-     sizeof class::member; // the new standard
-     </code>

What & How & Why

[ About ]

[ My Links ]

[ Notice ]

页面工具

站点工具

用户工具

差别