Merge pull request Light-City#32 from Aurelius84/master

Polish content and style of basic_content/abstract

basic_content/abstract/README.md

@@ -8,51 +8,133 @@
 
 ## 1.纯虚函数与抽象类
 
-C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数！我们只需声明它!通过声明中赋值0来声明纯虚函数！
-
-对应的代码：[test.cpp](./test.cpp)
-
- * 纯虚函数：没有函数体的虚函数
+C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数！我们只需声明它! 通过声明中赋值0来声明纯虚函数！
+```cpp
+// 抽象类
+Class A {
+public: 
+ virtual void show() = 0; // 纯虚函数
+ /* Other members */
+}; 
+```
+
+ * 纯虚函数：没有函数体的虚函数
  * 抽象类：包含纯虚函数的类
 
-对应的代码：[pure_virtual.cpp](./pure_virtual.cpp)
-
 抽象类只能作为基类来派生新类使用，不能创建抽象类的对象,抽象类的指针和引用->由抽象类派生出来的类的对象！
 
+> 代码样例：[test.cpp](./test.cpp)、[pure_virtual.cpp](./pure_virtual.cpp)
+
 ## 2.实现抽象类
 
 抽象类中：在成员函数内可以调用纯虚函数，在构造函数/析构函数内部不能使用纯虚函数。
 
 如果一个类从抽象类派生而来，它必须实现了基类中的所有纯虚函数，才能成为非抽象类。
-
-对应的代码：[abstract.cpp](./abstract.cpp)
+```cpp
+// A为抽象类
+class A {
+public:
+ virtual void f() = 0; // 纯虚函数
+ void g(){ this->f(); }
+ A(){} // 构造函数
+};
+
+class B : public A{
+public:
+ void f(){ cout<<"B:f()"<<endl;} // 实现了抽象类的纯虚函数
+};
+```
+
+> 代码样例：[abstract.cpp](./abstract.cpp)
 
 ## 3.重要点
 
-- 纯虚函数使一个类变成抽象类
-
-对应的代码：[interesting_facts1.cpp](./interesting_facts1.cpp)
-
-- 抽象类类型的指针和引用
-
-对应的代码：[interesting_facts2.cpp](./interesting_facts2.cpp)
-
-- 如果我们不在派生类中覆盖纯虚函数，那么派生类也会变成抽象类。
-
-对应的代码：[interesting_facts3.cpp](./interesting_facts3.cpp)
-
-- 抽象类可以有构造函数
-
-对应的代码：[interesting_facts4.cpp](./interesting_facts4.cpp)
-
-- 构造函数不能是虚函数，而析构函数可以是虚析构函数。
-
-对应的代码：[interesting_facts5.cpp](./interesting_facts5.cpp)
-
-当基类指针指向派生类对象并删除对象时，我们可能希望调用适当的析构函数。如果析构函数不是虚拟的，则只能调用基类析构函数。
+- [纯虚函数使一个类变成抽象类](./interesting_facts1.cpp)
+```cpp
+// 抽象类至少包含一个纯虚函数
+class Base{
+public: 
+ virtual void show() = 0; // 纯虚函数
+ int getX() { return x; } // 普通成员函数
+
+private:
+ int x; 
+}; 
+```
+
+- [抽象类类型的指针和引用](./interesting_facts2.cpp)
+```cpp
+class Derived : public Base { 
+public: 
+ void show() { cout << "In Derived \n"; } // 实现抽象类的纯虚函数
+ Derived(){} // 构造函数
+}; 
+
+int main(void) 
+{ 
+ //Base b; // error! 不能创建抽象类的对象
+ //Base *b = new Base(); error!
+
+ Base *bp = new Derived(); // 抽象类的指针和引用 -> 由抽象类派生出来的类的对象
+ bp->show();
+ return 0; 
+}
+```
+
+- [如果我们不在派生类中覆盖纯虚函数，那么派生类也会变成抽象类](./interesting_facts3.cpp)
+```cpp
+// Derived为抽象类
+class Derived: public Base 
+{ 
+public: 
+// void show() {}
+}; 
+```
+
+- [抽象类可以有构造函数](./interesting_facts4.cpp)
+```cpp
+// 抽象类
+class Base { 
+ protected: 
+ int x; 
+ public: 
+ virtual void fun() = 0; 
+ Base(int i) { x = i; } // 构造函数
+}; 
+// 派生类
+class Derived: public Base 
+{ 
+ int y; 
+public: 
+ Derived(int i, int j) : Base(i) { y = j; } // 构造函数
+ void fun() { cout << "x = " << x << ", y = " << y; }
+}; 
+```
+
+- [构造函数不能是虚函数，而析构函数可以是虚析构函数](./interesting_facts5.cpp)
+```cpp
+// 抽象类
+class Base {
+public:
+ Base(){ cout << "Constructor: Base" << endl; }
+ virtual ~Base(){ cout << "Destructor : Base" << endl; }
+
+ virtual void func() = 0;
+};
+
+class Derived: public Base {
+public:
+ Derived(){ cout << "Constructor: Derived" << endl; }
+ ~Derived(){ cout << "Destructor : Derived" << endl;}
+
+ void func(){cout << "In Derived.func()." << endl;}
+};
+```
+>当基类指针指向派生类对象并删除对象时，我们可能希望调用适当的析构函数。
+> 如果析构函数不是虚拟的，则只能调用基类析构函数。
 
 ## 4.完整实例
 
 抽象类由派生类继承实现！
 
-对应的代码：[derived_full.cpp](./derived_full.cpp)
+> 代码样例：[derived_full.cpp](./derived_full.cpp)

basic_content/abstract/abstract.cpp

@@ -7,16 +7,12 @@
  * @date 2019-07-20
  */
 
-
-
-
 #include<iostream>
-
-
 using namespace std;
+
 class A {
 public:
- virtual void f() = 0;
+ virtual void f() = 0; // 纯虚函数
  void g(){ this->f(); }
  A(){}
 };

basic_content/abstract/derived_full.cpp

@@ -21,7 +21,7 @@ class Derived: public Base
 { 
  int y; 
  public: 
- void fun() { cout << "fun() called"; } ///< 实现了fun()函数
+ void fun() { cout << "fun() called"; } // 实现了fun()函数
 }; 
 
 int main(void) 

basic_content/abstract/interesting_facts1.cpp

@@ -9,7 +9,6 @@
 #include<iostream> 
 using namespace std; 
 
-
 /**
  * @brief 抽象类至少包含一个纯虚函数
  */

basic_content/abstract/interesting_facts3.cpp

@@ -9,7 +9,6 @@
 #include<iostream> 
 using namespace std; 
 
-
 class Base
 { 
  int x; 

basic_content/abstract/pure_virtual.cpp

@@ -16,14 +16,19 @@ class A
 private:
  int a;
 public:
- virtual void show()=0; //< 纯虚函数
+ virtual void show()=0; // 纯虚函数
 };
 
 
 int main()
 {
- // 抽象类只能作为基类来派生新类使用，不能创建抽象类的对象,抽象类的指针和引用->由抽象类派生出来的类的对象！
-// A a; // error 抽象类，不能创建对象
+ /*
+ * 1. 抽象类只能作为基类来派生新类使用
+ * 2. 抽象类的指针和引用->由抽象类派生出来的类的对象！
+ */
+ A a; // error 抽象类，不能创建对象
+
  A *a1; // ok 可以定义抽象类的指针
-// A *a2 = new A; // error,A是抽象类，不能创建对象
+
+ A *a2 = new A(); // error, A是抽象类，不能创建对象
 }

practical_exercises/10_day_practice/day9/异常例子/3.cpp

@@ -3,11 +3,11 @@ using namespace std;
 void temperature(int t)
 {
  try{
- if(t==100) throw "·Ðµã£¡";
- else if(t==0) throw "±ùµã£¡";
+ if(t==100) throw "It's at the boiling point.";
+ else if(t==0) throw "It reached the freezing point";
  else cout<<"the temperature is OK..."<<endl;
  }
- catch(int x){cout<<"temperatore="<<x<<endl;}
+ catch(int x){cout<<"temperature="<<x<<endl;}
  catch(char const*s){cout<<s<<endl;}
 }
 int main(){

practical_exercises/10_day_practice/day9/异常例子/9.cpp

@@ -17,17 +17,17 @@ class DiskNotFound:public FileSysException{
  public:
  char *Where(){return "DiskNotFound...";}
 };
-void main(){
+int main(){
  try{
- ..... //³ÌÐò´úÂë
+// ..... //³ÌÐò´úÂë
  throw FileSysException();
  }
  catch(DiskNotFound p){cout<<p.Where()<<endl;}
  catch(FileNotFound p){cout<<p.Where()<<endl;}
  catch(FileSysException p){cout<<p.Where()<<endl;}
  catch(BasicException p){cout<<p.Where()<<endl;}
  try{
- ..... //³ÌÐò´úÂë
+// ..... //³ÌÐò´úÂë
  throw DiskNotFound();
  }
  catch(BasicException p){cout<<p.Where()<<endl;}