diff --git a/cpp_source/ch6.cpp b/cpp_source/ch05/ch5.cpp
similarity index 86%
rename from cpp_source/ch6.cpp
rename to cpp_source/ch05/ch5.cpp
index 09fbc1d..eef4955 100755
--- a/cpp_source/ch6.cpp
+++ b/cpp_source/ch05/ch5.cpp
@@ -1,10 +1,10 @@
 //
-// Created by cer on 17-9-19.
-// chapter 06
+// Created by cer on 17-9-18.
+// chapter 5
 // 语句
-#include <iostream>
-#include <stdexcept>
 
+#include <iostream>
+#include <vector>
 using namespace std;
 
 int divide(int a, int b){
@@ -27,3 +27,5 @@ int main(){
     }
     return 0;
 }
+
+
diff --git a/cpp_source/ch06/Chapter6.h b/cpp_source/ch06/Chapter6.h
new file mode 100644
index 0000000..8af6380
--- /dev/null
+++ b/cpp_source/ch06/Chapter6.h
@@ -0,0 +1,17 @@
+//
+// Created by cer on 19-1-20.
+//
+
+#ifndef CPP_PRIMER_PRACTICE_CHAPTER6_H
+#define CPP_PRIMER_PRACTICE_CHAPTER6_H
+
+int fact(int val);
+int func();
+
+template <typename T>
+T abs(T i)
+{
+    return i >= 0 ? i : -i;
+}
+
+#endif //CPP_PRIMER_PRACTICE_CHAPTER6_H
diff --git a/cpp_source/ch06/ch6.cpp b/cpp_source/ch06/ch6.cpp
new file mode 100755
index 0000000..644c5ff
--- /dev/null
+++ b/cpp_source/ch06/ch6.cpp
@@ -0,0 +1,47 @@
+//
+// Created by cer on 17-9-19.
+// chapter 06
+// 函数
+
+#include <iostream>
+#include <string>
+
+using namespace std
+
+int fact(int i)
+{
+    return i > 1 ? i * fact(i - 1) : 1;
+}
+
+void interactive_fact()
+{
+    string const prompt = "Enter a number within [1, 13) :\n";
+    string const out_of_range = "Out of range, please try again.\n";
+    for (int i; cout << prompt, cin >> i; )
+    {
+        if (i < 1 || i > 12)
+        {
+            cout << out_of_range;
+            continue;
+        }
+        cout << fact(i) << endl;
+    }
+}
+
+bool str_subrange(const string &str1, const string &str2){
+    if(str1.size()==str2.size())
+        return str1==str2;
+    string::size_type size={min(str1.size(),str2.size())};
+    string::size_type i=0;
+    while(i!=size){
+        if(str1[i]!=str2[i])
+        return ; //error! no return value!
+  }
+}
+
+int main()
+{
+//    interactive_fact();
+    str_subrange();
+    return 0;
+}
\ No newline at end of file
diff --git a/cpp_source/ch06/fact.cpp b/cpp_source/ch06/fact.cpp
new file mode 100644
index 0000000..7c52c7c
--- /dev/null
+++ b/cpp_source/ch06/fact.cpp
@@ -0,0 +1,21 @@
+//
+// Created by cer on 19-1-20.
+//
+
+#include "Chapter6.h"
+#include <iostream>
+
+int fact(int val)
+{
+    if (val == 0 || val == 1) return 1;
+    else return val * fact(val-1);
+}
+
+int func()
+{
+    int n, ret = 1;
+    std::cout << "input a number: ";
+    std::cin >> n;
+    while (n > 1) ret *= n--;
+    return ret;
+}
diff --git a/cpp_source/ch06/factMain.cpp b/cpp_source/ch06/factMain.cpp
new file mode 100644
index 0000000..1a651b5
--- /dev/null
+++ b/cpp_source/ch06/factMain.cpp
@@ -0,0 +1,14 @@
+//
+// Created by cer on 19-1-20.
+//
+
+
+#include "Chapter6.h"
+#include <iostream>
+
+int main()
+{
+    std::cout << "5! is " << fact(5) << std::endl;
+    std::cout << func() << std::endl;
+    std::cout << abs(-9.78) << std::endl;
+}
diff --git a/cpp_source/ch5.cpp b/cpp_source/ch5.cpp
deleted file mode 100755
index 6124c5c..0000000
--- a/cpp_source/ch5.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//
-// Created by cer on 17-9-18.
-// chapter 5
-// 表达式
-
-#include <iostream>
-#include <vector>
-using namespace std;
-
-int main(){
-    vector<int> ivec;
-    int cnt = 10;
-    while (cnt > 0){
-        ivec.push_back(cnt--);
-    }
-    vector<int>::iterator iter = ivec.begin();
-    // prints 10, 9, 8, 7 ... 1
-    while (iter != ivec.end()){
-        cout << *iter++ << endl;
-    }
-}
-
diff --git a/excersize/ch06.md b/excersize/ch06.md
index e69de29..c283d18 100644
--- a/excersize/ch06.md
+++ b/excersize/ch06.md
@@ -0,0 +1,1071 @@
+# 第六章 函数
+
+## 练习6.1
+实参和形参的区别的什么？
+
+解：
+
+实参是函数调用的实际值，是形参的初始值。
+
+## 练习6.2
+请指出下列函数哪个有错误，为什么？应该如何修改这些错误呢？
+
+```cpp
+(a) int f() {
+         string s;
+         // ...
+         return s;
+   }
+(b) f2(int i) { /* ... */ }
+(c) int calc(int v1, int v1) { /* ... */ }
+(d) double square (double x)  return x * x; 
+```
+
+解：
+
+应该改为下面这样：
+
+```cpp
+(a) string f() {
+         string s;
+         // ...
+         return s;
+   }
+(b) void f2(int i) { /* ... */ }
+(c) int calc(int v1, int v2) { /* ... */ }
+(d) double square (double x) { return x * x; }
+```
+
+## 练习6.3
+编写你自己的`fact`函数，上机检查是否正确。注：阶乘。
+
+解：
+
+```cpp
+#include <iostream>
+
+int fact(int i)
+{
+    if(i<0)
+    {
+        runtime_error err("Input cannot be a negative number");
+        cout << err.what() << endl;
+    }
+    return i > 1 ? i * fact( i - 1 ) : 1;
+}
+
+int main()
+{
+    std::cout << std::boolalpha << (120 == fact(5)) << std::endl;
+    return 0;
+}
+```
+
+启用`std::boolalpha`，可以输出 `"true"`或者 `"false"`。
+
+## 练习6.4
+编写一个与用户交互的函数，要求用户输入一个数字，计算生成该数字的阶乘。在main函数中调用该函数。
+
+```cpp
+#include <iostream>
+#include <string>
+
+int fact(int i)
+{
+    return i > 1 ? i * fact(i - 1) : 1;
+}
+
+void interactive_fact()
+{
+    std::string const prompt = "Enter a number within [1, 13) :\n";
+    std::string const out_of_range = "Out of range, please try again.\n";
+    for (int i; std::cout << prompt, std::cin >> i; )
+    {
+        if (i < 1 || i > 12)
+        {
+            std::cout << out_of_range; 
+            continue;
+        }
+        std::cout << fact(i) << std::endl;
+    }
+}
+
+int main()
+{
+    interactive_fact();
+    return 0;
+}
+```
+
+## 练习6.5
+编写一个函数输出其实参的绝对值。
+
+```cpp
+#include <iostream>
+
+int abs(int i)
+{
+   return i > 0 ? i : -i;
+}
+
+int main()
+{
+   std::cout << abs(-5) << std::endl;
+   return 0;
+}
+```
+
+## 练习6.6
+说明形参、局部变量以及局部静态变量的区别。编写一个函数，同时达到这三种形式。
+
+解：
+
+形参定义在函数形参列表里面；局部变量定义在代码块里面；
+局部静态变量在程序的执行路径第一次经过对象定义语句时初始化，并且直到程序终止时才被销毁。
+
+```cpp
+// 例子
+int count_add(int n)       // n是形参
+{
+    static int ctr = 0;    // ctr 是局部静态变量
+    ctr += n;
+    return ctr;
+}
+
+int main()
+{
+    for (int i = 0; i != 10; ++i)  // i 是局部变量
+      cout << count_add(i) << endl;
+
+    return 0;
+}
+```
+
+## 练习6.7
+编写一个函数，当它第一次被调用时返回0，以后每次被调用返回值加1。
+
+解：
+
+```cpp
+int generate()
+{
+    static int ctr = 0;
+    return ctr++;
+}
+```
+
+## 练习6.8
+编写一个名为Chapter6.h 的头文件，令其包含6.1节练习中的函数声明。
+
+解：
+
+```cpp
+
+int fact(int val);
+int func();
+
+template <typename T> 
+T abs(T i)
+{
+    return i >= 0 ? i : -i;
+}
+```
+
+## 练习6.9 : fact.cc | factMain.cc
+编写你自己的fact.cc 和factMain.cc ，这两个文件都应该包含上一小节的练习中编写的 Chapter6.h 头文件。通过这些文件，理解你的编译器是如何支持分离式编译的。
+
+解：
+
+fact.cc：
+
+```cpp
+#include "Chapter6.h"
+#include <iostream>
+
+int fact(int val)
+{
+    if (val == 0 || val == 1) return 1;
+    else return val * fact(val-1);
+}
+
+int func()
+{
+    int n, ret = 1;
+    std::cout << "input a number: ";
+    std::cin >> n;
+    while (n > 1) ret *= n--;
+    return ret;
+}
+
+```
+
+factMain.cc：
+
+```cpp
+#include "Chapter6.h"
+#include <iostream>
+
+int main()
+{
+    std::cout << "5! is " << fact(5) << std::endl; 
+    std::cout << func() << std::endl; 
+    std::cout << abs(-9.78) << std::endl;
+}
+```
+
+编译： `g++ factMain.cpp fact.cpp -o main`
+
+## 练习6.10
+编写一个函数，使用指针形参交换两个整数的值。
+在代码中调用该函数并输出交换后的结果，以此验证函数的正确性。
+
+解：
+
+```cpp
+#include <iostream>
+#include <string>
+
+void swap(int* lhs, int* rhs)
+{
+	int tmp;
+	tmp = *lhs;
+	*lhs = *rhs;
+	*rhs = tmp;
+}
+
+int main()
+{
+	for (int lft, rht; std::cout << "Please Enter:\n", std::cin >> lft >> rht;)
+	{
+		swap(&lft, &rht);
+		std::cout << lft << " " << rht << std::endl;
+	}
+
+	return 0;
+}
+```
+
+## 练习6.11
+编写并验证你自己的reset函数，使其作用于引用类型的参数。注：reset即置0。
+
+解：
+
+```cpp
+#include <iostream>
+
+void reset(int &i)
+{
+    i = 0;
+}
+
+int main()
+{
+    int i = 42;
+    reset(i);
+    std::cout << i  << std::endl;
+    return 0;
+}
+```
+
+## 练习6.12
+改写6.2.1节练习中的程序，使其引用而非指针交换两个整数的值。你觉得哪种方法更易于使用呢？为什么？
+
+```cpp
+#include <iostream>
+#include <string>
+
+
+void swap(int& lhs, int& rhs)
+{
+    int temp = lhs;
+    lhs = rhs;
+    rhs = temp;
+}
+
+int main()
+{
+    for (int left, right; std::cout << "Please Enter:\n", std::cin >> left >> right; )
+    {
+        swap(left, right);
+        std::cout << left << " " << right << std::endl;
+    }
+
+    return 0;
+}
+```
+很明显引用更好用。
+
+## 练习6.13
+假设`T`是某种类型的名字，说明以下两个函数声明的区别：
+一个是`void f(T)`, 另一个是`void f(&T)`。
+
+解：
+
+`void f(T)`的参数通过值传递，在函数中`T`是实参的副本，改变`T`不会影响到原来的实参。
+`void f(&T)`的参数通过引用传递，在函数中的`T`是实参的引用，`T`的改变也就是实参的改变。
+
+## 练习6.14
+举一个形参应该是引用类型的例子，再举一个形参不能是引用类型的例子。
+
+解：
+
+例如交换两个整数的函数，形参应该是引用
+
+```cpp
+void swap(int& lhs, int& rhs)
+{
+	int temp = lhs;
+	lhs = rhs;
+	rhs = temp;
+}
+```
+
+当实参的值是右值时，形参不能为引用类型
+
+```cpp
+int add(int a, int b)
+{
+	return a + b;
+}
+
+int main()
+{
+	int i = add(1,2);
+	return 0;
+}
+```
+
+## 练习6.15
+说明`find_char`函数中的三个形参为什么是现在的类型，特别说明为什么`s`是常量引用而`occurs`是普通引用？
+为什么`s`和`occurs`是引用类型而`c`不是？
+如果令`s`是普通引用会发生什么情况？
+如果令`occurs`是常量引用会发生什么情况？
+
+解：
+
+- 因为字符串可能很长，因此使用引用避免拷贝；
+- 而在函数中我们不希望改变`s`的内容，所以令`s`为常量。
+- `occurs`是要传到函数外部的变量，所以使用引用，`occurs`的值会改变，所以是普通引用。
+- 因为我们只需要`c`的值，这个实参可能是右值(右值实参无法用于引用形参)，所以`c`不能用引用类型。
+- 如果`s`是普通引用，也可能会意外改变原来字符串的内容。
+- `occurs`如果是常量引用，那么意味着不能改变它的值，那也就失去意义了。
+
+## 练习6.16
+下面的这个函数虽然合法，但是不算特别有用。指出它的局限性并设法改善。
+```cpp
+bool is_empty(string& s) { return s.empty(); }
+```
+
+解：
+
+局限性在于常量字符串和字符串字面值无法作为该函数的实参，如果下面这样调用是非法的：
+
+```cpp
+const string str;
+bool flag = is_empty(str); //非法
+bool flag = is_empty("hello"); //非法
+```
+
+所以要将这个函数的形参定义为常量引用：
+
+```cpp
+bool is_empty(const string& s) { return s.empty(); }
+```
+
+## 练习6.17
+编写一个函数，判断`string`对象中是否含有大写字母。
+编写另一个函数，把`string`对象全部改写成小写形式。
+在这两个函数中你使用的形参类型相同吗？为什么？
+
+解：
+
+两个函数的形参不一样。第一个函数使用常量引用，第二个函数使用普通引用。
+
+## 练习6.18
+为下面的函数编写函数声明，从给定的名字中推测函数具备的功能。
+
+- (a) 名为`compare`的函数，返回布尔值，两个参数都是`matrix`类的引用。
+- (b) 名为`change_val`的函数，返回`vector`的迭代器，有两个参数：一个是`int`，另一个是`vector`的迭代器。
+
+解：
+
+```cpp
+(a) bool compare(matrix &m1, matrix &m2);
+(b) vector<int>::iterator change_val(int, vector<int>::iterator);
+```
+
+## 练习6.19
+假定有如下声明，判断哪个调用合法、哪个调用不合法。对于不合法的函数调用，说明原因。
+
+```cpp
+double calc(double);
+int count(const string &, char);
+int sum(vector<int>::iterator, vector<int>::iterator, int);
+vector<int> vec(10);
+(a) calc(23.4, 55.1);
+(b) count("abcda",'a');
+(c) calc(66);
+(d) sum(vec.begin(), vec.end(), 3.8);
+```
+
+解：
+
+- (a) 不合法。`calc`只有一个参数。
+- (b) 合法。
+- (c) 合法。
+- (d) 合法。
+
+## 练习6.20
+引用形参什么时候应该是常量引用？如果形参应该是常量引用，而我们将其设为了普通引用，会发生什么情况？
+
+解：
+
+应该尽量将引用形参设为常量引用，除非有明确的目的是为了改变这个引用变量。
+如果形参应该是常量引用，而我们将其设为了普通引用，那么常量实参将无法作用于普通引用形参。
+
+## 练习6.21
+编写一个函数，令其接受两个参数：一个是`int`型的数，另一个是`int`指针。
+函数比较`int`的值和指针所指的值，返回较大的那个。
+在该函数中指针的类型应该是什么？
+
+解：
+
+```cpp
+#include <iostream>
+using std::cout;
+
+int larger_one(const int i, const int *const p)
+{
+    return (i > *p) ? i : *p;
+}
+
+int main()
+{
+    int i = 6;
+    cout << larger_one(7, &i);
+
+    return 0;
+}
+```
+
+应该是`const int *`类型。
+
+## 练习6.22
+编写一个函数，令其交换两个`int`指针。
+
+解：
+
+```cpp
+#include <iostream>
+#include <string>
+
+void swap(int*& lft, int*& rht)
+{
+    auto tmp = lft;
+    lft = rht;
+    rht = tmp;
+}
+
+int main()
+{
+    int i = 42, j = 99;
+    auto lft = &i;
+    auto rht = &j;
+    swap(lft, rht);
+    std::cout << *lft << " " << *rht << std::endl;
+
+    return 0;
+}
+```
+
+## 练习6.23
+参考本节介绍的几个`print`函数，根据理解编写你自己的版本。
+依次调用每个函数使其输入下面定义的`i`和`j`:
+
+```cpp
+int i = 0, j[2] = { 0, 1 };
+```
+
+解：
+
+```cpp
+#include <iostream>
+using std::cout; using std::endl; using std::begin; using std::end;
+
+void print(const int *pi)
+{
+    if(pi)
+        cout << *pi << endl;
+}
+
+void print(const char *p)
+{
+    if (p)
+        while (*p) cout << *p++;
+    cout << endl;
+}
+
+void print(const int *beg, const int *end)
+{
+    while (beg != end)
+        cout << *beg++ << endl;
+}
+
+void print(const int ia[], size_t size)
+{
+    for (size_t i = 0; i != size; ++i) {
+        cout << ia[i] << endl;
+    }
+}
+
+void print(int (&arr)[2])
+{
+    for (auto i : arr)
+        cout << i << endl;
+}
+
+int main()
+{
+    int i = 0, j[2] = { 0, 1 };
+    char ch[5] = "pezy";
+    
+    print(ch);
+    print(begin(j), end(j));
+    print(&i);
+    print(j, end(j)-begin(j));
+    print(j);
+    
+    return 0;
+}
+```
+
+## 练习6.24
+描述下面这个函数的行为。如果代码中存在问题，请指出并改正。
+
+```cpp
+void print(const int ia[10])
+{
+	for (size_t i = 0; i != 10; ++i)
+		cout << ia[i] << endl;
+}
+```
+
+解：
+
+当数组作为实参的时候，会被自动转换为指向首元素的指针。
+因此函数形参接受的是一个指针。
+如果要让这个代码成功运行，可以将实参改为数组的引用。
+
+```cpp
+void print(const int (&ia)[10])
+{
+	for (size_t i = 0; i != 10; ++i)
+		cout << ia[i] << endl;
+}
+```
+
+## 练习6.25
+编写一个`main`函数，令其接受两个实参。把实参的内容连接成一个`string`对象并输出出来。
+
+## 练习6.26
+编写一个程序，使其接受本节所示的选项；输出传递给`main`函数的实参内容。
+
+解：
+
+包括6.25
+
+```cpp
+#include <iostream>
+#include <string>
+
+int main(int argc, char **argv)
+{
+    std::string str;
+    for (int i = 1; i != argc; ++i)
+        str += std::string(argv[i]) + " ";
+
+    std::cout << str << std::endl;
+    return 0;
+}
+```
+
+## 练习6.27
+编写一个函数，它的参数是`initializer_list`类型的对象，函数的功能是计算列表中所有元素的和。
+
+解：
+
+```cpp
+#include <iostream>
+#include <initializer_list>
+
+int sum(std::initializer_list<int> const& il)
+{
+    int sum = 0;
+    for (auto i : il) sum += i;
+    return sum;
+}
+
+int main(void)
+{
+    auto il = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+    std::cout << sum(il) << std::endl;
+
+    return 0;
+}
+```
+
+## 练习6.28
+在`error_msg`函数的第二个版本中包含`ErrCode`类型的参数，其中循环内的`elem`是什么类型？
+
+解：
+
+`elem`是`const string &`类型。
+
+## 练习6.29
+在范围`for`循环中使用`initializer_list`对象时，应该将循环控制变量声明成引用类型吗？为什么？
+
+解：
+
+应该使用常量引用类型。`initializer_list`对象中的元素都是常量，我们无法修改`initializer_list`对象中的元素的值。
+
+## 练习6.30
+编译第200页的`str_subrange`函数，看看你的编译器是如何处理函数中的错误的。
+
+解：
+
+编译器信息：
+```
+g++ (Ubuntu 5.4.0-6ubuntu1~16.04.10) 5.4.0 20160609
+```
+
+编译错误信息：
+
+```
+ch6.cpp:38:9: error: return-statement with no value, in function returning ‘bool’ [-fpermissive]
+```
+
+## 练习6.31
+什么情况下返回的引用无效？什么情况下返回常量的引用无效？
+
+解：
+
+当返回的引用的对象是局部变量时，返回的引用无效；当我们希望返回的对象被修改时，返回常量的引用无效。
+
+## 练习6.32
+下面的函数合法吗？如果合法，说明其功能；如果不合法，修改其中的错误并解释原因。
+
+```cpp
+int &get(int *array, int index) { return array[index]; }
+int main()
+{
+    int ia[10];
+    for (int i = 0; i != 10; ++i)
+        get(ia, i) = i;
+}
+```
+
+解：
+
+合法。`get`函数根据索引取得数组中的元素的引用。
+
+## 练习6.33
+编写一个递归函数，输出`vector`对象的内容。
+
+解：
+
+```cpp
+#include <iostream>
+#include <vector>
+using std::vector; using std::cout;
+using Iter = vector<int>::const_iterator;
+
+void print(Iter first, Iter last)
+{
+    if (first != last)
+    {
+        cout << *first << " ";
+        print(++first, last);
+    }
+}
+
+int main()
+{
+    vector<int> vec{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+    print(vec.cbegin(), vec.cend());
+
+    return 0;
+}
+```
+
+## 练习6.34
+如果`factorial`函数的停止条件如下所示，将发生什么？
+
+```cpp
+if (val != 0)
+```
+
+解：
+如果`val`为正数，从结果上来说没有区别（多乘了个1）; 
+如果`val`为负数，那么递归永远不会结束。
+
+## 练习6.35
+在调用`factorial`函数时，为什么我们传入的值是`val-1`而非`val--`？
+
+解：
+
+如果传入的值是`val--`，那么将会永远传入相同的值来调用该函数，递归将永远不会结束。
+
+## 练习6.36
+编写一个函数声明，使其返回数组的引用并且该数组包含10个`string`对象。
+不用使用尾置返回类型、`decltype`或者类型别名。
+
+解：
+
+```cpp
+string (&fun())[10];
+```
+
+## 练习6.37
+为上一题的函数再写三个声明，一个使用类型别名，另一个使用尾置返回类型，最后一个使用`decltype`关键字。
+你觉得哪种形式最好？为什么？
+
+解：
+
+```cpp
+typedef string str_arr[10];
+str_arr& fun();
+
+auto fun()->string(&)[10];
+
+string s[10];
+decltype(s)& fun();
+```
+
+我觉得尾置返回类型最好。
+
+## 练习6.38
+修改`arrPtr`函数，使其返回数组的引用。
+
+解：
+
+```cpp
+decltype(odd)& arrPtr(int i)
+{
+    return (i % 2) ? odd : even;
+}
+```
+
+## 练习6.39
+说明在下面的每组声明中第二条语句是何含义。
+如果有非法的声明，请指出来。
+
+```cpp
+(a) int calc(int, int);
+	int calc(const int, const int);
+(b) int get();
+	double get();
+(c) int *reset(int *);
+	double *reset(double *);
+```
+	
+解：
+
+- (a) 非法。因为顶层const不影响传入函数的对象，所以第二个声明无法与第一个声明区分开来。
+- (b) 非法。对于重载的函数来说，它们应该只有形参的数量和形参的类型不同。返回值与重载无关。
+- (c) 合法。
+
+## 练习6.40
+下面的哪个声明是错误的？为什么？
+
+```cpp
+(a) int ff(int a, int b = 0, int c = 0);
+(b) char *init(int ht = 24, int wd, char bckgrnd);	
+```
+
+解：
+	
+(a) 正确。
+(b) 错误。因为一旦某个形参被赋予了默认值，那么它之后的形参都必须要有默认值。
+
+## 练习6.41
+下面的哪个调用是非法的？为什么？哪个调用虽然合法但显然与程序员的初衷不符？为什么？
+
+```cpp
+char *init(int ht, int wd = 80, char bckgrnd = ' ');
+(a) init();
+(b) init(24,10);
+(c) init(14,'*');
+```
+
+解：
+
+- (a) 非法。第一个参数不是默认参数，最少需要一个实参。
+- (b) 合法。
+- (c) 合法，但与初衷不符。字符`*`被解释成`int`传入到了第二个参数。而初衷是要传给第三个参数。
+
+##练习6.42
+给`make_plural`函数的第二个形参赋予默认实参's', 利用新版本的函数输出单词success和failure的单数和复数形式。
+
+解：
+
+```cpp
+#include <iostream>
+#include <string>
+
+using std::string;
+using std::cout;
+using std::endl;
+
+string make_plural(size_t ctr, const string& word, const string& ending = "s")
+{
+	return (ctr > 1) ? word + ending : word;
+}
+
+int main()
+{
+	cout << "singual: " << make_plural(1, "success", "es") << " "
+		<< make_plural(1, "failure") << endl;
+	cout << "plural : " << make_plural(2, "success", "es") << " "
+		<< make_plural(2, "failure") << endl;
+
+	return 0;
+}
+```
+
+## 练习6.43
+你会把下面的哪个声明和定义放在头文件中？哪个放在源文件中？为什么？
+
+```cpp
+(a) inline bool eq(const BigInt&, const BigInt&) {...}
+(b) void putValues(int *arr, int size);
+```
+
+解：
+
+全部都放进头文件。(a) 是内联函数，(b) 是声明。
+
+## 练习6.44
+将6.2.2节的`isShorter`函数改写成内联函数。
+
+解：
+
+```cpp
+inline bool is_shorter(const string &lft, const string &rht) 
+{
+    return lft.size() < rht.size();
+}
+```
+
+## 练习6.45
+回顾在前面的练习中你编写的那些函数，它们应该是内联函数吗？
+如果是，将它们改写成内联函数；如果不是，说明原因。
+
+解：
+
+一般来说，内联机制用于优化规模小、流程直接、频繁调用的函数。
+
+## 练习6.46
+能把`isShorter`函数定义成`constexpr`函数吗？
+如果能，将它改写成`constxpre`函数；如果不能，说明原因。
+
+解：
+
+不能。`constexpr`函数的返回值类型及所有形参都得是字面值类型。
+
+## 练习6.47
+改写6.3.2节练习中使用递归输出`vector`内容的程序，使其有条件地输出与执行过程有关的信息。
+例如，每次调用时输出`vector`对象的大小。
+分别在打开和关闭调试器的情况下编译并执行这个程序。
+
+解：
+
+```cpp
+#include <iostream>
+#include <vector>
+using std::vector; using std::cout; using std::endl;
+
+void printVec(vector<int> &vec)
+{
+#ifndef NDEBUG
+    cout << "vector size: " << vec.size() << endl;
+#endif
+    if (!vec.empty())
+    {
+        auto tmp = vec.back();
+        vec.pop_back();
+        printVec(vec);
+        cout << tmp << " ";
+    }
+}
+
+int main()
+{
+    vector<int> vec{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+    printVec(vec);
+    cout << endl;
+
+    return 0;
+}
+```
+
+## 练习6.48
+说明下面这个循环的含义，它对assert的使用合理吗？
+
+```cpp
+string s;
+while (cin >> s && s != sought) { } //空函数体
+assert(cin);
+```
+
+解：
+
+不合理。从这个程序的意图来看，应该用
+
+```cpp
+assert(s == sought);
+```
+
+## 练习6.49
+什么是候选函数？什么是可行函数？
+
+解：
+
+候选函数：与被调用函数同名，并且其声明在调用点可见。
+可行函数：形参与实参的数量相等，并且每个实参类型与对应的形参类型相同或者能转换成形参的类型。
+
+## 练习6.50
+已知有第217页对函数`f`的声明，对于下面的每一个调用列出可行函数。
+其中哪个函数是最佳匹配？
+如果调用不合法，是因为没有可匹配的函数还是因为调用具有二义性？
+
+```cpp
+(a) f(2.56, 42)
+(b) f(42)
+(c) f(42, 0)
+(d) f(2.56, 3.14)
+```
+
+解：
+
+- (a) `void f(int, int);`和`void f(double, double = 3.14);`是可行函数。
+该调用具有二义性而不合法。
+- (b) `void f(int);` 是可行函数。调用合法。
+- (c) `void f(int, int);`和`void f(double, double = 3.14);`是可行函数。
+`void f(int, int);`是最佳匹配。
+- (d) `void f(int, int);`和`void f(double, double = 3.14);`是可行函数。
+`void f(double, double = 3.14);`是最佳匹配。
+
+## 练习6.51
+编写函数`f`的4版本，令其各输出一条可以区分的消息。
+验证上一个练习的答案，如果你的回答错了，反复研究本节内容直到你弄清自己错在何处。
+
+解：
+
+```cpp
+#include <iostream>
+using std::cout; using std::endl;
+
+void f()
+{
+    cout << "f()" << endl;
+}
+
+void f(int)
+{
+    cout << "f(int)" << endl;
+}
+
+void f(int, int)
+{
+    cout << "f(int, int)" << endl;
+}
+
+void f(double, double)
+{
+    cout << "f(double, double)" << endl;
+}
+
+int main()
+{
+    //f(2.56, 42); // error: 'f' is ambiguous.
+    f(42);
+    f(42, 0);
+    f(2.56, 3.14);
+    
+    return 0;
+}
+
+```
+
+## 练习6.52
+已知有如下声明：
+```cpp
+void manip(int ,int);
+double dobj;
+```
+请指出下列调用中每个类型转换的等级。
+
+```cpp
+(a) manip('a', 'z');
+(b) manip(55.4, dobj);
+```
+
+解：
+
+- (a) 第3级。类型提升实现的匹配。
+- (b) 第4级。算术类型转换实现的匹配。
+
+## 练习6.53
+说明下列每组声明中的第二条语句会产生什么影响，并指出哪些不合法（如果有的话）。
+
+
+```cpp
+(a) int calc(int&, int&); 
+	int calc(const int&, const int&); 
+(b) int calc(char*, char*);
+	int calc(const char*, const char*);
+(c) int calc(char*, char*);
+	int calc(char* const, char* const);
+```
+	
+解：
+
+(c) 不合法。顶层const不影响传入函数的对象。
+
+## 练习6.54
+编写函数的声明，令其接受两个`int`形参并返回类型也是`int`；然后声明一个`vector`对象，令其元素是指向该函数的指针。
+
+解：
+
+```cpp
+int func(int, int);
+vector<decltype(func)*> v;
+```
+
+## 练习6.55
+编写4个函数，分别对两个`int`值执行加、减、乘、除运算；在上一题创建的`vector`对象中保存指向这些函数的指针。
+
+解：
+
+```cpp
+int add(int a, int b) { return a + b; }
+int subtract(int a, int b) { return a - b; }
+int multiply(int a, int b) { return a * b; }
+int divide(int a, int b) { return b != 0 ? a / b : 0; }
+
+v.push_back(add);
+v.push_back(subtract);
+v.push_back(multiply);
+v.push_back(divide);
+```
+
+## 练习6.56
+调用上述`vector`对象中的每个元素并输出结果。
+
+解：
+
+```cpp
+std::vector<decltype(func) *> vec{ add, subtract, multiply, divide };
+for (auto f : vec)
+          std::cout << f(2, 2) << std::endl;
+```
\ No newline at end of file
diff --git a/notes/ch04.md b/notes/ch04.md
index c8cbcfd..ec5d4f6 100644
--- a/notes/ch04.md
+++ b/notes/ch04.md
@@ -2,7 +2,10 @@
 
 ## 表达式基础
 - **重载运算符**：当运算符作用在类类型的运算对象时，用户可以自行定义其含义。
-- **左值和右值**：c中原意：左值**可以**在表达式左边，右值不能。c++：当一个对象被用作右值的时候，用的是对象的**值**（内容）；被用做左值时，用的是对象的**身份**（在内存中的位置）。
+- **左值和右值**：
+    - c中原意：左值**可以**在表达式左边，右值不能。
+    - c++：当一个对象被用作**右值**的时候，用的是对象的**值**（内容）；
+    - 被用做**左值**时，用的是对象的**身份**（在内存中的位置）。
 
 ## 算术运算符
 - **溢出**：当计算的结果超出该类型所能表示的范围时就会产生溢出。
diff --git a/notes/ch06.md b/notes/ch06.md
index 1733441..b3dbb82 100644
--- a/notes/ch06.md
+++ b/notes/ch06.md
@@ -1,7 +1,87 @@
-## 第六章 语句
+# 第六章 函数
 
-**异常处理**：
-- `throw`表达式：遇到了不可处理的错误。
-- `try`：和 `catch`配合，`try`中的代码出现异常交由`catch`解决。
-- `catch`：如上。
+## 函数基础
+- **函数定义**：包括返回类型、函数名字和0个或者多个**形参**（parameter）组成的列表和函数体。
+- **调用运算符**：调用运算符的形式是一对圆括号 `()`，作用于一个表达式，该表达式是函数或者指向函数的指针；
+圆括号内是用逗号隔开的**实参**（argument）列表。
+- **形参和实参**：形参和实参的个数和类型必须匹配上
+- **返回类型**： `void`表示函数不返回任何值。函数的返回类型不能是数组类型或者函数类型，但可以是指向数组或者函数的指针。
+- **名字**：名字的作用于是程序文本的一部分，名字在其中可见。
+- **生命周期**：对象的生命周期是程序执行过程中该对象存在的一段时间。
+- **局部变量**（local variable）：形参和函数体内部定义的变量统称为局部变量。它对函数而言是局部的，对函数外部而言是**隐藏**的。
+- **自动对象**：只存在于块执行期间的对象。当块的执行结束后，它的值就变成**未定义**的了。
+- **局部静态对象**： `static`类型的局部变量，生命周期贯穿函数调用前后。
+- **函数声明**：函数的声明和定义唯一的区别是声明无需函数体，用一个分号替代。函数声明主要用于描述函数的接口，也称函数原型。
+- **在头文件中进行函数声明**：建议变量在头文件中声明；在源文件中定义。
+- **分离编译**： `CC a.cc b.cc`直接编译生成可执行文件；`CC -c a.cc b.cc`编译生成对象代码`a.o b.o`； `CC a.o b.o`编译生成可执行文件。
 
+## 参数传递
+- **引用传递**（passed by reference）：又称传引用调用（called by reference），指形参是引用类型，引用形参是它对应的实参的别名。
+    - 引用形参直接关联到绑定的对象，而非对象的副本。
+    - 使用引用形参可以用于**返回额外的信息**。
+    - 经常用const引用来避免不必要的复制。
+    - `void swap(int &v1, int &v2)`
+- **值传递**（passed by value）：又称传值调用（called by value），指实参的值是通过**拷贝**传递给形参。
+- **指针形参**：常用在C中，C++建议使用引用类型的形参代替指针。
+- `const形参`：
+    - 形参的顶层const被忽略。
+    - 我们可以使用非常量初始化一个底层const对象，但是反过来不行。
+    - 在函数中，不能改变实参的**局部副本**。
+    - 尽量使用常量引用。
+- **数组形参**：
+    - 当我们为函数传递一个数组时，实际上传递的是指向数组首元素的指针。
+    - 要注意数组的实际长度，不能越界。
+- **main处理命令行选项**：
+    - `int main(int argc, char *argv[]){...}`
+    - 第一个形参代表参数的个数；第二个形参是参数C风格字符串数组。
+- **可变形参**：
+    - 所有实参类型相同，可以使用 `initializer_list`的标准库类型。
+    - 实参类型不同，可以使用`可变参数模板`。
+    - 省略形参符： `...`，便于C++访问某些C代码，这些C代码使用了 `varargs`的C标准功能。
+
+## 返回类型和return语句
+- **无返回值函数**：没有返回值的 `return`语句只能用在返回类型是 `void`的函数中，返回 `void`的函数不要求非得有 `return`语句。
+- **有返回值函数**：`return`语句的返回值的类型必须和函数的返回类型相同，或者能够**隐式地**转换成函数的返回类型。
+- **不要返回局部对象的引用或指针**。
+- **引用返回左值**：函数的返回类型决定函数调用是否是左值。调用一个返回引用的函数得到左值；其他返回类型得到右值。
+- **列表初始化返回值**：函数可以返回花括号包围的值的列表。（C++11）
+- **返回数组指针**： 
+    - `Type (*function (parameter_list))[dimension]`
+    - 使用类型别名： `typedef int arrT[10];` 或者 `using arrT = int[10;]`，然后 `arrT* func() {...}`
+    - 使用 `decltype`： `decltype(odd) *arrPtr(int i) {...}`
+    - **尾置返回类型**： 在形参列表后面以一个`->`开始：`auto func(int i) -> int(*)[10]`（C++11）
+
+## 函数重载
+- **重载**：如果同一作用域内几个函数名字相同但形参列表不同，我们称之为重载（overload）函数。
+- **重载和const形参**：
+    - 一个有顶层const的形参和没有它的函数无法区分。 `Record lookup(Phone* const)`和 `Record lookup(Phone*)`无法区分。
+    - 相反，是否有某个底层const形参可以区分。 `Record lookup(Account*)`和 `Record lookup(const Account*)`可以区分。
+- **重载和作用域**：若在内层作用域中声明名字，它将隐藏外层作用域中声明的同名实体，在不同的作用域中无法重载函数名。
+
+## 特殊用途语言特性
+- **默认实参**：
+    - `string screen(sz ht = 24, sz wid = 80, char backgrnd = ' ');`
+    - 一旦某个形参被赋予了默认值，那么它之后的形参都必须要有默认值。
+- **内联（inline）函数**：
+  - 普通函数的缺点：调用函数比求解等价表达式要慢得多。
+  - `inline`函数可以避免函数调用的开销，可以让编译器在编译时内联地展开该函数。
+  - `inline`函数应该在头文件中定义。
+- **constexpr函数**：
+    - 指能用于常量表达式的函数。
+    - `constexpr int new_sz() {return 42;}`
+    - 函数的返回类型及所有形参类型都要是字面值类型。
+    - constexpr函数应该在头文件中定义。
+
+## 函数匹配
+- 重载函数匹配的**三个步骤**：1.候选函数；2.可行函数；3.寻找最佳匹配。
+- **候选函数**：选定本次调用对应的重载函数集，集合中的函数称为候选函数（candidate function）。
+- **可行函数**：考察本次调用提供的实参，选出可以被这组实参调用的函数，新选出的函数称为可行函数（viable function）。
+- **寻找最佳匹配**：基本思想：实参类型和形参类型越接近，它们匹配地越好。
+
+## 函数指针
+- **函数指针**：是指向函数的指针。
+-  `bool (*pf)(const string &, const string &);` 注：两端的括号不可少。
+- **函数指针形参**：
+    - 形参中使用函数定义或者函数指针定义效果一样。
+    - 使用类型别名或者`decltype`。
+- **返回指向函数的指针**：1.类型别名；2.尾置返回类型。
diff --git a/notes/ch07.md b/notes/ch07.md
index 2cc57cc..b4c266e 100644
--- a/notes/ch07.md
+++ b/notes/ch07.md
@@ -1,37 +1,9 @@
-## 第七章 函数
-
-**形参和实参**：形参是在函数的形参表中定义的，并由调用函数时传递函数的实参初始化。
-
-**非引用形参**：
-- 普通的非引用类型的参数通过复制对应的实参实现初始化，因此函数执行完不会修改实参的值。
-- `指针形参`，被复制的指针只影响对指针的赋值。
-- `const形参`：既可以传递const实参，也可以传递非const实参，在函数中，不能改变实参的局部副本。
-
-**引用形参**：
-- 引用形参直接关联到绑定的对象，而非对象的副本。
-- 使用引用形参可以用于返回额外的信息。
-- 经常用const引用来避免不必要的复制。
-- `void swap(int &v1, int &v2)`
+## 第七章 类
 
 **传递指向指针的引用**： `void func(int *&v1)`，从右向左理解，v1是一个引用，于指向int型对象的指针相关联。
 
 **对于是容器类型的形参**：调用非引用的vector会复制vector的每一个元素，一般更倾向于通过船体指向容器中需要处理的元素的迭代器。
 
-**对于数组的形参**： 
-- 非引用：`void func(int*)`等价于 `void func(int[10])`，也就是说不会复制数组，而是转换为指向第一个元素的指针，且长度限制没有意义。
-- 引用：传递数组的引用本身，会检查实参数组的数组大小， `void func(int (&arr)[10])`
-
-**main函数接受命令行参数**：
-- 命令行： `prog -d -o ofile`
-- 代码： `int main(int argc, char *argv[])`，有 `argv[0] = "prog"; argv[1] = "-d";argv[2] = "-o";argv[3] = "ofile";`
-
-**静态局部对象**：一个变量如果位于函数的作用域内，但生命期跨越了这个函数的多次调用，定义为static（静态的）。
-
-**内联（inline）函数**：
-- 普通函数的缺点：调用函数比求解等价表达式要慢得多。
-- inline函数可以避免函数调用的开销，可以让编译器在编译时内联地展开该函数。
-- inline函数应该在头文件中定义。
-
 **类的成员函数**：
 - 每个成员函数都有一个额外的，隐含的形参this。
 - 形参表后面的const，改变了隐含的this形参的类型，如 `bool same_isbn(const Sales_item &rhs) const`，这种函数称为“常量成员函数”。
@@ -41,11 +13,48 @@
 - 构造函数放在类的`public`部分。
 - 初始化列表：冒号和花括号之间的代码： `Sales_item(): units_sold(0), revenue(0.0) { }`
 
-**重载函数**：
-- 出现在相同作用域的两个函数，具有相同的名字而形参表不同，称为重载函数。
-- 不能仅仅基于不同的返回类型而实现重载。
-- 重载函数的三个步骤：1.候选函数；2.可行函数；3.寻找最佳匹配。
-- 仅当形参是引用或指针时，形参是否为const才有影响。
-
-**指向函数的指针**： `bool (*pf)(const string &, const string &);`
-
+类
+
+**类背后的基本思想**：**数据抽象和封装**
+
+**类成员**：
+- 必须在类的内部声明，不能在其他地方增加成员。
+- 成员可以是数据，函数，类型别名。
+
+**构造函数**：
+- 与类同名的成员函数。
+- `Sales_item(): units_sold(0), revenue(0.0) { }`
+
+**成员函数**：
+- 类内部，声明成员函数是必须的，定义成员函数是可选的。
+- 将const加到形参表之后，将成员函数声明为常量。
+- 必须对任何 const 或引用类型成员以及没有默认构造函数的类类型的任何成员使用初始化式。
+- `ConstRef::ConstRef(int ii): i(ii), ci(i), ri(ii) { }`
+- 默认实参： `Sales_item(const std::string &book): isbn(book), units_sold(0), revenue(0.0) { }`
+
+**返回 `*this`**：
+- `return *this;`可以让成员函数连续调用。
+- 普通的非const成员函数：this是指向类类型的const指针（可以改变this所指向的值，不能改变this保存的地址）。
+- const成员函数：this是指向const类类型的const指针（既不能this所指向的值，也不能改变this保存的地址）。
+
+**可变数据成员**：`mutable size_t access_ctr; `
+
+**友元**：
+- 允许特定的非成员函数访问一个类的私有成员，友元的声明以关键字 `friend`开始。
+- 通常将友元声明成组地放在类定义的开始或者结尾。
+
+**static数据成员**：
+- 非static数据成员存在于类类型的每个对象中。
+- static数据成员独立于该类的任意对象而存在。
+- 每个static数据成员是与类关联的对象，并不与该类的对象相关联。
+- 不能通过构造函数初始化，而是在定义时进行初始化，如 `double Account::interestRate = initRate();`
+- 特殊的const static成员：可以在类定义体中进行初始化。
+
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
\ No newline at end of file
diff --git a/notes/ch08.md b/notes/ch08.md
index 6d6fb7e..0e2a68e 100644
--- a/notes/ch08.md
+++ b/notes/ch08.md
@@ -19,3 +19,11 @@
 
 **按行读取**：`getline(infile,line)`
 
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
\ No newline at end of file
diff --git a/notes/ch09.md b/notes/ch09.md
index b2537dc..354d83c 100644
--- a/notes/ch09.md
+++ b/notes/ch09.md
@@ -90,3 +90,12 @@
 - `q.top()`：返回具有最高优先级的元素值，不删除。
 - `q.push(item)`：在队尾压入一个新元素。
 
+
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
diff --git a/notes/ch10.md b/notes/ch10.md
index af0eb7f..6a1f0c2 100644
--- a/notes/ch10.md
+++ b/notes/ch10.md
@@ -37,3 +37,11 @@
 - `erase` 将删除某个键的所有元素，并返回删除的个数。
 - `find` 操作则返回一个迭代器， 指向第一个拥有正在查找的键的实例。
 
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
\ No newline at end of file
diff --git a/notes/ch11.md b/notes/ch11.md
index 72084c5..0c456ac 100644
--- a/notes/ch11.md
+++ b/notes/ch11.md
@@ -52,3 +52,11 @@
 - `alg(beg, end, beg2, other parms);`
 - `alg(beg, end, beg2, end2, other parms);`
 
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
\ No newline at end of file
diff --git a/notes/ch12.md b/notes/ch12.md
index be33557..865cc0d 100644
--- a/notes/ch12.md
+++ b/notes/ch12.md
@@ -35,3 +35,12 @@
 - 不能通过构造函数初始化，而是在定义时进行初始化，如 `double Account::interestRate = initRate();`
 - 特殊的const static成员：可以在类定义体中进行初始化。
 
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+- ****：
+