From 2bdeea85d16ffb02359f437f44676f6b8e899073 Mon Sep 17 00:00:00 2001 From: xliu79 Date: Sun, 19 Jul 2020 10:38:38 +0800 Subject: [PATCH] english --- english/basic_content/abstract/README.md | 140 ++++++++++ english/basic_content/abstract/abstract.cpp | 27 ++ .../basic_content/abstract/derived_full.cpp | 32 +++ .../abstract/interesting_facts1.cpp | 28 ++ .../abstract/interesting_facts2.cpp | 38 +++ .../abstract/interesting_facts3.cpp | 29 ++ .../abstract/interesting_facts4.cpp | 35 +++ .../abstract/interesting_facts5.cpp | 30 +++ .../basic_content/abstract/pure_virtual.cpp | 34 +++ english/basic_content/abstract/test.cpp | 23 ++ english/basic_content/assert/README.md | 61 +++++ english/basic_content/assert/assert.c | 18 ++ english/basic_content/assert/ignore_assert.c | 17 ++ english/basic_content/bit/README.md | 177 +++++++++++++ english/basic_content/bit/learn.cpp | 19 ++ english/basic_content/decltype/README.md | 138 ++++++++++ english/basic_content/decltype/decltype | Bin 0 -> 22080 bytes english/basic_content/decltype/decltype.cpp | 60 +++++ english/basic_content/explicit/README.md | 16 ++ english/basic_content/explicit/explicit | Bin 0 -> 9288 bytes english/basic_content/explicit/explicit.cpp | 46 ++++ english/basic_content/extern/README.md | 193 ++++++++++++++ english/basic_content/extern/extern_c++/add.c | 5 + .../basic_content/extern/extern_c++/add.cpp | 9 + english/basic_content/extern/extern_c++/add.h | 4 + english/basic_content/extern/extern_c++/add.o | Bin 0 -> 1248 bytes english/basic_content/extern/extern_c++/main | Bin 0 -> 8960 bytes english/basic_content/extern/extern_c/add.c | 5 + english/basic_content/extern/extern_c/add.cpp | 5 + english/basic_content/extern/extern_c/add.h | 6 + english/basic_content/extern/extern_c/add.o | Bin 0 -> 1248 bytes english/basic_content/extern/extern_c/main | Bin 0 -> 8608 bytes english/basic_content/friend/README.md | 115 ++++++++ english/basic_content/friend/friend_class | Bin 0 -> 9344 bytes english/basic_content/friend/friend_class.cpp | 28 ++ english/basic_content/friend/friend_func | Bin 0 -> 9336 bytes english/basic_content/friend/friend_func.cpp | 33 +++ english/basic_content/func_pointer/func1 | Bin 0 -> 9368 bytes .../func_pointer/func_pointer.cpp | 33 +++ english/basic_content/img/wechat.jpg | Bin 0 -> 28028 bytes english/basic_content/inline/README.md | 137 ++++++++++ english/basic_content/inline/inline | Bin 0 -> 9200 bytes english/basic_content/inline/inline.cpp | 57 ++++ english/basic_content/inline/inline.h | 19 ++ .../basic_content/inline/inline_virtual.cpp | 35 +++ english/basic_content/inline/iv | Bin 0 -> 14376 bytes english/basic_content/macro/README.md | 232 ++++++++++++++++ english/basic_content/macro/do_while | Bin 0 -> 9464 bytes english/basic_content/macro/do_while.cpp | 76 ++++++ english/basic_content/macro/sig_examp | Bin 0 -> 14360 bytes english/basic_content/macro/sig_examp.cpp | 86 ++++++ english/basic_content/maohao/.README.md.un~ | Bin 0 -> 1052 bytes english/basic_content/maohao/README.md | 14 + english/basic_content/maohao/README.md~ | 14 + english/basic_content/maohao/maohao.cpp | 20 ++ english/basic_content/pointer_refer/README.md | 174 ++++++++++++ .../pointer_refer/copy_construct | Bin 0 -> 9592 bytes .../pointer_refer/copy_construct.cpp | 35 +++ english/basic_content/pointer_refer/effec | Bin 0 -> 20576 bytes english/basic_content/pointer_refer/effec.cpp | 22 ++ english/basic_content/sizeof/README.md | 191 ++++++++++++++ english/basic_content/sizeof/blackclass.cpp | 18 ++ english/basic_content/sizeof/genA.cpp | 29 ++ english/basic_content/sizeof/geninhe.cpp | 62 +++++ english/basic_content/sizeof/moreinhe.cpp | 43 +++ english/basic_content/sizeof/morevir.cpp | 24 ++ english/basic_content/sizeof/static.cpp | 33 +++ english/basic_content/sizeof/virinhe.cpp | 38 +++ english/basic_content/sizeof/virmoreinhe.cpp | 38 +++ english/basic_content/static/README.md | 248 ++++++++++++++++++ english/basic_content/static/demo | Bin 0 -> 9104 bytes .../basic_content/static/nostatic_class.cpp | 28 ++ english/basic_content/static/static_class.cpp | 28 ++ english/basic_content/static/static_demo.cpp | 24 ++ .../static/static_error_variable.cpp | 26 ++ .../basic_content/static/static_funciton.cpp | 20 ++ .../basic_content/static/static_variable.cpp | 24 ++ english/basic_content/struct/README.md | 228 ++++++++++++++++ english/basic_content/struct/ext | Bin 0 -> 14536 bytes .../basic_content/struct/ext_struct_func.cpp | 33 +++ english/basic_content/struct/sf | Bin 0 -> 8992 bytes english/basic_content/struct/stff | Bin 0 -> 9152 bytes english/basic_content/struct/struct_func | Bin 0 -> 8768 bytes english/basic_content/struct/struct_func.c | 27 ++ english/basic_content/struct/struct_func.cpp | 25 ++ .../basic_content/struct/struct_func_func.cpp | 39 +++ english/basic_content/struct/stu | Bin 0 -> 9112 bytes english/basic_content/struct_class/README.md | 19 ++ english/basic_content/this/README.md | 89 +++++++ english/basic_content/this/img/constthis.png | Bin 0 -> 28641 bytes english/basic_content/this/img/genthis.png | Bin 0 -> 34264 bytes .../basic_content/this/img/thiscontrust.png | Bin 0 -> 59227 bytes english/basic_content/this/person | Bin 0 -> 33952 bytes english/basic_content/this/person.cpp | 41 +++ english/basic_content/union/README.md | 18 ++ english/basic_content/union/union | Bin 0 -> 9704 bytes english/basic_content/union/union.cpp | 50 ++++ english/basic_content/using/README.md | 120 +++++++++ english/basic_content/using/derived_base | Bin 0 -> 15168 bytes english/basic_content/using/derived_base.cpp | 48 ++++ english/basic_content/using/using_derived | Bin 0 -> 9320 bytes english/basic_content/using/using_derived.cpp | 36 +++ english/basic_content/using/using_global | Bin 0 -> 9296 bytes english/basic_content/using/using_global.cpp | 45 ++++ english/basic_content/using/using_typedef | Bin 0 -> 22024 bytes english/basic_content/using/using_typedef.cpp | 34 +++ english/basic_content/virtual/README.md | 102 +++++++ english/basic_content/virtual/set1/emp | Bin 0 -> 14464 bytes english/basic_content/virtual/set1/emp.cpp | 52 ++++ .../virtual/set2/default_arg.cpp | 39 +++ .../virtual/set3/copy_consrtuct.cpp | 41 +++ .../basic_content/virtual/set3/full_virde.cpp | 39 +++ .../virtual/set3/inline_virtual.cpp | 35 +++ .../virtual/set3/static_error.cpp | 13 + .../basic_content/virtual/set3/vir_con.cpp | 206 +++++++++++++++ english/basic_content/virtual/set3/vir_de.cpp | 41 +++ .../virtual/set3/virtual_function.cpp | 33 +++ .../virtual/set3/virtual_function1.cpp | 22 ++ .../virtual/set3/virtual_inline.cpp | 44 ++++ english/basic_content/virtual/set4/rtti | Bin 0 -> 14944 bytes english/basic_content/virtual/set4/rtti.cpp | 34 +++ .../basic_content/virtual/set4/warn_rtti.cpp | 35 +++ english/basic_content/volatile/README.md | 122 +++++++++ english/basic_content/volatile/noopt_vola.cpp | 15 ++ english/basic_content/volatile/nv | Bin 0 -> 8672 bytes english/basic_content/volatile/volatile.cpp | 16 ++ english/basic_content/vptr_vtable/README.md | 219 ++++++++++++++++ .../basic_content/vptr_vtable/img/base.jpg | Bin 0 -> 136050 bytes english/basic_content/vptr_vtable/vptr1.cpp | 105 ++++++++ 129 files changed, 5264 insertions(+) create mode 100644 english/basic_content/abstract/README.md create mode 100644 english/basic_content/abstract/abstract.cpp create mode 100644 english/basic_content/abstract/derived_full.cpp create mode 100644 english/basic_content/abstract/interesting_facts1.cpp create mode 100644 english/basic_content/abstract/interesting_facts2.cpp create mode 100644 english/basic_content/abstract/interesting_facts3.cpp create mode 100644 english/basic_content/abstract/interesting_facts4.cpp create mode 100644 english/basic_content/abstract/interesting_facts5.cpp create mode 100644 english/basic_content/abstract/pure_virtual.cpp create mode 100644 english/basic_content/abstract/test.cpp create mode 100644 english/basic_content/assert/README.md create mode 100644 english/basic_content/assert/assert.c create mode 100644 english/basic_content/assert/ignore_assert.c create mode 100644 english/basic_content/bit/README.md create mode 100644 english/basic_content/bit/learn.cpp create mode 100644 english/basic_content/decltype/README.md create mode 100755 english/basic_content/decltype/decltype create mode 100644 english/basic_content/decltype/decltype.cpp create mode 100644 english/basic_content/explicit/README.md create mode 100755 english/basic_content/explicit/explicit create mode 100644 english/basic_content/explicit/explicit.cpp create mode 100644 english/basic_content/extern/README.md create mode 100644 english/basic_content/extern/extern_c++/add.c create mode 100644 english/basic_content/extern/extern_c++/add.cpp create mode 100644 english/basic_content/extern/extern_c++/add.h create mode 100644 english/basic_content/extern/extern_c++/add.o create mode 100755 english/basic_content/extern/extern_c++/main create mode 100644 english/basic_content/extern/extern_c/add.c create mode 100644 english/basic_content/extern/extern_c/add.cpp create mode 100644 english/basic_content/extern/extern_c/add.h create mode 100644 english/basic_content/extern/extern_c/add.o create mode 100755 english/basic_content/extern/extern_c/main create mode 100644 english/basic_content/friend/README.md create mode 100755 english/basic_content/friend/friend_class create mode 100644 english/basic_content/friend/friend_class.cpp create mode 100755 english/basic_content/friend/friend_func create mode 100644 english/basic_content/friend/friend_func.cpp create mode 100755 english/basic_content/func_pointer/func1 create mode 100644 english/basic_content/func_pointer/func_pointer.cpp create mode 100755 english/basic_content/img/wechat.jpg create mode 100644 english/basic_content/inline/README.md create mode 100755 english/basic_content/inline/inline create mode 100644 english/basic_content/inline/inline.cpp create mode 100644 english/basic_content/inline/inline.h create mode 100644 english/basic_content/inline/inline_virtual.cpp create mode 100755 english/basic_content/inline/iv create mode 100644 english/basic_content/macro/README.md create mode 100755 english/basic_content/macro/do_while create mode 100644 english/basic_content/macro/do_while.cpp create mode 100755 english/basic_content/macro/sig_examp create mode 100644 english/basic_content/macro/sig_examp.cpp create mode 100644 english/basic_content/maohao/.README.md.un~ create mode 100644 english/basic_content/maohao/README.md create mode 100644 english/basic_content/maohao/README.md~ create mode 100644 english/basic_content/maohao/maohao.cpp create mode 100644 english/basic_content/pointer_refer/README.md create mode 100755 english/basic_content/pointer_refer/copy_construct create mode 100644 english/basic_content/pointer_refer/copy_construct.cpp create mode 100755 english/basic_content/pointer_refer/effec create mode 100644 english/basic_content/pointer_refer/effec.cpp create mode 100644 english/basic_content/sizeof/README.md create mode 100644 english/basic_content/sizeof/blackclass.cpp create mode 100644 english/basic_content/sizeof/genA.cpp create mode 100644 english/basic_content/sizeof/geninhe.cpp create mode 100644 english/basic_content/sizeof/moreinhe.cpp create mode 100644 english/basic_content/sizeof/morevir.cpp create mode 100644 english/basic_content/sizeof/static.cpp create mode 100644 english/basic_content/sizeof/virinhe.cpp create mode 100644 english/basic_content/sizeof/virmoreinhe.cpp create mode 100644 english/basic_content/static/README.md create mode 100755 english/basic_content/static/demo create mode 100644 english/basic_content/static/nostatic_class.cpp create mode 100644 english/basic_content/static/static_class.cpp create mode 100644 english/basic_content/static/static_demo.cpp create mode 100644 english/basic_content/static/static_error_variable.cpp create mode 100644 english/basic_content/static/static_funciton.cpp create mode 100644 english/basic_content/static/static_variable.cpp create mode 100644 english/basic_content/struct/README.md create mode 100755 english/basic_content/struct/ext create mode 100644 english/basic_content/struct/ext_struct_func.cpp create mode 100755 english/basic_content/struct/sf create mode 100755 english/basic_content/struct/stff create mode 100755 english/basic_content/struct/struct_func create mode 100644 english/basic_content/struct/struct_func.c create mode 100644 english/basic_content/struct/struct_func.cpp create mode 100644 english/basic_content/struct/struct_func_func.cpp create mode 100755 english/basic_content/struct/stu create mode 100644 english/basic_content/struct_class/README.md create mode 100644 english/basic_content/this/README.md create mode 100644 english/basic_content/this/img/constthis.png create mode 100644 english/basic_content/this/img/genthis.png create mode 100644 english/basic_content/this/img/thiscontrust.png create mode 100755 english/basic_content/this/person create mode 100644 english/basic_content/this/person.cpp create mode 100644 english/basic_content/union/README.md create mode 100755 english/basic_content/union/union create mode 100644 english/basic_content/union/union.cpp create mode 100644 english/basic_content/using/README.md create mode 100755 english/basic_content/using/derived_base create mode 100644 english/basic_content/using/derived_base.cpp create mode 100755 english/basic_content/using/using_derived create mode 100644 english/basic_content/using/using_derived.cpp create mode 100755 english/basic_content/using/using_global create mode 100644 english/basic_content/using/using_global.cpp create mode 100755 english/basic_content/using/using_typedef create mode 100644 english/basic_content/using/using_typedef.cpp create mode 100644 english/basic_content/virtual/README.md create mode 100755 english/basic_content/virtual/set1/emp create mode 100644 english/basic_content/virtual/set1/emp.cpp create mode 100644 english/basic_content/virtual/set2/default_arg.cpp create mode 100644 english/basic_content/virtual/set3/copy_consrtuct.cpp create mode 100644 english/basic_content/virtual/set3/full_virde.cpp create mode 100644 english/basic_content/virtual/set3/inline_virtual.cpp create mode 100644 english/basic_content/virtual/set3/static_error.cpp create mode 100644 english/basic_content/virtual/set3/vir_con.cpp create mode 100644 english/basic_content/virtual/set3/vir_de.cpp create mode 100644 english/basic_content/virtual/set3/virtual_function.cpp create mode 100644 english/basic_content/virtual/set3/virtual_function1.cpp create mode 100644 english/basic_content/virtual/set3/virtual_inline.cpp create mode 100755 english/basic_content/virtual/set4/rtti create mode 100644 english/basic_content/virtual/set4/rtti.cpp create mode 100644 english/basic_content/virtual/set4/warn_rtti.cpp create mode 100644 english/basic_content/volatile/README.md create mode 100644 english/basic_content/volatile/noopt_vola.cpp create mode 100755 english/basic_content/volatile/nv create mode 100644 english/basic_content/volatile/volatile.cpp create mode 100644 english/basic_content/vptr_vtable/README.md create mode 100644 english/basic_content/vptr_vtable/img/base.jpg create mode 100644 english/basic_content/vptr_vtable/vptr1.cpp diff --git a/english/basic_content/abstract/README.md b/english/basic_content/abstract/README.md new file mode 100644 index 0000000..e11aa35 --- /dev/null +++ b/english/basic_content/abstract/README.md @@ -0,0 +1,140 @@ +# 纯虚函数和抽象类 + +## 关于作者： + +个人公众号： + +![](../img/wechat.jpg) + +## 1.纯虚函数与抽象类 + +C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数！我们只需声明它! 通过声明中赋值0来声明纯虚函数！ +```cpp +// 抽象类 +Class A { +public: + virtual void show() = 0; // 纯虚函数 + /* Other members */ +}; +``` + + * 纯虚函数：没有函数体的虚函数 + * 抽象类：包含纯虚函数的类 + +抽象类只能作为基类来派生新类使用，不能创建抽象类的对象,抽象类的指针和引用->由抽象类派生出来的类的对象！ + +> 代码样例：[test.cpp](./test.cpp)、[pure_virtual.cpp](./pure_virtual.cpp) + +## 2.实现抽象类 + +抽象类中：在成员函数内可以调用纯虚函数，在构造函数/析构函数内部不能使用纯虚函数。 + +如果一个类从抽象类派生而来，它必须实现了基类中的所有纯虚函数，才能成为非抽象类。 +```cpp +// A为抽象类 +class A { +public: + virtual void f() = 0; // 纯虚函数 + void g(){ this->f(); } + A(){} // 构造函数 +}; + +class B : public A{ +public: + void f(){ cout<<"B:f()"< 代码样例：[abstract.cpp](./abstract.cpp) + +## 3.重要点 + +- [纯虚函数使一个类变成抽象类](./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) \ No newline at end of file diff --git a/english/basic_content/abstract/abstract.cpp b/english/basic_content/abstract/abstract.cpp new file mode 100644 index 0000000..3a26d99 --- /dev/null +++ b/english/basic_content/abstract/abstract.cpp @@ -0,0 +1,27 @@ +/** + * @file abstract.cpp + * @brief 抽象类中：在成员函数内可以调用纯虚函数，在构造函数/析构函数内部不能使用纯虚函数 + * 如果一个类从抽象类派生而来，它必须实现了基类中的所有纯虚函数，才能成为非抽象类 + * @author 光城 + * @version v1 + * @date 2019-07-20 + */ + +#include +using namespace std; + +class A { +public: + virtual void f() = 0; // 纯虚函数 + void g(){ this->f(); } + A(){} +}; +class B:public A{ +public: + void f(){ cout<<"B:f()"< +using namespace std; + +class Base +{ + int x; + public: + virtual void fun() = 0; + int getX() { return x; } +}; + +class Derived: public Base +{ + int y; + public: + void fun() { cout << "fun() called"; } // 实现了fun()函数 +}; + +int main(void) +{ + Derived d; + d.fun(); + return 0; +} diff --git a/english/basic_content/abstract/interesting_facts1.cpp b/english/basic_content/abstract/interesting_facts1.cpp new file mode 100644 index 0000000..048ede7 --- /dev/null +++ b/english/basic_content/abstract/interesting_facts1.cpp @@ -0,0 +1,28 @@ +/** + * @file interesting_facts1.cpp + * @brief 纯虚函数使一个类变成抽象类 + * @author 光城 + * @version v1 + * @date 2019-07-20 + */ + +#include +using namespace std; + +/** + * @brief 抽象类至少包含一个纯虚函数 + */ +class Test +{ + int x; +public: + virtual void show() = 0; + int getX() { return x; } +}; + +int main(void) +{ + Test t; //error! 不能创建抽象类的对象 + return 0; +} + diff --git a/english/basic_content/abstract/interesting_facts2.cpp b/english/basic_content/abstract/interesting_facts2.cpp new file mode 100644 index 0000000..84d293e --- /dev/null +++ b/english/basic_content/abstract/interesting_facts2.cpp @@ -0,0 +1,38 @@ +/** + * @file interesting_facts2.cpp + * @brief 抽象类类型的指针和引用 + * @author 光城 + * @version v1 + * @date 2019-07-20 + */ + +#include +using namespace std; + + +/** + * @brief 抽象类至少包含一个纯虚函数 + */ +class Base +{ + int x; +public: + virtual void show() = 0; + int getX() { return x; } + +}; +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; +} + diff --git a/english/basic_content/abstract/interesting_facts3.cpp b/english/basic_content/abstract/interesting_facts3.cpp new file mode 100644 index 0000000..fb76824 --- /dev/null +++ b/english/basic_content/abstract/interesting_facts3.cpp @@ -0,0 +1,29 @@ +/** + * @file interesting_facts3.cpp + * @brief 如果我们不在派生类中覆盖纯虚函数，那么派生类也会变成抽象类。 + * @author 光城 + * @version v1 + * @date 2019-07-20 + */ + +#include +using namespace std; + +class Base +{ + int x; +public: + virtual void show() = 0; + int getX() { return x; } +}; +class Derived: public Base +{ +public: +// void show() { } +}; +int main(void) +{ + Derived d; //error! 派生类没有实现纯虚函数，那么派生类也会变为抽象类，不能创建抽象类的对象 + return 0; +} + diff --git a/english/basic_content/abstract/interesting_facts4.cpp b/english/basic_content/abstract/interesting_facts4.cpp new file mode 100644 index 0000000..028554b --- /dev/null +++ b/english/basic_content/abstract/interesting_facts4.cpp @@ -0,0 +1,35 @@ +/** + * @file interesting_facts4.cpp + * @brief 抽象类可以有构造函数 + * @author 光城 + * @version v1 + * @date 2019-07-20 + */ + +#include +using namespace std; + +// An abstract class with constructor +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; } +}; + +int main(void) +{ + Derived d(4, 5); + d.fun(); + return 0; +} diff --git a/english/basic_content/abstract/interesting_facts5.cpp b/english/basic_content/abstract/interesting_facts5.cpp new file mode 100644 index 0000000..e9152b9 --- /dev/null +++ b/english/basic_content/abstract/interesting_facts5.cpp @@ -0,0 +1,30 @@ + +/** + * @file interesting_facts5.cpp + * @brief 构造函数不能是虚函数，而析构函数可以是虚析构函数。 + * 例如：当基类指针指向派生类对象并删除对象时，我们可能希望调用适当的析构函数。如果析构函数不是虚拟的，则只能调用基类析构函数。 + * @author 光城 + * @version v1 + * @date 2019-07-20 + */ +#include +using namespace std; + +class Base { + public: + Base() { cout << "Constructor: Base" << endl; } + virtual ~Base() { cout << "Destructor : Base" << endl; } +}; + +class Derived: public Base { + public: + Derived() { cout << "Constructor: Derived" << endl; } + ~Derived() { cout << "Destructor : Derived" << endl; } +}; + +int main() { + Base *Var = new Derived(); + delete Var; + return 0; +} + diff --git a/english/basic_content/abstract/pure_virtual.cpp b/english/basic_content/abstract/pure_virtual.cpp new file mode 100644 index 0000000..bfaf177 --- /dev/null +++ b/english/basic_content/abstract/pure_virtual.cpp @@ -0,0 +1,34 @@ +/** + * @file pure_virtual.cpp + * @brief 纯虚函数：没有函数体的虚函数 + * 抽象类：包含纯虚函数的类 + * + * @author 光城 + * @version v1 + * @date 2019-07-20 + */ + +#include + +using namespace std; +class A +{ +private: + int a; +public: + virtual void show()=0; // 纯虚函数 +}; + + +int main() +{ + /* + * 1. 抽象类只能作为基类来派生新类使用 + * 2. 抽象类的指针和引用->由抽象类派生出来的类的对象！ + */ + A a; // error 抽象类，不能创建对象 + + A *a1; // ok 可以定义抽象类的指针 + + A *a2 = new A(); // error, A是抽象类，不能创建对象 +} diff --git a/english/basic_content/abstract/test.cpp b/english/basic_content/abstract/test.cpp new file mode 100644 index 0000000..7797c90 --- /dev/null +++ b/english/basic_content/abstract/test.cpp @@ -0,0 +1,23 @@ +/** + * @file test.cpp + * @brief C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数！我们只需声明它!通过声明中赋值0来声明纯虚函数！ + * 纯虚函数：没有函数体的虚函数 + * @author 光城 + * @version v1 + * @date 2019-07-20 + */ + + + +/** + * @brief 抽象类 + */ +class Test +{ + // Data members of class +public: + // Pure Virtual Function + virtual void show() = 0; + + /* Other members */ +}; diff --git a/english/basic_content/assert/README.md b/english/basic_content/assert/README.md new file mode 100644 index 0000000..8699eff --- /dev/null +++ b/english/basic_content/assert/README.md @@ -0,0 +1,61 @@ +# assert那些事 + +## 关于作者： + +个人公众号： + +![](../img/wechat.jpg) + + + +## 1.第一个断言案例 + +断言，**是宏，而非函数**。 + +assert 宏的原型定义在 （C）、（C++）中。其作用是如果它的条件返回错误，则终止程序执行。 + +可以通过定义 `NDEBUG` 来关闭 assert，**但是需要在源代码的开头，include 之前。** + +```c +void assert(int expression); +``` + +> 代码样例：[assert.c](./assert.c) +```c +#include +#include + +int main() +{ + int x = 7; + + /* Some big code in between and let's say x + is accidentally changed to 9 */ + x = 9; + + // Programmer assumes x to be 7 in rest of the code + assert(x==7); + + /* Rest of the code */ + + return 0; +} +``` +输出： +```c +assert: assert.c:13: main: Assertion 'x==7' failed. +``` +可以看到输出会把源码文件，行号错误位置，提示出来！ + +## 2.断言与正常错误处理 + ++ 断言主要用于检查逻辑上不可能的情况。 + +>例如，它们可用于检查代码在开始运行之前所期望的状态，或者在运行完成后检查状态。与正常的错误处理不同，断言通常在运行时被禁用。 + ++ 忽略断言，在代码开头加上： +```c++ +#define NDEBUG // 加上这行，则 assert 不可用 +``` + +> 样例代码：[ignore_assert.c](./ignore_assert.c) diff --git a/english/basic_content/assert/assert.c b/english/basic_content/assert/assert.c new file mode 100644 index 0000000..f66a2c0 --- /dev/null +++ b/english/basic_content/assert/assert.c @@ -0,0 +1,18 @@ +#include +#include + +int main() +{ + int x = 7; + + /* Some big code in between and let's say x + * is accidentally changed to 9 */ + x = 9; + + // Programmer assumes x to be 7 in rest of the code + assert(x==7); + + /* Rest of the code */ + + return 0; +} diff --git a/english/basic_content/assert/ignore_assert.c b/english/basic_content/assert/ignore_assert.c new file mode 100644 index 0000000..0a5a15e --- /dev/null +++ b/english/basic_content/assert/ignore_assert.c @@ -0,0 +1,17 @@ +/** + * @file ignore_assert.c + * @brief 忽略断言 + * @author 光城 + * @version v1 + * @date 2019-07-25 + */ + +# define NDEBUG // 忽略断言 + +#include + +int main(){ + int x=7; + assert(x==5); + return 0; +} diff --git a/english/basic_content/bit/README.md b/english/basic_content/bit/README.md new file mode 100644 index 0000000..498ed23 --- /dev/null +++ b/english/basic_content/bit/README.md @@ -0,0 +1,177 @@ +## About Author： + + +![](../img/wechat.jpg) + +## What is Bit field ？ + +“ Bit field is a kind of data structure.Data can be stored compactly in bits, And allows the programmer to operate on the bits of this structure. One of the advantages of this data structure is that it can save storage space in data units, which is particularly important when programs need thousands of data units. The second advantage is that bit segments can easily access part of the contents of an integer value, which can simplify the program source code. The disadvantage of this data structure is that bit segment implementation depends on specific machines and systems, and different results may be obtained in different platforms, which leads to the fact that bit segments are not portable in nature + +- The layout of bit fields in memory is machine dependent +- The type of bit field must be integer or enumeration type. The behavior of bit field in signed type depends on the implementation +- The addressing operator (&) cannot be applied to a bit field, and no pointer can point to a bit field of a class + +## Bit field usage + +Bit fields usually use struct declarations, which set the name of each bit field member and determine its width: + +``` +struct bit_field_name +{ + type member_name : width; +}; +``` + + + +| Elements | Description | +| -------------- | ------------------------------------------------------------ | +| bit_field_name | Bit field structure name | +| type | must be int、signed int or unsigned int type | +| member_name | | +| width | | + +For example, declare the following bit field: + +``` +struct _PRCODE +{ + unsigned int code1: 2; + unsigned int cdde2: 2; + unsigned int code3: 8; +}; +struct _PRCODE prcode; +``` + +This definition makes' prcode 'contain two 2-bit fields and one 8-bit field. We can use the member operator of the structure to assign values to it + +``` +prcode.code1 = 0; +prcode.code2 = 3; +procde.code3 = 102; +``` + +When assigning a value, it should be noted that the size of the value should not exceed the capacity of the bit field member，For example prcode.code3 Is a bit domain member of 8 bits. Its capacity is 2^8 = 256，Assignment range should be [0,255]。 + +## Size and alignment of bit fields + +### Size of bit field + +For example, the following bit field： + +``` +struct box +{ + unsigned int a: 1; + unsigned int : 3; + unsigned int b: 4; +}; +``` +There is an unnamed bit field in the middle of the bit field structure, which occupies 3 bits and only plays a filling role and has no practical significance. The padding makes the structure use 8 bits in total. But C language uses unsigned int as the basic unit of bit field，Even if the only member of a structure is a bit field of 1 bit, the size of the structure is the same as that of an unsigned int.In some systems, the unsigned int is 16 bits, and in x86 systems it is 32 bits.For the following articles, the default value of unsigned int is 32 bits. + +### Alignment of bit fields + +A bit field member is not allowed to cross the boundary of two unsigned ints. If the total number of bits declared by a member exceeds the size of an unsigned int, the editor will automatically shift the bit field members to align them according to the boundary of the unsigned int + +For example： + +``` +struct stuff +{ + unsigned int field1: 30; + unsigned int field2: 4; + unsigned int field3: 3; +}; +``` + + + +`field1` + `field2` = 34 Bits，beyond 32 Bits, Complier`field2` move to the next unsigned int unit. stuff.field1 and stuff.field2 will leave the 2 Bits space， stuff.field3 follow closely stuff.field2.The structure is now of size 2 * 32 = 64 Bits。 + +This hole can be filled with the unnamed bit field member mentioned earlier, or we can use an unnamed bit field member with a width of 0 to align the next field member with the next integer. +For example: + +``` +struct stuff +{ + unsigned int field1: 30; + unsigned int : 2; + unsigned int field2: 4; + unsigned int : 0; + unsigned int field3: 3; +}; +``` + + + +Between stuff.field1 and stuff.field2 there is a 2 Bits space. Stuff.field3 will be stored in the next unsigned in. The size of this structure is 3 * 32 = 96 Bits。 + +Code：[learn.cpp](learn.cpp) + +## Initialization of bit field and remapping of bit + +### Initialization + + +The initialization method of bit field is the same as that of ordinary structure. Here, two methods are listed as follows: + +``` +struct stuff s1= {20,8,6}; +``` + +Or directly assign values to the bit field members: + +``` +struct stuff s1; +s1.field1 = 20; +s1.field2 = 8; +s1.field3 = 4; +``` + +### Re-mapping of bit field + +Declare a bit field with a size of 32 bits + +``` +struct box { + unsigned int ready: 2; + unsigned int error: 2; + unsigned int command: 4; + unsigned int sector_no: 24; +}b1; +``` + +#### Zeroing bit field by remapping + +``` +int* p = (int *) &b1; // 将 "位域结构体的地址" 映射至 "整形（int*) 的地址" +*p = 0; // clear s1, set all members to zero +``` + +#### The 32 bits bit field is remapped to the unsigned int type by union + +Let's briefly introduce the alliance + +> "Union" is a special class and a data structure of construction type.Many different data types can be defined in a "union". Any kind of data defined by the "union" can be loaded into a variable described as the "union" type. These data share the same memory to save space +> +> There are some similarities between "union" and "structure". But there are essential differences between them.In a structure, each member has its own memory space. The total length of a structure variable is the sum of the length of each member (except for empty structure, and boundary adjustment is not considered).In Union, members share a certain amount of memory space, and the length of a union variable is equal to the longest length of each member.It should be noted that the so-called sharing does not mean that multiple members are loaded into a joint variable at the same time, but that the joint variable can be assigned any member value, but only one value can be assigned at a time. + +We can declare the following Union: + +``` +union u_box { + struct box st_box; + unsigned int ui_box; +}; +``` + + + +In x86 system, unsigned int and box are 32 Bits, Through this combination, St_ Box and UI_ Box shares a piece of memory.Which bit in the specific bit field corresponds to which bit of the unsigned int depends on the compiler and hardware.Use union to return the bit field to zero. The code is as follows: + +``` +union u_box u; +u.ui_box = 0; +``` + +> From： diff --git a/english/basic_content/bit/learn.cpp b/english/basic_content/bit/learn.cpp new file mode 100644 index 0000000..505256b --- /dev/null +++ b/english/basic_content/bit/learn.cpp @@ -0,0 +1,19 @@ +#include + +using namespace std; +struct stuff +{ + unsigned int field1: 30; + unsigned int : 2; + unsigned int field2: 4; + unsigned int : 0; + unsigned int field3: 3; +}; +int main(){ + struct stuff s={1,3,5}; + cout<vec; +typedef decltype(vec.begin()) vectype; +for (vectype i = vec.begin; i != vec.end(); i++) +{ +//... +} +``` + +这样和auto一样，也提高了代码的可读性。 + +### 1.3 重用匿名类型 + +在C++中，我们有时候会遇上一些匿名类型，如: + +```c++ +struct +{ + int d ; + doubel b; +}anon_s; +``` + +而借助decltype，我们可以重新使用这个匿名的结构体： + +```c++ +decltype(anon_s) as ;//定义了一个上面匿名的结构体 +``` + +### 1.4 泛型编程中结合auto，用于追踪函数的返回值类型 + +这也是decltype最大的用途了。 + +```c++ +template +auto multiply(T x, T y)->decltype(x*y) +{ + return x*y; +} +``` + +完整代码见：[decltype.cpp](decltype.cpp) + +## 2.判别规则 + +对于decltype(e)而言，其判别结果受以下条件的影响： + +如果e是一个没有带括号的标记符表达式或者类成员访问表达式，那么的decltype（e）就是e所命名的实体的类型。此外，如果e是一个被重载的函数，则会导致编译错误。 +否则 ，假设e的类型是T，如果e是一个将亡值，那么decltype（e）为T&& +否则，假设e的类型是T，如果e是一个左值，那么decltype（e）为T&。 +否则，假设e的类型是T，则decltype（e）为T。 + +标记符指的是除去关键字、字面量等编译器需要使用的标记之外的程序员自己定义的标记，而单个标记符对应的表达式即为标记符表达式。例如： +```c++ +int arr[4] +``` +则arr为一个标记符表达式，而arr[3]+0不是。 + +举例如下： + +```c++ +int i = 4; +int arr[5] = { 0 }; +int *ptr = arr; +struct S{ double d; }s ; +void Overloaded(int); +void Overloaded(char);//重载的函数 +int && RvalRef(); +const bool Func(int); + +//规则一：推导为其类型 +decltype (arr) var1; //int 标记符表达式 + +decltype (ptr) var2;//int * 标记符表达式 + +decltype(s.d) var3;//doubel 成员访问表达式 + +//decltype(Overloaded) var4;//重载函数。编译错误。 + +//规则二：将亡值。推导为类型的右值引用。 + +decltype (RvalRef()) var5 = 1; + +//规则三：左值，推导为类型的引用。 + +decltype ((i))var6 = i; //int& + +decltype (true ? i : i) var7 = i; //int& 条件表达式返回左值。 + +decltype (++i) var8 = i; //int& ++i返回i的左值。 + +decltype(arr[5]) var9 = i;//int&. []操作返回左值 + +decltype(*ptr)var10 = i;//int& *操作返回左值 + +decltype("hello")var11 = "hello"; //const char(&)[9] 字符串字面常量为左值，且为const左值。 + + +//规则四：以上都不是，则推导为本类型 + +decltype(1) var12;//const int + +decltype(Func(1)) var13=true;//const bool + +decltype(i++) var14 = i;//int i++返回右值 +``` + +学习参考：https://www.cnblogs.com/QG-whz/p/4952980.html diff --git a/english/basic_content/decltype/decltype b/english/basic_content/decltype/decltype new file mode 100755 index 0000000000000000000000000000000000000000..fb9f578a277115e8c34da59ea4f0120b5dd4f17e GIT binary patch literal 22080 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 +#include +using namespace std; +/** + * 泛型编程中结合auto，用于追踪函数的返回值类型 + */ +template + +auto multiply(T x, T y)->decltype(x*y) +{ + return x*y; +} + +int main() +{ + int nums[] = {1,2,3,4}; + vector vec(nums,nums+4); + vector::iterator it; + + for(it=vec.begin();it!=vec.end();it++) + cout<<*it<<" "; + cout< https://stackoverflow.com/questions/4600295/what-is-the-meaning-of-operator-bool-const diff --git a/english/basic_content/explicit/explicit b/english/basic_content/explicit/explicit new file mode 100755 index 0000000000000000000000000000000000000000..ab3a4124b4c8e2fc61e774ca575ca55d4998cb7a GIT binary patch literal 9288 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 literal 0 HcmV?d00001 diff --git a/english/basic_content/explicit/explicit.cpp b/english/basic_content/explicit/explicit.cpp new file mode 100644 index 0000000..f659635 --- /dev/null +++ b/english/basic_content/explicit/explicit.cpp @@ -0,0 +1,46 @@ +#include + +using namespace std; + +struct A +{ + A(int) { } + operator bool() const { return true; } +}; + +struct B +{ + explicit B(int) {} + explicit operator bool() const { return true; } +}; + +void doA(A a) {} + +void doB(B b) {} + +int main() +{ + A a1(1); // OK：直接初始化 + A a2 = 1; // OK：复制初始化 + A a3{ 1 }; // OK：直接列表初始化 + A a4 = { 1 }; // OK：复制列表初始化 + A a5 = (A)1; // OK：允许 static_cast 的显式转换 + doA(1); // OK：允许从 int 到 A 的隐式转换 + if (a1); // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换 + bool a6(a1); // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换 + bool a7 = a1; // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换 + bool a8 = static_cast(a1); // OK ：static_cast 进行直接初始化 + + B b1(1); // OK：直接初始化 +// B b2 = 1; // 错误：被 explicit 修饰构造函数的对象不可以复制初始化 + B b3{ 1 }; // OK：直接列表初始化 +// B b4 = { 1 }; // 错误：被 explicit 修饰构造函数的对象不可以复制列表初始化 + B b5 = (B)1; // OK：允许 static_cast 的显式转换 +// doB(1); // 错误：被 explicit 修饰构造函数的对象不可以从 int 到 B 的隐式转换 + if (b1); // OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换 + bool b6(b1); // OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换 +// bool b7 = b1; // 错误：被 explicit 修饰转换函数 B::operator bool() 的对象不可以隐式转换 + bool b8 = static_cast(b1); // OK：static_cast 进行直接初始化 + + return 0; +} diff --git a/english/basic_content/extern/README.md b/english/basic_content/extern/README.md new file mode 100644 index 0000000..41c1ebe --- /dev/null +++ b/english/basic_content/extern/README.md @@ -0,0 +1,193 @@ +# extern "C" + +## 关于作者： + +个人公众号： + +![](../img/wechat.jpg) + +## 1.C++与C编译区别 + +在C++中常在头文件见到extern "C"修饰函数，那有什么作用呢？ 是用于C++链接在C语言模块中定义的函数。 + +C++虽然兼容C，但C++文件中函数编译后生成的符号与C语言生成的不同。因为C++支持函数重载，C++函数编译后生成的符号带有函数参数类型的信息，而C则没有。 + +例如`int add(int a, int b)`函数经过C++编译器生成.o文件后，`add`会变成形如`add_int_int`之类的, 而C的话则会是形如`_add`, 就是说：相同的函数，在C和C++中，编译后生成的符号不同。 + +这就导致一个问题：如果C++中使用C语言实现的函数，在编译链接的时候，会出错，提示找不到对应的符号。此时`extern "C"`就起作用了：告诉链接器去寻找`_add`这类的C语言符号，而不是经过C++修饰的符号。 + +## 2.C++调用C函数 + +C++调用C函数的例子: 引用C的头文件时，需要加`extern "C"` + +```c++ +//add.h +#ifndef ADD_H +#define ADD_H +int add(int x,int y); +#endif + +//add.c +#include "add.h" + +int add(int x,int y) { + return x+y; +} + +//add.cpp +#include +#include "add.h" +using namespace std; +int main() { + add(2,3); + return 0; +} +``` + +编译： + +``` +//Generate add.o file +gcc -c add.c +``` + +链接： + +``` +g++ add.cpp add.o -o main +``` + +没有添加extern "C" 报错： + +```c++ +> g++ add.cpp add.o -o main +add.o：在函数‘main’中： +add.cpp:(.text+0x0): `main'被多次定义 +/tmp/ccH65yQF.o:add.cpp:(.text+0x0)：第一次在此定义 +/tmp/ccH65yQF.o：在函数‘main’中： +add.cpp:(.text+0xf)：对‘add(int, int)’未定义的引用 +add.o：在函数‘main’中： +add.cpp:(.text+0xf)：对‘add(int, int)’未定义的引用 +collect2: error: ld returned 1 exit status +``` + +添加extern "C"后： + +`add.cpp` + +```c++ +#include +using namespace std; +extern "C" { + #include "add.h" +} +int main() { + add(2,3); + return 0; +} +``` + +编译的时候一定要注意，先通过gcc生成中间文件add.o。 + +``` +gcc -c add.c +``` + +然后编译： + +``` +g++ add.cpp add.o -o main +``` + +上述案例源代码见： + +- [add.h](extern_c++/add.h) + +- [add.c](extern_c++/add.c) + +- [add.cpp](extern_c++/add.cpp) + +## 2.C中调用C++函数 + +`extern "C"`在C中是语法错误，需要放在C++头文件中。 + +```c +// add.h +#ifndef ADD_H +#define ADD_H +extern "C" { + int add(int x,int y); +} +#endif + +// add.cpp +#include "add.h" + +int add(int x,int y) { + return x+y; +} + +// add.c +extern int add(int x,int y); +int main() { + add(2,3); + return 0; +} +``` + +编译： + +```c +g++ -c add.cpp +``` + +链接： + +``` +gcc add.c add.o -o main +``` + +上述案例源代码见： + +- [add.h](extern_c/add.h) + +- [add.c](extern_c/add.c) + +- [add.cpp](extern_c/add.cpp) + +综上，总结出使用方法，在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。所以使用extern "C"全部都放在于cpp程序相关文件或其头文件中。 + +总结出如下形式： + +（1）C++调用C函数： + +```c++ +//xx.h +extern int add(...) + +//xx.c +int add(){ + +} + +//xx.cpp +extern "C" { + #include "xx.h" +} +``` + +（2）C调用C++函数 + +```c +//xx.h +extern "C"{ + int add(); +} +//xx.cpp +int add(){ + +} +//xx.c +extern int add(); +``` + diff --git a/english/basic_content/extern/extern_c++/add.c b/english/basic_content/extern/extern_c++/add.c new file mode 100644 index 0000000..b347468 --- /dev/null +++ b/english/basic_content/extern/extern_c++/add.c @@ -0,0 +1,5 @@ +#include "add.h" + +int add(int x,int y) { + return x+y; +} diff --git a/english/basic_content/extern/extern_c++/add.cpp b/english/basic_content/extern/extern_c++/add.cpp new file mode 100644 index 0000000..8ed76fa --- /dev/null +++ b/english/basic_content/extern/extern_c++/add.cpp @@ -0,0 +1,9 @@ +#include +using namespace std; +extern "C" { + #include "add.h" +} +int main() { + add(2,3); + return 0; +} diff --git a/english/basic_content/extern/extern_c++/add.h b/english/basic_content/extern/extern_c++/add.h new file mode 100644 index 0000000..6984cdf --- /dev/null +++ b/english/basic_content/extern/extern_c++/add.h @@ -0,0 +1,4 @@ +#ifndef ADD_H +#define ADD_H +extern int add(int x,int y); +#endif diff --git a/english/basic_content/extern/extern_c++/add.o b/english/basic_content/extern/extern_c++/add.o new file mode 100644 index 0000000000000000000000000000000000000000..4c8c0166688e71a05f7f34c991ae4669b52a5660 GIT binary patch literal 1248 zcmbtT%}T>S5S}#kw<=XU2=x$8D(I3(4eCKEr79u{VvZtd8xgcEG+R(Xy$RKekKiNt z4qkfn=nMD&-g*#prrEXY8ZSDK{bs(MZ)f%=*M;r%gkgX*16H9MNfy9Lbp2e%%|QzK z!P{)UHZR|sjrN`QephH4&j(Mik=AnN(8 z$I|1$83$JOxeu%uhQLa-N+qZwSFQ1YZR~jSA@@rs!0N%N&w}H_qq<)SM5X^h2IX`I z`bp%(vS0fYvHtd^kS9(*`F)YEgRY;(1bQET)z6`p*0k|cP1bi+5`9@;;-bQ-skdsN z_);gSEp&+ccGno+i-aYC67+wefD`oEaxy{SqbM{X;sHduBdM4CD02GQk)$Q`@*IdG i)BBI>o$^{VpuI!@gNRgHuTOo&)qfC$QbI35um1^?FiF+` literal 0 HcmV?d00001 diff --git a/english/basic_content/extern/extern_c++/main b/english/basic_content/extern/extern_c++/main new file mode 100755 index 0000000000000000000000000000000000000000..451dd010f25752b80536895e8fcedd4f53e1729b GIT binary patch literal 8960 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 literal 0 HcmV?d00001 diff --git a/english/basic_content/extern/extern_c/main b/english/basic_content/extern/extern_c/main new file mode 100755 index 0000000000000000000000000000000000000000..f026f11a1bf6d3141b9b93812b53981122ec3df5 GIT binary patch literal 8608 zcmeHNU2Ggz6~4RczckKzohGgG0~xi6S$J+aU>G1S>c)$j`@Nrj5+s@`bI}Y#fx|iNF*D?M3+1l zIr$PDxnakseL;2dLbX9^$PRx(NqE|ZEG@`NJ29< znMx{+B@XoVggdR>`fhy>A~_e)x&AFw0 zrst~p#vOZeA=-M5*04hi&O7-}eennDH6gN%0{|{1QP|+s>N8MzK9rfRXnrbepU76f z_kG|B!9E~Beqr#PlfY2>RhnK`Xv~*rkfr0`JXvzz`Y4xOIXm#t+3pq30x}n>ADs<- zCG=z{mk$kuBE9E!-Kx{jnR6|~kM`tl_vGH}edva~Mspwgmiq4G^XBvK+gjV7x&OVn zcYAZUyAUD2>AE>H?=knjmwlHm;MWF2PlpCW$3oWpY%$}9xUMpuy2KvL63;f@<3W^6 zb7nhI&`9@!N5I4A-A}=v2LCPiv*0(uZ-TdDBGG+Cd*U_7`F&?BqWSe~omp zJOY=n9weGoTnaex8kKpyGR*o6+1jAw(^ys#@ph5-SKFjk2;LvbwE}caSk4jAI)RAo z|Gtw?k$ll>5G(HaR6bf85nc8g#Kb-FjQynIv=1O^a+uhxI5S!tO2TrLh}R74&+8&u zIuhOQFfpa_vwld)TsPyf36R7xmL;-3hVsX9P0AkSx2)u#vMcrfo$)@_o#^Ua>NwEZ z`30?cU^tt!v)UfLU2kpa$V#d0+ie|sYrEdo_K;)HcDJ^5w05-ab;owgKFqG5*Kn(` zKlB#%%cVviEOtfzs=|CJ_pdI@lX5*~QH6f`M6IZF9ekLbeErJftP?{OZO2`g(DxVw??Pp`zYjcu!Lvr$O+2SgsFl+L27s~Y;#X?2@dkgPR%KbML z?&os-W;_zTs!_P;l#OWjs zihs!!|BUoseO-P8eWiZ= zoj3}80Kaeg7fQJzL?qCjj@^|<5b>&a*m5BIv{&&!8Qd53< z8+xkW9p|5S@&5(%8%2fZ=SbSl*xAuheFU%V4tDliy*)=GmL+2GbbKt4vEymWp0q|L zQptD*9gj}6iABDtgbMFat!`6AGrRhQb)dH|9O||D_U}L19kC*zaBnwdkncA~GFjOPVf91~ zS;gUr9O|UOiA0Ad;#8xs;<2b5WmxgGs9}`82*pss%Xvo%-?A5`uw_!#cr+P9NUNt0 zUa>^d%4Xt-UaW??1bH}qdEHPY4;Yot*S4&9p=YKi?dUML zop$&*w-QOrgyTX_rtG*L3iq_w(J>{BCA0c)Hi1{#iI~ty8johig&vzuBA&zTv|~9D zPiGRTWSL;WmX1$E37}fXCv2h1?&)aiV=0JsddYVq z!R@b)zzu1llZg@3kg_Q}G<3amjHA#omnShl%Wt;-L89L?+;WBIC9l)?yA7|~IW+l} z(t{9caq#mt;x!-@zl&&6DxUZ`#hNxWO7XnzvsJ*I?5MaK-v#|`tgSi!MXw<}FDeDs zuRgaF_8-y-r^7gCFTwcBUIP;CJ0ugP!{obK>brX%@FaA!*I>Nx8IV9~0}^zk!r483 z$6%qo0^@mI8dUfih2;9#kNGpO)82z+L*+LVUQ>9AQ(C`L%k>70DdUF}en{b)lq2VN z_y08Pgbyn}-ak!Mz*8(Y{ycP47x$Cb&9e&6zb`7h%*AcuIUJ>UUSD5w^`9~P9f$b^ z7oOMQ3kuKmGTtq}`tx^4{yzCcX)?4K$LcFCJnttKRQ^q_{=3KT*TB=KS2bLPeFuN9 zbo;yIH-T*^!Si~$iGqUM{%-lN@SzepKkoyyPl{=lRX~c^+JJ z<>!6T3Uvy^{*F|XS^p0hO6xD|pHu>kfr>MZ`HBnA>rzeOxlRtlIF|3AK|1a~uk%_J z(Cx2=gW5i|e* literal 0 HcmV?d00001 diff --git a/english/basic_content/friend/README.md b/english/basic_content/friend/README.md new file mode 100644 index 0000000..64ba791 --- /dev/null +++ b/english/basic_content/friend/README.md @@ -0,0 +1,115 @@ +# 友元函数与友元类 + +## 关于作者： + +个人公众号： + +![](../img/wechat.jpg) + +## 0.概述 + +友元提供了一种 普通函数或者类成员函数 访问另一个类中的私有或保护成员 的机制。也就是说有两种形式的友元： + +（1）友元函数：普通函数对一个访问某个类中的私有或保护成员。 + +（2）友元类：类A中的成员函数访问类B中的私有或保护成员 + +优点：提高了程序的运行效率。 + +缺点：破坏了类的封装性和数据的透明性。 + +总结： +- 能访问私有成员 +- 破坏封装性 +- 友元关系不可传递 +- 友元关系的单向性 +- 友元声明的形式及数量不受限制 + +## 1.友元函数 + +在类声明的任何区域中声明，而定义则在类的外部。 + +``` +friend <类型><友元函数名>(<参数表>); +``` + +注意，友元函数只是一个普通函数，并不是该类的类成员函数，它可以在任何地方调用，友元函数中通过对象名来访问该类的私有或保护成员。 + +具体代码见：[friend_func.cpp](friend_func.cpp) + +```c++ +#include + +using namespace std; + +class A +{ +public: + A(int _a):a(_a){}; + friend int geta(A &ca); ///< 友元函数 +private: + int a; +}; + +int geta(A &ca) +{ + return ca.a; +} + +int main() +{ + A a(3); + cout<; +``` + +类B是类A的友元，那么类B可以直接访问A的私有成员。 + +具体代码见：[friend_class.cpp](friend_class.cpp) +```c++ +#include + +using namespace std; + +class A +{ +public: + A(int _a):a(_a){}; + friend class B; +private: + int a; +}; + +class B +{ +public: + int getb(A ca) { + return ca.a; + }; +}; + +int main() +{ + A a(3); + B b; + cout<^kdV@LLN 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 XW?bBV-oI#>)vDjC44$wl?e+f~T^ijn literal 0 HcmV?d00001 diff --git a/english/basic_content/friend/friend_class.cpp b/english/basic_content/friend/friend_class.cpp new file mode 100644 index 0000000..bfa2372 --- /dev/null +++ b/english/basic_content/friend/friend_class.cpp @@ -0,0 +1,28 @@ +#include + +using namespace std; + +class A +{ +public: + A(int _a):a(_a){}; + friend class B; +private: + int a; +}; + +class B +{ +public: + int getb(A ca) { + return ca.a; + }; +}; + +int main() +{ + A a(3); + B b; + cout<Allem3`v<>-S9b5Y9*iPc%*pdC5 zwH0Nl0-da`kaY}I8fa)6lh7t@lZJ#4YE!jpVFIaWLX-BTj=mU5MwelcK`f#1at@ z>%?_p5s+G30jVKwmYC10(9G+UoeR7MSDVuW+MEGdV9wPs=N1yD`brc~MU%g{%oLdm z;gtaSQCsJ)k|OvXSztb<+VM0sOp;gL2`0Y=w-mwm$O7~8s$tBzf7Ca+`c&LLX8;n( z0b-(4-bpk(|MAnFBI+BrW zHl7uFxNo~2i)R$vx4k2oPR08ogUPt5tFF0!N3YSANN4rINH*RQP9=;^e`s9jz|+ZW zsC#QqZ@O0x0q8Ya;;C3N9PKsy{^&>~qZ^q>!pMfBp->O7&4`eQ>glYJiAP4meR^NB z9_npHYb)#MFzZ0bXgX&UYfA|9JIY-~Z=(OiF6ib_YTg>vVUHWF=Aagl6G55`lrUr=lXAZjq(mzq8`PqzXRU&~M zt43_bb0I9ZCV`#7CGJqq$$=F@MbZ%&Hy_0o

40pReB|aoQWyQkF75Z`w=MmMHNC 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 KVVlxk|GxpiINdt{ literal 0 HcmV?d00001 diff --git a/english/basic_content/friend/friend_func.cpp b/english/basic_content/friend/friend_func.cpp new file mode 100644 index 0000000..8ef67cc --- /dev/null +++ b/english/basic_content/friend/friend_func.cpp @@ -0,0 +1,33 @@ +/** + * @file friend_func.cpp + * @brief 友元函数 + * @author 光城 + * @version v1 + * @date 2019-08-06 + */ + +#include + +using namespace std; + +class A +{ +public: + A(int _a):a(_a){}; + friend int geta(A &ca); ///< 友元函数 +private: + int a; +}; + +int geta(A &ca) +{ + return ca.a; +} + +int main() +{ + A a(3); + cout<+v9gw~_wv%{s?96`d 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 QZC0*+uQGVfrnJ}pFPw$%F8}}l literal 0 HcmV?d00001 diff --git a/english/basic_content/func_pointer/func_pointer.cpp b/english/basic_content/func_pointer/func_pointer.cpp new file mode 100644 index 0000000..60f8bb9 --- /dev/null +++ b/english/basic_content/func_pointer/func_pointer.cpp @@ -0,0 +1,33 @@ +/** + * @file func_pointer.cpp + * @brief 函数指针的使用！ + * @author 光城 + * @version v1 + * @date 2019-07-20 + */ + +#include +using namespace std; + +/** + * @brief 定义了一个变量pFun，这个变量是个指针，指向返回值和参数都是空的函数的指针！ + */ +void (*pFun)(int); + +/** + * @brief 代表一种新类型，不是变量！所以与上述的pFun不一样！ + */ +typedef void (*func)(void); + +void myfunc(void) +{ + cout<<"asda"<jVwx3g+9i@UZP#(neIyB` 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 R2%B2+=>LE6zqqFG{{VNFESCTP literal 0 HcmV?d00001 diff --git a/english/basic_content/inline/README.md b/english/basic_content/inline/README.md new file mode 100644 index 0000000..9f757a1 --- /dev/null +++ b/english/basic_content/inline/README.md @@ -0,0 +1,137 @@ +# inline那些事 + +## 关于作者： + +个人公众号： + +![](../img/wechat.jpg) + +## 1.类中内联 + +头文件中声明方法 + +```c++ + +class A +{ +public: + void f1(int x); + + /** + * @brief 类中定义了的函数是隐式内联函数,声明要想成为内联函数，必须在实现处(定义处)加inline关键字。 + * + * @param x + * @param y + */ + void Foo(int x,int y) ///< 定义即隐式内联函数！ + { + + }; + void f1(int x); ///< 声明后，要想成为内联函数，必须在定义处加inline关键字。 +}; +``` + +实现文件中定义内联函数： + +```c++ +#include +#include "inline.h" + +using namespace std; + +/** + * @brief inline要起作用,inline要与函数定义放在一起,inline是一种“用于实现的关键字,而不是用于声明的关键字” + * + * @param x + * @param y + * + * @return + */ +int Foo(int x,int y); // 函数声明 +inline int Foo(int x,int y) // 函数定义 +{ + return x+y; +} + +// 定义处加inline关键字，推荐这种写法！ +inline void A::f1(int x){ + +} + +int main() +{ + + + cout< +using namespace std; +class Base +{ +public: + inline virtual void who() + { + cout << "I am Base\n"; + } + virtual ~Base() {} +}; +class Derived : public Base +{ +public: + inline void who() // 不写inline时隐式内联 + { + cout << "I am Derived\n"; + } +}; + +int main() +{ + // 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。 + Base b; + b.who(); + + // 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。 + Base *ptr = new Derived(); + ptr->who(); + + // 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。 + delete ptr; + ptr = nullptr; + + system("pause"); + return 0; +} +``` + + + diff --git a/english/basic_content/inline/inline b/english/basic_content/inline/inline new file mode 100755 index 0000000000000000000000000000000000000000..c45bdb69855f545715aec5b2f72d729e5547ebea GIT binary patch literal 9200 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 literal 0 HcmV?d00001 diff --git a/english/basic_content/inline/inline.cpp b/english/basic_content/inline/inline.cpp new file mode 100644 index 0000000..5b1463b --- /dev/null +++ b/english/basic_content/inline/inline.cpp @@ -0,0 +1,57 @@ +#include +#include "inline.h" + + + +using namespace std; + +/** + * @brief inline要起作用,inline要与函数定义放在一起,inline是一种“用于实现的关键字,而不是用于声明的关键字” + * + * @param x + * @param y + * + * @return + */ +int Foo(int x,int y); // 函数声明 +inline int Foo(int x,int y) // 函数定义 +{ + return x+y; +} + + + +// 定义处加inline关键字，推荐这种写法！ +inline void A::f1(int x){ + + +} + + + +/** + * @brief 内联能提高函数效率，但并不是所有的函数都定义成内联函数！内联是以代码膨胀(复制)为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。 + * 如果执行函数体内代码的时间相比于函数调用的开销较大，那么效率的收货会更少！另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。 + * 以下情况不宜用内联： + * （1） 如果函数体内的代码比较长，使得内联将导致内存消耗代价比较高。 + * (2) 如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。 + * + * @return + */ +int main() +{ + + + cout< +using namespace std; +class Base +{ + public: + inline virtual void who() + { + cout << "I am Base\n"; + } + virtual ~Base() {} +}; +class Derived : public Base +{ + public: + inline void who() // 不写inline时隐式内联 + { + cout << "I am Derived\n"; + } +}; + +int main() +{ + // 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。 + Base b; + b.who(); + + // 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。 + Base *ptr = new Derived(); + ptr->who(); + + // 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。 + delete ptr; + + return 0; +} diff --git a/english/basic_content/inline/iv b/english/basic_content/inline/iv new file mode 100755 index 0000000000000000000000000000000000000000..e0b0e9501405bf0626321d3cd7f9f3847cce1749 GIT binary patch literal 14376 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 CDd;c& literal 0 HcmV?d00001 diff --git a/english/basic_content/macro/README.md b/english/basic_content/macro/README.md new file mode 100644 index 0000000..d20b612 --- /dev/null +++ b/english/basic_content/macro/README.md @@ -0,0 +1,232 @@ +# 宏那些事 + +## 关于作者： + +个人公众号： + +![](../img/wechat.jpg) + +## 1.宏中包含特殊符号 + +分为几种：`#`，`##`，`\` + +### 1.1 字符串化操作符（#） + +**在一个宏中的参数前面使用一个#,预处理器会把这个参数转换为一个字符数组**，换言之就是：**#是“字符串化”的意思，出现在宏定义中的#是把跟在后面的参数转换成一个字符串**。 + +**注意：其只能用于有传入参数的宏定义中，且必须置于宏定义体中的参数名前。** + +例如： + +```c++ +#define exp(s) printf("test s is:%s\n",s) +#define exp1(s) printf("test s is:%s\n",#s) +#define exp2(s) #s +int main() { + exp("hello"); + exp1(hello); + + string str = exp2( bac ); + cout<(b) ? (a) \ + :(b)) +int main() { + int max_val = MAX(3,6); + cout<0) + fun() +``` + +这个宏被展开后就是： + +``` +if(a>0) + f1(); + f2(); +``` + +本意是a>0执行f1 f2，而实际是f2每次都会执行，所以就错误了。 + +为了解决这种问题，在写代码的时候，通常可以采用`{}`块。 + +如： + +```c++ +#define fun() {f1();f2();} +if(a>0) + fun(); +// 宏展开 +if(a>0) +{ + f1(); + f2(); +}; +``` + +但是会发现上述宏展开后多了一个分号，实际语法不太对。(虽然编译运行没问题，正常没分号)。 + +### 2.2避免使用goto控制流 + +在一些函数中，我们可能需要在return语句之前做一些清理工作，比如释放在函数开始处由malloc申请的内存空间，使用goto总是一种简单的方法： + +```c++ +int f() { + int *p = (int *)malloc(sizeof(int)); + *p = 10; + cout<<*p< + diff --git a/english/basic_content/macro/do_while b/english/basic_content/macro/do_while new file mode 100755 index 0000000000000000000000000000000000000000..ce870355a31e584f8a9410bf0885232b45550550 GIT binary patch literal 9464 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 literal 0 HcmV?d00001 diff --git a/english/basic_content/macro/do_while.cpp b/english/basic_content/macro/do_while.cpp new file mode 100644 index 0000000..68af132 --- /dev/null +++ b/english/basic_content/macro/do_while.cpp @@ -0,0 +1,76 @@ +#include +#include + +using namespace std; +#define f1() cout<<"f1()"<0) + fun(); + + if(2>0) + fun1(); + + f(); + ff(); + fc(); + return 0; +} diff --git a/english/basic_content/macro/sig_examp b/english/basic_content/macro/sig_examp new file mode 100755 index 0000000000000000000000000000000000000000..b3423603ba11d3e62a3314c1f6e6bb20c5dc9dc3 GIT binary patch literal 14360 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 U)qdwz!~QYecnwjur;3vOH|(?W-T(jq literal 0 HcmV?d00001 diff --git a/english/basic_content/macro/sig_examp.cpp b/english/basic_content/macro/sig_examp.cpp new file mode 100644 index 0000000..85290a7 --- /dev/null +++ b/english/basic_content/macro/sig_examp.cpp @@ -0,0 +1,86 @@ +#include +#include +#include +#include + +using namespace std; + +///=========================================== +/** + * (#)字符串操作符 + */ +///=========================================== +#define exp(s) printf("test s is:%s\n",s) +#define exp1(s) printf("test s is:%s\n",#s) + +#define exp2(s) #s + + +///=========================================== +/** + *（##）符号连接操作符 + */ +///=========================================== +#define expA(s) printf("前缀加上后的字符串为:%s\n",gc_##s) //gc_s必须存在 + +#define expB(s) printf("前缀加上后的字符串为:%s\n",gc_ ## s) //gc_s必须存在 + +#define gc_hello1 "I am gc_hello1" + + +///=========================================== +/** + * (\)续行操作符 + */ +///=========================================== +#define MAX(a,b) ((a)>(b) ? (a) \ + :(b)) + +int main() { + ///=========================================== + /** + * (#)字符串操作符 + */ + ///=========================================== + exp("hello"); + exp1(hello); + + string str = exp2( bac ); + cout<;d*tqD}c3&f&8%m~CxKnwyP8ipC- z64oiQfMgjN;xB+?fdHlu#0E*h3}N^W1Yi-6%qXBi2mqr)1{@s>3|}RH=JNnCD7HZu z6ct3ox@jXgB0;K=0Vq;I5vd3g9F0g&D9{oBBT@mHudqg>8kX#vo0y-Gn2(Z$O&g!D F0sz?-VnqM| literal 0 HcmV?d00001 diff --git a/english/basic_content/maohao/README.md b/english/basic_content/maohao/README.md new file mode 100644 index 0000000..d78b3e5 --- /dev/null +++ b/english/basic_content/maohao/README.md @@ -0,0 +1,14 @@ +# :: 范围解析运算符那些事 + +## 关于作者： + +个人公众号： + +![](../img/wechat.jpg) + +- 全局作用域符（::name）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间 +- 类作用域符（class::name）：用于表示指定类型的作用域范围是具体某个类的 +- 命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的 + +具体代码见：[maohao.cpp](maohao.cpp) + diff --git a/english/basic_content/maohao/README.md~ b/english/basic_content/maohao/README.md~ new file mode 100644 index 0000000..228d627 --- /dev/null +++ b/english/basic_content/maohao/README.md~ @@ -0,0 +1,14 @@ +# :: 范围解析运算符那些事 + +## 关于作者： + +个人公众号： + +![](../img/wechat.jpg) + +- 全局作用域符（::name）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间 +- 类作用域符（class::name）：用于表示指定类型的作用域范围是具体某个类的 +- 命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的 + +具体代码见：[::.cpp](::.cpp) + diff --git a/english/basic_content/maohao/maohao.cpp b/english/basic_content/maohao/maohao.cpp new file mode 100644 index 0000000..3460e76 --- /dev/null +++ b/english/basic_content/maohao/maohao.cpp @@ -0,0 +1,20 @@ +#include +using namespace std; + +int count=0; // 全局(::)的count + +class A { +public: + static int count; // 类A的count (A::count) + +}; +// 静态变量必须在此处定义 +int A::count; +int main() { + ::count=1; // 设置全局的count为1 + A::count=5; // 设置类A的count为2 + cout< 引用必须初始化，而指针可以不初始化。 + +我们在定义一个引用的时候必须为其指定一个初始值，但是指针却不需要。 + +```c++ +int &r; //不合法，没有初始化引用 +int *p; //合法，但p为野指针，使用需要小心 +``` + +> 引用不能为空，而指针可以为空。 + +由于引用不能为空，所以我们在使用引用的时候不需要测试其合法性，而在使用指针的时候需要首先判断指针是否为空指针，否则可能会引起程序崩溃。 + +```c++ +void test_p(int* p) +{ + if(p != null_ptr) //对p所指对象赋值时需先判断p是否为空指针 + *p = 3; + return; +} +void test_r(int& r) +{ + r = 3; //由于引用不能为空，所以此处无需判断r的有效性就可以对r直接赋值 + return; +} +``` + +> 引用不能更换目标 + +指针可以随时改变指向，但是引用只能指向初始化时指向的对象，无法改变。 + +``` +int a = 1; +int b = 2; + +int &r = a; //初始化引用r指向变量a +int *p = &a; //初始化指针p指向变量a + +p = &b; //指针p指向了变量b +r = b; //引用r依然指向a，但a的值变成了b +``` + +## 2.引用 + +#### 左值引用 + +常规引用，一般表示对象的身份。 + +#### 右值引用 + +右值引用就是必须绑定到右值（一个临时对象、将要销毁的对象）的引用，一般表示对象的值。 + +右值引用可实现转移语义（Move Sementics）和精确传递（Perfect Forwarding），它的主要目的有两个方面： + +- 消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。 +- 能够更简洁明确地定义泛型函数。 + +#### 引用折叠 + +- `X& &`、`X& &&`、`X&& &` 可折叠成 `X&` +- `X&& &&` 可折叠成 `X&&` + +C++的引用**在减少了程序员自由度的同时提升了内存操作的安全性和语义的优美性**。比如引用强制要求必须初始化，可以让我们在使用引用的时候不用再去判断引用是否为空，让代码更加简洁优美，避免了指针满天飞的情形。除了这种场景之外引用还用于如下两个场景： + +> 引用型参数 + +一般我们使用const reference参数作为只读形参，这种情况下既可以避免参数拷贝还可以获得与传值参数一样的调用方式。 + +```c++ +void test(const vector &data) +{ + //... +} +int main() +{ + vector data{1,2,3,4,5,6,7,8}; + test(data); +} +``` + +> 引用型返回值 + +C++提供了重载运算符的功能，我们在重载某些操作符的时候，使用引用型返回值可以获得跟该操作符原来语法相同的调用方式，保持了操作符语义的一致性。一个例子就是operator []操作符，这个操作符一般需要返回一个引用对象，才能正确的被修改。 + +```c++ +vector v(10); +v[5] = 10; //[]操作符返回引用，然后vector对应元素才能被修改 + //如果[]操作符不返回引用而是指针的话，赋值语句则需要这样写 +*v[5] = 10; //这种书写方式，完全不符合我们对[]调用的认知，容易产生误解 +``` + +## 3.指针与引用的性能差距 + +指针与引用之间有没有性能差距呢？这种问题就需要进入汇编层面去看一下。我们先写一个test1函数，参数传递使用指针： + +```c++ +void test1(int* p) +{ + *p = 3; //此处应该首先判断p是否为空，为了测试的需要，此处我们没加。 + return; +} +``` + +该代码段对应的汇编代码如下： + +```c++ +(gdb) disassemble +Dump of assembler code for function test1(int*): + 0x0000000000400886 <+0>: push %rbp + 0x0000000000400887 <+1>: mov %rsp,%rbp + 0x000000000040088a <+4>: mov %rdi,-0x8(%rbp) +=> 0x000000000040088e <+8>: mov -0x8(%rbp),%rax + 0x0000000000400892 <+12>: movl $0x3,(%rax) + 0x0000000000400898 <+18>: nop + 0x0000000000400899 <+19>: pop %rbp + 0x000000000040089a <+20>: retq +End of assembler dump. + +``` + +上述代码1、2行是参数调用保存现场操作；第3行是参数传递，函数调用第一个参数一般放在rdi寄存器，此行代码把rdi寄存器值（指针p的值）写入栈中；第4行是把栈中p的值写入rax寄存器；第5行是把立即数3写入到**rax寄存器值所指向的内存**中，此处要注意(%rax)两边的括号，这个括号并并不是可有可无的，(%rax)和%rax完全是两种意义，(%rax)代表rax寄存器中值所代表地址部分的内存，即相当于C++代码中的*p，而%rax代表rax寄存器，相当于C++代码中的p值，所以汇编这里使用了(%rax)而不是%rax。 + +我们再写出参数传递使用引用的C++代码段test2： + +```c++ +void test2(int& r) +{ + r = 3; //赋值前无需判断reference是否为空 + return; +} +``` + +这段代码对应的汇编代码如下： + +```c++ +(gdb) disassemble +Dump of assembler code for function test2(int&): + 0x000000000040089b <+0>: push %rbp + 0x000000000040089c <+1>: mov %rsp,%rbp + 0x000000000040089f <+4>: mov %rdi,-0x8(%rbp) +=> 0x00000000004008a3 <+8>: mov -0x8(%rbp),%rax + 0x00000000004008a7 <+12>: movl $0x3,(%rax) + 0x00000000004008ad <+18>: nop + 0x00000000004008ae <+19>: pop %rbp + 0x00000000004008af <+20>: retq +End of assembler dump. + +``` + +我们发现test2对应的汇编代码和test1对应的汇编代码完全相同，这说明C++编译器在编译程序的时候将指针和引用编译成了完全一样的机器码。所以C++中的引用只是C++对指针操作的一个“语法糖”，在底层实现时C++编译器实现这两种操作的方法完全相同。 + +## 3.总结 + +C++中引入了引用操作，在对引用的使用加了更多限制条件的情况下，保证了引用使用的安全性和便捷性，还可以保持代码的优雅性。在适合的情况使用适合的操作，引用的使用可以一定程度避免“指针满天飞”的情况，对于提升程序稳定性也有一定的积极意义。最后，指针与引用底层实现都是一样的，不用担心两者的性能差距。 + +上述部分参考自： diff --git a/english/basic_content/pointer_refer/copy_construct b/english/basic_content/pointer_refer/copy_construct new file mode 100755 index 0000000000000000000000000000000000000000..fa57fa35baa5c641a48b72ad46bc334f7f32c8af GIT binary patch literal 9592 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 T`9=G)Q2#?p;U?RLvG@NUylS!) literal 0 HcmV?d00001 diff --git a/english/basic_content/pointer_refer/copy_construct.cpp b/english/basic_content/pointer_refer/copy_construct.cpp new file mode 100644 index 0000000..1fa28ba --- /dev/null +++ b/english/basic_content/pointer_refer/copy_construct.cpp @@ -0,0 +1,35 @@ +/** + * @file copy_construct.cpp + * @brief g++ -o copy_construct copy_construct.cpp -fno-elide-constructors + * -fno-elide-constructors选项(关闭返回值优化) + * @author 光城 + * @version v1 + * @date 2019-08-09 + */ + +#include +using namespace std; + +class Copyable { +public: + Copyable(){} + Copyable(const Copyable &o) { + cout << "Copied" << endl; + } +}; +Copyable ReturnRvalue() { + return Copyable(); //返回一个临时对象 +} +void AcceptVal(Copyable a) { + +} +void AcceptRef(const Copyable& a) { + +} + +int main() { + cout << "pass by value: " << endl; + AcceptVal(ReturnRvalue()); // 应该调用两次拷贝构造函数 + cout << "pass by reference: " << endl; + AcceptRef(ReturnRvalue()); //应该只调用一次拷贝构造函数 +} diff --git a/english/basic_content/pointer_refer/effec b/english/basic_content/pointer_refer/effec new file mode 100755 index 0000000000000000000000000000000000000000..a7bf86a27a0754eb4badaaf586b0dc4f4fb8abb3 GIT binary patch literal 20576 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 +using namespace std; +void test1(int* p) +{ + *p = 3; //此处应该首先判断p是否为空，为了测试的需要，此处我们没加。 + return; +} + +void test2(int& p) +{ + p = 3; //此处应该首先判断p是否为空，为了测试的需要，此处我们没加。 + return; +} + +int main() { + int a=10; + int *p=&a; + test1(p); + test2(a); + cout< +using namespace std; +class A{}; +int main() +{ + cout< +using namespace std; +class A +{ + public: + char b; + virtual void fun() {}; + static int c; + static int d; + static int f; +}; + +int main() +{ + /** + * @brief 16 字节对齐、静态变量不影响类的大小、vptr指针=8 + */ + cout< +using namespace std; +class A{ + virtual void fun(); + virtual void fun1(); + virtual void fun2(); + virtual void fun3(); +}; +int main() +{ + cout< + +using namespace std; + +class A +{ + public: + char a; + int b; +}; + +/** + * @brief 此时B按照顺序： + * char a + * int b + * short a + * long b + * 根据字节对齐4+4=8+8+8=24 + */ +class B:A +{ + public: + short a; + long b; +}; +class C +{ + A a; + char c; +}; +class A1 +{ + virtual void fun(){} +}; +class C1:public A1 +{ +}; + +int main() +{ + cout< +using namespace std; +class A +{ + virtual void fun() {} +}; +class B +{ + virtual void fun2() {} +}; +class C : virtual public A, virtual public B +{ + public: + virtual void fun3() {} +}; + +int main() +{ + /** + * @brief 8 8 16 派生类虚继承多个虚函数，会继承所有虚函数的vptr + */ + cout< + +using namespace std; + +class A{}; +int main() +{ + cout< + + +using namespace std; + +class A +{ + public: + A(); + ~A(); + static int a; + static void fun3(); + void fun(); + void fun1(); +}; + +int main() +{ + cout< + +using namespace std; + +class A +{ + public: + char a; + int b; +}; + +/** + * @brief 此时B按照顺序： + * char a + * int b + * short a + * long b + * 根据字节对齐4+4=8+8+8=24 + */ +class B:A +{ + public: + short a; + long b; +}; +class C +{ + A a; + char c; +}; + +class A1 +{ + virtual void fun(){} +}; +class C1:public A +{ +}; + + +int main() +{ + cout< + +using namespace std; + +class A +{ + public: + char a; + int b; +}; + +class B +{ + public: + short a; + long b; +}; + +/** + * @brief 8+16+8=32 + */ +class C:A,B +{ + char c; +}; + + +int main() +{ + cout< + +using namespace std; + +class A{ + + virtual void fun(); + virtual void fun1(); + virtual void fun2(); + virtual void fun3(); +}; +int main() +{ + cout< +using namespace std; +class A +{ + public: + char b; + virtual void fun() {}; + static int c; + static int d; + static int f; +}; + + + +int main() +{ + + /** + * @brief 16 字节对齐、静态变量不影响类的大小、vptr指针=8 + */ + cout< + +using namespace std; + +class A +{ + virtual void fun() {} +}; + +class B +{ + virtual void fun2() {} +}; +class C : virtual public A, virtual public B +{ + public: + virtual void fun3() {} +}; + + +int main() +{ + + /** + * @brief 8 8 16 派生类虚继承多个虚函数，会继承所有虚函数的vptr + */ + cout< + +using namespace std; + +class A +{ + virtual void fun() {} +}; + +class B +{ + virtual void fun2() {} +}; +class C : public A, public B +{ + public: + virtual void fun3() {} +}; + + +int main() +{ + + /** + * @brief 8 8 16 派生类继承多个虚函数，会继承所有虚函数的vptr + */ + cout< +#include +using namespace std; + +void demo() +{ + // static variable + static int count = 0; + cout << count << " "; + + // value is updated and + // will be carried to next + // function calls + count++; +} + +int main() +{ + for (int i=0; i<5; i++) + demo(); + return 0; +} +``` + +输出： + +``` +0 1 2 3 4 +``` + +您可以在上面的程序中看到变量count被声明为static。因此，它的值通过函数调用来传递。每次调用函数时，都不会对变量计数进行初始化。 + +- 类中的静态变量 + +由于声明为static的变量只被初始化一次，因为它们在单独的静态存储中分配了空间，因此类中的静态变量**由对象共享。**对于不同的对象，不能有相同静态变量的多个副本。也是因为这个原因，静态变量不能使用构造函数初始化。 + +```c++ + +#include +using namespace std; + +class Apple +{ +public: + static int i; + + Apple() + { + // Do nothing + }; +}; + +int main() +{ +Apple obj1; +Apple obj2; +obj1.i =2; +obj2.i = 3; + +// prints value of i +cout << obj1.i<<" "< +using namespace std; + +class Apple +{ +public: + static int i; + + Apple() + { + // Do nothing + }; +}; + +int Apple::i = 1; + +int main() +{ + Apple obj; + // prints value of i + cout << obj.i; +} +``` + +输出： + +``` +1 +``` + +**静态成员** + +- 类对象为静态 + +就像变量一样，对象也在声明为static时具有范围，直到程序的生命周期。 + +考虑以下程序，其中对象是非静态的。 + +```c++ +#include +using namespace std; + +class Apple +{ + int i; + public: + Apple() + { + i = 0; + cout << "Inside Constructor\n"; + } + ~Apple() + { + cout << "Inside Destructor\n"; + } +}; + +int main() +{ + int x = 0; + if (x==0) + { + Apple obj; + } + cout << "End of main\n"; +} + +``` + + +输出： + +```c++ +Inside Constructor +Inside Destructor +End of main +``` + +在上面的程序中，对象在if块内声明为非静态。因此，变量的范围仅在if块内。因此，当创建对象时，将调用构造函数，并且在if块的控制权越过析构函数的同时调用，因为对象的范围仅在声明它的if块内。 +如果我们将对象声明为静态，现在让我们看看输出的变化。 + +```c++ +#include +using namespace std; + +class Apple +{ + int i; + public: + Apple() + { + i = 0; + cout << "Inside Constructor\n"; + } + ~Apple() + { + cout << "Inside Destructor\n"; + } +}; + +int main() +{ + int x = 0; + if (x==0) + { + static Apple obj; + } + cout << "End of main\n"; +} + +``` + + +输出： + +``` +Inside Constructor +End of main +Inside Destructor +``` + +您可以清楚地看到输出的变化。现在，在main结束后调用析构函数。这是因为静态对象的范围是贯穿程序的生命周期。 + +- 类中的静态函数 + +就像类中的静态数据成员或静态变量一样，静态成员函数也不依赖于类的对象。我们被允许使用对象和'.'来调用静态成员函数。但建议使用类名和范围解析运算符调用静态成员。 + +允许静态成员函数仅访问静态数据成员或其他静态成员函数，它们无法访问类的非静态数据成员或成员函数。 + +```c++ +#include +using namespace std; + +class Apple +{ + public: + // static member function + static void printMsg() + { + cout<<"Welcome to Apple!"; + } +}; + +// main function +int main() +{ + // invoking a static member function + Apple::printMsg(); +} +``` + +输出： + +``` +Welcome to Apple! +``` + diff --git a/english/basic_content/static/demo b/english/basic_content/static/demo new file mode 100755 index 0000000000000000000000000000000000000000..fdd7a26994d71699bb7e0d3ce8f176a51e58c4c2 GIT binary patch literal 9104 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 M0AiOT(^>vM0n>|1lK=n! literal 0 HcmV?d00001 diff --git a/english/basic_content/static/nostatic_class.cpp b/english/basic_content/static/nostatic_class.cpp new file mode 100644 index 0000000..b4e56d2 --- /dev/null +++ b/english/basic_content/static/nostatic_class.cpp @@ -0,0 +1,28 @@ +#include +using namespace std; + +class Apple +{ + int i; + public: + Apple() + { + i = 0; + cout << "Inside Constructor\n"; + } + ~Apple() + { + cout << "Inside Destructor\n"; + } +}; + +int main() +{ + int x = 0; + if (x==0) + { + Apple obj; + } + cout << "End of main\n"; +} + diff --git a/english/basic_content/static/static_class.cpp b/english/basic_content/static/static_class.cpp new file mode 100644 index 0000000..007e400 --- /dev/null +++ b/english/basic_content/static/static_class.cpp @@ -0,0 +1,28 @@ +#include +using namespace std; + +class Apple +{ + int i; + public: + Apple() + { + i = 0; + cout << "Inside Constructor\n"; + } + ~Apple() + { + cout << "Inside Destructor\n"; + } +}; + +int main() +{ + int x = 0; + if (x==0) + { + static Apple obj; + } + cout << "End of main\n"; +} + diff --git a/english/basic_content/static/static_demo.cpp b/english/basic_content/static/static_demo.cpp new file mode 100644 index 0000000..1910088 --- /dev/null +++ b/english/basic_content/static/static_demo.cpp @@ -0,0 +1,24 @@ +// the use of static Static +// variables in a Function +#include +#include +using namespace std; + +void demo() +{ + // static variable + static int count = 0; + cout << count << " "; + + // value is updated and + // will be carried to next + // function calls + count++; +} + +int main() +{ + for (int i=0; i<5; i++) + demo(); + return 0; +} diff --git a/english/basic_content/static/static_error_variable.cpp b/english/basic_content/static/static_error_variable.cpp new file mode 100644 index 0000000..47b1319 --- /dev/null +++ b/english/basic_content/static/static_error_variable.cpp @@ -0,0 +1,26 @@ +// variables inside a class + +#include +using namespace std; + +class Apple +{ + public: + static int i; + + Apple() + { + // Do nothing + }; +}; + +int main() +{ + Apple obj1; + Apple obj2; + obj1.i =2; + obj2.i = 3; + + // prints value of i + cout << obj1.i<<" "< +using namespace std; + +class Apple +{ + public: + // static member function + static void printMsg() + { + cout<<"Welcome to Apple!"; + } +}; + +// main function +int main() +{ + // invoking a static member function + Apple::printMsg(); +} + diff --git a/english/basic_content/static/static_variable.cpp b/english/basic_content/static/static_variable.cpp new file mode 100644 index 0000000..b14780e --- /dev/null +++ b/english/basic_content/static/static_variable.cpp @@ -0,0 +1,24 @@ +// variables inside a class + +#include +using namespace std; + +class GfG +{ + public: + static int i; + + GfG() + { + // Do nothing + }; +}; + +int GfG::i = 1; + +int main() +{ + GfG obj; + // prints value of i + cout << obj.i; +} diff --git a/english/basic_content/struct/README.md b/english/basic_content/struct/README.md new file mode 100644 index 0000000..cea8af9 --- /dev/null +++ b/english/basic_content/struct/README.md @@ -0,0 +1,228 @@ +# 一文搞懂C和C++中struct + +## 关于作者： + +个人公众号： + +![](../img/wechat.jpg) + +## 1.C中struct + +- 在C中struct只单纯的用作数据的复合类型，也就是说，在结构体声明中只能将数据成员放在里面，而不能将函数放在里面。 +- 在C结构体声明中不能使用C++访问修饰符，如：public、protected、private 而在C++中可以使用。 +- 在C中定义结构体变量，如果使用了下面定义必须加struct。 +- C的结构体不能继承（没有这一概念）。 +- 若结构体的名字与函数名相同，可以正常运行且正常的调用！例如：可以定义与 struct Base 不冲突的 void Base() {}。 + +完整案例： + +```c +#include + +struct Base { // public + int v1; +// public: //error + int v2; + //private: + int v3; + //void print(){ // c中不能在结构体中嵌入函数 + // printf("%s\n","hello world"); + //}; //error! +}; + +void Base(){ + printf("%s\n","I am Base func"); +} +//struct Base base1; //ok +//Base base2; //error +int main() { + struct Base base; + base.v1=1; + //base.print(); + printf("%d\n",base.v1); + Base(); + return 0; +} +``` + +最后输出： + +``` +1 +I am Base func +``` + +完整代码见：[struct_func.c](./struct_func.c) + +## 2.C++中struct + +与C对比如下： + +- C++结构体中不仅可以定义数据，还可以定义函数。 +- C++结构体中可以使用访问修饰符，如：public、protected、private 。 +- C++结构体使用可以直接使用不带struct。 +- C++继承 +- 若结构体的名字与函数名相同，可以正常运行且正常的调用！但是定义结构体变量时候只用用带struct的！ + +例如： + +> 情形1：不适用typedef定义结构体别名 + +未添加同名函数前： + +```c++ +struct Student { + +}; +Student(){} +Struct Student s; //ok +Student s; //ok +``` + +添加同名函数后： + +```c++ +struct Student { + +}; +Student(){} +Struct Student s; //ok +Student s; //error +``` + +> 情形二：使用typedef定义结构体别名 + +```c++ +typedef struct Base1 { + int v1; +// private: //error! + int v3; + public: //显示声明public + int v2; + void print(){ + printf("%s\n","hello world"); + }; +}B; +//void B() {} //error! 符号 "B" 已经被定义为一个 "struct Base1" 的别名 +``` + +> 前三种案例 + +```c++ +#include +#include + +struct Base { + int v1; +// private: //error! + int v3; + public: //显示声明public + int v2; + void print(){ + printf("%s\n","hello world"); + }; +}; + +int main() { + struct Base base1; //ok + Base base2; //ok + Base base; + base.v1=1; + base.v3=2; + base.print(); + printf("%d\n",base.v1); + printf("%d\n",base.v3); + return 0; +} +``` + +完整代码见：[struct_func.cpp](struct_func.cpp) + +> 继承案例 + +```c++ +#include +#include +struct Base { + int v1; +// private: //error! + int v3; + public: //显示声明public + int v2; + virtual void print(){ + printf("%s\n","Base"); + }; +}; +struct Derived:Base { + + public: + int v2; + void print(){ + printf("%s\n","Derived"); + }; +}; +int main() { + Base *b=new Derived(); + b->print(); + return 0; +} +``` + +完整代码见：[ext_struct_func.cpp](./ext_struct_func.cpp) + +> 同名函数 + +```c++ +#include +#include + +struct Base { + int v1; +// private: //error! + int v3; + public: //显示声明public + int v2; + void print(){ + printf("%s\n","hello world"); + }; +}; + +typedef struct Base1 { + int v1; +// private: //error! + int v3; + public: //显示声明public + int v2; + void print(){ + printf("%s\n","hello world"); + }; +}B; +void Base(){ + printf("%s\n","I am Base func"); +} +//void B() {} //error! 符号 "B" 已经被定义为一个 "struct Base1" 的别名 +int main() { + struct Base base; //ok + //Base base1; // error! + base.v1=1; + base.v3=2; + base.print(); + printf("%d\n",base.v1); + printf("%d\n",base.v3); + Base(); + return 0; +} +``` +完整代码见：[struct_func_func.cpp](./struct_func_func.cpp) + +## 3.总结 + +### C和C++中的Struct区别 + +| C | C++ | +| ------------------------------------------------------ | ------------------------------------------------------------ | +| 不能将函数放在结构体声明 | 能将函数放在结构体声明 | +| 在C结构体声明中不能使用C++访问修饰符。 | public、protected、private 在C++中可以使用。 | +| 在C中定义结构体变量，如果使用了下面定义必须加struct。 | 可以不加struct | +| 结构体不能继承（没有这一概念）。 | 可以继承 | +| 若结构体的名字与函数名相同，可以正常运行且正常的调用！ | 若结构体的名字与函数名相同，使用结构体，只能使用带struct定义！ | diff --git a/english/basic_content/struct/ext b/english/basic_content/struct/ext new file mode 100755 index 0000000000000000000000000000000000000000..45104f89893cae70439235bf4bab081661c77884 GIT binary patch literal 14536 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 literal 0 HcmV?d00001 diff --git a/english/basic_content/struct/ext_struct_func.cpp b/english/basic_content/struct/ext_struct_func.cpp new file mode 100644 index 0000000..7ab1eb2 --- /dev/null +++ b/english/basic_content/struct/ext_struct_func.cpp @@ -0,0 +1,33 @@ +#include +#include +using namespace std; +struct Base { + int v1; +// private: //error! + int v3; + public: //显示声明public + int v2; + virtual void print(){ + printf("%s\n","Base"); + }; + Base(){cout<<"Base construct"<print(); + delete b; + return 0; +} diff --git a/english/basic_content/struct/sf b/english/basic_content/struct/sf new file mode 100755 index 0000000000000000000000000000000000000000..321061d21e6b74b8b0d849adf04d1b76e15d119f GIT binary patch literal 8992 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 literal 0 HcmV?d00001 diff --git a/english/basic_content/struct/stff b/english/basic_content/struct/stff new file mode 100755 index 0000000000000000000000000000000000000000..de4372784a1ac8ea9c10b399a4f029d1afecc810 GIT binary patch literal 9152 zcmeHNeQaA-6~DHVG+j5x-8z=FW3@&r+KqTln}&>u?m3Cumyx!iaknv+y*jp&m^pT2 zKX*w*N2_c_rt1i7piY25j7#m7WK@4o`>M0y^B9Ofcu-m~#z@Q+Z|5RMO&?t*}JqLii;> zc2w8J3#16XS0MY#Qo@pM0H+;hvop~zw`KwuiyT))Mp=m z`Pm15{)vb0z4y7F^^-mgC6AjB@CZQ-uhY>z z&6z&8X2eErGlrtclo-n<)8-KH*m%^4 znu+nG34yFs?O~&Rxo0T>;*;1PVTc{_jDeT64bE|ZnoO_h#l7Dh` z$^JGsei=*HBmPX8AQvp|2j}&&Dw)I%QYT(fSblX9E7dLDB4yBG(_YDGEvls>Em-~f& z*Nj;|e?)?(8fPt~;+EeatGNC-yqnf)NRd23nG178(E4AIOif&PM#{e+nYv^gp?m9nVP=vEh&GGWNPxll$5_sGBtJKpp-iy4^2Uq)cRUa;n`dD!i)OknX`S7 zp3^h_<(kk>pFGh>?DXknnwbAQ4F56Iw6^h1A_4o;r)z=2*ktDl^|PIo=2KYPx+xa4gGduv)N z24=1D4}N^1(Jw@PY`&_X&H84v6hRz??kJPQ-K&>f+7h7jehv#S{PKVFX0O&`kF|C`J~?g{ez_I^=9aN5~rtc{g-={m_Gcr?*k|>qpSP&1k26zb2Rer~miB|7s6R;k!t52R@TTV@j3+ zURV;6oSe==MCV&f_!=~s!l6jgI&9ZOa?b$g`_&qWmd{bEmE4HW9TDvZM6|aMy>+gb zA%4uQ5i8yK<~)|nXP+6jC1cx_#8=rBN^VwM?jb5oj1C}@@JS-#wSQbn<^7h=QkN)v zq+XLL#`~1a_2%+u?tp^6dj|7qGwaP;K{wwi|1s#K(=bI51a3QkMyh4Lznbu0Yx<5&yRz0th6|0_~Tcw}s`4Ex%7gf!}gu?mz#Wfn2eyZo; zPq2~u@zrzAt3%MQ6|eb<#Jz%Ut3>=Acoc~X(VsJFp75FeLFoIXX65V0OW?nh{wsA! z`liII*Zc36&@V25H%i@GH;{_o;cs z=ZP->Ux{c8?@M*c_WmXO{0O+O#<-}kk(|y%WzXML=LSY4>gnT0?A^n%v zqk_d-QlF(V--~|piPd7n;eRC#Bveo5{?iPc%B464(S&>p@mJ};#&;o>HFIWuXebav zxa|6_-9~Rue*}@fazM{8M~xVT^eE~U<n0%wRNS#LY}LXGHVkB9<8)OC`)iJn+#i z*R<7EGKP}rq!G<#qZ39VZDuFLP&PW6Fyi^q(FvH?BmlFt+#Z>J0V5BtK~M z7%-<>IpUATw%wr}VI#b=o8q0aOE`_-vk}&ng5JHmjZT;bh5eaqnhRLX+1@THi zhEj#m{i&Uy9X(wtZmDT9GKpv;#UNGOGM3BBZiD=9gRm47bvUUVNL5NI23i#%b@;GF zQyn?g-YIwUS2SaKe&hYAq?tg43UgK@G)3 zN0TwsA!CwzAk+l`beITWagSobs%_*yW^{hRmR9a}Hvpr%DBI6@G)MyX49NuFXDz9G?qc~?B5_IwX{ zQ8g4N9!Xq()?Xr?T$^ zC*u2$`~?8=afw>@f3k7f-vf;LmFh?2YtR&z3}4zxQr%Jl3rN}RgUUXr93CubS_%Fg zi1~dE`xDCkgtF)QvKy!T4Tn9S`(~8=Aa|^Cz~!>P2ORc%k6Wh#5Q?$79IKLm#CMfF z7sKbOpfaTOX(wm@{ScYde{9e9!ichu*o~2P+D|*|`TlrZ*_-6tM$Z0w3VHO?yjm`$ zdnW&$?d&h7{qwMGvf1-}w2_>Gocd1rFVLYXa`}93^}SE~zrmJUzVA_4jp^_OZR0}K%ewdez6_%MTb4#fBKX?*ONW49n0sC zAdK73=ij}`(5bJwgUy8p0AaxrVkOvqivwqS=5%l2vhAv`sg2`&R#ce|QI^ef-)?_Q h)xU#2PN2*2Y{J9s;r)-Md9CuFQ31yfIx?N*{}aP|l5_w7 literal 0 HcmV?d00001 diff --git a/english/basic_content/struct/struct_func b/english/basic_content/struct/struct_func new file mode 100755 index 0000000000000000000000000000000000000000..8541eba04debc9e9e2a892f8ac02d5ba9654f50c GIT binary patch literal 8768 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 + +struct Base { // public + int v1; +// public: //error + int v2; + //private: + int v3; + //void print(){ // c中不能在结构体中嵌入函数 + // printf("%s\n","hello world"); + //}; //error! +}; + +void Base(){ + printf("%s\n","I am Base func"); +} +//struct Base base1; //ok +//Base base2; //error + +int main() { + struct Base base; + base.v1=1; + //base.print(); + printf("%d\n",base.v1); + Base(); + return 0; +} diff --git a/english/basic_content/struct/struct_func.cpp b/english/basic_content/struct/struct_func.cpp new file mode 100644 index 0000000..09bef26 --- /dev/null +++ b/english/basic_content/struct/struct_func.cpp @@ -0,0 +1,25 @@ +#include +#include + +struct Base { + int v1; +// private: //error! + int v3; + public: //显示声明public + int v2; + void print(){ + printf("%s\n","hello world"); + }; +}; + +int main() { + struct Base base1; //ok + Base base2; //ok + Base base; + base.v1=1; + base.v3=2; + base.print(); + printf("%d\n",base.v1); + printf("%d\n",base.v3); + return 0; +} diff --git a/english/basic_content/struct/struct_func_func.cpp b/english/basic_content/struct/struct_func_func.cpp new file mode 100644 index 0000000..bce3749 --- /dev/null +++ b/english/basic_content/struct/struct_func_func.cpp @@ -0,0 +1,39 @@ +#include +#include + +struct Base { + int v1; +// private: //error! + int v3; + public: //显示声明public + int v2; + void print(){ + printf("%s\n","hello world"); + }; +}; + +typedef struct Base1 { + int v1; +// private: //error! + int v3; + public: //显示声明public + int v2; + void print(){ + printf("%s\n","hello world"); + }; +}B; +void Base(){ + printf("%s\n","I am Base func"); +} +//void B() {} //error! 符号 "B" 已经被定义为一个 "struct Base1" 的别名 +int main() { + struct Base base; //ok + //Base base1; // error! + base.v1=1; + base.v3=2; + base.print(); + printf("%d\n",base.v1); + printf("%d\n",base.v3); + Base(); + return 0; +} diff --git a/english/basic_content/struct/stu b/english/basic_content/struct/stu new file mode 100755 index 0000000000000000000000000000000000000000..6dabbe152c2f4faf6d091db222b375f2d752acfe GIT binary patch literal 9112 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 literal 0 HcmV?d00001 diff --git a/english/basic_content/struct_class/README.md b/english/basic_content/struct_class/README.md new file mode 100644 index 0000000..119e039 --- /dev/null +++ b/english/basic_content/struct_class/README.md @@ -0,0 +1,19 @@ +# struct与class区别 + +## 关于作者： + +个人公众号： + +![](../img/wechat.jpg) + +关于C与C++中struct内容：见[struct那些事](../struct) + +总的来说，struct 更适合看成是一个数据结构的实现体，class 更适合看成是一个对象的实现体。 + +区别: + +最本质的一个区别就是默认的访问控制 + +默认的继承访问权限。struct 是 public 的，class 是 private 的。 + +struct 作为数据结构的实现体，它默认的数据访问控制是 public 的，而 class 作为对象的实现体，它默认的成员变量访问控制是 private 的。 diff --git a/english/basic_content/this/README.md b/english/basic_content/this/README.md new file mode 100644 index 0000000..f950237 --- /dev/null +++ b/english/basic_content/this/README.md @@ -0,0 +1,89 @@ +# this指针那些事 + +## 关于作者 + +微信公众号： + +![](../img/wechat.jpg) + +## 1.this指针 + +相信在坐的很多人，都在学Python，对于Python来说有self，类比到C++中就是this指针，那么下面一起来深入分析this指针在类中的使用！ + +首先来谈谈this指针的用处： + +（1）一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。 + +（2）this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。 + +其次，this指针的使用： + +（1）在类的非静态成员函数中返回类对象本身的时候，直接使用 return *this。 + +（2）当参数与成员变量名相同时，如this->n = n （不能写成n = n)。 + +另外，在网上大家会看到this会被编译器解析成`A *const `，`A const * `，究竟是哪一个呢？下面通过断点调试分析： + +现有如下例子： + +```c++ +#include +#include + + +using namespace std; +class Person{ +public: + typedef enum { + BOY = 0, + GIRL + }SexType; + Person(char *n, int a,SexType s){ + name=new char[strlen(n)+1]; + strcpy(name,n); + age=a; + sex=s; + } + int get_age() const{ + + return this->age; + } + Person& add_age(int a){ + age+=a; + return *this; + } + ~Person(){ + delete [] name; + } +private: + char * name; + int age; + SexType sex; +}; + + +int main(){ + Person p("zhangsan",20,Person::BOY); + cout<v-vEc4rTmuD)26qb-cXtV#^!HrP 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 literal 0 HcmV?d00001 diff --git a/english/basic_content/this/img/thiscontrust.png b/english/basic_content/this/img/thiscontrust.png new file mode 100644 index 0000000000000000000000000000000000000000..94aa0d64f9b8d8cc9f57c80d5700c4f158c986b1 GIT binary patch literal 59227 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 D_5-oZ literal 0 HcmV?d00001 diff --git a/english/basic_content/this/person b/english/basic_content/this/person new file mode 100755 index 0000000000000000000000000000000000000000..99a540ec8aaedaff282930946a1ea2071cc4a95a GIT binary patch literal 33952 zcmeHwd3==B)&G5FGGT_qA&>(60qP&Q!oo!^<&-m>ooax+PsJ{ z?j=ymzj=UZ77tyo0yWJjkm89SkKeR^yy2SN@{2V^hx42Fwe9{E zP@`Vsk#oWbspRDu0bf1}{tLj5#OJT0;A5kd>mLO_Zh?@AoD9{gGs%Ezr`k0l0Z!9trs3iDZAs z-`m#d>#Xs$bTpzOTZ8^~U0RkD%~}d@4#ZQ*v^)`NraKVuC8(HM<=YtB8;J#>jYO(9 z#KeHs7>Ww??St6RSzxy>(6ieY_D7-$_-H5wd|<%u^Cv?C5is{LpQ+tmeHaGj` zRn@4KYuc7I`|7Id)1kVm2GzWI^U`H)zS^pJ8ohZli0j#~+Kt!%?b7erzjF{GCRgq@ z@#_Y>#uV6u)i2v;?aQMF-VYov1GG(MdJW=5k;ob3bd8BiO^&$eS#HXpXOR4OJ#+VN z3?B~l36nlK=O(ypo4U)Sf2(|#(9!3Zu215YeRAx{?EjNYyB!0($wKHo8F_^vP(=D_&%i^W>1%Ta-W+lyZC3^!3Qk`=8F+K3 zm9)MLyrpX<3}oO7(_EC=pMf8jfp5L?WoPTPjvW&{s`cuJl8)o=BC++#N1Vqr(W!C2nJUEaP5@zf*!Zo8Ux^ z#9wEesz2e8_@5c4%1;zXd;{X)Lx{^&`%2rvr+2m<{GZk<|9G;!v+ePRj$($;`uM|M z0gr!vtXCbMh>UN9$CWQv>fTR6(HmPU4+FGb`Ifu&;EQ{v+)Gwe@Aw@LGU3zI)ShO4aj15Dr8`r%iF!Nc#{!Jzfv$<~LDFKIO%Ykm6tWO15Xp2clkx!Q3|m%snK zHq>9G#&1N%<1q-f<1t4gP{!Y+qz4ryRIOJoQ7Ok?ZbrT|v)7p6)Kfc7T#P&ncfd4e z2V1YrnK_%%A8a{Z`%vq3El=G?x$ozE;(%1Z&+!w0{Q zBoGz|xK^PiAbghTo0yKoYr&x%{fnXF2ix;ev@V4u5bJdgmRlg@k|lV-SjJg=!LV4% z9X_=5f~A|59z3;lJG*Uh|bya&c|UF9bLJK7Gu*>><3Yvxcd&en(jVLx8}9>lo% zm87Tk*Oq;)Ir!%_2j5%{4yTHK(|YAGqjkYwQh#QL-?n4v_N6m|2her{fZqZ<4EO}# zQ%J9a+D`&52jo12{rg_P7XYonfOf{qxOjsy1`3QR`D2`ij4=hom*KYyWt~j|^BS36 zsToKoeGOz}naW+T!aZr#xV*j2{c6eNbI+bPqk?GCpc|_2HBvYy}F4B)$^<3sIxWTr}J?VOT zi`#Qu&NBDx|8%svYYybLx|^;Xv)1kHcQ-9{*DQ6@_`0E(7*>8_&@_6Xy5}4e4v33H1L52KG47i8u&m1 zA86qJTMg{Tz96pyc^d9Acq9&Ew!DwR9- zvdrhKQ_OgQ2`8KIEi;|_9K5ilA=m%De=5$vVVjpA{ml1hj*eS<^_lX**P-q_g(kt@5$` zBK0|xtMg+^N#d3qC(U@+OgGv5KL^%x?CgRbGu!o96aLABZ<;U{n?$@yOgPJgjV4@S z!c8U&n{bZ_518;a6AH788=f;Q^vvGam5L=(o`$OWs+!8il*DQ;t8J{RsjsT7oud;x zbv3n(HH|e3-hUqw-&v86oj|7L^`zt&?a@eokCE&Vu1zbNK&qf^f z8!81H+A842lz^LV7jW~p1l;m70k^&?;I6%7@XgBweCuNZzP*LDx8EBVaNqR;?*EE_?>r&kyMGt(y$R?l4*P=(1w6c6!1pf^ zaO^Vz9yuo9(f<+f*joY~p9ELqu>YV*zz;VI_|brXAKxJ0iO&o8$s+=O`Ue3|8gM}l z`%@l(T)Wd)F3@F!1&%eY6FAABJh}EM29=X*KhvOEa_!R$DkRrF)66%^%y*XL8#5W| z&1rlco!eQ4pfhLn%Lu!CsAm9qn1Ne$I{C-UU9bV&Bd6~f z$n-Sg#!4h_NRvnbnk0D${Z&XVL~<%kB3#DpKo`~lP`=Rce%;Fpx)$4GvfB%+uJ4))@kZ^r$1Onot(q6+6BqjKad zBrN(75*$Bx3^c`GN5dE9piU*-$Y$iW_z|8MgKl$Iz72w+XVA*Itt`#`IR;lfhcRU) zh*sja7Qejrk)|g3I{QSXQlD>+1i+W=SMntc9^iW)!lUqYLZ;kR_u+mih(3wm=kUwR z;V3(tub~RVNS^#Qn!}jB#y%F68B}_$%-$3tgm~Z+bw(x}HM{CTfbZXi_=fdB;?H>(IohE8!fR zHsgz!4X~gnldG6lZj?w(y#ZQtjx{>+VCp~|uxQlOFO5Zt+t>yI(tpWH$tRsIe(G=0 zPn;#jMu2+I{FF2dWR~y-Y0fm*HJSAKNHn5?S;n0vpAwcJe55R@K~0@YNv zX%>Q^D*Pj&Q_rD7>kTLDhVk`-LcUD_nhZW2rV3+LMxFc2P&}-hi;VvQUuG;{z;e9C z1}K$rO{I$JU@neFwm^>#SB)3tI$X7@1=MX4FwZZb;iQ1ZcLmJP#gxn8Y8o$K;bB3Z z`xya?zAE6n`vff6DJ0%j0n4I-Y~Cwi`4s|Mt`o4bOh{VK63|vBVAXj7);uC4Yo8Rb z?s)<0UleeDL`XJt5R7fOLO|o)QyH88Lx7?$!Us4Wy@MV+cqD!;b_U`m=zW#(J3j)^h|LK2N~M z+XURcO~4%=5^(3o1$^Q@0Y{z`@TtEFc>gBIlAC8Yu0}KG=H(b;rxE5FGX;(@1_U~d zg#um17J*}pn*bg8T`}|yM}A;M1wrV10pW;%?#l%9+#(?IB>@*cC}8(51VrBy&|5N{ z*)OUU(7#DQa*u%2Z36auSHQr}1nfI5;F324TsC$FvtL;z;Hp{ySFaZEksSiANea03 zV*;-GtbiNt1Mv7Z)u}U<&Q8iVg5I z&WfMgF?3WEqEmP(K98`s;=2g%pZ-9OqW{_kl(J2SPLXALFFLJqPH#m{RWSVx464dA zeFJ(NvfT(TbF|_L;8sn472zCX#&U216E$NsJTvCtm(M(c^7rE!P}5#TPzxBZ23^JP zKx0(YLu^|`0^yvBMJUx-aW@hRDo%l~XU0OAJAz?8Y9I_hjB1$-4?qsh@MB3bd;)`n zs`wa!M#W;(##V6x40C3*QYcEb3{hdS4{S{)-=pL$RNKQx$b{1@RWX3#jEV}BWt%aE zwMKR|>!au6kLAc9KoljM}Q$ChiN(XiilhY{cDbMx9lwVJq%FGg?sfcWBR@Fr%KTjc7CX zUNh>Qdkb{qzF0?(&b^wnm+IK6s@IsdU&nHcbNnpzdV{88%)Nu+-efePENEpaz}%&j z`Bsgx&3ze7?f$rq<;;B&mf^lr$J9BiphWjq4E7SE(%;vo+((ToG^cKWO1zz?+~3eB z+uX0C!QJ=jSWYG0(Q|)CN1T;>LD2nxjup(cvDqHhG0!<)V39vDXqZN2SEyULpE6!z zA*%2R77|GHEB7-RWmMuVM&*81$MB}!xD7ADOdR7no)^$5tC?}z-<4RXcqY?&ss%)r z1I&69#cYD0)jxvLIM1l*gM0f4RH7UOs{^Dg*l<9=#v=l@eM`Xhrv>adDPX627Abv| z0(PwisQo0Qoxc9lU=GpgB#Mq8JpQ_cxYu0>_g zvU-j7yBx>wo&%A?{+3=080MtjCX;&mEufz;!%;YwL%*Z2avzwMd;{IiD4O4i)|~hP z?5=3xUr@P;Pas}&t^}vUa}+J%%y8mZlw0H_w)(4JCi7QE-m@Gh9C?4@@ZiXMjiZAj z?{y9ej=aBdOmO7=FNX?8-kTg5%7T$SD(??pgdUmkGbkzl0JzIdm4x8LjH2L+6zFOc zQq(;t#f2ip#Z=L5!TuUkiK1v)pp6(`Rmm@57~pUgI>P@ohf3k_9%KWD$iKtEhpMQO zX=n$i^}onLt92}93Z_~mIJ#On6H+BVLsoEjWsn1x2qp&!j?RJhsY=S&8H(mt!$3?K zw!j8W4iX%l!|SX?{Soj12Q&B1!Q2uYJvZk$Y#7*6am_xIU($o%b0x363E;Zi0OEBq z9@pp4rAz)k9{P5=wjr_PErttR6O7qYr_>R%#cWX!?n;(iA^G#8)m^|N^*>%3cLW-(1`9) zl50#xq^AK6L6tZSO54}418hq2C6a7-n%vyRix`v!8tz~vCm4SO+5U#x&|^vpjlV#L zS2TQ+42ld7xLw(B0gSt3l2L=mH4VQYgK5S|FgVn3DRP#~F}U_U+;9~mXG`Qr!?lc@ zBatsQ+{DOSi5zYC7$a52I)Hl{u3)XJMYe|;U~8(R)@VdIkEo&+)UMdec4%~t`2?$) zfO$@us5mOSoCxcna=ieh=x~mUZ{Saq#kkY;GWwYg7pTUZF})Z@<~wELKIu7{EBN*R z*F=v$DP)lE0%vK*L1^+Q!V7asH+>ZF+>b)Y(#=dh_g0XWZfB};Env7)TSOG{mF^e- zK1VI0A@g^hfty`58oA#D%f&g4NGz#}u0^kB3(0MXlO3gy z9K7d1zS5wv3t?_nq`ojDH?D>t*C+khw}t#=y=E?s9M6?e)cuPLNK1{)=b zyJtFyT$U>DvsB$>lEy8yA!(1W0i! z8HFN#g|PQxs;*C{xHYF0kwxm=2rZOG#r`fL5pQ6y7obqM{28`Ydb@D>RGN!~G7BVI zZx<{4u87EOzf5HY9Y`|lY%p#GN|N&C(yn}>1?~)L35Bhxre{cSjSz6pP`81Zb_Bh; zbds>-Mq)mBYh8Ky8fIy?WNT-V*od?rqo|&f;{JkdaF0-N?=hRo>tNwYN$2icmUQ{T z%KI}CJtRcjvK*AqOs~K|P#TwXZr$m0oplx*Vd-}ziTj(GNkP~|X-bq%ADAyUu}!mq zA3_D1ub>&+N&BuPkr+B_shWSqM*BRClAEN1LaF9gQBvtKrf@=^nerwr;bt=7R%#}< z$yC%SwhMPxGxB&(U@lU+)y|{`(wWi?m`@zE-3iCKJlU(7CST2o6pp zd=0}nuEQ|#$p;yBx>C4L{tt%pUH=0ePrjDn0+$c^ocx~*7rFiji6>vj@Fdq-hOcM1 z%(V{gdh!hndt56}-^n*|WSi}J4$@A(nWkE!3Lk-N-k;F_REVCrRV-Cg%}vzNr>F^T z91m(jx|nL_`=X_Hkv%t*2i0LFd#U@w%*~DF?A+cu8qBAp$k&)IO)DYMo7ui>M(<0g zN2y&%xl27*lJXv8(?4o(-ou|xsz(SuJ?B;o8B3g$zJVx!38^%`|@-^KX|P$}N2HQOoqV%T*=ehjpbZs#OIfszw-9dBvlfg;7Ozg=jpA_kqUeA`E&T775dYBFQk2q$w#w|na^$EoH0$00gV#41G>V={o*C&U1PW_TC@xeHf07Uc126k z0#jyko?NsJ^_wz_{kZ7A;TfjPrhOMJC2h?gN#G@IEhmRX-B8e!d7J?iy+GRe6r`w$ z9F_{-cSx{I_+CJQX5p()0R}G?>{K+- zlmmh-WAG!yHrfh)gVt`$DVPM$S^{^Yc9k`7Z`8E~S<4pCZz)#-+A3Sfu+w!4#g};* zE^r+~hO!k5PjY=5jZ(IfVUKGg^R_ZP+ZAWtHim0l?=tTyhMQb>LsMm|8TPu8Evde!C>=Gxpn~T<rv$5ZnUcnDl88$Rjuw1^{Vn9!#S$xF;J9;&H&AV zg7OQ$0)e<~t?74@u}L3g82`TTRZx`oo~P;eT!M5i@-_WldIOVwfML*I3QYOFUeGjs z6urItMcZ8nFLB!!S`(U9e1#Ap7BSl&SYdw{i5-=?(rHUj45X1XS5 zet~iw;tqcV{%KKfkd3n8!?a9r1lXVIfSYBeMTDg~>&ywY)yzj78cFM|u z`}>l?^ulv6`jsP22y@{mtl3~pQVCRM2aX3p>0^<=7Z?4<=;2IYDNIXsho3QeK={1p_Q zQf58>`|vI$x0TF?GnrI!2e&d@-$I`+xsyTV>OzZ^e1e-A7}mh9lc)K5xjv4aw$n(K5xaumnEo z(MjHO4ImdubMV2BiG2bsQM_2Nd=8|s&GX?yi)E9DPlZg<39y3VLa_oqBr>s+QRCt> zg~3S+o6iu0q1fK5Swc+uUCDH06EmS~CIc_}WpRN)`T3YhHxCV1d3Q4Fqc)n;CMIQd z6{)iK2#HE0|DGZFP5#frpo(7+v2SC#XiK`e_6x6qd+~Isz}M30450$w1}KzTd=Kqj z{JM?#_@v9^T}YJ_32#35(%5BDm}Bu|!Fmr+y33^Yd>AIRSL-|BT8h`%`CLrutD1ie zk5c?~O2nsRCXz1{6yHN6pP6N7W_>-y`MZtJ&~%~eFUJ(5c#XlwX}XHkv+{lqj-EpYQ0bqWvXK?uHlr0=cHu z%QWOoH0QMYPl5~^Ik*=-kABm90LC}%Zq|gm`+AYj&41PWK2v_X3n|?2*C~8DpqiBp zDbF*^X8@*3_@DaI{)<_;hpLfTgihVXe&J4FvhkU*;n4(K+c?qhh_yzAI z=d%Z08ii3)w>ywJ!ysTXpGjm0)AAn0Jjpv#`KTf@^EwK(#2{euh3RC*_-5H00A~#v zzre^n|18X@$8E1;gtoC<@lu=G0ot?i!0Y=`X zpf^@0@a)a-e1k=eBWEN3M%bM3dm!GxFOS7&9f-C`s0yaQJd6on%+XTKpCC-ab#uDca;0qaCA&5;s zM$ong$lLL|;14K>fz2^U%o=X?BS7Yx69|Zyg)DGO4{o2s$esP7pK-@Ar2G-Tt>kLE zv1jY$0(Wh_M&S0XHwxUWwowz=F9sTS*k_}%_-&^!41k9!qz*Q*zP9N=HR6{R_JZHS zYWQSDZ7BxcI|iLB--{?7uF4(ixMK@ay71e|?BuxPE~FVVSU2nC#ZRZH4}oZBpE71r zQ??tu%IAdkTl2g^u{cfl1JLbSj|Ma5kdf`i=&l1O-iq}o|HnaVy$K94y7SC1iN9f%L{|IA@~xk!yEiQLLQ`F9(o%gZqDuBe_3}9Eckg8 za_aKXd<40p$x`IHyk{9ue5D3O@w!|YC zv@cM0HzVj}3l#&CfOR<2!CVPCh#iBBLd%SJVae{!%d`04IlE44D{KO z8*EXy>A`|%zl}3gUfyDK8$6mChaeV|gH^y#&y2ah()kHk7uN_31Jl8qq$8 z_=thtK{?O2dKJfRs7qUBU7prp2TagOE5NR;)sD23jcHCG)JBFerpj1Z=*iRG;sS>l z1D(od1jYQR(=Am-ZDGtk-k31PJ1JOr+cJ@2t3%Zm+MwHQVcjV zBn!l2;Yc^4&|Gp~U&uU)j2WaVNWpNPaY&h&6aUM=$Hgom8V~q!Y8r#UqDEFQ5@#r} z59hA+`a=EvagoD1Jpfug@Q4 zvB@}V0wajwIJ177nWhg?(>RJ4M-b)$p{(Gdu2dwN#2ZmEH3ALTg9z3mn$q;iNN-4o zbUjTjQc;rvLQ@?0FG$ggqW8x8gFrx!S__)ax6+qZF$B@I)k$b1RM!eeeSQ9j*)Eu8 z*{s>BJ37=h*Py3x_aP`kX&lw8{yFdjpBSuKwLB3h8m;T!$~w z6W`kxXPf&{u~Z@ytW&;l1c$@LRWgnP<9Lc48!{G8`uL7=ve%cu8-K{j2B%5l1vMYv z7z^)>1Vdt^d}R$BeSIM9^L6d>CHnk?2KiQQEtLmP3ZwSXxcK0N!+xz3){r=wS=JseR z!Cz+&^q#0r_C&zVhdzzd?FN+O^`v5nNH?s_BQ@o5f3@=w41q(GEs1Kxl5JgUx@uZl z8uqZ%7Bp%i7U=C`U0I_rtDi!q+D6nNz9-Zlj>ciJ{oVM5{Bk(ou!H~VVdKG;_SJ#j z4IQ;O=`S4hcPCUNVRjGbxjWf|lL?{A6}?HF3VnpbC<2C*j0aJbp}oK-a)F=hZ<%7(*lxOrS;4Yj;y&$#^t6Tw*B7pG4y`d~lQ>-xS>tTztRL}GuSryt_=#c3hhrzb*5)6=nT zG|Z&hvo{g&$3&}8YJ<-=#L3pq8xn1+68G7tOJ9rCbSgN7HWYt zNp}bh^x>pRSXT{>ne6cKh1f=`zqGCQ?d^}4{R~YQ@9lzXj7H({AuXucfc-d;lDZ13 z{tynN6d@pe)=88&NV0EVOM8GOX({zzRIt&v*4G_M@;uBA`T&egqTnP|8NpeZ5gdhi zamd%F!srJ<>H6V*f57bFO1eGuZFTrCxFxi;gf*~iha6y~iSx z6M+bn6bVNH=#Vn@fb?HClE0&6!)mrt#*nHTNL#_)-cTd+8dNht^O*4caX%9r!b@=9Yga$e>=E4u0j%hEir)Tf=T@3dj zk~G$9-Gn*aQHi~N3}I`1{$Q{_6jr@m`s7#bPX9&E*G{z`c7yR1y<`u_9xZ z#^#&T1*k2eVxew$|2-j}=n9R737+ou(97x65S>>%Y&aQ$Z>JTqKcxEtkF3S`ob5*8 z2D^O;Kgu0_c&>{kt(K)+GG@TXp| z;T)KTDaFYMKrh{;cwBL^C!WH2g~0@8L*lH57#*iMKKP3+VW8bS{5q>Sbas+CCX)@v zPJgto$FKH;&G8EDWcF&yccRtBcSg|g>?BW+?LG6#pDjEtWmFZ@6%V2QPZIg8> zGHuQ5H|a5&>Z1Sb#hgfm#rv7R zdmQ633z2@#{M3+hlo!!E%+>Q4JzbSUmj%7pvsn3-4$k8`vcIgIiV3yk$xvGtNX2+S|$ON@@nbT|OCxfm)y0q>ZSt^`|@fS@1 zA;cLbd;2(9hpR;E1$5KFtFp+`8XtOFnk+kjx5=KRhzVk%si)A0EoKQZIZ+yuo!ybX zz0z>}H=h99A619Rx_G#eyh5XPmn|Ct@TPnWEruT zLhlRu_pvB(6_*W}7n&<%S$<cM~h`f>hQ{tfxCjPc+w}7!Htd(=r!lQQFt(`7%A=$Q{Kpn)X01Y{nN%#C zt=G~SF6K8EJk95vQ(K#Leuk&AH<^ls&g%}vxWj^|AB&^&^rsy>mEE37Ov28?P7-of zh9PNScV%CHJQ>2c){nG)bO*X2{7KJ(zl`)^Ev@$wxRlb}sZ+eMbXmPxL55^}w|1jZ zCA}&bPs#cG7}YV#MpM1e>PY@$ejwi42QNdfilL(y>h9yw`+6}A!!{>QbOu;62Gs&= z(}dAVNRoxCOwq(?$cgw#Z11GkFPNfWu!dz}T?iR5KW4l}nIouW_m=WReUZqR#?@GWV(Y;{cdR;=Z#%B};P55*Qg>TU-sM8X0L3+js0of(BL+bMf@wEbM ziE*2WV4eo`8Z-c8t&|~as2gLD7z!fjJf|rwzNo-~z+8R(Yv)j`z4 zUV>&=59fY9-Lzc%YAe4ef&D4n)EI;I2E<{4Og2tVTVM?9m}`nNVp|3y{R+Zkd2LOd zQJXy+TpP@7v<_c)JT7ylVQRBB7#8WiwHQX?yC@aGvPnm=oSXhsgP7Zx{VP zg+HyCgkEVzVlBE$4;wAPPljXmBX*Z?B!mtsy+b}wp}V#(jQKLlH0Q6)btA2bPD>!Y zGeSDhja zeFnT~3Ol15GR)4Hxlzi&QATC91MLBZ7LK$3hOlYNfeH;H0FxW|Icv&8gTzw3UmP=? z4x~1>!(`V_t2RU4f3h(Z9&sOnlL0a|9dSlmqZ;P!CVDoS82@7oIc4R(vTef}-3f*+ zCg4$IG2sthm`WtILC8cl+wA7S-dnJhE5l}o*)@F47~eV}0iROHZZ-?kGeQnAvVy_# zn_G{X_voD@V-$ja!Jei#M=smBgl57uT(E8<-jVzd-( zz$d3C(bD35L$^`(B>9CJs~urur?EM!=MqD9XQ6oh2f6iF;CAzE5$lEdhDR6pu9tThHNW=KIU?S!k|W}C(&xWrGPC0`&{HGQ=c=PQ-b_*n z+wsUJoI4WUsjTzZGBernb+dvoBhimdpZ_+LJ}-R^-cWqLI_eyW&l&27Yb3lo{oS>p ze8#DJMra2+UO#Jo)NJ8N84$m;46mV@!S(nU0*wuoq+d((Tj%b6PiIUa;q1z?1%rcOuT2T z7oowc3PIv`W#N|tk1s8$qvlIpl!I3Xeg;lU%x>R{fhV8+S$qx%{ct<^9PlI6>!{Ed zDC^xatK1(8eu}bQGPCf{1J81^-*OuZ0^*0g#WqU0XM)~P6V&l6JLmrpj-+R>8BzWw z5o~z>S}lBr+pS;di-zg5-^5$zW3oJ6R|}uv{e@@Kc+_zFzaI2_$uRr+oZ#V4O#guF za=nhg1nBLkX+PGxh&(s50(i^sTlhzS_n3Jz!84=aUjlw4dENn@{H<{YFD}Y;x6lvw zZv`S}W{Eo7FbckN6nxCYXMcC@X5c-;*{i#OAD`h@@kWGPe9>g2dhsYdk4cjWUIxBk zg!XzHc-ZokBGfSCQ1@R+%A8&z4&+iFkUVJTv?dvt$-QvFq_yX|B z=HDgsnH+TZGT=wDhwDb6|I{e>UbHXEy?5HKA%*bpiIMdAj9G5BeomV7{CZR7)r1D3 zp0n$<1bFh_pGCjR#AotgxK!-Wot`Is+9YU~az_~7v7k#NQ{iwGcc4}^Z}6>Y>*&N6 z2nRnj=);l#`@=Cl6Y~Y*zV2we3%emfY?dT^{uK5{v2_u}1U^_bzhOcB$V7Nn6pP?# zMZbR^mSjon`r$EZZ^#!+_4aZ*FC!-V7DGreXT(Pdz1x zv$+4$?_Af+|o|LpUG|-j6LQ5A!nDK$iL21!d(n82LIZ++#We*aFGUWrBS!F|wncwal zmTGM=)Q+&l@b7-gGpmpgb%}}&|7fV!oALR~p`Y&r5A(a5stS+$u`&e2idJBc6~cNu z)ZeG7@SrtRh3{}y;-P{W!<$c4d>bxU840Q?#(Ml%yjBJG#lTNPY%E9$-eO8%pL0mW zhcxUi`kBED_2GoiDtX3Hgeb@mE{w3*j*MEJU^mET%F zbH2mNBlp3ZHD9qXwFqS9x7OK7Gye>W(1h9fmjnMM&L+3YKWy^~NFD3s^GxXf#^2I;%0 z)^z+JLYeuk{fwh#{*!4+9Vjs47Q7`ZzqRji#H9%>dChET`K|b!S^2GX%TY5wUV9yK zS>;;D&t&Dd_EGNP0vngfMn`bZuK!)YvHn*3J!HZk@JO9_R@;_zfx4!Sb z{a@sNFe|^ce^Y~(_0j-*#1`hhX`cKZ|(E&_(@*YI!wnjtraHxHGU+u)NHL+ zt?$KW>pQzWUqW8|FIPIhwXg6N{}&rqHhp&dZ=j+4R{81uC3CALn?5`K7V=ts6T$R8 zl+(ARKBLR6aNTX73kPSc^!&9N{VX6IipO8%d%()2G`1DDArJO9d2 z^5564Gpw={J4*fzGk>=J?43Hpi}?4%%*!g@f;&ek|2PLGT&5U0g1eQ^La={li6}`& w_i2h~R)(yo@UwiM#gnipYQ|g|&IDM9pJjj6_{HRr%5O^Pd;?hyGrRo%1H+ujoB#j- literal 0 HcmV?d00001 diff --git a/english/basic_content/this/person.cpp b/english/basic_content/this/person.cpp new file mode 100644 index 0000000..613dab9 --- /dev/null +++ b/english/basic_content/this/person.cpp @@ -0,0 +1,41 @@ +#include +#include + + +using namespace std; +class Person{ +public: + typedef enum { + BOY = 0, + GIRL + }SexType; + Person(char *n, int a,SexType s){ + name=new char[strlen(n)+1]; + strcpy(name,n); + age=a; + sex=s; + } + int get_age() const{ + + return this->age; + } + Person& add_age(int a){ + age+=a; + return *this; + } + ~Person(){ + delete [] name; + } +private: + char * name; + int age; + SexType sex; +}; + + +int main(){ + Person p("zhangsan",20,Person::BOY); + cout<6ZoOH=3|u&OIbf?ah;46;1y8<)+A7 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 +/** + * 默认访问控制符为public + */ +union UnionTest { + /** + * 可以含有构造函数、析构函数 + */ + UnionTest() : i(10) {print(i);}; + ~UnionTest(){}; + int i; +private: + void print(int i){std::cout< +#define isNs1 1 +//#define isGlobal 2 +using namespace std; +void func() +{ + cout<<"::func"< +using namespace std; + +class Base{ + public: + void f(){ cout<<"f()"< V1; +using V2 = vector; +``` +完整代码见：[using_typedef.cpp](using_typedef.cpp) diff --git a/english/basic_content/using/derived_base b/english/basic_content/using/derived_base new file mode 100755 index 0000000000000000000000000000000000000000..952568af0a1cd97323845d08059ce62a05e48c01 GIT binary patch literal 15168 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 + +using namespace std; + +class Base1 { + public: + Base1():value(10) {} + virtual ~Base1() {} + void test1() { cout << "Base test1..." << endl; } + protected: // 保护 + int value; +}; +// 默认为私有继承 +class Derived1 : Base1 { + public: + void test2() { cout << "value is " << value << endl; } +}; + +class Base { + public: + Base():value(20) {} + virtual ~Base() {} + void test1() { cout << "Base test1..." << endl; } + private: //私有 + int value; +}; + +/** + * 子类对父类成员的访问权限跟如何继承没有任何关系， + * “子类可以访问父类的public和protected成员，不可以访问父类的private成员”——这句话对任何一种继承都是成立的。 + * + */ +class Derived : Base { + public: + using Base::value; + void test2() { cout << "value is " << value << endl; } +}; + + +int main() +{ + Derived1 d1; + d1.test2(); + + Derived d; + d.test2(); + return 0; +} diff --git a/english/basic_content/using/using_derived b/english/basic_content/using/using_derived new file mode 100755 index 0000000000000000000000000000000000000000..641ac8b671a8dd7bbec9bff9af71cb9a96e8fb1a GIT binary patch literal 9320 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 +using namespace std; + +class Base{ + public: + void f(){ cout<<"f()"<+(q@SZjFG-Lwv%{s?96^H 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 +#define isNs1 1 +//#define isGlobal 2 +using namespace std; +void func() +{ + cout<<"::func"<$2Dn7ptW{o{#oTL|f_yO|3QWx6j$< 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 Sx$0lXFGzfqoZFV1_5VK+_sQ1) literal 0 HcmV?d00001 diff --git a/english/basic_content/using/using_typedef.cpp b/english/basic_content/using/using_typedef.cpp new file mode 100644 index 0000000..5807122 --- /dev/null +++ b/english/basic_content/using/using_typedef.cpp @@ -0,0 +1,34 @@ +/** + * @file using_typedef.cpp + * @brief g++ -o using_typedef using_typedef.cpp -std=c++11 + * 取代typedef，使用using来定义别名 + * @author 光城 + * @version v1 + * @date 2019-08-07 + */ + +#include +#include +using namespace std; + +typedef vector V1; +using V2 = vector; + + +int main() +{ + int nums1[] = {1,2,3,4,5,6}; + V1 vec1(nums1,nums1+sizeof(nums1)/sizeof(int)); + int nums2[] = {5,7,6}; + V2 vec2(nums2,nums2+sizeof(nums2)/sizeof(int)); + + for(auto i:vec1) + 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

~~bC(%AqPQcOLZGjZLb7%$ zAp*n=#PS0okT{xwJ&T$-t7SNu%VQy|U<|b7lIa*JsM=846ajgi1E>a$WWgfm6yLO9 zLnteU7f24MC3+wMBg|Q<)>>_8aQ%qROX$AWM_Kvv!Nw+2iCKb>mx$^!Q@2@FX972VD1F$~tbI|W$Dw7l(6xwg2 zD(my_mHUC=r(Q{)_d{d`C~)47Lsb@Kj#=>_YP1)|{qw%bR<*&mT}k5Si7YI~^dX?M zx5m7-RFiU=(vM2c@}Febe+3JAAEubH{z;{O(xK1&vp$dixYBQCgUd9lrZx!AE1dL6 z$Ep8iU=$P8U1?wEywc}=Qi#YxzS>I>j9tI9|D!rOX%|MF-;bDn&7sfxL?@L#`^#pW z{L>D7ejj~734Wg@hplkG4E;4KcK`W3F`+h?`8|^5o#TH_>GSpD_p~9U{{|~6>h%A6 z4t?Io;=jM4_}GiH|I=tB|G9tO?>etG#2@7bWyIP4Pl0>!;V|+30{=aZGhR-8%IaNh z)93xO+N}UlobpcoB4o&a?w|Lmd>>Q)SJ0)o%lf>Z%zrO+fsCW@{O107T$5 +using namespace std; + + +class Employee +{ + public: + virtual void raiseSalary() + { + cout<<0<raiseSalary(); // Polymorphic Call: Calls raiseSalary() + // according to the actual object, not + // according to the type of pointer +} +int main(){ + Employee *emp[]={new Manager(),new Engineer}; + globalRaiseSalary(emp,2); + return 0; +} diff --git a/english/basic_content/virtual/set2/default_arg.cpp b/english/basic_content/virtual/set2/default_arg.cpp new file mode 100644 index 0000000..4797818 --- /dev/null +++ b/english/basic_content/virtual/set2/default_arg.cpp @@ -0,0 +1,39 @@ +/** + * @file first_example.cpp + * @brief 虚函数中默认参数 + * 规则：虚函数是动态绑定的，默认参数是静态绑定的。默认参数的使用需要看指针或者应用本身的类型，而不是对象的类型！ + * @author 光城 + * @version v1 + * @date 2019-07-24 + */ + +#include +using namespace std; + +class Base +{ + public: + virtual void fun ( int x = 10 ) + { + cout << "Base::fun(), x = " << x << endl; + } +}; + +class Derived : public Base +{ + public: + virtual void fun ( int x=20 ) + { + cout << "Derived::fun(), x = " << x << endl; + } +}; + + +int main() +{ + Derived d1; + Base *bp = &d1; + bp->fun(); // 10 + return 0; +} + diff --git a/english/basic_content/virtual/set3/copy_consrtuct.cpp b/english/basic_content/virtual/set3/copy_consrtuct.cpp new file mode 100644 index 0000000..e65ca89 --- /dev/null +++ b/english/basic_content/virtual/set3/copy_consrtuct.cpp @@ -0,0 +1,41 @@ +#include +using namespace std; + +class Base +{ + public: + +}; + +class Derived : public Base +{ + public: + Derived() + { + cout << "Derived created" << endl; + } + + Derived(const Derived &rhs) + { + cout << "Derived created by deep copy" << endl; + } + + ~Derived() + { + cout << "Derived destroyed" << endl; + } +}; + +int main() +{ + Derived s1; + + Derived s2 = s1; // Compiler invokes "copy constructor" + // Type of s1 and s2 are concrete to compiler + + // How can we create Derived1 or Derived2 object + // from pointer (reference) to Base class pointing Derived object? + + return 0; +} + diff --git a/english/basic_content/virtual/set3/full_virde.cpp b/english/basic_content/virtual/set3/full_virde.cpp new file mode 100644 index 0000000..d4ef7a8 --- /dev/null +++ b/english/basic_content/virtual/set3/full_virde.cpp @@ -0,0 +1,39 @@ +/** + * @file full_virde.cpp + * @brief 将基类的析构函数声明为虚函数 + * 输出结果： + * Constructing base + * Constructing derived + * Destructing derived + * Destructing base + * @author 光城 + * @version v1 + * @date 2019-07-24 + */ +#include + +using namespace std; + +class base { + public: + base() + { cout<<"Constructing base \n"; } + virtual ~base() + { cout<<"Destructing base \n"; } +}; + +class derived: public base { + public: + derived() + { cout<<"Constructing derived \n"; } + ~derived() + { cout<<"Destructing derived \n"; } +}; + +int main(void) +{ + derived *d = new derived(); + base *b = d; + delete b; + return 0; +} diff --git a/english/basic_content/virtual/set3/inline_virtual.cpp b/english/basic_content/virtual/set3/inline_virtual.cpp new file mode 100644 index 0000000..1ec1a06 --- /dev/null +++ b/english/basic_content/virtual/set3/inline_virtual.cpp @@ -0,0 +1,35 @@ +#include +using namespace std; +class Base +{ + public: + inline virtual void who() + { + cout << "I am Base\n"; + } + virtual ~Base() {} +}; +class Derived : public Base +{ + public: + inline void who() // 不写inline时隐式内联 + { + cout << "I am Derived\n"; + } +}; + +int main() +{ + // 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。 + Base b; + b.who(); + + // 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。 + Base *ptr = new Derived(); + ptr->who(); + + // 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。 + delete ptr; + + return 0; +} diff --git a/english/basic_content/virtual/set3/static_error.cpp b/english/basic_content/virtual/set3/static_error.cpp new file mode 100644 index 0000000..5a79667 --- /dev/null +++ b/english/basic_content/virtual/set3/static_error.cpp @@ -0,0 +1,13 @@ +/** + * @file static_error.cpp + * @brief 静态函数不可以声明为虚函数，同时也不能被const和volatile关键字修饰! + * 原因如下： + * static成员函数不属于任何类对象或类实例，所以即使给此函数加上virutal也是没有任何意义 + * 虚函数依靠vptr和vtable来处理。vptr是一个指针，在类的构造函数中创建生成，并且只能用this指针来访问它，静态成员函数没有this指针，所以无法访问vptr。 + * @author 光城 + * @version v1 + * @date 2019-07-24 + */ + +virtual static void fun() { } +static void fun() const { } diff --git a/english/basic_content/virtual/set3/vir_con.cpp b/english/basic_content/virtual/set3/vir_con.cpp new file mode 100644 index 0000000..78c4a07 --- /dev/null +++ b/english/basic_content/virtual/set3/vir_con.cpp @@ -0,0 +1,206 @@ +/** + * @file vir_con.cpp + * @brief 构造函数不可以声明为虚函数。同时除了inline之外，构造函数不允许使用其它任何关键字。 + * + * 为什么构造函数不可以为虚函数？ + * + * 尽管虚函数表vtable是在编译阶段就已经建立的，但指向虚函数表的指针vptr是在运行阶段实例化对象时才产生的。 如果类含有虚函数，编译器会在构造函数中添加代码来创建vptr。 问题来了，如果构造函数是虚的，那么它需要vptr来访问vtable，可这个时候vptr还没产生。 因此，构造函数不可以为虚函数。 + * 我们之所以使用虚函数，是因为需要在信息不全的情况下进行多态运行。而构造函数是用来初始化实例的，实例的类型必须是明确的。 + * 因此，构造函数没有必要被声明为虚函数。 + * 尽管构造函数不可以为虚函数，但是有些场景下我们确实需要 “Virtual Copy Constructor”。 “虚复制构造函数”的说法并不严谨，其只是一个实现了对象复制的功能的类内函数。 举一个应用场景，比如剪切板功能。 复制内容作为基类，但派生类可能包含文字、图片、视频等等。 我们只有在程序运行的时候才知道我们需要复制的具体是什么类型的数据。 + * + * @author 光城 + * @version v1 + * @date 2019-07-24 + */ + +#include +using namespace std; + +//// LIBRARY SRART +class Base +{ + public: + Base() { } + + virtual // Ensures to invoke actual object destructor + ~Base() { } + + virtual void ChangeAttributes() = 0; + + // The "Virtual Constructor" + static Base *Create(int id); + + // The "Virtual Copy Constructor" + virtual Base *Clone() = 0; +}; + +class Derived1 : public Base +{ + public: + Derived1() + { + cout << "Derived1 created" << endl; + } + + Derived1(const Derived1& rhs) + { + cout << "Derived1 created by deep copy" << endl; + } + + ~Derived1() + { + cout << "~Derived1 destroyed" << endl; + } + + void ChangeAttributes() + { + cout << "Derived1 Attributes Changed" << endl; + } + + Base *Clone() + { + return new Derived1(*this); + } +}; + +class Derived2 : public Base +{ + public: + Derived2() + { + cout << "Derived2 created" << endl; + } + + Derived2(const Derived2& rhs) + { + cout << "Derived2 created by deep copy" << endl; + } + + ~Derived2() + { + cout << "~Derived2 destroyed" << endl; + } + + void ChangeAttributes() + { + cout << "Derived2 Attributes Changed" << endl; + } + + Base *Clone() + { + return new Derived2(*this); + } +}; + +class Derived3 : public Base +{ + public: + Derived3() + { + cout << "Derived3 created" << endl; + } + + Derived3(const Derived3& rhs) + { + cout << "Derived3 created by deep copy" << endl; + } + + ~Derived3() + { + cout << "~Derived3 destroyed" << endl; + } + + void ChangeAttributes() + { + cout << "Derived3 Attributes Changed" << endl; + } + + Base *Clone() + { + return new Derived3(*this); + } +}; + +// We can also declare "Create" outside Base. +// But is more relevant to limit it's scope to Base +Base *Base::Create(int id) +{ + // Just expand the if-else ladder, if new Derived class is created + // User need not be recompiled to create newly added class objects + + if( id == 1 ) + { + return new Derived1; + } + else if( id == 2 ) + { + return new Derived2; + } + else + { + return new Derived3; + } +} +//// LIBRARY END + +//// UTILITY SRART +class User +{ + public: + User() : pBase(0) + { + // Creates any object of Base heirarchey at runtime + + int input; + + cout << "Enter ID (1, 2 or 3): "; + cin >> input; + + while( (input != 1) && (input != 2) && (input != 3) ) + { + cout << "Enter ID (1, 2 or 3 only): "; + cin >> input; + } + + // Create objects via the "Virtual Constructor" + pBase = Base::Create(input); + } + + ~User() + { + if( pBase ) + { + delete pBase; + pBase = 0; + } + } + + void Action() + { + // Duplicate current object + Base *pNewBase = pBase->Clone(); + + // Change its attributes + pNewBase->ChangeAttributes(); + + // Dispose the created object + delete pNewBase; + } + + private: + Base *pBase; +}; + +//// UTILITY END + +//// Consumer of User (UTILITY) class +int main() +{ + User *user = new User(); + + user->Action(); + + delete user; +} + diff --git a/english/basic_content/virtual/set3/vir_de.cpp b/english/basic_content/virtual/set3/vir_de.cpp new file mode 100644 index 0000000..79c7c65 --- /dev/null +++ b/english/basic_content/virtual/set3/vir_de.cpp @@ -0,0 +1,41 @@ +/** + * @file vir_de.cpp + * @brief 派生类的析构函数没有被调用! + * 输出结果： + * Constructing base + * Constructing derived + * Destructing base + * @author 光城 + * @version v1 + * @date 2019-07-24 + */ + +// CPP program without virtual destructor +// causing undefined behavior +#include + +using namespace std; + +class base { + public: + base() + { cout<<"Constructing base \n"; } + ~base() + { cout<<"Destructing base \n"; } +}; + +class derived: public base { + public: + derived() + { cout<<"Constructing derived \n"; } + ~derived() + { cout<<"Destructing derived \n"; } +}; + +int main(void) +{ + derived *d = new derived(); + base *b = d; + delete b; + return 0; +} diff --git a/english/basic_content/virtual/set3/virtual_function.cpp b/english/basic_content/virtual/set3/virtual_function.cpp new file mode 100644 index 0000000..1b6d039 --- /dev/null +++ b/english/basic_content/virtual/set3/virtual_function.cpp @@ -0,0 +1,33 @@ +/** + * @file virtual_function.cpp + * @brief 虚函数可以被私有化，但有一些细节需要注意。 + * 基类指针指向继承类对象，则调用继承类对象的函数； + * int main()必须声明为Base类的友元，否则编译失败。 编译器报错： ptr无法访问私有函数。 + * 当然，把基类声明为public， 继承类为private，该问题就不存在了。----> 见另外一个例子！ + * @author 光城 + * @version v1 + * @date 2019-07-24 + */ + +#include +using namespace std; + +class Derived; + +class Base { + private: + virtual void fun() { cout << "Base Fun"; } + friend int main(); +}; + +class Derived: public Base { + public: + void fun() { cout << "Derived Fun"; } +}; + +int main() +{ + Base *ptr = new Derived; + ptr->fun(); + return 0; +} diff --git a/english/basic_content/virtual/set3/virtual_function1.cpp b/english/basic_content/virtual/set3/virtual_function1.cpp new file mode 100644 index 0000000..27648e1 --- /dev/null +++ b/english/basic_content/virtual/set3/virtual_function1.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; + +class Derived; + +class Base { + public: + virtual void fun() { cout << "Base Fun"; } + // friend int main(); +}; + +class Derived: public Base { + private: + void fun() { cout << "Derived Fun"; } +}; + +int main() +{ + Base *ptr = new Derived; + ptr->fun(); + return 0; +} diff --git a/english/basic_content/virtual/set3/virtual_inline.cpp b/english/basic_content/virtual/set3/virtual_inline.cpp new file mode 100644 index 0000000..ac89964 --- /dev/null +++ b/english/basic_content/virtual/set3/virtual_inline.cpp @@ -0,0 +1,44 @@ +/** + * @file virtual_inline.cpp + * @brief 通常类成员函数都会被编译器考虑是否进行内联。 + * 但通过基类指针或者引用调用的虚函数必定不能被内联。 + * 当然，实体对象调用虚函数或者静态调用时可以被内联，虚析构函数的静态调用也一定会被内联展开。 + * @author 光城 + * @version v1 + * @date 2019-07-24 + */ + +#include +using namespace std; +class Base +{ + public: + virtual void who() + { + cout << "I am Base\n"; + } +}; +class Derived: public Base +{ + public: + void who() + { + cout << "I am Derived\n"; + } +}; + +int main() +{ + // note here virtual function who() is called through + // object of the class (it will be resolved at compile + // time) so it can be inlined. + Base b; + b.who(); + + // Here virtual function is called through pointer, + // so it cannot be inlined + Base *ptr = new Derived(); + ptr->who(); + + return 0; +} diff --git a/english/basic_content/virtual/set4/rtti b/english/basic_content/virtual/set4/rtti new file mode 100755 index 0000000000000000000000000000000000000000..c7cb891947c159533e2642f0e4a220670dcf1fcf GIT binary patch literal 14944 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 Nc;HR8SZ~FO{{~3pA-Mnm literal 0 HcmV?d00001 diff --git a/english/basic_content/virtual/set4/rtti.cpp b/english/basic_content/virtual/set4/rtti.cpp new file mode 100644 index 0000000..649687e --- /dev/null +++ b/english/basic_content/virtual/set4/rtti.cpp @@ -0,0 +1,34 @@ +/** + * @file rtti.cpp + * @brief 在面向对象程序设计中，有时我们需要在运行时查询一个对象是否能作为某种多态类型使用。与Java的instanceof，以及C#的as、is运算符类似，C++提供了dynamic_cast函数用于动态转型。相比C风格的强制类型转换和C++ reinterpret_cast，dynamic_cast提供了类型安全检查，是一种基于能力查询(Capability Query)的转换，所以在多态类型间进行转换更提倡采用dynamic_cast + * @author 光城 + * @version v1 + * @date 2019-07-24 + */ + +// CPP program to illustrate +// // Run Time Type Identification +#include +#include +using namespace std; +class B { virtual void fun() {} }; +class D: public B { }; + +int main() +{ + B *b = new D; // 向上转型 + B &obj = *b; + D *d = dynamic_cast(b); // 向下转型 + if(d != NULL) + cout << "works"<(obj); + cout << "works"< +int main(void) +{ + const int local = 10; + int *ptr = (int*) &local; + + printf("Initial value of local : %d \n", local); + + *ptr = 100; + + printf("Modified value of local: %d \n", local); + + return 0; +} diff --git a/english/basic_content/volatile/nv b/english/basic_content/volatile/nv new file mode 100755 index 0000000000000000000000000000000000000000..b5eb220e6d350b522a09a8eefe268b6282a9a874 GIT binary patch literal 8672 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 + +int main(void) +{ + const volatile int local = 10; + int *ptr = (int*) &local; + + printf("Initial value of local : %d \n", local); + + *ptr = 100; + + printf("Modified value of local: %d \n", local); + + return 0; +} diff --git a/english/basic_content/vptr_vtable/README.md b/english/basic_content/vptr_vtable/README.md new file mode 100644 index 0000000..1b82cc6 --- /dev/null +++ b/english/basic_content/vptr_vtable/README.md @@ -0,0 +1,219 @@ +# 深入浅出C++虚函数的vptr与vtable + +## 关于作者： + +个人公众号： + +![](../img/wechat.jpg) + + + +## 1.基础理论 + +为了实现虚函数，C ++使用一种称为虚拟表的特殊形式的后期绑定。该虚拟表是用于解决在动态/后期绑定方式的函数调用函数的查找表。虚拟表有时会使用其他名称，例如“vtable”，“虚函数表”，“虚方法表”或“调度表”。 + +虚拟表实际上非常简单，虽然用文字描述有点复杂。首先，**每个使用虚函数的类（或者从使用虚函数的类派生）都有自己的虚拟表**。该表只是编译器在编译时设置的静态数组。虚拟表包含可由类的对象调用的每个虚函数的一个条目。此表中的每个条目只是一个函数指针，指向该类可访问的派生函数。 + +其次，编译器还会添加一个隐藏指向基类的指针，我们称之为vptr。vptr在创建类实例时自动设置，以便指向该类的虚拟表。与this指针不同，this指针实际上是编译器用来解析自引用的函数参数，vptr是一个真正的指针。 + +因此，它使每个类对象的分配大一个指针的大小。这也意味着vptr由派生类继承，这很重要。 + +## 2.实现与内部结构 + +下面我们来看自动与手动操纵vptr来获取地址与调用虚函数！ + +开始看代码之前，为了方便大家理解，这里给出调用图： + +![base](./img/base.jpg) + +代码全部遵循标准的注释风格，相信大家看了就会明白，不明白的话，可以留言！ + +```c++ +/** + * @file vptr1.cpp + * @brief C++虚函数vptr和vtable + * 编译：g++ -g -o vptr vptr1.cpp -std=c++11 + * @author 光城 + * @version v1 + * @date 2019-07-20 + */ + +#include +#include +using namespace std; + +/** + * @brief 函数指针 + */ +typedef void (*Fun)(); + +/** + * @brief 基类 + */ +class Base +{ + public: + Base(){}; + virtual void fun1() + { + cout << "Base::fun1()" << endl; + } + virtual void fun2() + { + cout << "Base::fun2()" << endl; + } + virtual void fun3(){} + ~Base(){}; +}; + +/** + * @brief 派生类 + */ +class Derived: public Base +{ + public: + Derived(){}; + void fun1() + { + cout << "Derived::fun1()" << endl; + } + void fun2() + { + cout << "DerivedClass::fun2()" << endl; + } + ~Derived(){}; +}; +/** + * @brief 获取vptr地址与func地址,vptr指向的是一块内存，这块内存存放的是虚函数地址，这块内存就是我们所说的虚表 + * + * @param obj + * @param offset + * + * @return + */ +Fun getAddr(void* obj,unsigned int offset) +{ + cout<<"======================="<fun1(); + cout<<"基类引用指向基类实例并调用虚函数"<fun1(); +``` + +其过程为：首先程序识别出fun1()是个虚函数，其次程序使用pt->vptr来获取Derived的虚拟表。第三，它查找Derived虚拟表中调用哪个版本的fun1()。这里就可以发现调用的是Derived::fun1()。因此pt->fun1()被解析为Derived::fun1()! + +除此之外，上述代码大家会看到，也包含了手动获取vptr地址，并调用vtable中的函数，那么我们一起来验证一下上述的地址与真正在自动调用vtable中的虚函数，比如上述`pt->fun1()`的时候，是否一致！ + +这里采用gdb调试，在编译的时候记得加上`-g`。 + +通过`gdb vptr`进入gdb调试页面，然后输入`b Derived::fun1`对fun1打断点，然后通过输入r运行程序到断点处，此时我们需要查看调用栈中的内存地址，通过`disassemable fun1`可以查看当前有关fun1中的相关汇编代码，我们看到了`0x0000000000400ea8`，然后再对比上述的结果会发现与手动调用的fun1一致，fun2类似，以此证明代码正确! + +gdb调试信息如下： + +```c++ +(gdb) b Derived::fun1 +Breakpoint 1 at 0x400eb4: file vptr1.cpp, line 23. +(gdb) r +Starting program: /home/light/Program/CPlusPlusThings/virtual/pure_virtualAndabstract_class/vptr +基类对象直接调用 +Base::fun1() +基类引用指向派生类实例 +Base::fun1() +基类指针指向派生类实例并调用虚函数 + +Breakpoint 1, Derived::fun1 (this=0x614c20) at vptr1.cpp:23 +23 cout << "Derived::fun1()" << endl; +(gdb) disassemble fun1 +Dump of assembler code for function Derived::fun1(): + 0x0000000000400ea8 <+0>: push %rbp + 0x0000000000400ea9 <+1>: mov %rsp,%rbp + 0x0000000000400eac <+4>: sub $0x10,%rsp + 0x0000000000400eb0 <+8>: mov %rdi,-0x8(%rbp) +=> 0x0000000000400eb4 <+12>: mov $0x401013,%esi + 0x0000000000400eb9 <+17>: mov $0x602100,%edi + 0x0000000000400ebe <+22>: callq 0x4009d0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt> + 0x0000000000400ec3 <+27>: mov $0x400a00,%esi + 0x0000000000400ec8 <+32>: mov %rax,%rdi + 0x0000000000400ecb <+35>: callq 0x4009f0 <_ZNSolsEPFRSoS_E@plt> + 0x0000000000400ed0 <+40>: nop + 0x0000000000400ed1 <+41>: leaveq + 0x0000000000400ed2 <+42>: retq +End of assembler dump. +(gdb) disassemble fun2 +Dump of assembler code for function Derived::fun2(): + 0x0000000000400ed4 <+0>: push %rbp + 0x0000000000400ed5 <+1>: mov %rsp,%rbp + 0x0000000000400ed8 <+4>: sub $0x10,%rsp + 0x0000000000400edc <+8>: mov %rdi,-0x8(%rbp) + 0x0000000000400ee0 <+12>: mov $0x401023,%esi + 0x0000000000400ee5 <+17>: mov $0x602100,%edi + 0x0000000000400eea <+22>: callq 0x4009d0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt> + 0x0000000000400eef <+27>: mov $0x400a00,%esi + 0x0000000000400ef4 <+32>: mov %rax,%rdi + 0x0000000000400ef7 <+35>: callq 0x4009f0 <_ZNSolsEPFRSoS_E@plt> + 0x0000000000400efc <+40>: nop + 0x0000000000400efd <+41>: leaveq + 0x0000000000400efe <+42>: retq +End of assembler dump. +``` + diff --git a/english/basic_content/vptr_vtable/img/base.jpg b/english/basic_content/vptr_vtable/img/base.jpg new file mode 100644 index 0000000000000000000000000000000000000000..669f2a053c32663bb767dd3cbe2cfdc21463f661 GIT binary patch literal 136050 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 QwxG;`WBX%%x^Vq}0ox`K +#include +using namespace std; + +/** + * @brief 函数指针 + */ +typedef void (*Fun)(); + + +/** + * @brief 基类 + */ +class Base +{ + public: + Base(){}; + virtual void fun1() + { + cout << "Base::fun1()" << endl; + } + virtual void fun2() + { + cout << "Base::fun2()" << endl; + } + virtual void fun3(){} + ~Base(){}; +}; + + +/** + * @brief 派生类 + */ +class Derived: public Base +{ + public: + Derived(){}; + void fun1() + { + cout << "Derived::fun1()" << endl; + } + void fun2() + { + cout << "DerivedClass::fun2()" << endl; + } + ~Derived(){}; +}; + +/** + * @brief 获取vptr地址与func地址,vptr指向的是一块内存，这块内存存放的是虚函数地址，这块内存就是我们所说的虚表 + * + * @param obj + * @param offset + * + * @return + */ +Fun getAddr(void* obj,unsigned int offset) +{ + cout<<"======================="<fun1(); + cout<<"基类引用指向基类实例并调用虚函数"<