update c++ and math

Author: selfboot

Algorithm/README.md

@@ -68,7 +68,7 @@
 [为什么我反对纯算法面试题](http://coolshell.cn/articles/8138.html)  
 [十道海量数据处理面试题与十个方法大总结](http://blog.csdn.net/v_JULY_v/article/details/6279498)  
 [Bloom Filter详解](http://zheming.wang/blog/2014/07/22/2B59B3D3-6AF2-4759-8585-3B9B7C480C33/)  
-
+[递归算法的时间复杂度终结篇](http://www.cnblogs.com/python27/archive/2011/12/09/2282486.html)  
 
 [1]: http://7xrlu9.com1.z0.glb.clouddn.com/Algorithm_1.jpg
 [2]: http://7xrlu9.com1.z0.glb.clouddn.com/Algorithm_2.jpg

Algorithm/Sort.md

@@ -19,7 +19,7 @@
 |冒泡排序  |n^2      |n^2     |1     |**稳定**  | 是 |
 |归并排序  |nlogn    | nlogn  | n    | **稳定** | 是 |
 |基数排序  |d(r+n)   |d(r+n)  |rd+n  | **稳定** | **否** |
-|计数排序  |d(r+n)   |d(r+n)  |rd+n  | **稳定** | **否** |
+|计数排序  |d(n)   |d(n)  |..  | **不稳定** | **否** |
 
 对于比较排序来说，有很多性能上的根本限制。在最差情況下，任何一种比较排序至少需要O(nlogn)比较操作，这是比较操作所获的信息有限所导致的，或者说是全序集的模糊代数结构所导致的。
 

C++/11_Features.md

@@ -4,23 +4,52 @@ C++11修复大量缺陷和降低代码拖沓，比如lambda表达式的支持将
 
 # 类型推导 auto
 
-在C++11中，假如`编译器`可以从变量的初始化中得到它的类型，那么你不必要指定类型。比如，你可以这样写：
+编译时常常需要把表达式的值赋值给变量，这就要求在声明变量时清楚的知道表达式的类型，然后做到这点并非容易，有时甚至根本做不到。为了解决这个问题，C++ 11 新标准引入了 auto 类型说明符。用它就能让编译器替我们去分析表达式所属的类型。比如，你可以这样写：
 
-    auto x=0;       //x has type int because 0 is int
-    auto c='a';     //char
-    auto d=0.5;     //double
-    auto national_debt=14400000000000LL;    //long long
+```c++
+auto x=0;       //x has type int because 0 is int
+auto c='a';     //char
+auto d=0.5;     //double
+auto national_debt=14400000000000LL;    //long long
+```
 
 编译器在编译阶段就可以推导出x的类型是int，c的类型是 char。当然，这不是一个证明auto有用的一个漂亮的例子，当使用模板特别是STL时auto很好用，比如：STL中的容器的迭代子类型。
 
-    vector<int>::const_iterator ci = vi.begin();
-    auto ci = vi.begin();
+```c++
+vector<int>::const_iterator ci = vi.begin();
+auto ci = vi.begin();
+```
 
-使用auto必需一个初始化值，编译器可以通过这个初始化值推导出类型。因为auto是来简化模板类引入的代码难读的问题，如上面的示例，iteration这种类型就最适合用auto的。
+使用auto必需一个初始化值，编译器可以通过这个初始化值推导出类型。因为auto是来简化模板类引入的代码难读的问题，如上面的示例，iteration这种类型就最适合用auto的。但是，我们不应该把其滥用。比如下面的代码的可读性就降低了。因为，我不知道ProcessData返回什么？int? bool? 还是对象？或是别的什么？这让后面的程序不知道怎么做。
 
-但是，我们不应该把其滥用。比如下面的代码的可读性就降低了。因为，我不知道ProcessData返回什么？int? bool? 还是对象？或是别的什么？这让后面的程序不知道怎么做。
+```c++
+auto obj = ProcessData(someVariables);
+```
 
-    auto obj = ProcessData(someVariables);
+再来看下面的例子：
+
+```c++
+const int a=12;
+auto b = a;
+b= 3;
+cout << b << endl;      // 3
+```
+
+这是因为**编译器推断出来的 auto 类型有时候和初始值的类型并不完全一样，编译器会适当地改变结果类型使其更符合初始化规则**。首先，使用引用时，编译器以引用对象的类型作为 auto 的类型；其次 **auto 一般会忽略顶层 const，同时底层const则会保留下来**（这就可以解释上面的结果）。如果希望推断出的 auto 是一个顶层 const，需要明确指出：
+
+```c++
+const int a=12;
+const auto b = a;
+```
+
+此外，还可以将引用的类型设置为 auto，这时引用的初始化规则仍然适用，也即不能为非常量引用绑定字面值。注意，设置一个类型为 auto 的引用时，**初始值中的顶层常量属性仍然保留**。
+
+```c++
+const int ci=10;        // 顶层常量属性
+auto &g = ci;
+// auto &h = 42;        // Error, 不能为非常量引用绑定字面值
+const auto &j = 42;     // 正确: 可以为常量引用绑定字面值
+```
 
 # 区间迭代
 

C++/Basic.md

@@ -69,28 +69,28 @@ void main( void )
 
 左值与右值这两概念是从 c 中传承而来的，在 c 中，左值指的是既能够出现在等号左边也能出现在等号右边的变量(或表达式)，右值指的则是只能出现在等号右边的变量(或表达式)。
 
-    int a;
-    int b;
+```c++
+int a;
+int b;
     
-    a = 3;
-    b = 4;
-    a = b;
-    b = a;
+a = 3;
+b = 4;
+a = b;
+b = a;
     
-    // 以下写法不合法。
-    3 = a;
-    a+b = 4;
+// 以下写法不合法。
+3 = a;
+a+b = 4;
+```
 
 在 C 语言中，通常来说有名字的变量就是左值(如上面例子中的 a, b)，而由运算操作(加减乘除，函数调用返回值等)所产生的中间结果(没有名字)就是右值，如上的 3 + 4， a + b 等。可以认为**左值就是在程序中能够寻址的东西，右值就是没法取到它的地址的东西**。
 
 如上概念到了 c++ 中，就变得稍有不同。具体来说，在 c++ 中，`每一个表达式或者是一个左值，或者是一个右值`，相应的，该表达式也就被称作“左值表达式"，"右值表达式"。对于内置的基本数据类型来说(primitive types)，左值右值的概念和 c 没有太多不同，不同的地方在于自定义的类型:
 
-* 对于内置的类型，右值是不可被修改的(non-modifiable)，也不可被 const, volatile 所修饰(cv-qualitification ignored)
+* 对于内置的类型，右值是不可被修改的(non-modifiable)，也不可被 const, volatile 所修饰；
 * 对于自定义的类型(user-defined types)，右值却允许通过它的成员函数进行修改。
 
-C++ 中自定义类型允许有成员函数，而通过右值调用成员函数是被允许的，但成员函数有可能不是 const 类型，因此通过调用右值的成员函数，也就可能会修改了该右值。
-
-此外，**右值只能被 const 类型的 reference 所指向**，当一个右值被 const reference 指向时，它的生命周期就被延长了。
+C++ 中自定义类型允许有成员函数，而通过右值调用成员函数是被允许的，但成员函数有可能不是 const 类型，因此通过调用右值的成员函数，也就可能会修改了该右值。此外，**右值只能被 const 类型的 reference 所指向**，当一个右值被 const reference 指向时，它的生命周期就被延长了。
 
 具体示例在 [C++_LR_Value](../Coding/C++_LR_Value.cpp)。
 

C++/Keywords.md

@@ -11,12 +11,33 @@ const只是在`编译期的保护`，编译期会检查const变量有没有被
 1. const 的引用，对常量的引用不能用作修改它绑定的对象，但是由于对象本身可能是非常量，所以允许通过其他途径改变值。
 2. 对指针来说，可以指定指针本身为常量（const pointer, `常量指针`），也可以指定指针所指的对象为常量（pointer to const, `指向常量的指针`），或二者同时指定为const；
 3. 在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
-4. 对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。
+4. 对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”（返回值是引用类型时，是可以作为左值使用的，一般用于操作符重载）。
 5. 对于类的成员函数，可以用const关键字来说明这个函数是 "只读(read-only)"函数，不会修改任何数据成员。为了声明一个const成员函数，把const关键字放在函数括号的后面。
 
 ［[改变 const 变量的值](http://www.nowcoder.com/questionTerminal/36f828664d2d4d14a1428ae49f701f23)］
-
-代码实例参见 [C++_Const.cpp](../Coding/C++_Const.cpp)
+
+const 可以分为 `顶层const` 和 `底层const`，顶层const可以表示任意的对象是常量，这一点对任何数据类型都适用，如算术类型、类指针等。底层 const 则与指针或者引用等复合类型的基本类型部分有关。比较特别的是，指针既可以是顶层 const 又可以是底层 const。
+
+```c++
+int i=0;
+const int ci = 42;  // 不能改变 ci 的值，是顶层 const;
+int* const p1 = &i; // 不能改变 p1 的值，是顶层 const;
+const int *p2 = &ci;// 允许改变 p2 的值，是底层 const;
+const int *const p3 = p2;// 前一个const底层，后一个顶层
+const int &r = ci;  // 用于声明引用的都是 底层 const
+```
+
+在执行对象的拷贝动作时，常量是顶层const 时不受影响。拷贝执行操作并不会改变被拷贝对象的值，因此拷入和拷出的对象是否是常量都没什么影响。另一方面，**底层 const 的限制不能忽视**，当执行拷贝操作时，拷入和拷出的对象必须具有相同的底层 const 资格，或者两个对象的数据类型必须能够转换。一般来说，**非常量可以转换为常量**，反之则不行，如下：
+
+```c++
+int tmp = 88;           // 顶层 const
+const int * pp = &tmp;  // 底层const
+// int *p = pp;         // pp 包含底层 const 的定义, 而 p 没有
+```
+
+上面例子中如果允许`*pp = p3`，那么就可以通过 p 改变 pp 所指对象的值，这样 pp 就失去了底层 const 的约束。
+
+详细的代码示例参见 [C++_Const.cpp](../Coding/C++_Const.cpp)。
 
 # static
 
@@ -319,13 +340,15 @@ struct B : A
 [When to use extern in C++](http://stackoverflow.com/questions/10422034/when-to-use-extern-in-c)  
 [What does the explicit keyword in C++ mean?](http://stackoverflow.com/questions/121162/what-does-the-explicit-keyword-in-c-mean)   
 [What is the meaning of “operator bool() const”](http://stackoverflow.com/questions/4600295/what-is-the-meaning-of-operator-bool-const)  
+[Appearing and Disappearing consts in C++](http://aristeia.com/Papers/appearing%20and%20disappearing%20consts.pdf)  
 
 [揭秘 typedef四用途与两陷阱](http://niehan.blog.techweb.com.cn/archives/325.html)  
 [typedef 用法总结](http://blog.csdn.net/gaohuaid/article/details/16829599)  
 [C/C++中的static关键字的总结](https://yq.aliyun.com/articles/47641)  
 [Where are static variables stored (in C/C++)?](http://stackoverflow.com/questions/93039/where-are-static-variables-stored-in-c-c)  
 [extern "C"](http://book.51cto.com/art/200904/121028.htm)
 [详解C中volatile关键字](http://www.cnblogs.com/yc_sunniwell/archive/2010/06/24/1764231.html)   
-
+[关于C++ const 的全面总结](http://blog.csdn.net/eric_jo/article/details/4138548)  
+ 
 Effective C++：条款30， 透彻理解 inlining的里里外外  
 

Coding/C++_Const.cpp

@@ -1,6 +1,6 @@
 /*
  * @Author: [email protected]
- * @Last Modified time: 2016-04-11 22:47:29
+ * @Last Modified time: 2016-09-15 15:53:55
  */
 
 #include <iostream>
@@ -10,7 +10,20 @@ class MyClass
 {
 private:
     int counter;
+
 public:
+    MyClass(){
+        counter = 100;
+    }
+
+    /*
+    成员函数的 const 和 non-const 是重载版本, 各自的隐藏参数分别是 const *this 和 *this.
+
+    1. non-const 对象调用 non-const 函数,如果没有对应的 non-const 函数,则调用 const 函数
+        因为 non-const *this 指针可以隐式转换为 const *this 指针, 反之则不能。
+    2. const 对象只能调用 const 成员函数
+        因为const 对象调用成员函数时,传递 const this 指针, non-const 函数只接受普通的this 指针
+     */
     void Foo()
     {
         counter++;
@@ -24,23 +37,84 @@ class MyClass
         std::cout << "Foo const" << std::endl;
     }
 
+    void Bar(){
+        std::cout << "Bar const" << std::endl;
+    }
+
+    // const 参数
+    void add(const int another){
+        counter += another;
+        // another = 12;                   // Error!
+        std::cout << counter << endl;
+    }
+
+    // 返回值为 const 类型
+    const int& get_c(){
+        return counter;
+    }
+
+    int& get(){
+        return counter;
+    }
 };
 
 int main(){
 
-    // 2. 对常量的引用
+    // 对常量的引用不能用作修改它绑定的对象
     int num = 10;
     const int &ref = num;
     num += 100;
     // ref += 100;    // 编译不通过
     // cannot assign to variable 'b' with const-qualified type 'const int &'
     cout << num << endl;
 
-    // 6. 成员函数后面加 const
+    // const 成员函数和 non-const成员函数
     MyClass c;
     const MyClass& const_c = c;
     c.Foo();
     const_c.Foo();
+    c.Bar();
+    // const_c.Bar();  // Error, 'this' argument has type 'const MyClass', but function is not marked const.
+
+    c.get() = 1000;
+    cout << c.get() << endl;
+    // c.get_c() = 1000;    // Error!
+
+    // const pointer and pointer to const
+    int i=10, j=20;
+    const int *p_to_const = &i;
+    // *p_to_const = 11;        // Error.
+    p_to_const = nullptr;       // OK.
+    int *const const_p = &i;
+    // const_p = nullptr;       // Error.
+    *const_p = 12;              // OK.
+    const int *const c_p_to_const = &i;
+    // c_p_to_const = nullptr;  // Error.
+    // *c_p_to_const = 12;      // OK.
+
+
+    /* 顶层 const 和 底层 const
+     * 在执行对象的拷贝动作时，常量是顶层const 时不受影响。
+     * 另一方面，底层 const 的限制不能忽视，当执行拷贝操作时，拷入和拷出的对象必须具有相同的底层 const 资格，
+     * 或者两个对象的数据类型必须能够转换。
+     */
+
+    int tmp = 22;
+    const int const_tmp = 88;   // 顶层 const
+    tmp = const_tmp;            // OK, 常量是顶层const 时不受影响
+    std::cout << tmp << endl;
+    const int *p2 = &tmp;       // 底层 const,允许改变 p2 的值
+    int tt = 10;
+    const int *const p3 = &tt;  // 前一个为顶层const, 后一个为顶层const
+    p2 = p3;                    // OK,
+    std::cout << *p2 << std::endl;
+
+    // int *pp = p3;           // Error. p3 包含底层 const 的定义, 而 pp 没有
+    const int *ppp = p3;        // OK.
+    int *pInt = &tmp;
+    ppp = pInt;                 // int * 能够转换为 const int *
 
+    // int &r = const_tmp;     // 普通的 int& 不能绑定到 int 常量上
+    const int &r2 = tmp;        // const int& 可以绑定到一个普通 int 上
     return 0;
 }