\n\n/// 重定义一个函数指针类型\ntypedef void (*pf) ();\n\n/**\n * @brief 父类 \n */ \ntypedef struct _A\n{\n pf _f;\n}A;\n\n\n/**\n * @brief 子类\n */\ntypedef struct _B\n{ \n A _b; ///< 在子类中定义一个基类的对象即可实现对父类的继承。 \n}B;\n\nvoid FunA() \n{\n printf(\"%s\\n\",\"Base A::fun()\");\n}\n\nvoid FunB() \n{\n printf(\"%s\\n\",\"Derived B::fun()\");\n}\n\n\nint main() \n{\n A a;\n B b;\n\n a._f = FunA;\n b._b._f = FunB;\n\n A *pa = &a;\n pa->_f();\n pa = (A *)&b; /// 让父类指针指向子类的对象,由于类型不匹配所以要进行强转 \n pa->_f();\n return 0;\n}\n"
},
{
"path": "basic_content/const/BUILD",
"content": "# please run `bazel run basic_content/const:const_function`\n# please run `bazel run basic_content/const:const_num`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\n# Don't panic if you get compilation errors, this is what this code demonstrates, as expected.\ncc_binary(\n name = \"const_function\",\n srcs = [\"const_function.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\n# Don't panic if you get compilation errors, this is what this code demonstrates, as expected.\ncc_binary(\n name = \"const_num\",\n srcs = [\"const_num.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/const/README.md",
"content": "## 关于作者\n\n微信公众号：\n\n\n\n## 1.const含义\n\n常类型是指使用类型修饰符**const**说明的类型，常类型的变量或对象的值是不能被更新的。\n\n## 2.const作用\n\n+ 可以定义常量\n\n```cpp\nconst int a=100;\n```\n\n+ 类型检查\n\n + const常量与`#define`宏定义常量的区别：\n > const常量具有类型，编译器可以进行安全检查；#define宏定义没有数据类型，只是简单的字符串替换，不能进行安全检查。感谢两位大佬指出这里问题，见：[issue](https://github.com/Light-City/CPlusPlusThings/issues/5)\n\n + const常量支持所有类型。\n + 其他情况下它只是一个 `const` 限定的变量，不要将与常量混淆。\n\n+ 防止修改，起保护作用，增加程序健壮性\n\n```cpp\nvoid f(const int i){\n i++; // error!\n}\n```\n\n+ 可以节省空间，避免不必要的内存分配\n\n + const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是像`#define`一样给出的是立即数。\n + const定义的常量在程序运行过程中只有一份拷贝，而`#define`定义的常量在内存中有若干个拷贝。\n\n## 3.const对象默认为文件局部变量\n\n注意：非const变量默认为extern。要使const变量能够在其他文件中访问，必须在文件中显式地指定它为extern。
\n\n> 未被const修饰的变量在不同文件的访问\n\n```cpp\n// file1.cpp\nint ext;\n// file2.cpp\n#include\n\nextern int ext;\nint main(){\n std::cout<<(ext+10)< const常量在不同文件的访问\n\n```cpp\n// extern_file1.cpp\nextern const int ext=12;\n// extern_file2.cpp\n#include\nextern const int ext;\nint main(){\n std::cout< 小结：
可以发现未被const修饰的变量不需要extern显式声明！而const常量需要显式声明extern，并且需要做初始化！因为常量在定义后就不能被修改，所以定义时必须初始化。\n\n## 4.定义常量\n\n```c++\nconst int b = 10;\nb = 0; // error: assignment of read-only variable ‘b’\nconst string s = \"helloworld\";\nconst int i,j=0 // error: uninitialized const ‘i’\n```\n\n上述有两个错误：\n+ b 为常量，不可更改！\n+ i 为常量，必须进行初始化！(因为常量在定义后就不能被修改，所以定义时必须初始化。)\n\n## 5.指针与const\n\n与指针相关的const有四种：\n\n```c++\nconst char * a; // 指向const对象的指针或者说指向常量的指针。\nchar const * a; // 同上\nchar * const a; // 指向类型对象的const指针。或者说常指针、const指针。\nconst char * const a; // 指向const对象的const指针。\n```\n\n> **小结：**
\n> 如果*const*位于`*`的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；
如果const位于`*`的右侧，*const*就是修饰指针本身，即指针本身是常量。\n\n**另一种解读方式**
\n利用英文从右边往左边读，并且以to为分界，to之前为描述指针的特性，to之后为描述目标的特性
\n```c++\nconst char * p; //p is a pointer to const char\nchar const * p; //同上\nchar * const p; //p is a const pointer to char\nconst char * const p; //p is a const pointer to const char\n```\n当指针被加上const特性，则指针不可改变指向的地址
\n当指向的目标特性为char，则内容可以透过指针被修改，如: *char='y';
\n当指向的目标特性为const char，则内容不可透过指针修改
\n\n具体使用如下：\n\n（1） **指向常量的指针**\n\n```cpp\nconst int *ptr;\n*ptr = 10; // error\n```\n\nptr是一个指向int类型const对象的指针，const定义的是int类型，也就是ptr所指向的对象类型，而不是ptr本身，所以ptr可以不用赋初始值。但是不能通过ptr去修改所指对象的值。\n\n除此之外，也不能使用void`*`指针保存const对象的地址，必须使用const void`*`类型的指针保存const对象的地址。\n\n```c++\nconst int p = 10;\nconst void * vp = &p;\nvoid *vp = &p; // error\n```\n\n另外一个重点是：**允许把非const对象的地址赋给指向const对象的指针**。\n\n将非const对象的地址赋给const对象的指针:\n\n```c++\nconst int *ptr;\nint val = 3;\nptr = &val; // ok\n```\n\n我们不能通过ptr指针来修改val的值，即使它指向的是非const对象!\n\n我们不能使用指向const对象的指针修改基础对象，然而如果该指针指向了非const对象，可用其他方式修改其所指的对象。可以修改const指针所指向的值的，但是不能通过const对象指针来进行而已！如下修改：\n\n```c++\nint *ptr1 = &val;\n*ptr1=4;\ncout<<*ptr< 小结：
1.对于指向常量的指针，不能通过指针来修改对象的值。
2.不能使用void`*`指针保存const对象的地址，必须使用const void`*`类型的指针保存const对象的地址。
3.允许把非const对象的地址赋值给const对象的指针，如果要修改指针所指向的对象值，必须通过其他方式修改，不能直接通过当前指针直接修改。\n\n（2） **常指针**\n\nconst指针必须进行初始化，且const指针指向的值能修改，但指向不能修改。\n\n```cpp\n#include\nusing namespace std;\nint main(){\n int num=0, num1=1;\n int * const ptr=# // const指针必须初始化！且const指针的指向不能修改\n ptr = &num1; // error! const指针不能修改指向！\n cout<<*ptr<\nusing namespace std;\nint main(){\n int num=0, num1=1;\n int * const ptr=# // const指针必须初始化！且const指针的指向不能修改\n *ptr = 1;\n cout<<*ptr< int `*`错误！\n\n```cpp\n#include\nusing namespace std;\nint main(){\n const int num=0;\n int * const ptr=# // error! const int* -> int*\n cout<<*ptr< const修饰函数返回值\n\n这个跟const修饰普通变量以及指针的含义基本相同：\n\n（1）**const int**\n\n```cpp\nconst int func1();\n```\n\n这个本身无意义，因为参数返回本身就是赋值给其他的变量！\n\n（2）**const int***\n\n```cpp\nconst int* func2();\n```\n\n指针指向的内容不变。\n\n（3）int *const\n\n```cpp\nint *const func2();\n```\n\n指针本身不可变。\n\n> const修饰函数参数\n\n（1）传递过来的参数及指针本身在函数内不可变，无意义！\n\n```cpp\nvoid func(const int var); // 传递过来的参数不可变\nvoid func(int *const var); // 指针本身不可变\n```\n\n表明参数在函数体内不能被修改，但此处没有任何意义，var本身就是形参，在函数内不会改变。包括传入的形参是指针也是一样。\n\n输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const 修饰。\n\n（2）**参数指针所指内容为常量不可变**\n\n```cpp\nvoid StringCopy(char *dst, const char *src);\n```\n\n其中src 是输入参数，dst 是输出参数。给src加上const修饰后，如果函数体内的语句试图改动src的内容，编译器将指出错误。这就是加了const的作用之一。\n\n（3）**参数为引用，为了增加效率同时防止修改。**\n\n```cpp\nvoid func(const A &a)\n```\n\n对于非内部数据类型的参数而言，像void func(A a) 这样声明的函数注定效率比较低。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。\n\n为了提高效率，可以将函数声明改为void func(A &a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临\n时对象。\n\n> 但是函数void func(A &a) 存在一个缺点：
“引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为\nvoid func(const A &a)。\n\n以此类推，是否应将void func(int x) 改写为void func(const int &x)，以便提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非常快，“值传递”和“引用传递”的效率几乎相当。\n\n> 小结：
1.对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void func(A a) 改为void func(const A &a)。
2.对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void func(int x) 不应该改为void func(const int &x)。\n\n以上解决了两个面试问题：\n\n+ 如果函数需要传入一个指针，是否需要为该指针加上const，把const加在指针不同的位置有什么区别；\n+ 如果写的函数需要传入的参数是一个复杂类型的实例，传入值参数或者引用参数有什么区别，什么时候需要为传入的引用参数加上const。 \n\n## 7.类中使用const\n\n在一个类中，任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时，不慎修改 数据成员，或者调用了其它非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性。\n\n使用const关键字进行说明的成员函数，称为常成员函数。只有常成员函数才有资格操作常量或常对象，没有使用const关键字进行说明的成员函数不能用来操作常对象。\n\n对于类中的const成员变量必须通过初始化列表进行初始化，如下所示：\n\n```cpp\nclass Apple{\nprivate:\n int people[100];\npublic:\n Apple(int i); \n const int apple_number;\n};\n\nApple::Apple(int i):apple_number(i)\n{\n\n}\n```\n\nconst对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.\n\n例如：\n\n```cpp\n// apple.cpp\nclass Apple\n{\nprivate:\n int people[100];\npublic:\n Apple(int i); \n const int apple_number;\n void take(int num) const;\n int add();\n int add(int num) const;\n int getCount() const;\n\n};\n// apple.cpp\nApple::Apple(int i) : apple_number(i)\n{\n}\nint Apple::add(int num)\n{\n take(num);\n return 0;\n}\nint Apple::add(int num) const\n{\n take(num);\n return 0;\n}\nvoid Apple::take(int num) const\n{\n std::cout << \"take func \" << num << std::endl;\n}\nint Apple::getCount() const\n{\n take(1);\n // add(); // error\n return apple_number;\n}\nint main()\n{\n Apple a(2);\n cout << a.getCount() << endl;\n a.add(10);\n const Apple b(3);\n b.add(100);\n return 0;\n}\n// main.cpp\n```\n> 编译：bazel run basic_content/const/class_const/first_example:main
\n\n此时报错，上面getCount()方法中调用了一个add方法，而add方法并非const修饰，所以运行报错。也就是说const成员函数只能访问const成员函数。\n\n当调用改为：\n\n```\nconst Apple b(3);\nb.add(); // error\n```\n此时，可以证明的是const对象只能访问const成员函数。\n\n我们除了上述的初始化const常量用初始化列表方式外，也可以通过下面方法：\n\n第一：将常量定义与static结合，也就是：\n\n```cpp\nstatic const int apple_number\n```\n\n第二：在外面初始化：\n\n```cpp\nconst int Apple::apple_number=10;\n```\n\n当然，如果你使用c++11进行编译，直接可以在定义出初始化，可以直接写成：\n\n```cpp\nstatic const int apple_number=10;\n// 或者\nconst int apple_number=10;\n```\n\n这两种都在c++11中支持！\n\n编译的时候加上`-std=c++11`即可！\n\n这里提到了static，下面简单的说一下：\n\n在C++中，static静态成员变量不能在类的内部初始化。在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化。\n\n在类中声明：\n\n```cpp\nstatic int ap;\n```\n\n在类实现文件中使用：\n\n```cpp\nint Apple::ap=666\n```\n\n对于此项，c++11不能进行声明并初始化，也就是上述使用方法。\n"
},
{
"path": "basic_content/const/class_const/c++11_example/BUILD",
"content": "# please run `bazel run basic_content/const/class_const/c++11_example:main`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\", \"cc_library\")\n\ncc_library(\n name = \"apple\",\n srcs = [\"apple.cpp\"],\n hdrs = [\"apple.h\"],\n)\n\ncc_binary(\n name = \"main\",\n srcs = [\"main.cpp\"],\n deps = [\n \":apple\",\n ],\n)"
},
{
"path": "basic_content/const/class_const/c++11_example/apple.cpp",
"content": "#include \"apple.h\"\n#include \n\nusing namespace std;\nApple::Apple(int i) {}\nint Apple::add(int num) {\n take(num);\n return 0;\n}\nint Apple::add(int num) const {\n take(num);\n return 0;\n}\nvoid Apple::take(int num) const { cout << \"take func \" << num << endl; }\nint Apple::getCount() const {\n take(1);\n // add(); //error\n return apple_number;\n}"
},
{
"path": "basic_content/const/class_const/c++11_example/apple.h",
"content": "#pragma once\n\nclass Apple {\npublic:\n Apple(int i);\n // 使用c++11标准编译\n static const int apple_number = 10;\n // const int apple_number=10;\n void take(int num) const;\n int add(int num);\n int add(int num) const;\n int getCount() const;\n};\n"
},
{
"path": "basic_content/const/class_const/c++11_example/main.cpp",
"content": "#include \"apple.h\"\n#include \nusing namespace std;\nint main() {\n Apple a(2);\n cout << a.getCount() << endl;\n a.add(10);\n const Apple b(3);\n b.add(100);\n return 0;\n}\n"
},
{
"path": "basic_content/const/class_const/first_example/BUILD",
"content": "# please run `bazel run basic_content/const/class_const/first_example:main`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\", \"cc_library\")\n\ncc_library(\n name = \"apple\",\n srcs = [\"apple.cpp\"],\n hdrs = [\"apple.h\"],\n)\n\ncc_binary(\n name = \"main\",\n srcs = [\"main.cpp\"],\n deps = [\n \":apple\",\n ],\n)"
},
{
"path": "basic_content/const/class_const/first_example/apple.cpp",
"content": "#include \"apple.h\"\n#include \n\nApple::Apple(int i) : apple_number(i) {}\nint Apple::add(int num) {\n take(num);\n return 0;\n}\nint Apple::add(int num) const {\n take(num);\n return 0;\n}\nvoid Apple::take(int num) const {\n std::cout << \"take func \" << num << std::endl;\n}\nint Apple::getCount() const {\n take(1);\n // add(); //error\n return apple_number;\n}"
},
{
"path": "basic_content/const/class_const/first_example/apple.h",
"content": "#pragma once\n\nclass Apple {\npublic:\n Apple(int i);\n const int apple_number;\n void take(int num) const;\n int add(int num);\n int add(int num) const;\n int getCount() const;\n};\n"
},
{
"path": "basic_content/const/class_const/first_example/main.cpp",
"content": "#include \"apple.h\"\n#include \nusing namespace std;\n\nint main() {\n Apple a(2);\n cout << a.getCount() << endl;\n a.add(10);\n const Apple b(3);\n b.add(100);\n return 0;\n}\n"
},
{
"path": "basic_content/const/class_const/overload_example/BUILD",
"content": "# please run `bazel run basic_content/const/class_const/overload_example:main`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\", \"cc_library\")\n\ncc_library(\n name = \"apple\",\n srcs = [\"apple.cpp\"],\n hdrs = [\"apple.h\"],\n)\n\n# Don't panic if you get compilation errors, this is what this code demonstrates, as expected.\ncc_binary(\n name = \"main\",\n srcs = [\"main.cpp\"],\n deps = [\n \":apple\",\n ],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/const/class_const/overload_example/apple.cpp",
"content": "#include \"apple.h\"\n#include \n\nint Apple::apple_number = 10;\n\nApple::Apple(int i) { apple_number = i; }\nint Apple::add() {\n take(1);\n return 0;\n}\nint Apple::add(int num) const {\n take(num);\n return num;\n}\nvoid Apple::take(int num) const {\n std::cout << \"take func \" << num << std::endl;\n}\nint Apple::getCount() const {\n take(1);\n add(); // error\n return apple_number;\n}"
},
{
"path": "basic_content/const/class_const/overload_example/apple.h",
"content": "#pragma once\n\nclass Apple {\npublic:\n Apple(int i);\n static int apple_number;\n void take(int num) const;\n int add();\n int add(int num) const;\n int getCount() const;\n};\n"
},
{
"path": "basic_content/const/class_const/overload_example/main.cpp",
"content": "#include \"apple.h\"\n#include \nusing namespace std;\n\nint main() {\n Apple a(2);\n cout << a.getCount() << endl;\n a.add(10);\n // const Apple b(3);\n // b.add(); // error\n return 0;\n}\n"
},
{
"path": "basic_content/const/class_const/static_example/BUILD",
"content": "# please run `bazel run basic_content/const/class_const/static_example:main`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\", \"cc_library\")\n\ncc_library(\n name = \"apple\",\n srcs = [\"apple.cpp\"],\n hdrs = [\"apple.h\"],\n)\n\ncc_binary(\n name = \"main\",\n srcs = [\"main.cpp\"],\n deps = [\n \":apple\",\n ],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/const/class_const/static_example/apple.cpp",
"content": "#include \"apple.h\"\n#include \n\nconst int Apple::apple_number = 10;\nint Apple::ap = 666;\nApple::Apple(int i) {}\nint Apple::add(int num) {\n take(num);\n return 0;\n}\nint Apple::add(int num) const {\n take(num);\n return 0;\n}\nvoid Apple::take(int num) const {\n std::cout << \"take func \" << num << std::endl;\n}\nint Apple::getCount() const {\n take(1);\n // add(); //error\n return apple_number;\n}"
},
{
"path": "basic_content/const/class_const/static_example/apple.h",
"content": "#pragma once\nclass Apple {\npublic:\n Apple(int i);\n static int ap; // 在类实现文件中定义并初始化\n static const int apple_number;\n void take(int num) const;\n int add(int num);\n int add(int num) const;\n int getCount() const;\n};\n"
},
{
"path": "basic_content/const/class_const/static_example/main.cpp",
"content": "#include \"apple.h\"\n#include \nint main() {\n Apple a(2);\n std::cout << a.getCount() << std::endl;\n std::cout << a.ap << std::endl;\n a.add(10);\n const Apple b(3);\n b.add(100);\n return 0;\n}\n"
},
{
"path": "basic_content/const/const_function.cpp",
"content": "#include \nusing namespace std;\n\nvoid f(const int i) {\n i = 10; // error: assignment of read-only parameter ‘i’\n cout << i << endl;\n}\n\nint main() { f(1); }\n"
},
{
"path": "basic_content/const/const_num.cpp",
"content": "#include \nusing namespace std;\nint main() {\n const int b = 10;\n b = 0; // error\n const string s = \"helloworld\";\n const int i, j = 0;\n}\n"
},
{
"path": "basic_content/const/extern_const/BUILD",
"content": "# please run `bazel run basic_content/const/extern_const:const_file1` and `# please run `bazel run basic_content/const/extern_const:file`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"const_file1\",\n srcs = [\"const_file1.cpp\", \"const_file2.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"file\",\n srcs = [\"file1.cpp\", \"file2.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/const/extern_const/const_file1.cpp",
"content": "extern const int ext = 12;"
},
{
"path": "basic_content/const/extern_const/const_file2.cpp",
"content": "#include \n/**\n * by 光城\n * compile: g++ -o file const_file2.cpp const_file1.cpp\n * execute: ./file\n */\nextern const int ext;\nint main() { std::cout << ext << std::endl; }"
},
{
"path": "basic_content/const/extern_const/file1.cpp",
"content": "int ext;"
},
{
"path": "basic_content/const/extern_const/file2.cpp",
"content": "#include \n/**\n * by 光城\n * compile: g++ -o file file2.cpp file1.cpp\n * execute: ./file\n */\nextern int ext;\nint main() { std::cout << (ext + 10) << std::endl; }"
},
{
"path": "basic_content/const/funciton_const/condition1/BUILD",
"content": "# please run `bazel run basic_content/const/funciton_const/condition2:condition1`\n# please run `bazel run basic_content/const/funciton_const/condition2:condition2`\n# please run `bazel run basic_content/const/funciton_const/condition2:condition3`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\n# Don't panic if you get compilation errors, this is what this code demonstrates, as expected.\ncc_binary(\n name = \"condition1\",\n srcs = [\"condition1.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\n# Don't panic if you get compilation errors, this is what this code demonstrates, as expected.\ncc_binary(\n name = \"condition2\",\n srcs = [\"condition2.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"condition3\",\n srcs = [\"condition3.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/const/funciton_const/condition1/condition1.cpp",
"content": "#include \nusing namespace std;\n\nint main() {\n const int *ptr;\n *ptr = 10; // error\n}\n"
},
{
"path": "basic_content/const/funciton_const/condition1/condition2.cpp",
"content": "#include \nusing namespace std;\n\nint main() {\n const int p = 10;\n // const void *vp = &p; // const pointer to const data\n void *vp = (void*)&p; // ✅ C-style cast\n}\n"
},
{
"path": "basic_content/const/funciton_const/condition1/condition3.cpp",
"content": "#include \nusing namespace std;\n\nint main() {\n const int *ptr;\n int val = 3;\n ptr = &val; // ok\n int *ptr1 = &val;\n *ptr1 = 4;\n cout << *ptr << endl;\n}\n"
},
{
"path": "basic_content/const/funciton_const/condition2/BUILD",
"content": "# please run `bazel run basic_content/const/funciton_const/condition2:condition1`\n# please run `bazel run basic_content/const/funciton_const/condition2:condition2`\n# please run `bazel run basic_content/const/funciton_const/condition2:condition3`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"condition1\",\n srcs = [\"condition1.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\n# Don't panic if you get compilation errors, this is what this code demonstrates, as expected.\ncc_binary(\n name = \"condition2\",\n srcs = [\"condition2.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"condition3\",\n srcs = [\"condition3.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/const/funciton_const/condition2/condition1.cpp",
"content": "#include \nusing namespace std;\nint main() {\n int num = 0;\n int *const ptr = # // const指针必须初始化！且const指针的指向不能修改\n int *t = #\n *t = 1;\n cout << *ptr << endl;\n}\n"
},
{
"path": "basic_content/const/funciton_const/condition2/condition2.cpp",
"content": "#include \nusing namespace std;\nint main() {\n const int num = 0;\n int *const ptr = # // error! const int* -> int*\n cout << *ptr << endl;\n}\n"
},
{
"path": "basic_content/const/funciton_const/condition2/condition3.cpp",
"content": "#include \nusing namespace std;\nint main() {\n const int num = 10;\n const int *const ptr = #\n cout << *ptr << endl;\n}\n"
},
{
"path": "basic_content/const/funciton_const/condition3/BUILD",
"content": "# please run `bazel run basic_content/const/funciton_const/condition3:condition1`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\n# Don't panic if you get compilation errors, this is what this code demonstrates, as expected.\ncc_binary(\n name = \"condition1\",\n srcs = [\"condition1.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/const/funciton_const/condition3/condition1.cpp",
"content": "#include \nusing namespace std;\n\nint main() {\n const int p = 3;\n const int *const ptr = &p;\n cout << *ptr << endl;\n}\n"
},
{
"path": "basic_content/decltype/BUILD",
"content": "# please run `bazel run basic_content/decltype:decltype`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"decltype\",\n srcs = [\"decltype.cpp\"],\n copts = [\"-std=c++11\"]\n)\n"
},
{
"path": "basic_content/decltype/README.md",
"content": "# decltype那些事\n\n## 关于作者：\n\n个人公众号：\n\n\n\n## 1.基本使用\ndecltype的语法是:\n\n```\ndecltype (expression)\n```\n\n这里的括号是必不可少的,decltype的作用是“查询表达式的类型”，因此，上面语句的效果是，返回 expression 表达式的类型。注意，decltype 仅仅“查询”表达式的类型，并不会对表达式进行“求值”。\n\n\n### 1.1 推导出表达式类型\n\n```\nint i = 4;\ndecltype(i) a; //推导结果为int。a的类型为int。\n```\n\n### 1.2 与using/typedef合用，用于定义类型。\n\n```c++\nusing size_t = decltype(sizeof(0));//sizeof(a)的返回值为size_t类型\nusing ptrdiff_t = decltype((int*)0 - (int*)0);\nusing nullptr_t = decltype(nullptr);\nvectorvec;\ntypedef decltype(vec.begin()) vectype;\nfor (vectype i = vec.begin; i != vec.end(); i++)\n{\n//...\n}\n```\n\n这样和auto一样，也提高了代码的可读性。\n\n### 1.3 重用匿名类型\n\n在C++中，我们有时候会遇上一些匿名类型，如:\n\n```c++\nstruct \n{\n int d ;\n double b;\n}anon_s;\n```\n\n而借助decltype，我们可以重新使用这个匿名的结构体：\n\n```c++\ndecltype(anon_s) as ;//定义了一个上面匿名的结构体\n```\n\n### 1.4 泛型编程中结合auto，用于追踪函数的返回值类型\n\n这也是decltype最大的用途了。\n\n```c++\ntemplate \nauto multiply(T x, T y)->decltype(x*y)\n{\n\treturn x*y;\n}\n```\n\n完整代码见：[decltype.cpp](decltype.cpp)\n\n## 2.判别规则\n\n对于decltype(e)而言，其判别结果受以下条件的影响：\n\n如果e是一个没有带括号的标记符表达式或者类成员访问表达式，那么的decltype（e）就是e所命名的实体的类型。此外，如果e是一个被重载的函数，则会导致编译错误。\n否则 ，假设e的类型是T，如果e是一个将亡值，那么decltype（e）为T&&\n否则，假设e的类型是T，如果e是一个左值，那么decltype（e）为T&。\n否则，假设e的类型是T，则decltype（e）为T。\n\n标记符指的是除去关键字、字面量等编译器需要使用的标记之外的程序员自己定义的标记，而单个标记符对应的表达式即为标记符表达式。例如：\n```c++\nint arr[4]\n```\n则arr为一个标记符表达式，而arr[3]+0不是。\n\n举例如下：\n\n```c++\nint i = 4;\nint arr[5] = { 0 };\nint *ptr = arr;\nstruct S{ double d; }s ;\nvoid Overloaded(int);\nvoid Overloaded(char);//重载的函数\nint && RvalRef();\nconst bool Func(int);\n\n//规则一：推导为其类型\ndecltype (arr) var1; //int[] 标记符表达式\n\ndecltype (ptr) var2;//int * 标记符表达式\n\ndecltype(s.d) var3;//doubel 成员访问表达式\n\n//decltype(Overloaded) var4;//重载函数。编译错误。\n\n//规则二：将亡值。推导为类型的右值引用。\n\ndecltype (RvalRef()) var5 = 1;\n\n//规则三：左值，推导为类型的引用。\n\ndecltype ((i))var6 = i; //int&\n\ndecltype (true ? i : i) var7 = i; //int& 条件表达式返回左值。\n\ndecltype (++i) var8 = i; //int& ++i返回i的左值。\n\ndecltype(arr[5]) var9 = i;//int&. []操作返回左值\n\ndecltype(*ptr)var10 = i;//int& *操作返回左值\n\ndecltype(\"hello\")var11 = \"hello\"; //const char(&)[9] 字符串字面常量为左值，且为const左值。\n\n\n//规则四：以上都不是，则推导为本类型\n\ndecltype(1) var12;//const int\n\ndecltype(Func(1)) var13=true;//const bool\n\ndecltype(i++) var14 = i;//int i++返回右值\n```\n\n学习参考：https://www.cnblogs.com/QG-whz/p/4952980.html\n"
},
{
"path": "basic_content/decltype/decltype.cpp",
"content": "#include \n#include \nusing namespace std;\n/**\n * 泛型编程中结合auto，用于追踪函数的返回值类型\n */\ntemplate \n\nauto multiply(T x, T y) -> decltype(x * y) {\n return x * y;\n}\n\nint main() {\n int nums[] = {1, 2, 3, 4};\n vector vec(nums, nums + 4);\n vector::iterator it;\n\n for (it = vec.begin(); it != vec.end(); it++)\n cout << *it << \" \";\n cout << endl;\n\n using nullptr_t = decltype(nullptr);\n nullptr_t nu;\n int *p = NULL;\n if (p == nu)\n cout << \"NULL\" << endl;\n\n typedef decltype(vec.begin()) vectype;\n\n for (vectype i = vec.begin(); i != vec.end(); i++)\n cout << *i << \" \";\n cout << endl;\n\n /**\n * 匿名结构体\n */\n struct {\n int d;\n double b;\n } anon_s;\n\n decltype(anon_s) as{1, 2.0}; // 定义了一个上面匿名的结构体\n\n cout << multiply(11, 2) << \":\" << as.b << endl;\n\n return 0;\n}\n"
},
{
"path": "basic_content/enum/BUILD",
"content": "# please run `bazel run basic_content/enum:classic_practice`\n# please run `bazel run basic_content/enum:tradition_color`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"classic_practice\",\n srcs = [\"classic_practice.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\n# Don't panic if you get compilation errors, this is what this code demonstrates, as expected.\ncc_binary(\n name = \"tradition_color\",\n srcs = [\"tradition_color.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/enum/README.md",
"content": "# 从初级到高级的enum那些事\n\n## 关于作者：\n\n个人公众号：\n\n\n\n\n## 传统行为\n\n\n枚举有如下问题：\n\n- 作用域不受限,会容易引起命名冲突。例如下面无法编译通过的：\n\n```c++\nenum Color\n{\n RED,\n BLUE\n};\nenum Feeling\n{\n EXCITED,\n BLUE\n};\n\nint main()\n{\n Color a = BLUE; // error\n Feeling b = EXCITED;\n std::cout << a << \":\" << b << std::endl;\n return 0;\n}\n```\n- 会隐式转换为int\n- 用来表征枚举变量的实际类型不能明确指定，从而无法支持枚举类型的前向声明。\n\n具体实现见：[tradition_color.cpp](tradition_color.cpp)\n\n## 经典做法\n\n解决作用域不受限带来的命名冲突问题的一个简单方法是，给枚举变量命名时加前缀，如上面例子改成 COLOR_BLUE 以及 FEELING_BLUE。\n\n一般说来，为了一致性我们会把所有常量统一加上前缀。但是这样定义枚举变量的代码就显得累赘。C 程序中可能不得不这样做。不过 C++ 程序员恐怕都不喜欢这种方法。替代方案是命名空间:\n```c++\nnamespace Color \n{\n enum Type\n {\n RED=15,\n YELLOW,\n BLUE\n };\n};\n```\n\n这样之后就可以用 `Color::Type c = Color::RED;` 来定义新的枚举变量了。如果 `using namespace Color` 后，前缀还可以省去，使得代码简化。不过，因为命名空间是可以随后被扩充内容的，所以它提供的作用域封闭性不高。在大项目中，还是有可能不同人给不同的东西起同样的枚举类型名。\n\n更“有效”的办法是用一个类或结构体来限定其作用域，例如：定义新变量的方法和上面命名空间的相同。不过这样就不用担心类在别处被修改内容。这里用结构体而非类，是因为本身希望这些常量可以公开访问。\n\n```c++\nstruct Color1\n{\n enum Type\n {\n RED=102,\n YELLOW,\n BLUE\n };\n};\n```\n\n具体实现见：[classic_practice.cpp](classic_practice.cpp)\n\n## C++11 的枚举类\n\n上面的做法解决了第一个问题，但对于后两个仍无能为力。庆幸的是，C++11 标准中引入了“枚举类”(enum class)，可以较好地解决上述问题。\n\n- 新的enum的作用域不在是全局的\n- 不能隐式转换成其他类型\n\n```c++\n/**\n * @brief C++11的枚举类\n * 下面等价于enum class Color2:int\n */\nenum class Color2\n{\n RED=2,\n YELLOW,\n BLUE\n};\nColor2 c2 = Color2::RED;\ncout << static_cast(c2) << endl; //必须转！\n```\n\n- 可以指定用特定的类型来存储enum\n\n```c++\nenum class Color3:char; // 前向声明\n\n// 定义\nenum class Color3:char \n{\n RED='r',\n BLUE\n};\nchar c3 = static_cast(Color3::RED);\n```\n\n具体实现见：[classic_practice.cpp](classic_practice.cpp)\n\n## 类中的枚举类型\n\n有时我们希望某些常量只在类中有效。 由于#define 定义的宏常量是全局的，不能达到目的，于是想到使用const 修饰数据成员来实现。而const 数据成员的确是存在的，但其含义却不是我们所期望的。\n\nconst 数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的，因为类可以创建多个对象，不同的对象其 const 数据成员的值可以不同。 \n\n不能在类声明中初始化 const 数据成员。以下用法是错误的，因为类的对象未被创建时，编译器不知道 SIZE 的值是什么。(c++11标准前)\n\n```c++\nclass A \n{\n const int SIZE = 100; // 错误，企图在类声明中初始化 const 数据成员 \n int array[SIZE]; // 错误，未知的 SIZE \n}; \n```\n\n正确应该在类的构造函数的初始化列表中进行：\n\n```c++\nclass A \n{\n A(int size); // 构造函数 \n const int SIZE ; \n}; \nA::A(int size) : SIZE(size) // 构造函数的定义\n{ \n\n} \nA a(100); // 对象 a 的 SIZE 值为 100 \nA b(200); // 对象 b 的 SIZE 值为 200 \n```\n\n怎样才能建立在整个类中都恒定的常量呢？\n\n别指望 const 数据成员了，应该用类中的枚举常量来实现。例如:\n\n```c++\nclass Person{\npublic:\n typedef enum {\n BOY = 0,\n GIRL\n }SexType;\n};\n//访问的时候通过，Person::BOY或者Person::GIRL来进行访问。\n```\n\n枚举常量不会占用对象的存储空间，它们在编译时被全部求值。\n\n枚举常量的缺点是：它的隐含数据类型是整数，其最大值有限，且不能表示浮点。\n"
},
{
"path": "basic_content/enum/classic_practice.cpp",
"content": "#include \nusing namespace std;\n/**\n * @brief namespace解决作用域不受限\n */\nnamespace Color {\nenum Type { RED = 15, YELLOW, BLUE };\n};\n\n/**\n * @brief 上述如果 using namespace Color 后，前缀还可以省去，使得代码简化。\n * 不过，因为命名空间是可以随后被扩充内容的，所以它提供的作用域封闭性不高。\n * 在大项目中，还是有可能不同人给不同的东西起同样的枚举类型名。\n * 更“有效”的办法是用一个类或结构体来限定其作用域。\n *\n * 定义新变量的方法和上面命名空间的相同。\n * 不过这样就不用担心类在别处被修改内容。\n * 这里用结构体而非类，一是因为本身希望这些常量可以公开访问，\n * 二是因为它只包含数据没有成员函数。\n */\nstruct Color1 {\n enum Type { RED = 102, YELLOW, BLUE };\n};\n\n/**\n * @brief C++11的枚举类\n * 下面等价于enum class Color2:int\n */\nenum class Color2 { RED = 2, YELLOW, BLUE };\n\nenum class Color3 : char; // 前向声明\n\n// 定义\nenum class Color3 : char { RED = 'r', BLUE };\n\nint main() {\n // 定义新的枚举变量\n Color::Type c = Color::RED;\n cout << c << endl;\n /**\n * 上述的另一种方法：\n * using namespace Color; // 定义新的枚举变量\n * Type c = RED;\n */\n Color1 c1;\n cout << c1.RED << endl;\n\n Color1::Type c11 = Color1::BLUE;\n cout << c11 << endl;\n\n Color2 c2 = Color2::RED;\n cout << static_cast(c2) << endl;\n\n char c3 = static_cast(Color3::RED);\n cout << c3 << endl;\n return 0;\n}\n"
},
{
"path": "basic_content/enum/tradition_color.cpp",
"content": "#include \nusing namespace std;\n\nenum Color { RED, BLUE };\nenum Feeling { EXCITED, BLUE };\n\nint main() {\n Color a = BLUE; // error\n Feeling b = EXCITED;\n std::cout << a << \":\" << b << std::endl;\n return 0;\n}\n"
},
{
"path": "basic_content/explicit/BUILD",
"content": "# please run `bazel run basic_content/explicit:explicit`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\n# Don't panic if you get compilation errors, this is what this code demonstrates, as expected.\ncc_binary(\n name = \"explicit\",\n srcs = [\"explicit.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/explicit/README.md",
"content": "# explicit(显式)关键字那些事\n\n## 关于作者：\n\n个人公众号：\n\n\n\n- explicit 修饰构造函数时，可以防止隐式转换和复制初始化\n- explicit 修饰转换函数时，可以防止隐式转换，但按语境转换除外\n\n\n代码参见:[.explicit.cpp](./explicit.cpp)\n\n参考链接：\n> https://stackoverflow.com/questions/4600295/what-is-the-meaning-of-operator-bool-const\n"
},
{
"path": "basic_content/explicit/explicit.cpp",
"content": "#include \n\nusing namespace std;\n\nstruct A {\n A(int) {}\n operator bool() const { return true; }\n};\n\nstruct B {\n explicit B(int) {}\n explicit operator bool() const { return true; }\n};\n\nvoid doA(A a) {}\n\nvoid doB(B b) {}\n\nint main() {\n A a1(1); // OK：直接初始化\n A a2 = 1; // OK：复制初始化\n A a3{1}; // OK：直接列表初始化\n A a4 = {1}; // OK：复制列表初始化\n A a5 = (A)1; // OK：允许 static_cast 的显式转换\n doA(1); // OK：允许从 int 到 A 的隐式转换\n if (a1)\n ; // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换\n bool a6(a1); // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换\n bool a7 = a1; // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换\n bool a8 = static_cast(a1); // OK ：static_cast 进行直接初始化\n\n B b1(1); // OK：直接初始化\n // B b2 = 1; // 错误：被 explicit\n // 修饰构造函数的对象不可以复制初始化\n B b3{1}; // OK：直接列表初始化\n // B b4 = { 1 }; // 错误：被 explicit\n // 修饰构造函数的对象不可以复制列表初始化\n B b5 = (B)1; // OK：允许 static_cast 的显式转换\n // doB(1); // 错误：被 explicit\n // 修饰构造函数的对象不可以从 int 到 B 的隐式转换\n if (b1)\n ; // OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool\n // 的按语境转换\n bool b6(b1); // OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B\n // 到 bool 的按语境转换\n // bool b7 = b1; // 错误：被 explicit 修饰转换函数\n // B::operator bool() 的对象不可以隐式转换\n bool b8 = static_cast(b1); // OK：static_cast 进行直接初始化\n\n return 0;\n}\n"
},
{
"path": "basic_content/extern/README.md",
"content": "# extern \"C\"\n\n## 关于作者：\n\n个人公众号：\n\n\n\n## 1.C++与C编译区别\n\n在C++中常在头文件见到extern \"C\"修饰函数，那有什么作用呢？ 是用于C++链接在C语言模块中定义的函数。\n\nC++虽然兼容C，但C++文件中函数编译后生成的符号与C语言生成的不同。因为C++支持函数重载，C++函数编译后生成的符号带有函数参数类型的信息，而C则没有。\n\n例如`int add(int a, int b)`函数经过C++编译器生成.o文件后，`add`会变成形如`add_int_int`之类的, 而C的话则会是形如`_add`, 就是说：相同的函数，在C和C++中，编译后生成的符号不同。\n\n这就导致一个问题：如果C++中使用C语言实现的函数，在编译链接的时候，会出错，提示找不到对应的符号。此时`extern \"C\"`就起作用了：告诉链接器去寻找`_add`这类的C语言符号，而不是经过C++修饰的符号。\n\n## 2.C++调用C函数\n\nC++调用C函数的例子: 引用C的头文件时，需要加`extern \"C\"`\n\n```c++\n//add.h\n#ifndef ADD_H\n#define ADD_H\nint add(int x,int y);\n#endif\n\n//add.c\n#include \"add.h\"\n\nint add(int x,int y) {\n return x+y;\n}\n\n//add.cpp\n#include \n#include \"add.h\"\nusing namespace std;\nint main() {\n add(2,3);\n return 0;\n}\n```\n\n编译：\n\n```\n//Generate add.o file\ngcc -c add.c\n```\n\n链接：\n\n```\ng++ add.cpp add.o -o main\n```\n\n没有添加extern \"C\" 报错：\n\n```c++\n> g++ add.cpp add.o -o main \nadd.o：在函数‘main’中：\nadd.cpp:(.text+0x0): `main'被多次定义\n/tmp/ccH65yQF.o:add.cpp:(.text+0x0)：第一次在此定义\n/tmp/ccH65yQF.o：在函数‘main’中：\nadd.cpp:(.text+0xf)：对‘add(int, int)’未定义的引用\nadd.o：在函数‘main’中：\nadd.cpp:(.text+0xf)：对‘add(int, int)’未定义的引用\ncollect2: error: ld returned 1 exit status\n```\n\n添加extern \"C\"后：\n\n`add.cpp`\n\n```c++\n#include \nusing namespace std;\nextern \"C\" {\n #include \"add.h\"\n}\nint main() {\n std::cout << add(2, 3) << std::endl;\n return 0;\n}\n```\n\n编译的时候一定要注意，先通过gcc生成中间文件add.o。\n\n```\ngcc -c add.c \n```\n\n然后编译：\n\n```\ng++ add.cpp add.o -o main\n```\n\n如果使用bazel编译，运行:`bazel run basic_content/extern/extern_c++:main`\n\n而通常为了C代码能够通用，即既能被C调用，又能被C++调用，头文件通常会有如下写法：\n\n```c\n#ifdef __cplusplus\nextern \"C\"{\n#endif\nint add(int x,int y);\n#ifdef __cplusplus\n}\n#endif\n```\n\n即在C++调用该接口时，会以C接口的方式调用。这种方式使得C++者不需要额外的extern C，而标准库头文件通常也是类似的做法，否则你为何不需要extern C就可以直接使用stdio.h中的C函数呢？\n\n\n上述案例源代码见：\n\n- [add.h](extern_c++/add.h)\n\n- [add.c](extern_c++/add.c)\n\n- [add.cpp](extern_c++/add.cpp)\n\n## 2.C中调用C++函数\n\n`extern \"C\"`在C中是语法错误，需要放在C++头文件中。\n\n```c\n// add.h\n#ifndef ADD_H\n#define ADD_H\nextern \"C\" {\n int add(int x,int y);\n}\n#endif\n\n// add.cpp\n#include \"add.h\"\n\nint add(int x,int y) {\n return x+y;\n}\n\n// add.c\nextern int add(int x,int y);\nint main() {\n add(2,3);\n return 0;\n}\n```\n\n编译：\n\n```c\ng++ -c add.cpp\n```\n\n链接：\n\n```\ngcc add.c add.o -o main\n```\n\n上述案例源代码见：\n\n- [add.h](extern_c/add.h)\n\n- [add.c](extern_c/add.c)\n\n- [add.cpp](extern_c/add.cpp)\n\n综上，总结出使用方法，在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern \"C\"声明，在.c文件中包含了extern \"C\"时会出现编译语法错误。所以使用extern \"C\"全部都放在于cpp程序相关文件或其头文件中。\n\n总结出如下形式：\n\n（1）C++调用C函数：\n\n```c++\n//xx.h\nextern int add(...)\n\n//xx.c\nint add(){\n \n}\n\n//xx.cpp\nextern \"C\" {\n #include \"xx.h\"\n}\n```\n\n（2）C调用C++函数\n\n```c\n//xx.h\nextern \"C\"{\n int add();\n}\n//xx.cpp\nint add(){\n \n}\n//xx.c\nextern int add();\n```\n\n\n不过与C++调用C接口不同，C++确实是能够调用编译好的C函数，而这里C调用C++，不过是把C++代码当成C代码编译后调用而已。也就是说，C并不能直接调用C++库函数。\n"
},
{
"path": "basic_content/extern/extern_c/BUILD",
"content": "# please run `bazel run basic_content/extern/extern_c:main`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\", \"cc_library\")\n\ncc_library(\n name = \"add\",\n srcs = [\"add.cpp\"],\n hdrs = [\"add.h\"],\n)\n\ncc_binary(\n name = \"main\",\n srcs = [\"add.c\"],\n deps = [\":add\"],\n)"
},
{
"path": "basic_content/extern/extern_c/add.c",
"content": "extern int add(int x,int y);\nint main() {\n add(2,3);\n return 0;\n}\n"
},
{
"path": "basic_content/extern/extern_c/add.cpp",
"content": "#include \"add.h\"\n\nint add(int x, int y) { return x + y; }\n"
},
{
"path": "basic_content/extern/extern_c/add.h",
"content": "#ifndef ADD_H\n#define ADD_H\nextern \"C\" {\nint add(int x, int y);\n}\n#endif\n"
},
{
"path": "basic_content/extern/extern_c++/BUILD",
"content": "# please run `bazel run basic_content/extern/extern_c++:main`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\", \"cc_library\")\n\ncc_library(\n name = \"add\",\n srcs = [\"add.c\"],\n hdrs = [\"add.h\"],\n)\n\ncc_binary(\n name = \"main\",\n srcs = [\"add.cpp\"],\n deps = [\":add\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/extern/extern_c++/add.c",
"content": "#include \"add.h\"\n\nint add(int x,int y) {\n return x+y;\n}\n"
},
{
"path": "basic_content/extern/extern_c++/add.cpp",
"content": "#include \nusing namespace std;\nextern \"C\" {\n#include \"add.h\"\n}\nint main() {\n std::cout << add(2, 3) << std::endl;\n return 0;\n}\n"
},
{
"path": "basic_content/extern/extern_c++/add.h",
"content": "#ifndef ADD_H\n#define ADD_H\nextern int add(int x, int y);\n#endif\n"
},
{
"path": "basic_content/friend/BUILD",
"content": "# please run `bazel run basic_content/friend:friend_class`\n# please run `bazel run basic_content/friend:friend_func`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"friend_class\",\n srcs = [\"friend_class.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"friend_func\",\n srcs = [\"friend_func.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/friend/README.md",
"content": "# 友元函数与友元类\n\n## 关于作者：\n\n个人公众号：\n\n\n\n## 0.概述\n\n友元提供了一种 普通函数或者类成员函数 访问另一个类中的私有或保护成员 的机制。也就是说有两种形式的友元：\n\n（1）友元函数：普通函数对一个访问某个类中的私有或保护成员。\n\n（2）友元类：类A中的成员函数访问类B中的私有或保护成员\n\n优点：提高了程序的运行效率。\n\n缺点：破坏了类的封装性和数据的透明性。\n\n总结：\n- 能访问私有成员\n- 破坏封装性\n- 友元关系不可传递\n- 友元关系的单向性\n- 友元声明的形式及数量不受限制\n\n## 1.友元函数\n\n在类声明的任何区域中声明，而定义则在类的外部。\n\n```\nfriend <类型><友元函数名>(<参数表>);\n```\n\n注意，友元函数只是一个普通函数，并不是该类的类成员函数，它可以在任何地方调用，友元函数中通过对象名来访问该类的私有或保护成员。\n\n具体代码见：[friend_func.cpp](friend_func.cpp)\n\n```c++\n#include \n\nusing namespace std;\n\nclass A\n{\npublic:\n A(int _a):a(_a){};\n friend int geta(A &ca); ///< 友元函数\nprivate:\n int a;\n};\n\nint geta(A &ca) \n{\n return ca.a;\n}\n\nint main()\n{\n A a(3); \n cout<;\n```\n\n类B是类A的友元，那么类B可以直接访问A的私有成员。\n\n具体代码见：[friend_class.cpp](friend_class.cpp)\n```c++\n#include \n\nusing namespace std;\n\nclass A\n{\npublic:\n A(int _a):a(_a){};\n friend class B;\nprivate:\n int a;\n};\n\nclass B\n{\npublic:\n int getb(A ca) {\n return ca.a; \n };\n};\n\nint main() \n{\n A a(3);\n B b;\n cout<\n\nusing namespace std;\n\nclass A {\npublic:\n A(int _a) : a(_a){};\n friend class B;\n\nprivate:\n int a;\n};\n\nclass B {\npublic:\n int getb(A ca) { return ca.a; };\n};\n\nint main() {\n A a(3);\n B b;\n cout << b.getb(a) << endl;\n return 0;\n}\n"
},
{
"path": "basic_content/friend/friend_func.cpp",
"content": "#include \n\nusing namespace std;\n\nclass A {\npublic:\n A(int _a) : a(_a){};\n friend int geta(A &ca); ///< 友元函数\nprivate:\n int a;\n};\n\nint geta(A &ca) { return ca.a; }\n\nint main() {\n A a(3);\n cout << geta(a) << endl;\n\n return 0;\n}\n"
},
{
"path": "basic_content/func_pointer/BUILD",
"content": "# please run `bazel run basic_content/func_pointer:func_pointer`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"func_pointer\",\n srcs = [\"func_pointer.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/func_pointer/func_pointer.cpp",
"content": "/**\n * @file func_pointer.cpp\n * @brief 函数指针的使用！\n * @author 光城\n * @version v1\n * @date 2019-07-20\n */\n\n#include \nusing namespace std;\n\n/**\n * @brief\n * 定义了一个变量pFun，这个变量是个指针，指向返回值为空和参数为int的函数的指针！\n */\nvoid (*pFun)(int);\n\n/**\n * @brief 代表一种新类型，不是变量！所以与上述的pFun不一样！\n */\ntypedef void (*func)(void);\n\nvoid myfunc(void) { cout << \"asda\" << endl; }\n\nvoid glFun(int a) { cout << a << endl; }\nint main() {\n func pfun = myfunc; /*赋值*/\n pfun(); /*调用*/\n pFun = glFun;\n (*pFun)(2);\n}\n"
},
{
"path": "basic_content/inline/BUILD",
"content": "# please run `bazel run basic_content/inline:inline_virtual`\n# please run `bazel run basic_content/inline:main`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\", \"cc_library\")\n\ncc_library(\n name = \"inline\",\n hdrs = [\"inline.h\"],\n)\n\ncc_binary(\n name = \"inline_virtual\",\n srcs = [\"inline_virtual.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"main\",\n srcs = [\"inline.cpp\"],\n deps = [\n \":inline\",\n ],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/inline/README.md",
"content": "# inline那些事\n\n## 关于作者：\n\n个人公众号：\n\n\n\n## 1.类中内联\n\n头文件中声明方法\n\n```c++\n\nclass A\n{\npublic:\n void f1(int x); \n\n /**\n * @brief 类中定义了的函数是隐式内联函数,声明要想成为内联函数，必须在实现处(定义处)加inline关键字。\n *\n * @param x\n * @param y\n */\n void Foo(int x,int y) ///< 定义即隐式内联函数！\n {\n \n };\n void f2(int x); ///< 声明后，要想成为内联函数，必须在定义处加inline关键字。 \n};\n```\n\n实现文件中定义内联函数：\n\n```c++\n#include \n#include \"inline.h\"\n\nusing namespace std;\n\n/**\n * @brief inline要起作用,inline要与函数定义放在一起,inline是一种“用于实现的关键字,而不是用于声明的关键字”\n *\n * @param x\n * @param y\n *\n * @return \n */\nint Foo(int x,int y); // 函数声明\ninline int Foo(int x,int y) // 函数定义\n{\n return x+y;\n}\n\n// 定义处加inline关键字，推荐这种写法！\ninline void A::f1(int x){\n\n}\n\nint main()\n{\n\n \n cout< \nusing namespace std;\nclass Base\n{\npublic:\n inline virtual void who()\n {\n cout << \"I am Base\\n\";\n }\n virtual ~Base() {}\n};\nclass Derived : public Base\n{\npublic:\n inline void who() // 不写inline时隐式内联\n {\n cout << \"I am Derived\\n\";\n }\n};\n\nint main()\n{\n // 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。 \n Base b;\n b.who();\n\n // 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。 \n Base *ptr = new Derived();\n ptr->who();\n\n // 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。\n delete ptr;\n ptr = nullptr;\n\n \n return 0;\n} \n```\n\n\n\n"
},
{
"path": "basic_content/inline/inline.cpp",
"content": "#include \"inline.h\"\n#include \n\nusing namespace std;\n\n/**\n * @brief\n * inline要起作用,inline要与函数定义放在一起,inline是一种“用于实现的关键字,而不是用于声明的关键字”\n *\n * @param x\n * @param y\n *\n * @return\n */\nint Foo(int x, int y); // 函数声明\ninline int Foo(int x, int y) // 函数定义\n{\n return x + y;\n}\n\n// 定义处加inline关键字，推荐这种写法！\ninline void A::f1(int x) {}\n\n/**\n * @brief\n * 内联能提高函数效率，但并不是所有的函数都定义成内联函数！内联是以代码膨胀(复制)为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。\n * 如果执行函数体内代码的时间相比于函数调用的开销较大，那么效率的收货会更少！另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。\n * 以下情况不宜用内联：\n * （1） 如果函数体内的代码比较长，使得内联将导致内存消耗代价比较高。\n * (2) 如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。\n *\n * @return\n */\nint main() { cout << Foo(1, 2) << endl; }\n/**\n * 编译器对 inline 函数的处理步骤\n * 将 inline 函数体复制到 inline 函数调用点处；\n * 为所用 inline 函数中的局部变量分配内存空间；\n * 将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；\n * 如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用\n * GOTO）。\n */\n"
},
{
"path": "basic_content/inline/inline.h",
"content": "#pragma once\nclass A {\npublic:\n void f1(int x);\n\n /**\n * @brief\n * 类中定义了的函数是隐式内联函数,声明要想成为内联函数，必须在实现处(定义处)加inline关键字。\n *\n * @param x\n * @param y\n */\n void Foo(int x, int y) ///< 定义即隐式内联函数！\n {\n\n };\n void f2(int x); ///< 声明后，要想成为内联函数，必须在定义处加inline关键字。\n};\n"
},
{
"path": "basic_content/inline/inline_virtual.cpp",
"content": "#include \nusing namespace std;\nclass Base {\npublic:\n inline virtual void who() { cout << \"I am Base\\n\"; }\n virtual ~Base() {}\n};\nclass Derived : public Base {\npublic:\n inline void who() // 不写inline时隐式内联\n {\n cout << \"I am Derived\\n\";\n }\n};\n\nint main() {\n // 此处的虚函数\n // who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。\n Base b;\n b.who();\n\n // 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。\n Base *ptr = new Derived();\n ptr->who();\n\n // 因为Base有虚析构函数（virtual ~Base() {}），所以 delete\n // 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。\n delete ptr;\n\n return 0;\n}\n"
},
{
"path": "basic_content/macro/BUILD",
"content": "# please run `bazel run basic_content/macro:do_while`\n# please run `bazel run basic_content/sig_examp:sig_examp`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"do_while\",\n srcs = [\"do_while.cpp\"],\n copts = [\"-std=c++11\"],\n)\n\ncc_binary(\n name = \"sig_examp\",\n srcs = [\"sig_examp.cpp\"],\n copts = [\"-std=c++11\"],\n)\n"
},
{
"path": "basic_content/macro/README.md",
"content": "# 宏那些事\n\n## 关于作者：\n\n个人公众号：\n\n\n\n## 1.宏中包含特殊符号\n\n分为几种：`#`，`##`，`\\`\n\n### 1.1 字符串化操作符（#）\n\n**在一个宏中的参数前面使用一个#,预处理器会把这个参数转换为一个字符数组**，换言之就是：**#是“字符串化”的意思，出现在宏定义中的#是把跟在后面的参数转换成一个字符串**。\n\n**注意：其只能用于有传入参数的宏定义中，且必须置于宏定义体中的参数名前。**\n\n例如：\n\n```c++\n#define exp(s) printf(\"test s is:%s\\n\",s)\n#define exp1(s) printf(\"test s is:%s\\n\",#s)\n#define exp2(s) #s \nint main() {\n exp(\"hello\");\n exp1(hello);\n\n string str = exp2( bac );\n cout<(b) ? (a) \\\n :(b)) \nint main() {\n int max_val = MAX(3,6);\n cout<0)\n\tfun()\n```\n\n这个宏被展开后就是：\n\n```\nif(a>0)\n\tf1();\n\tf2();\n```\n\n本意是a>0执行f1 f2，而实际是f2每次都会执行，所以就错误了。\n\n为了解决这种问题，在写代码的时候，通常可以采用`{}`块。\n\n如：\n\n```c++\n#define fun() {f1();f2();}\nif(a>0)\n\tfun();\n// 宏展开\nif(a>0)\n{\n f1();\n f2();\n};\n```\n\n但是会发现上述宏展开后多了一个分号，实际语法不太对。(虽然编译运行没问题，正常没分号)。\n\n### 2.2避免使用goto控制流\n\n在一些函数中，我们可能需要在return语句之前做一些清理工作，比如释放在函数开始处由malloc申请的内存空间，使用goto总是一种简单的方法：\n\n```c++\nint f() {\n int *p = (int *)malloc(sizeof(int));\n *p = 10; \n cout<<*p<\n\n"
},
{
"path": "basic_content/macro/do_while.cpp",
"content": "#include \n#include \n\nusing namespace std;\n#define f1() cout << \"f1()\" << endl;\n#define f2() cout << \"f2()\" << endl;\n\n#define fun() \\\n { \\\n f1(); \\\n f2(); \\\n }\n#define fun1() \\\n do { \\\n f1(); \\\n f2(); \\\n } while (0)\n\nint f() {\n int *p = (int *)malloc(sizeof(int));\n *p = 10;\n cout << *p << endl;\n#ifndef DEBUG\n int error = 1;\n#endif\n if (error)\n goto END;\n\n // dosomething\nEND:\n cout << \"free\" << endl;\n free(p);\n return 0;\n}\n\nint ff() {\n\n int *p = (int *)malloc(sizeof(int));\n *p = 10;\n cout << *p << endl;\n\n do {\n#ifndef DEBUG\n int error = 1;\n#endif\n if (error)\n break;\n // dosomething\n } while (0);\n\n cout << \"free\" << endl;\n free(p);\n return 0;\n}\n\nint fc() {\n int k1 = 10;\n cout << k1 << endl;\n do {\n int k1 = 100;\n cout << k1 << endl;\n } while (0);\n cout << k1 << endl;\n return 0;\n}\n\nint main() {\n\n if (1 > 0)\n fun();\n\n if (2 > 0)\n fun1();\n\n f();\n ff();\n fc();\n return 0;\n}\n"
},
{
"path": "basic_content/macro/sig_examp.cpp",
"content": "#include \n#include \n#include \n#include \n\nusing namespace std;\n\n///===========================================\n/**\n * (#)字符串操作符\n */\n///===========================================\n#define exp(s) printf(\"test s is:%s\\n\", s)\n#define exp1(s) printf(\"test s is:%s\\n\", #s)\n\n#define exp2(s) #s\n\n///===========================================\n/**\n *（##）符号连接操作符\n */\n///===========================================\n#define expA(s) printf(\"前缀加上后的字符串为:%s\\n\", gc_##s) // gc_s必须存在\n\n#define expB(s) printf(\"前缀加上后的字符串为:%s\\n\", gc_##s) // gc_s必须存在\n\n#define gc_hello1 \"I am gc_hello1\"\n\n///===========================================\n/**\n * (\\)续行操作符\n */\n///===========================================\n#define MAX(a, b) ((a) > (b) ? (a) : (b))\n\nint main() {\n ///===========================================\n /**\n * (#)字符串操作符\n */\n ///===========================================\n exp(\"hello\");\n exp1(hello);\n\n string str = exp2(bac);\n cout << str << \" \" << str.size() << endl;\n /**\n * 忽略传入参数名前面和后面的空格。\n */\n string str1 = exp2(asda bac);\n /**\n * 当传入参数名间存在空格时，编译器将会自动连接各个子字符串，\n * 用每个子字符串之间以一个空格连接，忽略剩余空格。\n */\n cout << str1 << \" \" << str1.size() << endl;\n\n ///===========================================\n /**\n * (#)字符串操作符\n */\n ///===========================================\n\n const char *gc_hello = \"I am gc_hello\";\n expA(hello);\n expB(hello1);\n\n char var1_p[20];\n char var2_p[20];\n\n // 连接后的实际参数名赋值\n strcpy(var1_p, \"aaaa\");\n strcpy(var2_p, \"bbbb\");\n\n ///===========================================\n /**\n * (\\)续行操作符\n */\n ///===========================================\n int max_val = MAX(3, 6);\n cout << max_val << endl;\n return 0;\n}\n"
},
{
"path": "basic_content/maohao/BUILD",
"content": "# please run `bazel run basic_content/maohao:maohao`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"maohao\",\n srcs = [\"maohao.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/maohao/README.md",
"content": "# :: 范围解析运算符那些事\n\n## 关于作者：\n\n个人公众号：\n\n\n\n- 全局作用域符（::name）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间\n- 类作用域符（class::name）：用于表示指定类型的作用域范围是具体某个类的\n- 命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的\n\n具体代码见：[maohao.cpp](maohao.cpp)\n\n"
},
{
"path": "basic_content/maohao/maohao.cpp",
"content": "#include \nusing namespace std;\n\nint count = 0; // 全局(::)的count\n\nclass A {\npublic:\n static int count; // 类A的count (A::count)\n};\n// 静态变量必须在此处定义\nint A::count;\nint main() {\n ::count = 1; // 设置全局的count为1\n A::count = 5; // 设置类A的count为2\n cout << A::count << endl;\n // int count=3; // 局部count\n // count=4; // 设置局部的count为4\n return 0;\n}\n"
},
{
"path": "basic_content/pointer_refer/BUILD",
"content": "# please run `bazel run basic_content/pointer_refer:copy_construct`\n# please run `bazel run basic_content/pointer_refer:effec`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"copy_construct\",\n srcs = [\"copy_construct.cpp\"],\n copts = [\"-std=c++11\", \"-fno-elide-constructors\"]\n)\n\ncc_binary(\n name = \"effec\",\n srcs = [\"effec.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/pointer_refer/README.md",
"content": "# 引用与指针那些事\n\n## 关于作者：\n\n个人公众号：\n\n\n\n## 1.引用与指针\n\n总论：\n\n| 引用 | 指针 |\n| ------------ | ------------ |\n| 必须初始化 | 可以不初始化 |\n| 不能为空 | 可以为空 |\n| 不能更换目标 | 可以更换目标 |\n\n> 引用必须初始化，而指针可以不初始化。\n\n我们在定义一个引用的时候必须为其指定一个初始值，但是指针却不需要。\n\n```c++\nint &r; //不合法，没有初始化引用\nint *p; //合法，但p为野指针，使用需要小心\n```\n\n> 引用不能为空，而指针可以为空。\n\n由于引用不能为空，所以我们在使用引用的时候不需要测试其合法性，而在使用指针的时候需要首先判断指针是否为空指针，否则可能会引起程序崩溃。\n\n```c++\nvoid test_p(int* p)\n{\n \tif(p != null_ptr) //对p所指对象赋值时需先判断p是否为空指针\n \t*p = 3;\n return;\n}\nvoid test_r(int& r)\n{\n r = 3; //由于引用不能为空，所以此处无需判断r的有效性就可以对r直接赋值\n return;\n}\n```\n\n> 引用不能更换目标\n\n指针可以随时改变指向，但是引用只能指向初始化时指向的对象，无法改变。\n\n```\nint a = 1;\nint b = 2;\n\nint &r = a; //初始化引用r指向变量a\nint *p = &a; //初始化指针p指向变量a\n\np = &b; //指针p指向了变量b\nr = b; //引用r依然指向a，但a的值变成了b\n```\n\n## 2.引用\n\n#### 左值引用\n\n常规引用，一般表示对象的身份。\n\n#### 右值引用\n\n右值引用就是必须绑定到右值（一个临时对象、将要销毁的对象）的引用，一般表示对象的值。\n\n右值引用可实现转移语义（Move Sementics）和精确传递（Perfect Forwarding），它的主要目的有两个方面：\n\n- 消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。\n- 能够更简洁明确地定义泛型函数。\n\n#### 引用折叠\n\n- `X& &`、`X& &&`、`X&& &` 可折叠成 `X&`\n- `X&& &&` 可折叠成 `X&&`\n\nC++的引用**在减少了程序员自由度的同时提升了内存操作的安全性和语义的优美性**。比如引用强制要求必须初始化，可以让我们在使用引用的时候不用再去判断引用是否为空，让代码更加简洁优美，避免了指针满天飞的情形。除了这种场景之外引用还用于如下两个场景：\n\n> 引用型参数\n\n一般我们使用const reference参数作为只读形参，这种情况下既可以避免参数拷贝还可以获得与传值参数一样的调用方式。\n\n```c++\nvoid test(const vector &data)\n{\n //...\n}\nint main()\n{\n \tvector data{1,2,3,4,5,6,7,8};\n test(data);\n}\n```\n\n> 引用型返回值\n\nC++提供了重载运算符的功能，我们在重载某些操作符的时候，使用引用型返回值可以获得跟该操作符原来语法相同的调用方式，保持了操作符语义的一致性。一个例子就是operator []操作符，这个操作符一般需要返回一个引用对象，才能正确的被修改。\n\n```c++\nvector v(10);\nv[5] = 10; //[]操作符返回引用，然后vector对应元素才能被修改\n //如果[]操作符不返回引用而是指针的话，赋值语句则需要这样写\n*v[5] = 10; //这种书写方式，完全不符合我们对[]调用的认知，容易产生误解\n```\n\n## 3.指针与引用的性能差距\n\n指针与引用之间有没有性能差距呢？这种问题就需要进入汇编层面去看一下。我们先写一个test1函数，参数传递使用指针：\n\n```c++\nvoid test1(int* p)\n{\n *p = 3; //此处应该首先判断p是否为空，为了测试的需要，此处我们没加。\n return;\n}\n```\n\n该代码段对应的汇编代码如下：\n\n```c++\n(gdb) disassemble \nDump of assembler code for function test1(int*):\n 0x0000000000400886 <+0>: push %rbp\n 0x0000000000400887 <+1>: mov %rsp,%rbp\n 0x000000000040088a <+4>: mov %rdi,-0x8(%rbp)\n=> 0x000000000040088e <+8>: mov -0x8(%rbp),%rax\n 0x0000000000400892 <+12>: movl $0x3,(%rax)\n 0x0000000000400898 <+18>: nop\n 0x0000000000400899 <+19>: pop %rbp\n 0x000000000040089a <+20>: retq \nEnd of assembler dump.\n\n```\n\n上述代码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。\n\n我们再写出参数传递使用引用的C++代码段test2：\n\n```c++\nvoid test2(int& r)\n{\n r = 3; //赋值前无需判断reference是否为空\n return;\n}\n```\n\n这段代码对应的汇编代码如下：\n\n```c++\n(gdb) disassemble \nDump of assembler code for function test2(int&):\n 0x000000000040089b <+0>: push %rbp\n 0x000000000040089c <+1>: mov %rsp,%rbp\n 0x000000000040089f <+4>: mov %rdi,-0x8(%rbp)\n=> 0x00000000004008a3 <+8>: mov -0x8(%rbp),%rax\n 0x00000000004008a7 <+12>: movl $0x3,(%rax)\n 0x00000000004008ad <+18>: nop\n 0x00000000004008ae <+19>: pop %rbp\n 0x00000000004008af <+20>: retq \nEnd of assembler dump.\n\n```\n\n我们发现test2对应的汇编代码和test1对应的汇编代码完全相同，这说明C++编译器在编译程序的时候将指针和引用编译成了完全一样的机器码。所以C++中的引用只是C++对指针操作的一个“语法糖”，在底层实现时C++编译器实现这两种操作的方法完全相同。\n\n## 3.总结\n\nC++中引入了引用操作，在对引用的使用加了更多限制条件的情况下，保证了引用使用的安全性和便捷性，还可以保持代码的优雅性。在适合的情况使用适合的操作，引用的使用可以一定程度避免“指针满天飞”的情况，对于提升程序稳定性也有一定的积极意义。最后，指针与引用底层实现都是一样的，不用担心两者的性能差距。\n\n上述部分参考自：\n"
},
{
"path": "basic_content/pointer_refer/copy_construct.cpp",
"content": "/**\n * @file copy_construct.cpp\n * @brief g++ -o copy_construct copy_construct.cpp -fno-elide-constructors\n * -fno-elide-constructors选项(关闭返回值优化)\n * @author 光城\n * @version v1\n * @date 2019-08-09\n */\n\n#include \nusing namespace std;\n\nclass Copyable {\npublic:\n Copyable() {}\n Copyable(const Copyable &o) { cout << \"Copied\" << endl; }\n};\nCopyable ReturnRvalue() {\n return Copyable(); // 返回一个临时对象\n}\nvoid AcceptVal(Copyable a) {}\nvoid AcceptRef(const Copyable &a) {}\n\nint main() {\n cout << \"pass by value: \" << endl;\n AcceptVal(ReturnRvalue()); // 应该调用两次拷贝构造函数\n cout << \"pass by reference: \" << endl;\n AcceptRef(ReturnRvalue()); // 应该只调用一次拷贝构造函数\n}\n"
},
{
"path": "basic_content/pointer_refer/effec.cpp",
"content": "#include \nusing namespace std;\nvoid test1(int *p) {\n *p = 3; //此处应该首先判断p是否为空，为了测试的需要，此处我们没加。\n return;\n}\n\nvoid test2(int &p) {\n p = 3; //此处应该首先判断p是否为空，为了测试的需要，此处我们没加。\n return;\n}\n\nint main() {\n int a = 10;\n int *p = &a;\n test1(p);\n test2(a);\n cout << a << endl;\n return 0;\n}\n"
},
{
"path": "basic_content/sizeof/BUILD",
"content": "# please run `bazel run basic_content/sizeof:blackclass`\n# please run `bazel run basic_content/sizeof:genA`\n# please run `bazel run basic_content/sizeof:geninhe`\n# please run `bazel run basic_content/sizeof:moreinhe`\n# please run `bazel run basic_content/sizeof:morevir`\n# please run `bazel run basic_content/sizeof:static`\n# please run `bazel run basic_content/sizeof:virinhe`\n# please run `bazel run basic_content/sizeof:virmoreinhe`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"blackclass\",\n srcs = [\"blackclass.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"genA\",\n srcs = [\"genA.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"geninhe\",\n srcs = [\"geninhe.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"moreinhe\",\n srcs = [\"moreinhe.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"static\",\n srcs = [\"static.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"virinhe\",\n srcs = [\"virinhe.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"virmoreinhe\",\n srcs = [\"virmoreinhe.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/sizeof/README.md",
"content": "# 类大小计算\n\n首先来个总结，然后下面给出实际例子，实战！\n\n- 空类的大小为1字节\n- 一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。\n- 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。\n- 普通继承，派生类继承了所有基类的函数与成员，要按照字节对齐来计算大小\n- 虚函数继承，不管是单继承还是多继承，都是继承了基类的vptr。(32位操作系统4字节，64位操作系统 8字节)！\n- 虚继承,继承基类的vptr。\n\n## 1.原则1\n\n```c++\n/**\n * @file blackclass.cpp\n * @brief 空类的大小为1字节\n * @author 光城\n * @version v1\n * @date 2019-07-21\n */\n#include\nusing namespace std;\nclass A{};\nint main()\n{\n cout<\nusing namespace std;\nclass A\n{\n public:\n char b;\n virtual void fun() {};\n static int c;\n static int d;\n static int f;\n};\n\nint main()\n{\n /**\n * @brief 16 字节对齐、静态变量不影响类的大小、vptr指针=8\n */\n cout<\nusing namespace std;\nclass A{\n virtual void fun();\n virtual void fun1();\n virtual void fun2();\n virtual void fun3();\n};\nint main()\n{\n cout<\n\nusing namespace std;\n\nclass A\n{\n public:\n char a;\n int b;\n};\n\n/**\n * @brief 此时B按照顺序：\n * char a\n * int b\n * short a\n * long b\n * 根据字节对齐4+4+8+8=24\n * \n * 或编译器优化\n * char a\n * short a\n * int b\n * long b\n * 根据字节对齐2+2+4+8=16\n */\nclass B:A\n{\n public:\n short a;\n long b;\n};\n/**\n* 把A的成员拆开看，char为1，int为4，所以是1+（3）+4+1+（3）=12，（）为字节补齐\n*/\nclass C\n{\n A a;\n char c;\n};\n\nclass A1\n{\n virtual void fun(){}\n};\nclass C1:public A1\n{\n};\n\n\nint main()\n{\n cout<\nusing namespace std;\nclass A\n{\n virtual void fun() {}\n};\nclass B\n{\n virtual void fun2() {}\n};\nclass C : virtual public A, virtual public B\n{\n public:\n virtual void fun3() {}\n};\n\nint main()\n{\n /**\n * @brief 8 8 16 派生类虚继承多个虚函数，会继承所有虚函数的vptr\n */\n cout<\n#include \nusing namespace std;\nclass A {};\nint main() {\n cout << sizeof(A) << endl;\n return 0;\n}\n"
},
{
"path": "basic_content/sizeof/genA.cpp",
"content": "/**\n * @file genA.cpp\n * @brief\n * 普通成员函数，大小为1,一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。\n * @author 光城\n * @version v1\n * @date 2019-07-21\n */\n\n#include \n\nusing namespace std;\n\nclass A {\npublic:\n A();\n ~A();\n static int a;\n static void fun3();\n void fun();\n void fun1();\n};\n\nint main() {\n cout << sizeof(A) << endl; // 1\n return 0;\n}\n"
},
{
"path": "basic_content/sizeof/geninhe.cpp",
"content": "/**\n * @file geninhe.cpp\n * @brief 1.普通单继承,继承就是基类+派生类自身的大小(注意字节对齐)\n * 注意：类的数据成员按其声明顺序加入内存，无访问权限无关，只看声明顺序。\n * 2.虚单继承，派生类继承基类vptr\n * @author 光城\n * @version v1\n * @date 2019-07-21\n */\n\n#include \n\nusing namespace std;\n\nclass A {\npublic:\n char a;\n int b;\n};\n\n/**\n * @brief 此时B按照顺序：\n * char a\n * int b\n * short a\n * long b\n * 根据字节对齐4+4+8+8=24\n *\n * 或编译器优化\n * char a\n * short a\n * int b\n * long b\n * 根据字节对齐2+2+4+8=16\n */\nclass B : A {\npublic:\n short a;\n long b;\n};\n/**\n * 把A的成员拆开看，char为1，int为4，所以是1+（3）+4+1+（3）=12，（）为字节补齐\n */\nclass C {\n A a;\n char c;\n};\n\nclass A1 {\n virtual void fun() {}\n};\nclass C1 : public A1 {};\n\nint main() {\n cout << sizeof(A) << endl; // 8\n cout << sizeof(B) << endl; // 16\n cout << sizeof(C) << endl; // 12\n\n /**\n * @brief 对于虚单函数继承，派生类也继承了基类的vptr，所以是8字节\n */\n cout << sizeof(C1) << endl; // 8\n return 0;\n}\n"
},
{
"path": "basic_content/sizeof/moreinhe.cpp",
"content": "/**\n * @file moreinhe.cpp\n * @brief 普通多继承与虚函数多继承\n * @author 光城\n * @version v1\n * @date 2019-07-21\n */\n\n#include \n\nusing namespace std;\n\nclass A {\npublic:\n char a;\n int b;\n};\n\nclass B {\npublic:\n short a;\n long b;\n};\n\n/**\n * @brief 8+16+8=32\n */\nclass C : A, B {\n char c;\n};\n\nint main() {\n cout << sizeof(A) << endl; // 8\n cout << sizeof(B) << endl; // 16\n cout << sizeof(C) << endl; // 32\n\n return 0;\n}\n"
},
{
"path": "basic_content/sizeof/morevir.cpp",
"content": "/**\n * @file morevir.cpp\n * @brief 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。\n * @author 光城\n * @version v1\n * @date 2019-07-21\n */\n\n#include \n\nusing namespace std;\n\nclass A {\n\n virtual void fun();\n virtual void fun1();\n virtual void fun2();\n virtual void fun3();\n};\nint main() {\n cout << sizeof(A) << endl;\n return 0;\n}\n"
},
{
"path": "basic_content/sizeof/static.cpp",
"content": "/**\n * @file static.cpp\n * @brief 静态数据成员\n * 静态数据成员被编译器放在程序的一个global data\n * members中，它是类的一个数据成员，但不影响类的大小。不管这个类产生了多少个实例，还是派生了多少新的类，静态数据成员只有一个实例。静态数据成员，一旦被声明，就已经存在。\n * @author 光城\n * @version v1\n * @date 2019-07-21\n */\n\n#include \nusing namespace std;\nclass A {\npublic:\n char b;\n virtual void fun(){};\n static int c;\n static int d;\n static int f;\n};\n\nint main() {\n\n /**\n * @brief 16 字节对齐、静态变量不影响类的大小、vptr指针=8\n */\n cout << sizeof(A) << endl;\n\n return 0;\n}\n"
},
{
"path": "basic_content/sizeof/virinhe.cpp",
"content": "/**\n * @file virnhe.cpp\n * @brief 虚继承\n * @author 光城\n * @version v1\n * @date 2019-07-21\n */\n\n#include \n\nusing namespace std;\n\nclass A {\n virtual void fun() {}\n};\n\nclass B {\n virtual void fun2() {}\n};\nclass C : virtual public A, virtual public B {\npublic:\n virtual void fun3() {}\n};\n\nint main() {\n\n /**\n * @brief 8 8 16 派生类虚继承多个虚函数，会继承所有虚函数的vptr\n */\n cout << sizeof(A) << \" \" << sizeof(B) << \" \" << sizeof(C);\n\n return 0;\n}\n"
},
{
"path": "basic_content/sizeof/virmoreinhe.cpp",
"content": "/**\n * @file virmoreinhe.cpp\n * @brief 虚函数多继承\n * @author 光城\n * @version v1\n * @date 2019-07-21\n */\n\n#include \n\nusing namespace std;\n\nclass A {\n virtual void fun() {}\n};\n\nclass B {\n virtual void fun2() {}\n};\nclass C : public A, public B {\npublic:\n virtual void fun3() {}\n};\n\nint main() {\n\n /**\n * @brief 8 8 16 派生类继承多个虚函数，会继承所有虚函数的vptr\n */\n cout << sizeof(A) << \" \" << sizeof(B) << \" \" << sizeof(C);\n\n return 0;\n}\n"
},
{
"path": "basic_content/static/BUILD",
"content": "# please run `bazel run basic_content/static:nostatic_class`\n# please run `bazel run basic_content/static:static_class`\n# please run `bazel run basic_content/static:static_demo`\n# please run `bazel run basic_content/static:static_error_variable`\n# please run `bazel run basic_content/static:static_funciton`\n# please run `bazel run basic_content/static:static_variable`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"nostatic_class\",\n srcs = [\"nostatic_class.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"static_class\",\n srcs = [\"static_class.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"static_demo\",\n srcs = [\"static_demo.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"sstatic_error_variable\",\n srcs = [\"static_error_variable.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"static_funciton\",\n srcs = [\"static_funciton.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"static_variable\",\n srcs = [\"static_variable.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/static/README.md",
"content": "# static那些事\n\n## 关于作者\n\n微信公众号：\n\n\n\n当与不同类型一起使用时，Static关键字具有不同的含义。我们可以使用static关键字：\n\n**静态变量：** 函数中的变量，类中的变量\n\n**静态类的成员：** 类对象和类中的函数\n\n现在让我们详细看一下静态的这些用法：\n\n**静态变量**\n\n- 函数中的静态变量\n\n当变量声明为static时，空间**将在程序的生命周期内分配**。即使多次调用该函数，静态变量的空间也**只分配一次**，前一次调用中的变量值通过下一次函数调用传递。这对于在C / C ++或需要存储先前函数状态的任何其他应用程序非常有用。\n\n```c++\n#include \n#include \nusing namespace std; \n\nvoid demo() \n{ \n\t// static variable \n\tstatic int count = 0; \n\tcout << count << \" \"; \n\t\n\t// value is updated and \n\t// will be carried to next \n\t// function calls \n\tcount++; \n} \n\nint main() \n{ \n\tfor (int i=0; i<5; i++)\t \n\t\tdemo(); \n\treturn 0; \n} \n```\n\n输出：\n\n```\n0 1 2 3 4 \n```\n\n您可以在上面的程序中看到变量count被声明为static。因此，它的值通过函数调用来传递。每次调用函数时，都不会对变量计数进行初始化。\n\n- 类中的静态变量\n\n由于声明为static的变量只被初始化一次，因为它们在单独的静态存储中分配了空间，因此类中的静态变量**由对象共享**。对于不同的对象，不能有相同静态变量的多个副本。也是因为这个原因，静态变量不能使用构造函数初始化。\n\n```c++\n\n#include \nusing namespace std; \n\nclass Apple \n{ \npublic: \n\tstatic int i; \n\t\n\tApple() \n\t{ \n\t\t// Do nothing \n\t}; \n}; \n\nint main() \n{ \nApple obj1; \nApple obj2; \nobj1.i =2; \nobj2.i = 3; \n\t\n// prints value of i \ncout << obj1.i<<\" \"< \nusing namespace std; \n\nclass Apple \n{ \npublic: \n\tstatic int i; \n\t\n\tApple() \n\t{ \n\t\t// Do nothing \n\t}; \n}; \n\nint Apple::i = 1; \n\nint main() \n{ \n\tApple obj; \n\t// prints value of i \n\tcout << obj.i; \n} \n```\n\n输出：\n\n```\n1\n```\n\n**静态成员**\n\n- 类对象为静态\n\n就像变量一样，对象也在声明为static时具有范围，直到程序的生命周期。\n\n考虑以下程序，其中对象是非静态的。\n\n```c++\n#include \nusing namespace std; \n\nclass Apple \n{ \n\tint i; \n\tpublic: \n\t\tApple() \n\t\t{ \n\t\t\ti = 0; \n\t\t\tcout << \"Inside Constructor\\n\"; \n\t\t} \n\t\t~Apple() \n\t\t{ \n\t\t\tcout << \"Inside Destructor\\n\"; \n\t\t} \n}; \n\nint main() \n{ \n\tint x = 0; \n\tif (x==0) \n\t{ \n\t\tApple obj; \n\t} \n\tcout << \"End of main\\n\"; \n} \n\n```\n\n\n输出：\n\n```c++\nInside Constructor\nInside Destructor\nEnd of main\n```\n\n在上面的程序中，对象在if块内声明为非静态。因此，变量的范围仅在if块内。因此，当创建对象时，将调用构造函数，并且在if块的控制权越过析构函数的同时调用，因为对象的范围仅在声明它的if块内。\n如果我们将对象声明为静态，现在让我们看看输出的变化。\n\n```c++\n#include \nusing namespace std; \n\nclass Apple \n{ \n\tint i; \n\tpublic: \n\t\tApple() \n\t\t{ \n\t\t\ti = 0; \n\t\t\tcout << \"Inside Constructor\\n\"; \n\t\t} \n\t\t~Apple() \n\t\t{ \n\t\t\tcout << \"Inside Destructor\\n\"; \n\t\t} \n}; \n\nint main() \n{ \n\tint x = 0; \n\tif (x==0) \n\t{ \n\t\tstatic Apple obj; \n\t} \n\tcout << \"End of main\\n\"; \n} \n\n```\n\n\n输出：\n\n```\nInside Constructor\nEnd of main\nInside Destructor\n```\n\n您可以清楚地看到输出的变化。现在，在main结束后调用析构函数。这是因为静态对象的范围是贯穿程序的生命周期。\n\n- 类中的静态函数\n\n就像类中的静态数据成员或静态变量一样，静态成员函数也不依赖于类的对象。我们被允许使用对象和'.'来调用静态成员函数。但建议使用类名和范围解析运算符调用静态成员。\n\n允许静态成员函数仅访问静态数据成员或其他静态成员函数，它们无法访问类的非静态数据成员或成员函数。\n\n```c++\n#include \nusing namespace std; \n\nclass Apple \n{ \n public: \n // static member function \n static void printMsg() \n {\n cout<<\"Welcome to Apple!\"; \n }\n}; \n\n// main function \nint main() \n{ \n // invoking a static member function \n Apple::printMsg(); \n} \n```\n\n输出：\n\n```\nWelcome to Apple!\n```\n\n**限定访问范围**\nstatic还有限定访问范围的作用（类似于匿名名字空间）。来自issue:https://github.com/Light-City/CPlusPlusThings/issues/142\n```cpp\n// source1.cpp\nextern void sayHello();\nconst char* msg = \"Hello World!\\n\";\nint main()\n{\n sayHello();\n return 0;\n}\n\n// source2.cpp\n#include \nextern char* msg;\nvoid sayHello()\n{\n printf(\"%s\", msg);\n}\n```\ng++对于上面两个代码文件是可以正常编译并且打印Hello World!，但如果给source1.cpp中的msg加上static，则会导致undefined reference to 'msg'的编译错误：\n```cpp\n// source1.cpp\nextern void sayHello();\nstatic const char* msg = \"Hello World!\\n\";\nint main()\n{\n sayHello();\n return 0;\n}\n```\n"
},
{
"path": "basic_content/static/nostatic_class.cpp",
"content": "#include \nusing namespace std;\n\nclass Apple {\n int i;\n\npublic:\n Apple() {\n i = 0;\n cout << \"Inside Constructor\\n\";\n }\n ~Apple() { cout << \"Inside Destructor\\n\"; }\n};\n\nint main() {\n int x = 0;\n if (x == 0) {\n Apple obj;\n }\n cout << \"End of main\\n\";\n}\n"
},
{
"path": "basic_content/static/static_class.cpp",
"content": "#include \nusing namespace std;\n\nclass Apple {\n int i;\n\npublic:\n Apple() {\n i = 0;\n cout << \"Inside Constructor\\n\";\n }\n ~Apple() { cout << \"Inside Destructor\\n\"; }\n};\n\nint main() {\n int x = 0;\n if (x == 0) {\n static Apple obj;\n }\n cout << \"End of main\\n\";\n}\n"
},
{
"path": "basic_content/static/static_demo.cpp",
"content": "// the use of static Static\n// variables in a Function\n#include \n#include \nusing namespace std;\n\nvoid demo() {\n // static variable\n static int count = 0;\n cout << count << \" \";\n\n // value is updated and\n // will be carried to next\n // function calls\n count++;\n}\n\nint main() {\n for (int i = 0; i < 5; i++)\n demo();\n return 0;\n}\n"
},
{
"path": "basic_content/static/static_error_variable.cpp",
"content": "// variables inside a class\n\n#include \nusing namespace std;\n\nclass Apple {\npublic:\n static int i;\n\n Apple(){\n // Do nothing\n };\n};\n\nint main() {\n Apple obj1;\n Apple obj2;\n obj1.i = 2;\n obj2.i = 3;\n\n // prints value of i\n cout << obj1.i << \" \" << obj2.i;\n}\n"
},
{
"path": "basic_content/static/static_funciton.cpp",
"content": "#include \nusing namespace std;\n\nclass Apple {\npublic:\n // static member function\n static void printMsg() { cout << \"Welcome to Apple!\"; }\n};\n\n// main function\nint main() {\n // invoking a static member function\n Apple::printMsg();\n}\n"
},
{
"path": "basic_content/static/static_variable.cpp",
"content": "// variables inside a class\n\n#include \nusing namespace std;\n\nclass GfG {\npublic:\n static int i;\n\n GfG(){\n // Do nothing\n };\n};\n\nint GfG::i = 1;\n\nint main() {\n GfG obj;\n // prints value of i\n cout << obj.i;\n}\n"
},
{
"path": "basic_content/struct/BUILD",
"content": "# please run `bazel run basic_content/struct:ext_struct_func`\n# please run `bazel run basic_content/struct:struct_func_func`\n# please run `bazel run basic_content/struct:struct_func`\n# please run `bazel run basic_content/struct:struct_func_cpp`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"ext_struct_func\",\n srcs = [\"ext_struct_func.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"struct_func_func\",\n srcs = [\"struct_func_func.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"struct_func\",\n srcs = [\"struct_func.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"struct_func_cpp\",\n srcs = [\"struct_func.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/struct/README.md",
"content": "# 一文搞懂C和C++中struct\n\n## 关于作者：\n\n个人公众号：\n\n\n\n## 1.C中struct\n\n- 在C中struct只单纯的用作数据的复合类型，也就是说，在结构体声明中只能将数据成员放在里面，而不能将函数放在里面。 \n- 在C结构体声明中不能使用C++访问修饰符，如：public、protected、private 而在C++中可以使用。\n- 在C中定义结构体变量，如果使用了下面定义必须加struct。\n- C的结构体不能继承（没有这一概念）。\n- 若结构体的名字与函数名相同，可以正常运行且正常的调用！例如：可以定义与 struct Base 不冲突的 void Base() {}。\n\n完整案例：\n\n```c\n#include\n\nstruct Base { // public\n int v1; \n// public: //error\n int v2; \n //private:\n int v3; \n //void print(){ // c中不能在结构体中嵌入函数\n // printf(\"%s\\n\",\"hello world\");\n //}; //error!\n};\n\nvoid Base(){\n printf(\"%s\\n\",\"I am Base func\");\n}\n//struct Base base1; //ok\n//Base base2; //error\nint main() {\n struct Base base;\n base.v1=1;\n //base.print();\n printf(\"%d\\n\",base.v1);\n Base();\n return 0;\n}\n```\n\n最后输出：\n\n```\n1\nI am Base func\n```\n\n完整代码见：[struct_func.c](./struct_func.c)\n\n## 2.C++中struct\n\n与C对比如下：\n\n- C++结构体中不仅可以定义数据，还可以定义函数。\n- C++结构体中可以使用访问修饰符，如：public、protected、private 。\n- C++结构体使用可以直接使用不带struct。\n- C++继承\n- 若结构体的名字与函数名相同，可以正常运行且正常的调用！但是定义结构体变量时候只能用带struct的！\n\n例如：\n\n> 情形1：不适用typedef定义结构体别名\n\n未添加同名函数前：\n\n```c++\nstruct Student {\n \n};\n//Student(){}\nstruct Student s; //ok\nStudent s; //ok\n```\n\n添加同名函数后：\n\n```c++\nstruct Student {\n \n};\nStudent(){}\nstruct Student s; //ok\nStudent s; //error\n```\n\n> 情形二：使用typedef定义结构体别名\n\n```c++\ntypedef struct Base1 { \n int v1;\n int v3;\n public: //显示声明public\n int v2;\n void print(){ \n printf(\"%s\\n\",\"hello world\");\n }; \n}B;\n//void B() {} //error! 符号 \"B\" 已经被定义为一个 \"struct Base1\" 的别名\n```\n\n> 前三种案例\n\n```c++\n#include\n#include\n\nstruct Base { \n int v1;\n// private: //error!\n int v3;\n public: //显示声明public\n int v2;\n void print(){ \n printf(\"%s\\n\",\"hello world\");\n }; \n};\n\nint main() {\n struct Base base1; //ok\n Base base2; //ok\n Base base;\n base.v1=1;\n base.v3=2;\n base.print();\n printf(\"%d\\n\",base.v1);\n printf(\"%d\\n\",base.v3);\n return 0;\n}\n```\n\n完整代码见：[struct_func.cpp](struct_func.cpp)\n\n> 继承案例\n\n```c++\n#include\n#include\nstruct Base { \n int v1;\n// private: //error!\n int v3;\n public: //显示声明public\n int v2;\n virtual void print(){ \n printf(\"%s\\n\",\"Base\");\n }; \n};\nstruct Derived:Base { \n\n public:\n int v2;\n void print(){ \n printf(\"%s\\n\",\"Derived\");\n }; \n};\nint main() {\n Base *b=new Derived();\n b->print();\n return 0;\n}\n```\n\n完整代码见：[ext_struct_func.cpp](./ext_struct_func.cpp)\n\n> 同名函数\n\n```c++\n#include\n#include\n\nstruct Base { \n int v1;\n// private: //error!\n int v3;\n public: //显示声明public\n int v2;\n void print(){ \n printf(\"%s\\n\",\"hello world\");\n }; \n};\n\ntypedef struct Base1 { \n int v1;\n// private: //error!\n int v3;\n public: //显示声明public\n int v2;\n void print(){ \n printf(\"%s\\n\",\"hello world\");\n }; \n}B;\nvoid Base(){\n printf(\"%s\\n\",\"I am Base func\");\n}\n//void B() {} //error! 符号 \"B\" 已经被定义为一个 \"struct Base1\" 的别名\nint main() {\n struct Base base; //ok\n //Base base1; // error!\n base.v1=1;\n base.v3=2;\n base.print();\n printf(\"%d\\n\",base.v1);\n printf(\"%d\\n\",base.v3);\n Base();\n return 0;\n}\n```\n完整代码见：[struct_func_func.cpp](./struct_func_func.cpp)\n\n## 3.总结\n\n### C和C++中的Struct区别\n\n| C | C++ |\n| ------------------------------------------------------ | ------------------------------------------------------------ |\n| 不能将函数放在结构体声明 | 能将函数放在结构体声明 |\n| 在C结构体声明中不能使用C++访问修饰符。 | public、protected、private 在C++中可以使用。 |\n| 在C中定义结构体变量，如果使用了下面定义必须加struct。 | 可以不加struct |\n| 结构体不能继承（没有这一概念）。 | 可以继承 |\n| 若结构体的名字与函数名相同，可以正常运行且正常的调用！ | 若结构体的名字与函数名相同，使用结构体，只能使用带struct定义！ |\n"
},
{
"path": "basic_content/struct/ext_struct_func.cpp",
"content": "#include \n#include \nusing namespace std;\nstruct Base {\n int v1;\n // private: //error!\n int v3;\n\npublic: // 显示声明public\n int v2;\n virtual void print() { printf(\"%s\\n\", \"Base\"); };\n Base() { cout << \"Base construct\" << endl; };\n virtual ~Base() { cout << \"Base deconstruct\" << endl; };\n};\n\nstruct Derived : Base {\n\n Derived() { cout << \"Derived construct\" << endl; };\n virtual ~Derived() { cout << \"Derived deconstruct\" << endl; };\n\npublic:\n int v2;\n void print() { printf(\"%s\\n\", \"Derived\"); };\n};\n\nint main() {\n Base *b = new Derived();\n b->print();\n delete b;\n return 0;\n}\n"
},
{
"path": "basic_content/struct/struct_func.c",
"content": "#include \n\nstruct Base\n{ // public\n int v1;\n // public: //error\n int v2;\n // private:\n int v3;\n // void print(){ // c中不能在结构体中嵌入函数\n // printf(\"%s\\n\",\"hello world\");\n // }; //error!\n};\n\nvoid Base()\n{\n printf(\"%s\\n\", \"I am Base func\");\n}\n// struct Base base1; //ok\n// Base base2; //error\n\nint main()\n{\n struct Base base;\n base.v1 = 1;\n // base.print();\n printf(\"%d\\n\", base.v1);\n Base();\n return 0;\n}\n"
},
{
"path": "basic_content/struct/struct_func.cpp",
"content": "#include \n#include \n\nstruct Base {\n int v1;\n // private: //error!\n int v3;\n\npublic: // 显示声明public\n int v2;\n void print() { printf(\"%s\\n\", \"hello world\"); };\n};\n\nint main() {\n struct Base base1; // ok\n Base base2; // ok\n Base base;\n base.v1 = 1;\n base.v3 = 2;\n base.print();\n printf(\"%d\\n\", base.v1);\n printf(\"%d\\n\", base.v3);\n return 0;\n}\n"
},
{
"path": "basic_content/struct/struct_func_func.cpp",
"content": "#include \n#include \n\nstruct Base {\n int v1;\n // private: //error!\n int v3;\n\npublic: // 显示声明public\n int v2;\n void print() { printf(\"%s\\n\", \"hello world\"); };\n};\n\ntypedef struct Base1 {\n int v1;\n // private: //error!\n int v3;\n\npublic: // 显示声明public\n int v2;\n void print() { printf(\"%s\\n\", \"hello world\"); };\n} B;\nvoid Base() { printf(\"%s\\n\", \"I am Base func\"); }\n// void B() {} //error! 符号 \"B\" 已经被定义为一个 \"struct Base1\" 的别名\nint main() {\n struct Base base; // ok\n // Base base1; // error!\n base.v1 = 1;\n base.v3 = 2;\n base.print();\n printf(\"%d\\n\", base.v1);\n printf(\"%d\\n\", base.v3);\n Base();\n return 0;\n}\n"
},
{
"path": "basic_content/struct_class/README.md",
"content": "# struct与class区别\n\n## 关于作者：\n\n个人公众号：\n\n\n\n关于C与C++中struct内容：见[struct那些事](../struct)\n\n总的来说，struct 更适合看成是一个数据结构的实现体，class 更适合看成是一个对象的实现体。\n\n区别:\n\n最本质的一个区别就是默认的访问控制\n\n默认的继承访问权限。struct 是 public 的，class 是 private 的。\n\nstruct 作为数据结构的实现体，它默认的数据访问控制是 public 的，而 class 作为对象的实现体，它默认的成员变量访问控制是 private 的。\n"
},
{
"path": "basic_content/this/BUILD",
"content": "# please run `bazel run basic_content/this:person`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"person\",\n srcs = [\"person.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/this/README.md",
"content": "# this指针那些事\n\n## 关于作者\n\n微信公众号：\n\n\n\n## 1.this指针\n\n相信在坐的很多人，都在学Python，对于Python来说有self，类比到C++中就是this指针，那么下面一起来深入分析this指针在类中的使用！\n\n首先来谈谈this指针的用处：\n\n（1）一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。\n\n（2）this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。\n\n其次，this指针的使用：\n\n（1）在类的非静态成员函数中返回类对象本身的时候，直接使用 return *this。\n\n（2）当参数与成员变量名相同时，如this->n = n （不能写成n = n)。\n\n另外，在网上大家会看到this会被编译器解析成`A *const `，`A const * `，究竟是哪一个呢？下面通过断点调试分析：\n\n现有如下例子：\n\n```c++\n#include\n#include\n\n\nusing namespace std;\nclass Person{\npublic:\n typedef enum {\n BOY = 0, \n GIRL \n }SexType;\n Person(char *n, int a,SexType s){\n name=new char[strlen(n)+1];\n strcpy(name,n);\n age=a;\n sex=s;\n }\n int get_age() const{\n \n return this->age; \n }\n Person& add_age(int a){\n age+=a;\n return *this; \n }\n ~Person(){\n delete [] name;\n }\nprivate:\n char * name;\n int age;\n SexType sex;\n};\n\n\nint main(){\n Person p(\"zhangsan\",20,Person::BOY); \n cout<\n#include \n\nusing namespace std;\nclass Person {\npublic:\n typedef enum { BOY = 0, GIRL } SexType;\n Person(char *n, int a, SexType s) {\n name = new char[strlen(n) + 1];\n strcpy(name, n);\n age = a;\n sex = s;\n }\n int get_age() const { return this->age; }\n Person &add_age(int a) {\n age += a;\n return *this;\n }\n ~Person() { delete[] name; }\n\nprivate:\n char *name;\n int age;\n SexType sex;\n};\n\nint main() {\n Person p(\"zhangsan\", 20, Person::BOY);\n cout << p.get_age() << endl;\n\n return 0;\n}\n"
},
{
"path": "basic_content/union/BUILD",
"content": "# please run `bazel run basic_content/union:union`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"union\",\n srcs = [\"union.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/union/README.md",
"content": "# UNION那些事\n\n## 关于作者：\n\n个人公众号：\n\n\n\n联合（union）是一种节省空间的特殊的类，一个 union 可以有多个数据成员，但是在任意时刻只有一个数据成员可以有值。当某个成员被赋值后其他成员变为未定义状态。联合有如下特点：\n\n- 默认访问控制符为 public\n- 可以含有构造函数、析构函数\n- 不能含有引用类型的成员\n- 不能继承自其他类，不能作为基类\n- 不能含有虚函数\n- 匿名 union 在定义所在作用域可直接访问 union 成员\n- 匿名 union 不能包含 protected 成员或 private 成员\n- 全局匿名联合必须是静态（static）的\n"
},
{
"path": "basic_content/union/union.cpp",
"content": "/**\n * @file union.cpp\n * @brief UNION\n * @author 光城\n * @version v1\n * @date 2019-08-06\n */\n\n#include \n/**\n * 默认访问控制符为public\n */\nunion UnionTest {\n /**\n * 可以含有构造函数、析构函数\n */\n UnionTest() : i(10) { print(i); };\n ~UnionTest(){};\n int i;\n\nprivate:\n void print(int i) { std::cout << i << std::endl; };\n};\n/**\n * 全局匿名联合必须是静态的\n */\nstatic union {\n int i;\n double d;\n};\n\nint main() {\n UnionTest u;\n\n union {\n int i;\n double d;\n };\n\n std::cout << u.i << std::endl; // 输出 UnionTest 联合的 10\n\n ::i = 20;\n std::cout << ::i << std::endl; // 输出全局静态匿名联合的 20\n /**\n * 匿名union在定义所在作用域可直接访问union成员\n */\n i = 30;\n std::cout << i << std::endl; // 输出局部匿名联合的 30\n\n return 0;\n}\n"
},
{
"path": "basic_content/using/BUILD",
"content": "# please run `bazel run basic_content/using:derived_base`\n# please run `bazel run basic_content/using:using_derived`\n# please run `bazel run basic_content/using:using_global`\n# please run `bazel run basic_content/using:using_typedef`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\n# Don't panic if you get compilation errors, this is what this code demonstrates, as expected.\ncc_binary(\n name = \"derived_base\",\n srcs = [\"derived_base.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"using_derived\",\n srcs = [\"using_derived.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"using_global\",\n srcs = [\"using_global.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"using_typedef\",\n srcs = [\"using_typedef.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/using/README.md",
"content": "# using那些事\n## 关于作者：\n\n个人公众号：\n\n\n\n## 基本使用\n\n局部与全局using，具体操作与使用见下面案例：\n\n```c++\n#include \n#define isNs1 1\n//#define isGlobal 2\nusing namespace std;\nvoid func() \n{\n cout<<\"::func\"<\nusing namespace std;\n\nclass Base{\n public:\n void f(){ cout<<\"f()\"< V1; \nusing V2 = vector;\n```\n完整代码见：[using_typedef.cpp](using_typedef.cpp)\n"
},
{
"path": "basic_content/using/derived_base.cpp",
"content": "#include \n\nusing namespace std;\n\nclass Base1 {\npublic:\n Base1() : value(10) {}\n virtual ~Base1() {}\n void test1() { cout << \"Base test1...\" << endl; }\n\nprotected: // 保护\n int value;\n};\n// 默认为私有继承\nclass Derived1 : Base1 {\npublic:\n void test2() { cout << \"value is \" << value << endl; }\n};\n\nclass Base {\npublic:\n Base() : value(20) {}\n virtual ~Base() {}\n void test1() { cout << \"Base test1...\" << endl; }\n\nprivate: // 私有\n int value;\n};\n\n/**\n * 子类对父类成员的访问权限跟如何继承没有任何关系，\n * “子类可以访问父类的public和protected成员，不可以访问父类的private成员”——这句话对任何一种继承都是成立的。\n *\n */\nclass Derived : Base {\npublic:\n using Base::value;\n void test2() { cout << \"value is \" << value << endl; }\n};\n\nint main() {\n Derived1 d1;\n d1.test2();\n\n Derived d;\n d.test2();\n return 0;\n}\n"
},
{
"path": "basic_content/using/using_derived.cpp",
"content": "/**\n * @file using_derived.cpp\n * @brief 函数重装\n * @author 光城\n * @version v1\n * @date 2019-08-07\n */\n\n#include \nusing namespace std;\n\nclass Base {\npublic:\n void f() { cout << \"f()\" << endl; }\n void f(int n) { cout << \"Base::f(int)\" << endl; }\n};\n\nclass Derived : private Base {\npublic:\n using Base::f;\n void f(int n) { cout << \"Derived::f(int)\" << endl; }\n};\n\nint main() {\n Derived d;\n d.f();\n d.f(1);\n return 0;\n}\n"
},
{
"path": "basic_content/using/using_global.cpp",
"content": "/**\n * @file using_global.cpp\n * @brief using各种使用\n * @author 光城\n * @version v1\n * @date 2019-08-07\n */\n\n#include \n#define isNs1 1\n// #define isGlobal 2\nusing namespace std;\nvoid func() { cout << \"::func\" << endl; }\n\nnamespace ns1 {\nvoid func() { cout << \"ns1::func\" << endl; }\n} // namespace ns1\n\nnamespace ns2 {\n#ifdef isNs1\nusing ns1::func; /// ns1中的函数\n#elif isGlobal\nusing ::func; /// 全局中的函数\n#else\nvoid func() { cout << \"other::func\" << endl; }\n#endif\n} // namespace ns2\n\nint main() {\n /**\n * 这就是为什么在c++中使用了cmath而不是math.h头文件\n */\n ns2::func(); // 会根据当前环境定义宏的不同来调用不同命名空间下的func()函数\n return 0;\n}\n"
},
{
"path": "basic_content/using/using_typedef.cpp",
"content": "/**\n * @file using_typedef.cpp\n * @brief bazel run basic_content/using:using_typedef\n * 取代typedef，使用using来定义别名\n * @author 光城\n * @version v1\n * @date 2019-08-07\n */\n\n#include \n#include \nusing namespace std;\n\ntypedef vector V1;\nusing V2 = vector;\n\nint main() {\n int nums1[] = {1, 2, 3, 4, 5, 6};\n V1 vec1(nums1, nums1 + sizeof(nums1) / sizeof(int));\n int nums2[] = {5, 7, 6};\n V2 vec2(nums2, nums2 + sizeof(nums2) / sizeof(int));\n\n for (auto i : vec1)\n cout << i << \" \";\n cout << endl;\n\n for (auto i : vec2)\n cout << i << \" \";\n cout << endl;\n\n return 0;\n}\n"
},
{
"path": "basic_content/virtual/README.md",
"content": "# virtual那些事\n\n## 关于作者：\n\n个人公众号：\n\n\n\n## 1.虚函数与运行多态\n\n对应的代码：[emp.cpp](./set1/emp.cpp)\n\n**虚函数的调用取决于指向或者引用的对象的类型，而不是指针或者引用自身的类型。**\n\n## 2.vptr与vtable\n\n见[vptr_vtable那些事](../vptr_vtable)\n\n## 3.虚函数中默认参数\n\n对应的代码：[default_arg.cpp](./set2/default_arg.cpp)\n\n**默认参数是静态绑定的，虚函数是动态绑定的。 默认参数的使用需要看指针或者引用本身的类型，而不是对象的类型**。\n\n## 4.可以不可以\n\n（1） **静态函数可以声明为虚函数吗？**\n\n原因主要有两方面：\n\n**静态函数不可以声明为虚函数，同时也不能被const 和 volatile关键字修饰**\n\nstatic成员函数不属于任何类对象或类实例，所以即使给此函数加上virutal也是没有任何意义\n\n虚函数依靠vptr和vtable来处理。vptr是一个指针，在类的构造函数中创建生成，并且只能用this指针来访问它，静态成员函数没有this指针，所以无法访问vptr。\n\n代码学习：[static_error.cpp ](./set3/static_error.cpp )\n\n（2）**构造函数可以为虚函数吗？**\n\n构造函数不可以声明为虚函数。同时除了inline|explicit之外，构造函数不允许使用其它任何关键字。\n\n为什么构造函数不可以为虚函数？\n\n尽管虚函数表vtable是在编译阶段就已经建立的，但指向虚函数表的指针vptr是在运行阶段实例化对象时才产生的。 如果类含有虚函数，编译器会在构造函数中添加代码来创建vptr。 问题来了，如果构造函数是虚的，那么它需要vptr来访问vtable，可这个时候vptr还没产生。 因此，构造函数不可以为虚函数。\n\n我们之所以使用虚函数，是因为需要在信息不全的情况下进行多态运行。而构造函数是用来初始化实例的，实例的类型必须是明确的。 因此，构造函数没有必要被声明为虚函数。\n\n代码学习：\n\n- [copy_consrtuct.cpp](./set3/copy_consrtuct.cpp) \n\n- [vir_con.cpp](./set3/vir_con.cpp) \n\n（3）**析构函数可以为虚函数吗？**\n\n**析构函数可以声明为虚函数。如果我们需要删除一个指向派生类的基类指针时，应该把析构函数声明为虚函数。 事实上，只要一个类有可能会被其它类所继承， 就应该声明虚析构函数(哪怕该析构函数不执行任何操作)。**\n\n代码学习：\n\n- [full_virde.cpp](./set3/full_virde.cpp)\n\n- [vir_de.cpp ](./set3/vir_de.cpp) \n\n（4）**虚函数可以为私有函数吗？**\n\n- 基类指针指向继承类对象，则调用继承类对象的函数；\n- int main()必须声明为Base类的友元，否则编译失败。 编译器报错： ptr无法访问私有函数。 当然，把基类声明为public， 继承类为private，该问题就不存在了。\n\n代码学习：\n\n- [virtual_function.cpp](./set3/virtual_function.cpp)\n- [virtual_function1.cpp](./set3/virtual_function1.cpp)\n\n（5）**虚函数可以被内联吗？**\n\n**通常类成员函数都会被编译器考虑是否进行内联。 但通过基类指针或者引用调用的虚函数必定不能被内联。 当然，实体对象调用虚函数或者静态调用时可以被内联，虚析构函数的静态调用也一定会被内联展开。**\n\n- 虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。\n- 内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。\n- `inline virtual` 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 `Base::who()`），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。\n\n代码学习：\n\n- [virtual_inline.cpp](./set3/virtual_inline.cpp)\n\n- [inline_virtual.cpp](./set3/inline_virtual.cpp)\n\n## 5.RTTI与dynamic_cast\n\nRTTI（Run-Time Type Identification)，通过运行时类型信息程序能够使用[基类](https://baike.baidu.com/item/%E5%9F%BA%E7%B1%BB/9589663)的[指针](https://baike.baidu.com/item/%E6%8C%87%E9%92%88/2878304)或引用来检查这些指针或引用所指的对象的实际[派生类](https://baike.baidu.com/item/%E6%B4%BE%E7%94%9F%E7%B1%BB)型。\n\n在面向对象程序设计中，有时我们需要在运行时查询一个对象是否能作为某种多态类型使用。与Java的instanceof，以及C#的as、is运算符类似，C++提供了dynamic_cast函数用于动态转型。相比C风格的强制类型转换和C++ reinterpret_cast，dynamic_cast提供了类型安全检查，是一种基于能力查询(Capability Query)的转换，所以在多态类型间进行转换更提倡采用dynamic_cast。\n\n代码学习：\n\n- [rtti.cpp](./set4/rtti.cpp)\n- [warn_rtti.cpp](./set4/warn_rtti.cpp)\n\n## 6.纯虚函数和抽象类\n\n见[纯虚函数和抽象类那些事](../abstract)\n"
},
{
"path": "basic_content/virtual/set1/BUILD",
"content": "# please run `bazel run basic_content/virtual/set1:emp`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"emp\",\n srcs = [\"emp.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/virtual/set1/emp.cpp",
"content": "#include \nusing namespace std;\n\nclass Employee {\npublic:\n virtual void raiseSalary() { cout << 0 << endl; }\n\n virtual void promote() { /* common promote code */\n }\n};\n\nclass Manager : public Employee {\n virtual void raiseSalary() { cout << 100 << endl; }\n\n virtual void promote() { /* Manager specific promote */\n }\n};\nclass Engineer : public Employee {\n virtual void raiseSalary() { cout << 200 << endl; }\n\n virtual void promote() { /* Manager specific promote */\n }\n};\n\n// Similarly, there may be other types of employees\n// We need a very simple function to increment salary of all employees\n// Note that emp[] is an array of pointers and actual pointed objects can\n// be any type of employees. This function should ideally be in a class\n// like Organization, we have made it global to keep things simple\nvoid globalRaiseSalary(Employee *emp[], int n) {\n for (int i = 0; i < n; i++)\n emp[i]->raiseSalary(); // Polymorphic Call: Calls raiseSalary()\n // according to the actual object, not\n // according to the type of pointer\n}\nint main() {\n Employee *emp[] = {new Manager(), new Engineer};\n globalRaiseSalary(emp, 2);\n return 0;\n}\n"
},
{
"path": "basic_content/virtual/set2/BUILD",
"content": "# please run `bazel run basic_content/virtual/set2:default_arg`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"default_arg\",\n srcs = [\"default_arg.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/virtual/set2/default_arg.cpp",
"content": "/**\n * @file first_example.cpp\n * @brief 虚函数中默认参数\n * 规则：虚函数是动态绑定的，默认参数是静态绑定的。默认参数的使用需要看指针或者应用本身的类型，而不是对象的类型！\n * @author 光城\n * @version v1\n * @date 2019-07-24\n */\n\n#include \nusing namespace std;\n\nclass Base {\npublic:\n virtual void fun(int x = 10) { cout << \"Base::fun(), x = \" << x << endl; }\n};\n\nclass Derived : public Base {\npublic:\n virtual void fun(int x = 20) { cout << \"Derived::fun(), x = \" << x << endl; }\n};\n\nint main() {\n Derived d1;\n Base *bp = &d1;\n bp->fun(); // 10\n return 0;\n}\n"
},
{
"path": "basic_content/virtual/set3/BUILD",
"content": "# please run `bazel run //basic_content/virtual/set3:copy_consrtuct`\n# please run `bazel run //basic_content/virtual/set3:full_virde`\n# please run `bazel run //basic_content/virtual/set3:inline_virtual`\n# please run `bazel run //basic_content/virtual/set3:vir_con`\n# please run `bazel run //basic_content/virtual/set3:vir_de`\n# please run `bazel run //basic_content/virtual/set3:virtual_function`\n# please run `bazel run //basic_content/virtual/set3:virtual_function1`\n# please run `bazel run //basic_content/virtual/set3:virtual_inline`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"copy_consrtuct\",\n srcs = [\"copy_consrtuct.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"full_virde\",\n srcs = [\"full_virde.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"inline_virtual\",\n srcs = [\"inline_virtual.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"vir_con\",\n srcs = [\"vir_con.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"vir_de\",\n srcs = [\"vir_de.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"virtual_function\",\n srcs = [\"virtual_function.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"virtual_function1\",\n srcs = [\"virtual_function1.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"virtual_inline\",\n srcs = [\"virtual_inline.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/virtual/set3/copy_consrtuct.cpp",
"content": "#include \nusing namespace std;\n\nclass Base {\npublic:\n};\n\nclass Derived : public Base {\npublic:\n Derived() { cout << \"Derived created\" << endl; }\n\n Derived(const Derived &rhs) {\n cout << \"Derived created by deep copy\" << endl;\n }\n\n ~Derived() { cout << \"Derived destroyed\" << endl; }\n};\n\nint main() {\n Derived s1;\n\n Derived s2 = s1; // Compiler invokes \"copy constructor\"\n // Type of s1 and s2 are concrete to compiler\n\n // How can we create Derived1 or Derived2 object\n // from pointer (reference) to Base class pointing Derived object?\n\n return 0;\n}\n"
},
{
"path": "basic_content/virtual/set3/full_virde.cpp",
"content": "/**\n * @file full_virde.cpp\n * @brief 将基类的析构函数声明为虚函数\n * 输出结果：\n * Constructing base\n * Constructing derived\n * Destructing derived\n * Destructing base\n * @author 光城\n * @version v1\n * @date 2019-07-24\n */\n#include \n\nusing namespace std;\n\nclass base {\npublic:\n base() { cout << \"Constructing base \\n\"; }\n virtual ~base() { cout << \"Destructing base \\n\"; }\n};\n\nclass derived : public base {\npublic:\n derived() { cout << \"Constructing derived \\n\"; }\n ~derived() { cout << \"Destructing derived \\n\"; }\n};\n\nint main(void) {\n derived *d = new derived();\n base *b = d;\n delete b;\n return 0;\n}\n"
},
{
"path": "basic_content/virtual/set3/inline_virtual.cpp",
"content": "#include \nusing namespace std;\nclass Base {\npublic:\n inline virtual void who() { cout << \"I am Base\\n\"; }\n virtual ~Base() {}\n};\nclass Derived : public Base {\npublic:\n inline void who() // 不写inline时隐式内联\n {\n cout << \"I am Derived\\n\";\n }\n};\n\nint main() {\n // 此处的虚函数\n // who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。\n Base b;\n b.who();\n\n // 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。\n Base *ptr = new Derived();\n ptr->who();\n\n // 因为Base有虚析构函数（virtual ~Base() {}），所以 delete\n // 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。\n delete ptr;\n\n return 0;\n}\n"
},
{
"path": "basic_content/virtual/set3/static_error.cpp",
"content": "/**\n * @file static_error.cpp\n * @brief 静态函数不可以声明为虚函数，同时也不能被const和volatile关键字修饰!\n * 原因如下：\n * static成员函数不属于任何类对象或类实例，所以即使给此函数加上virutal也是没有任何意义\n * 虚函数依靠vptr和vtable来处理。vptr是一个指针，在类的构造函数中创建生成，并且只能用this指针来访问它，静态成员函数没有this指针，所以无法访问vptr。\n * @author 光城\n * @version v1\n * @date 2019-07-24\n */\n\nvirtual static void fun() {}\nstatic void fun() const {}\n"
},
{
"path": "basic_content/virtual/set3/vir_con.cpp",
"content": "/**\n * @file vir_con.cpp\n * @brief\n * 构造函数不可以声明为虚函数。同时除了inline之外，构造函数不允许使用其它任何关键字。\n *\n * 为什么构造函数不可以为虚函数？\n *\n * 尽管虚函数表vtable是在编译阶段就已经建立的，但指向虚函数表的指针vptr是在运行阶段实例化对象时才产生的。\n * 如果类含有虚函数，编译器会在构造函数中添加代码来创建vptr。\n * 问题来了，如果构造函数是虚的，那么它需要vptr来访问vtable，可这个时候vptr还没产生。\n * 因此，构造函数不可以为虚函数。\n * 我们之所以使用虚函数，是因为需要在信息不全的情况下进行多态运行。而构造函数是用来初始化实例的，实例的类型必须是明确的。\n * 因此，构造函数没有必要被声明为虚函数。\n * 尽管构造函数不可以为虚函数，但是有些场景下我们确实需要 “Virtual Copy\n * Constructor”。\n * “虚复制构造函数”的说法并不严谨，其只是一个实现了对象复制的功能的类内函数。\n * 举一个应用场景，比如剪切板功能。\n * 复制内容作为基类，但派生类可能包含文字、图片、视频等等。\n * 我们只有在程序运行的时候才知道我们需要复制的具体是什么类型的数据。\n *\n * @author 光城\n * @version v1\n * @date 2019-07-24\n */\n\n#include \nusing namespace std;\n\n//// LIBRARY SRART\nclass Base {\npublic:\n Base() {}\n\n virtual // Ensures to invoke actual object destructor\n ~Base() {}\n\n virtual void ChangeAttributes() = 0;\n\n // The \"Virtual Constructor\"\n static Base *Create(int id);\n\n // The \"Virtual Copy Constructor\"\n virtual Base *Clone() = 0;\n};\n\nclass Derived1 : public Base {\npublic:\n Derived1() { cout << \"Derived1 created\" << endl; }\n\n Derived1(const Derived1 &rhs) {\n cout << \"Derived1 created by deep copy\" << endl;\n }\n\n ~Derived1() { cout << \"~Derived1 destroyed\" << endl; }\n\n void ChangeAttributes() { cout << \"Derived1 Attributes Changed\" << endl; }\n\n Base *Clone() { return new Derived1(*this); }\n};\n\nclass Derived2 : public Base {\npublic:\n Derived2() { cout << \"Derived2 created\" << endl; }\n\n Derived2(const Derived2 &rhs) {\n cout << \"Derived2 created by deep copy\" << endl;\n }\n\n ~Derived2() { cout << \"~Derived2 destroyed\" << endl; }\n\n void ChangeAttributes() { cout << \"Derived2 Attributes Changed\" << endl; }\n\n Base *Clone() { return new Derived2(*this); }\n};\n\nclass Derived3 : public Base {\npublic:\n Derived3() { cout << \"Derived3 created\" << endl; }\n\n Derived3(const Derived3 &rhs) {\n cout << \"Derived3 created by deep copy\" << endl;\n }\n\n ~Derived3() { cout << \"~Derived3 destroyed\" << endl; }\n\n void ChangeAttributes() { cout << \"Derived3 Attributes Changed\" << endl; }\n\n Base *Clone() { return new Derived3(*this); }\n};\n\n// We can also declare \"Create\" outside Base.\n// But is more relevant to limit it's scope to Base\nBase *Base::Create(int id) {\n // Just expand the if-else ladder, if new Derived class is created\n // User need not be recompiled to create newly added class objects\n\n if (id == 1) {\n return new Derived1;\n } else if (id == 2) {\n return new Derived2;\n } else {\n return new Derived3;\n }\n}\n//// LIBRARY END\n\n//// UTILITY SRART\nclass User {\npublic:\n User() : pBase(0) {\n // Creates any object of Base heirarchey at runtime\n\n int input;\n\n cout << \"Enter ID (1, 2 or 3): \";\n cin >> input;\n\n while ((input != 1) && (input != 2) && (input != 3)) {\n cout << \"Enter ID (1, 2 or 3 only): \";\n cin >> input;\n }\n\n // Create objects via the \"Virtual Constructor\"\n pBase = Base::Create(input);\n }\n\n ~User() {\n if (pBase) {\n delete pBase;\n pBase = 0;\n }\n }\n\n void Action() {\n // Duplicate current object\n Base *pNewBase = pBase->Clone();\n\n // Change its attributes\n pNewBase->ChangeAttributes();\n\n // Dispose the created object\n delete pNewBase;\n }\n\nprivate:\n Base *pBase;\n};\n\n//// UTILITY END\n\n//// Consumer of User (UTILITY) class\nint main() {\n User *user = new User();\n\n user->Action();\n\n delete user;\n}\n"
},
{
"path": "basic_content/virtual/set3/vir_de.cpp",
"content": "/**\n * @file vir_de.cpp\n * @brief 派生类的析构函数没有被调用!\n * 输出结果：\n * Constructing base\n * Constructing derived\n * Destructing base\n * @author 光城\n * @version v1\n * @date 2019-07-24\n */\n\n// CPP program without virtual destructor\n// causing undefined behavior\n#include \n\nusing namespace std;\n\nclass base {\npublic:\n base() { cout << \"Constructing base \\n\"; }\n ~base() { cout << \"Destructing base \\n\"; }\n};\n\nclass derived : public base {\npublic:\n derived() { cout << \"Constructing derived \\n\"; }\n ~derived() { cout << \"Destructing derived \\n\"; }\n};\n\nint main(void) {\n derived *d = new derived();\n base *b = d;\n delete b;\n return 0;\n}\n"
},
{
"path": "basic_content/virtual/set3/virtual_function.cpp",
"content": "/**\n * @file virtual_function.cpp\n * @brief 虚函数可以被私有化，但有一些细节需要注意。\n * 基类指针指向继承类对象，则调用继承类对象的函数；\n * int main()必须声明为Base类的友元，否则编译失败。 编译器报错：\n * ptr无法访问私有函数。 当然，把基类声明为public，\n * 继承类为private，该问题就不存在了。----> 见另外一个例子！\n * @author 光城\n * @version v1\n * @date 2019-07-24\n */\n\n#include \nusing namespace std;\n\nclass Derived;\n\nclass Base {\nprivate:\n virtual void fun() { cout << \"Base Fun\"; }\n friend int main();\n};\n\nclass Derived : public Base {\npublic:\n void fun() { cout << \"Derived Fun\"; }\n};\n\nint main() {\n Base *ptr = new Derived;\n ptr->fun();\n return 0;\n}\n"
},
{
"path": "basic_content/virtual/set3/virtual_function1.cpp",
"content": "#include \nusing namespace std;\n\nclass Derived;\n\nclass Base {\npublic:\n virtual void fun() { cout << \"Base Fun\"; }\n // friend int main();\n};\n\nclass Derived : public Base {\nprivate:\n void fun() { cout << \"Derived Fun\"; }\n};\n\nint main() {\n Base *ptr = new Derived;\n ptr->fun();\n return 0;\n}\n"
},
{
"path": "basic_content/virtual/set3/virtual_inline.cpp",
"content": "/**\n * @file virtual_inline.cpp\n * @brief 通常类成员函数都会被编译器考虑是否进行内联。\n * 但通过基类指针或者引用调用的虚函数必定不能被内联。\n * 当然，实体对象调用虚函数或者静态调用时可以被内联，虚析构函数的静态调用也一定会被内联展开。\n * @author 光城\n * @version v1\n * @date 2019-07-24\n */\n\n#include \nusing namespace std;\nclass Base {\npublic:\n virtual void who() { cout << \"I am Base\\n\"; }\n};\nclass Derived : public Base {\npublic:\n void who() { cout << \"I am Derived\\n\"; }\n};\n\nint main() {\n // note here virtual function who() is called through\n // object of the class (it will be resolved at compile\n // time) so it can be inlined.\n Base b;\n b.who();\n\n // Here virtual function is called through pointer,\n // so it cannot be inlined\n Base *ptr = new Derived();\n ptr->who();\n\n return 0;\n}\n"
},
{
"path": "basic_content/virtual/set4/BUILD",
"content": "# please run `bazel run basic_content/virtual/set4:rtti`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"rtti\",\n srcs = [\"rtti.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/virtual/set4/rtti.cpp",
"content": "/**\n * @file rtti.cpp\n * @brief\n * 在面向对象程序设计中，有时我们需要在运行时查询一个对象是否能作为某种多态类型使用。与Java的instanceof，以及C#的as、is运算符类似，C++提供了dynamic_cast函数用于动态转型。相比C风格的强制类型转换和C++\n * reinterpret_cast，dynamic_cast提供了类型安全检查，是一种基于能力查询(Capability\n * Query)的转换，所以在多态类型间进行转换更提倡采用dynamic_cast\n * @author 光城\n * @version v1\n * @date 2019-07-24\n */\n\n// CPP program to illustrate\n// Run Time Type Identification\n#include \n#include \nusing namespace std;\nclass B {\n virtual void fun() {}\n};\nclass D : public B {};\n\nint main() {\n B *b = new D; // 向上转型\n B &obj = *b;\n D *d = dynamic_cast(b); // 向下转型\n if (d != NULL)\n cout << \"works\" << endl;\n else\n cout << \"cannot cast B* to D*\";\n\n try {\n D &dobj = dynamic_cast(obj);\n cout << \"works\" << endl;\n } catch (bad_cast bc) { // ERROR\n cout << bc.what() << endl;\n }\n return 0;\n}\n"
},
{
"path": "basic_content/virtual/set4/warn_rtti.cpp",
"content": "// 在使用时需要注意：被转换对象obj的类型T1必须是多态类型，即T1必须公有继承自其它类，或者T1拥有虚函数（继承或自定义）。若T1为非多态类型，使用dynamic_cast会报编译错误。\n\n// A为非多态类型\n\nclass A {};\n\n// B为多态类型\n\nclass B {\n\npublic:\n virtual ~B() {}\n};\n\n// D为非多态类型\n\nclass D : public A {};\n\n// E为非多态类型\n\nclass E : private A {};\n\n// F为多态类型\n\nclass F : private B {};\n"
},
{
"path": "basic_content/volatile/BUILD",
"content": "# please run `bazel run basic_content/volatile:noopt_vola`\n# please run `bazel run basic_content/volatile:volatile`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"noopt_vola\",\n srcs = [\"noopt_vola.cpp\"],\n copts = [\"-std=c++11\"]\n)\n\ncc_binary(\n name = \"volatile\",\n srcs = [\"volatile.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/volatile/README.md",
"content": "## 关于作者：\n\n个人公众号：\n\n\n\n## 1.volatile\n\n被 `volatile` 修饰的变量，在对其进行读写操作时，会引发一些**可观测的副作用**。而这些可观测的副作用，是由**程序之外的因素决定的**。\n\n## 2.volatile应用\n（1）并行设备的硬件寄存器（如状态寄存器）。\n假设要对一个设备进行初始化，此设备的某一个寄存器为0xff800000。\n\n```c++\nint *output = (unsigned int *)0xff800000; //定义一个IO端口； \nint init(void) \n{ \n int i; \n for(i=0;i< 10;i++)\n { \n *output = i; \n } \n}\n```\n经过编译器优化后，编译器认为前面循环半天都是废话，对最后的结果毫无影响，因为最终只是将output这个指针赋值为 9，所以编译器最后给你编译编译的代码结果相当于：\n```c++\nint init(void) \n{ \n *output = 9; \n}\n```\n如果你对此外部设备进行初始化的过程是必须是像上面代码一样顺序的对其赋值，显然优化过程并不能达到目的。反之如果你不是对此端口反复写操作，而是反复读操作，其结果是一样的，编译器在优化后，也许你的代码对此地址的读操作只做了一次。然而从代码角度看是没有任何问题的。这时候就该使用volatile通知编译器这个变量是一个不稳定的，在遇到此变量时候不要优化。\n\n（2）一个中断服务子程序中访问到的变量；\n\n```c++\nstatic int i=0;\n\nint main()\n{\n while(1)\n {\n if(i) dosomething();\n }\n}\n\n/* Interrupt service routine */\nvoid IRS()\n{\n\ti=1;\n}\n```\n上面示例程序的本意是产生中断时，由中断服务子程序IRS响应中断，变更程序变量i，使在main函数中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远不会被调用。如果将变量i加上volatile修饰，则编译器保证对变量i的读写操作都不会被优化，从而保证了变量i被外部程序更改后能及时在原程序中得到感知。\n\n（3）多线程应用中被多个任务共享的变量。\n当多个线程共享某一个变量时，该变量的值会被某一个线程更改，应该用 volatile 声明。作用是防止编译器优化把变量从内存装入CPU寄存器中，当一个线程更改变量后，未及时同步到其它线程中导致程序出错。volatile的意思是让编译器每次操作该变量时一定要从内存中真正取出，而不是使用已经存在寄存器中的值。示例如下：\n```c++\nvolatile bool bStop=false; //bStop 为共享全局变量 \n//第一个线程\nvoid threadFunc1()\n{\n ...\n while(!bStop){...}\n}\n//第二个线程终止上面的线程循环\nvoid threadFunc2()\n{\n ...\n bStop = true;\n}\n```\n要想通过第二个线程终止第一个线程循环，如果bStop不使用volatile定义，那么这个循环将是一个死循环，因为bStop已经读取到了寄存器中，寄存器中bStop的值永远不会变成FALSE，加上volatile，程序在执行时，每次均从内存中读出bStop的值，就不会死循环了。\n\n是否了解volatile的应用场景是区分C/C++程序员和嵌入式开发程序员的有效办法，搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，这些都要求用到volatile变量，不懂得volatile将会带来程序设计的灾难。\n\n## 3.volatile常见问题\n下面的问题可以看一下面试者是不是真正了解volatile。\n（1）一个参数既可以是const还可以是volatile吗？为什么？\n可以。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。\n\n（2）一个指针可以是volatile吗？为什么？\n可以。尽管这并不常见。一个例子是当一个中断服务子程序修改一个指向一个buffer的指针时。\n\n（3）下面的函数有什么错误？\n```c++\nint square(volatile int *ptr) \n{ \nreturn *ptr * *ptr; \n} \n```\n这段代码有点变态，其目的是用来返回指针ptr指向值的平方，但是，由于ptr指向一个volatile型参数，编译器将产生类似下面的代码：\n```c++\nint square(volatile int *ptr) \n{ \nint a,b; \na = *ptr; \nb = *ptr; \nreturn a * b; \n} \n```\n由于*ptr的值可能被意想不到地改变，因此a和b可能是不同的。结果，这段代码可能返回的不是你所期望的平方值！正确的代码如下：\n```c++\nlong square(volatile int *ptr) \n{ \nint a=*ptr; \nreturn a * a; \n} \n```\n## 4.volatile使用\n\n- volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素（操作系统、硬件、其它线程等）更改。所以使用 volatile 告诉编译器不应对这样的对象进行优化。\n\n- volatile 关键字声明的变量，每次访问时都必须从内存中取出值（没有被 volatile 修饰的变量，可能由于编译器的优化，从 CPU 寄存器中取值）\n- const 可以是 volatile （如只读的状态寄存器）\n- 指针可以是 volatile\n\n代码学习：\n\n- [noopt_vola.cpp](./noopt_vola.cpp)\n- [volatile.cpp](./volatile.cpp)\n\n"
},
{
"path": "basic_content/volatile/noopt_vola.cpp",
"content": "/* Compile code without optimization option */\n#include \nint main(void) {\n const int local = 10;\n int *ptr = (int *)&local;\n\n printf(\"Initial value of local : %d \\n\", local);\n\n *ptr = 100;\n\n printf(\"Modified value of local: %d \\n\", local);\n\n return 0;\n}\n"
},
{
"path": "basic_content/volatile/volatile.cpp",
"content": "/* Compile code with optimization option */\n#include \n\nint main(void) {\n const volatile int local = 10;\n int *ptr = (int *)&local;\n\n printf(\"Initial value of local : %d \\n\", local);\n\n *ptr = 100;\n\n printf(\"Modified value of local: %d \\n\", local);\n\n return 0;\n}\n"
},
{
"path": "basic_content/vptr_vtable/BUILD",
"content": "# please run `bazel run basic_content/vptr_vtable:vptr1`\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"vptr1\",\n srcs = [\"vptr1.cpp\"],\n copts = [\"-std=c++11\"]\n)"
},
{
"path": "basic_content/vptr_vtable/README.md",
"content": "# 深入浅出C++虚函数的vptr与vtable\n\n## 关于作者：\n\n个人公众号：\n\n\n\n\n\n## 1.基础理论\n\n为了实现虚函数，C ++使用一种称为虚拟表的特殊形式的后期绑定。该虚拟表是用于解决在动态/后期绑定方式的函数调用函数的查找表。虚拟表有时会使用其他名称，例如“vtable”，“虚函数表”，“虚方法表”或“调度表”。\n\n虚拟表实际上非常简单，虽然用文字描述有点复杂。首先，**每个使用虚函数的类（或者从使用虚函数的类派生）都有自己的虚拟表**。该表只是编译器在编译时设置的静态数组。虚拟表包含可由类的对象调用的每个虚函数的一个条目。此表中的每个条目只是一个函数指针，指向该类可访问的派生函数。\n\n其次，编译器还会添加一个隐藏指向基类的指针，我们称之为vptr。vptr在创建类实例时自动设置，以便指向该类的虚拟表。与this指针不同，this指针实际上是编译器用来解析自引用的函数参数，vptr是一个真正的指针。\n\n因此，它使每个类对象的分配大一个指针的大小。这也意味着vptr由派生类继承，这很重要。\n\n## 2.实现与内部结构\n\n下面我们来看自动与手动操纵vptr来获取地址与调用虚函数！\n\n开始看代码之前，为了方便大家理解，这里给出调用图：\n\n\n\n代码全部遵循标准的注释风格，相信大家看了就会明白，不明白的话，可以留言！\n\n```c++\n/**\n * @file vptr1.cpp\n * @brief C++虚函数vptr和vtable\n * 编译：g++ -g -o vptr vptr1.cpp -std=c++11\n * @author 光城\n * @version v1\n * @date 2019-07-20\n */\n\n#include \n#include \nusing namespace std;\n\n/**\n * @brief 函数指针\n */\ntypedef void (*Fun)();\n\n/**\n * @brief 基类\n */\nclass Base\n{\n public:\n Base(){};\n virtual void fun1()\n {\n cout << \"Base::fun1()\" << endl;\n }\n virtual void fun2()\n {\n cout << \"Base::fun2()\" << endl;\n }\n virtual void fun3(){}\n ~Base(){};\n};\n\n/**\n * @brief 派生类\n */\nclass Derived: public Base\n{\n public:\n Derived(){};\n void fun1()\n {\n cout << \"Derived::fun1()\" << endl;\n }\n void fun2()\n {\n cout << \"DerivedClass::fun2()\" << endl;\n }\n ~Derived(){};\n};\n/**\n * @brief 获取vptr地址与func地址,vptr指向的是一块内存，这块内存存放的是虚函数地址，这块内存就是我们所说的虚表\n *\n * @param obj\n * @param offset\n *\n * @return \n */\nFun getAddr(void* obj,unsigned int offset)\n{\n cout<<\"=======================\"<fun1();\n cout<<\"基类引用指向派生类实例并调用虚函数\"<fun1();\n```\n\n其过程为：首先程序识别出fun1()是个虚函数，其次程序使用pt->vptr来获取Derived的虚拟表。第三，它查找Derived虚拟表中调用哪个版本的fun1()。这里就可以发现调用的是Derived::fun1()。因此pt->fun1()被解析为Derived::fun1()!\n\n除此之外，上述代码大家会看到，也包含了手动获取vptr地址，并调用vtable中的函数，那么我们一起来验证一下上述的地址与真正在自动调用vtable中的虚函数，比如上述`pt->fun1()`的时候，是否一致！\n\n这里采用gdb调试，在编译的时候记得加上`-g`。\n\n通过`gdb vptr`进入gdb调试页面，然后输入`b Derived::fun1`对fun1打断点，然后通过输入r运行程序到断点处，此时我们需要查看调用栈中的内存地址，通过`disassemable fun1`可以查看当前有关fun1中的相关汇编代码，我们看到了`0x0000000000400ea8`，然后再对比上述的结果会发现与手动调用的fun1一致，fun2类似，以此证明代码正确!\n\ngdb调试信息如下：\n\n```c++\n(gdb) b Derived::fun1\nBreakpoint 1 at 0x400eb4: file vptr1.cpp, line 23.\n(gdb) r\nStarting program: /home/light/Program/CPlusPlusThings/virtual/pure_virtualAndabstract_class/vptr \n基类对象直接调用\nBase::fun1()\n基类引用指向派生类实例\nBase::fun1()\n基类指针指向派生类实例并调用虚函数\n\nBreakpoint 1, Derived::fun1 (this=0x614c20) at vptr1.cpp:23\n23\t cout << \"Derived::fun1()\" << endl;\n(gdb) disassemble fun1\nDump of assembler code for function Derived::fun1():\n 0x0000000000400ea8 <+0>:\tpush %rbp\n 0x0000000000400ea9 <+1>:\tmov %rsp,%rbp\n 0x0000000000400eac <+4>:\tsub $0x10,%rsp\n 0x0000000000400eb0 <+8>:\tmov %rdi,-0x8(%rbp)\n=> 0x0000000000400eb4 <+12>:\tmov $0x401013,%esi\n 0x0000000000400eb9 <+17>:\tmov $0x602100,%edi\n 0x0000000000400ebe <+22>:\tcallq 0x4009d0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>\n 0x0000000000400ec3 <+27>:\tmov $0x400a00,%esi\n 0x0000000000400ec8 <+32>:\tmov %rax,%rdi\n 0x0000000000400ecb <+35>:\tcallq 0x4009f0 <_ZNSolsEPFRSoS_E@plt>\n 0x0000000000400ed0 <+40>:\tnop\n 0x0000000000400ed1 <+41>:\tleaveq \n 0x0000000000400ed2 <+42>:\tretq \nEnd of assembler dump.\n(gdb) disassemble fun2\nDump of assembler code for function Derived::fun2():\n 0x0000000000400ed4 <+0>:\tpush %rbp\n 0x0000000000400ed5 <+1>:\tmov %rsp,%rbp\n 0x0000000000400ed8 <+4>:\tsub $0x10,%rsp\n 0x0000000000400edc <+8>:\tmov %rdi,-0x8(%rbp)\n 0x0000000000400ee0 <+12>:\tmov $0x401023,%esi\n 0x0000000000400ee5 <+17>:\tmov $0x602100,%edi\n 0x0000000000400eea <+22>:\tcallq 0x4009d0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>\n 0x0000000000400eef <+27>:\tmov $0x400a00,%esi\n 0x0000000000400ef4 <+32>:\tmov %rax,%rdi\n 0x0000000000400ef7 <+35>:\tcallq 0x4009f0 <_ZNSolsEPFRSoS_E@plt>\n 0x0000000000400efc <+40>:\tnop\n 0x0000000000400efd <+41>:\tleaveq \n 0x0000000000400efe <+42>:\tretq \nEnd of assembler dump.\n```\n\n"
},
{
"path": "basic_content/vptr_vtable/vptr1.cpp",
"content": "#include \n#include \nusing namespace std;\n\n/**\n * @brief 函数指针\n */\ntypedef void (*Fun)();\n\n/**\n * @brief 基类\n */\nclass Base {\npublic:\n Base(){};\n virtual void fun1() { cout << \"Base::fun1()\" << endl; }\n virtual void fun2() { cout << \"Base::fun2()\" << endl; }\n virtual void fun3() {}\n ~Base(){};\n};\n\n/**\n * @brief 派生类\n */\nclass Derived : public Base {\npublic:\n Derived(){};\n void fun1() { cout << \"Derived::fun1()\" << endl; }\n void fun2() { cout << \"DerivedClass::fun2()\" << endl; }\n ~Derived(){};\n};\n\n/**\n * @brief\n * 获取vptr地址与func地址,vptr指向的是一块内存，这块内存存放的是虚函数地址，这块内存就是我们所说的虚表\n *\n * @param obj\n * @param offset\n *\n * @return\n */\nFun getAddr(void *obj, unsigned int offset) {\n cout << \"=======================\" << endl;\n void *vptr_addr =\n (void *)*(unsigned long *)obj; // 64位操作系统，占8字节，通过*(unsigned\n // long *)obj取出前8字节，即vptr指针\n printf(\"vptr_addr:%p\\n\", vptr_addr);\n\n /**\n * @brief 通过vptr指针访问virtual\n * table，因为虚表中每个元素(虚函数指针)在64位编译器下是8个字节，因此通过*(unsigned\n * long *)vptr_addr取出前8字节， 后面加上偏移量就是每个函数的地址！\n */\n void *func_addr = (void *)*((unsigned long *)vptr_addr + offset);\n printf(\"func_addr:%p\\n\", func_addr);\n return (Fun)func_addr;\n}\nint main(void) {\n Base ptr;\n Derived d;\n Base *pt = new Derived(); // 基类指针指向派生类实例\n Base &pp = ptr; // 基类引用指向基类实例\n Base &p = d; // 基类引用指向派生类实例\n cout << \"基类对象直接调用\" << endl;\n ptr.fun1();\n cout << \"基类引用指向基类实例\" << endl;\n pp.fun1();\n cout << \"基类指针指向派生类实例并调用虚函数\" << endl;\n pt->fun1();\n cout << \"基类引用指向派生类实例并调用虚函数\" << endl;\n p.fun1();\n\n // 手动查找vptr 和 vtable\n Fun f1 = getAddr(pt, 0);\n (*f1)();\n Fun f2 = getAddr(pt, 1);\n (*f2)();\n\n delete pt;\n return 0;\n}\n"
},
{
"path": "codingStyleIdioms/1_classInitializers/1.1_nest.cpp",
"content": "/* 1.1_类之间嵌套.cpp */\n//\n// Created by light on 19-12-9.\n//\n\n#include \n\nclass Animal {\npublic:\n Animal() {\n std::cout << \"Animal() is called\" << std::endl;\n }\n\n Animal(const Animal &) {\n std::cout << \"Animal (const Animal &) is called\" << std::endl;\n }\n\n Animal &operator=(const Animal &) {\n std::cout << \"Animal & operator=(const Animal &) is called\" << std::endl;\n return *this;\n }\n\n ~Animal() {\n std::cout << \"~Animal() is called\" << std::endl;\n }\n};\n\nclass Dog {\npublic:\n // 第一种： 使用初始化列表。\n Dog(const Animal &animal) : __animal(animal) {\n std::cout << \"Dog(const Animal &animal) is called\" << std::endl;\n }\n // 第二种：构造函数赋值来初始化对象。\n// Dog(const Animal &animal) {\n// __animal = animal;\n// std::cout << \"Dog(const Animal &animal) is called\" << std::endl;\n// }\n ~Dog() {\n std::cout << \"~Dog() is called\" << std::endl;\n }\n\nprivate:\n Animal __animal;\n};\n\nint main() {\n Animal animal;\n std::cout << std::endl;\n Dog d(animal);\n std::cout << std::endl;\n return 0;\n}"
},
{
"path": "codingStyleIdioms/1_classInitializers/1.2_nodefault_ctor.cpp",
"content": "/* 1.2_无默认构造的继承.cpp */\n//\n// Created by light on 19-12-9.\n//\n#include \nclass Animal {\npublic:\n Animal(int age) {\n std::cout << \"Animal(int age) is called\" << std::endl;\n }\n\n Animal(const Animal & animal) {\n std::cout << \"Animal (const Animal &) is called\" << std::endl;\n }\n\n Animal &operator=(const Animal & amimal) {\n std::cout << \"Animal & operator=(const Animal &) is called\" << std::endl;\n return *this;\n }\n\n ~Animal() {\n std::cout << \"~Animal() is called\" << std::endl;\n }\n\n};\n\nclass Dog : Animal {\npublic:\n Dog(int age) : Animal(age) {\n std::cout << \"Dog(int age) is called\" << std::endl;\n }\n\n ~Dog() {\n std::cout << \"~Dog() is called\" << std::endl;\n }\n};\n\nint main() {\n Animal animal(10);\n std::cout << std::endl;\n Dog d(100);\n std::cout << std::endl;\n return 0;\n}"
},
{
"path": "codingStyleIdioms/1_classInitializers/1.3_const.cpp",
"content": "/* 1.3_类中const数据成员、引用数据成员.cpp */\n//\n// Created by light on 19-12-9.\n//\n\n#include \n\nclass Animal {\npublic:\n Animal(int& age,std::string name):age_(age),name_(name) {\n std::cout << \"Animal(int age) is called\" << std::endl;\n }\nprivate:\n int &age_;\n const std::string name_;\n};\n\nint main() {\n int x = 10;\n Animal animal(x,\"hh\");\n return 0;\n}"
},
{
"path": "codingStyleIdioms/1_classInitializers/BUILD",
"content": "# please run `bazel run //codingStyleIdioms/1_classInitializers:1.2_nodefault_ctor`\n# please run `bazel run //codingStyleIdioms/1_classInitializers:initializer`\n# please run `bazel run //codingStyleIdioms/1_classInitializers:1.1_nest`\n# please run `bazel run //codingStyleIdioms/1_classInitializers:1.3_const`\n\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"1.2_nodefault_ctor\",\n srcs = [\"1.2_nodefault_ctor.cpp\"],\n copts = [\"-std=c++11\"],\n)\ncc_binary(\n name = \"initializer\",\n srcs = [\"initializer.cpp\"],\n copts = [\"-std=c++11\"],\n)\ncc_binary(\n name = \"1.1_nest\",\n srcs = [\"1.1_nest.cpp\"],\n copts = [\"-std=c++11\"],\n)\ncc_binary(\n name = \"1.3_const\",\n srcs = [\"1.3_const.cpp\"],\n copts = [\"-std=c++11\"],\n)\n"
},
{
"path": "codingStyleIdioms/1_classInitializers/README.md",
"content": "# 初始化列表与赋值\n\n- const成员的初始化只能在构造函数初始化列表中进行\n- 引用成员的初始化也只能在构造函数初始化列表中进行\n- 对象成员（对象成员所对应的类没有默认构造函数）的初始化，也只能在构造函数初始化列表中进行\n\n## 类之间嵌套\n\n**第一种： 使用初始化列表。**\n\n\n```cpp\nclass Animal {\npublic:\n Animal() {\n std::cout << \"Animal() is called\" << std::endl;\n }\n\n Animal(const Animal &) {\n std::cout << \"Animal (const Animal &) is called\" << std::endl;\n }\n\n Animal &operator=(const Animal &) {\n std::cout << \"Animal & operator=(const Animal &) is called\" << std::endl;\n return *this;\n }\n\n ~Animal() {\n std::cout << \"~Animal() is called\" << std::endl;\n }\n};\n\nclass Dog {\npublic:\n Dog(const Animal &animal) : __animal(animal) {\n std::cout << \"Dog(const Animal &animal) is called\" << std::endl;\n }\n\n ~Dog() {\n std::cout << \"~Dog() is called\" << std::endl;\n }\n\nprivate:\n Animal __animal;\n};\n\nint main() {\n Animal animal;\n std::cout << std::endl;\n Dog d(animal);\n std::cout << std::endl;\n return 0;\n}\n```\n\n运行结果：\n```cpp\nAnimal() is called\n\nAnimal (const Animal &) is called\nDog(const Animal &animal) is called\n\n~Dog() is called\n~Animal() is called\n~Animal() is called\n```\n\n依次分析从上到下：\n\nmain函数中`Animal animal;`调用默认构造。\n\n`Dog d(animal);`等价于：\n\n```\nAnimal __animal = animal;\n```\n实际上就是调用了拷贝构造，因此输出了：\n```\nAnimal (const Animal &) is called\n```\n再然后打印Dog的构造函数里面的输出。\n\n最后调用析构，程序结束。\n\n**第二种：构造函数赋值来初始化对象。**\n\n构造函数修改如下：\n```cpp\nDog(const Animal &animal) {\n __animal = animal;\n std::cout << \"Dog(const Animal &animal) is called\" << std::endl;\n}\n```\n此时输出结果：\n```\nAnimal() is called\n\nAnimal() is called\nAnimal & operator=(const Animal &) is called\nDog(const Animal &animal) is called\n\n~Dog() is called\n~Animal() is called\n~Animal() is called\n```\n\n于是得出：\n\n当调用`Dog d(animal);`时，等价于：\n\n先定义对象，再进行赋值，因此先调用了默认构造，再调用=操作符重载函数。\n\n```cpp\n// 假设之前已经有了animal对象\nAnimal __animal;\n__animal = animal;\n```\n\n> 小结\n\n通过上述我们得出如下结论：\n\n- **类中包含其他自定义的class或者struct，采用初始化列表，实际上就是创建对象同时并初始化**\n- **而采用类中赋值方式，等价于先定义对象，再进行赋值，一般会先调用默认构造，在调用=操作符重载函数。**\n\n## 无默认构造函数的继承关系中\n\n现考虑把上述的关系改为继承，并修改Animal与Dog的构造函数，如下代码：\n\n```cpp\nclass Animal {\npublic:\n Animal(int age) {\n std::cout << \"Animal(int age) is called\" << std::endl;\n }\n\n Animal(const Animal & animal) {\n std::cout << \"Animal (const Animal &) is called\" << std::endl;\n }\n\n Animal &operator=(const Animal & amimal) {\n std::cout << \"Animal & operator=(const Animal &) is called\" << std::endl;\n return *this;\n }\n\n ~Animal() {\n std::cout << \"~Animal() is called\" << std::endl;\n }\n};\n\nclass Dog : Animal {\npublic:\n Dog(int age) : Animal(age) {\n std::cout << \"Dog(int age) is called\" << std::endl;\n }\n\n ~Dog() {\n std::cout << \"~Dog() is called\" << std::endl;\n }\n\n};\n```\n\n上述是通过初始化列表给基类带参构造传递参数，如果不通过初始化列表传递，会发生什么影响？\n\n去掉初始化列表\n```\nDog(int age) {\n std::cout << \"Dog(int age) is called\" << std::endl;\n}\n```\n运行程序：\n\n```\nerror: no matching function for call to ‘Animal::Animal()’\n```\n\n由于在Animal中没有默认构造函数，所以报错，遇到这种问题属于灾难性的，我们应该尽量避免，可以通过初始化列表给基类的构造初始化。\n\n\n## 类中const数据成员、引用数据成员\n\n特别是引用数据成员，必须用初始化列表初始化，而不能通过赋值初始化！\n\n例如：在上述的Animal中添加私有成员，并修改构造函数：\n```cpp\nclass Animal {\npublic:\n Animal(int age,std::string name) {\n std::cout << \"Animal(int age) is called\" << std::endl;\n }\nprivate:\n int &age_;\n const std::string name_;\n};\n```\n\n报下面错误：\n\n```cpp\nerror: uninitialized reference member in ‘int&’\n```\n\n应该改为下面：\n\n```cpp\nAnimal(int age, std::string name) : age_(age), name_(name) {\n std::cout << \"Animal(int age) is called\" << std::endl;\n}\n```\n\n"
},
{
"path": "codingStyleIdioms/1_classInitializers/initializer.cpp",
"content": "/* initializer.cpp */\n//\n// Created by light on 19-12-9.\n//\n\n#include \n\nusing namespace std;\n\nclass A {\npublic:\n A(int a) : _a(a), _p(nullptr) { // 初始化列表\n\n }\n\nprivate:\n int _a;\n int *_p;\n};\n\nint main() {\n A aa(10);\n return 0;\n}\n"
},
{
"path": "codingStyleIdioms/2_enumclass/BUILD",
"content": "# please run `bazel run //codingStyleIdioms/2_enumclass:namespace`\n\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"namespace\",\n srcs = [\"namespace.cpp\"],\n copts = [\"-std=c++11\"],\n)\n"
},
{
"path": "codingStyleIdioms/2_enumclass/README.md",
"content": "# C++惯用法之enum class\n\n在Effective modern C++中Item 10: Prefer scoped enums to unscoped enum，调到要用有范围的enum class代替无范围的enum。\n\n例如：\n\n```cpp\nenum Shape {circle,retangle};\nauto circle = 10; // error\n```\n\n上述错误是因为两个circle在同一范围。\n对于enum等价于：\n```cpp\n#define circle 0\n#define retangle 1\n```\n因此后面再去定义circle就会出错。\n\n所以不管枚举名是否一样,里面的成员只要有一致的,就会出问题。\n例如：\n```cpp\nenum A {a,b};\nenum B {c,a};\n```\na出现两次,在enum B的a处报错。\n\n根据前面我们知道,enum名在范围方面没有什么作用,因此我们想到了namespace,如下例子:\n```cpp\n// 在创建枚举时，将它们放在名称空间中，以便可以使用有意义的名称访问它们:\nnamespace EntityType {\n enum Enum {\n Ground = 0,\n Human,\n Aerial,\n Total\n };\n}\n\nvoid foo(EntityType::Enum entityType)\n{\n if (entityType == EntityType::Ground) {\n /*code*/\n }\n}\n```\n将命名空间起的有意思点,就可以达到想要的效果。\n\n但是不断的使用命名空间,势必太繁琐,而且如果我不想使用namespace,要达到这样的效果,便会变得不安全,也没有约束。\n\n因此在c++11后,引入enum class。\n\nenum class 解决了为enum成员定义类型、类型安全、约束等问题。\n回到上述例子：\n```cpp\n// enum class\nenum class EntityType {\n Ground = 0,\n Human,\n Aerial,\n Total\n};\n\nvoid foo(EntityType entityType)\n{\n if (entityType == EntityType::Ground) {\n /*code*/\n }\n}\n```\n这便是这一节要阐述的惯用法:enum class。"
},
{
"path": "codingStyleIdioms/2_enumclass/namespace.cpp",
"content": "//\n// Created by light on 19-12-9.\n//\n\n#include \n\nusing namespace std;\n// 在创建枚举时，将它们放在名称空间中，以便可以使用有意义的名称访问它们:\nnamespace EntityType {\n enum Enum {\n Ground = 0,\n Human,\n Aerial,\n Total\n };\n}\n\nvoid foo(EntityType::Enum entityType)\n{\n if (entityType == EntityType::Ground) {\n /*code*/\n }\n}\n\n// enum class\nenum class EntityType1 {\n Ground = 0,\n Human,\n Aerial,\n Total\n};\n\nvoid foo(EntityType1 entityType)\n{\n if (entityType == EntityType1::Ground) {\n /*code*/\n }\n}\n\nint main() {\n\n return 0;\n}\n"
},
{
"path": "codingStyleIdioms/3_RAII/BUILD",
"content": "# please run `bazel run //codingStyleIdioms/3_RAII:RAII_fstram`\n# please run `bazel run //codingStyleIdioms/3_RAII:c++_example1`\n# please run `bazel run //codingStyleIdioms/3_RAII:c++_example`\n# please run `bazel run //codingStyleIdioms/3_RAII:RAII`\n# please run `bazel run //codingStyleIdioms/3_RAII:c_example`\n# please run `bazel run //codingStyleIdioms/3_RAII:c++_example2`\n\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"RAII_fstram\",\n srcs = [\"RAII_fstram.cpp\"],\n copts = [\"-std=c++11\"],\n)\ncc_binary(\n name = \"c++_example1\",\n srcs = [\"c++_example1.cpp\"],\n copts = [\"-std=c++11\"],\n)\ncc_binary(\n name = \"c++_example\",\n srcs = [\"c++_example.cpp\"],\n copts = [\"-std=c++11\"],\n)\ncc_binary(\n name = \"RAII\",\n srcs = [\"RAII.cpp\"],\n copts = [\"-std=c++11\"],\n)\ncc_binary(\n name = \"c_example\",\n srcs = [\"c_example.cpp\"],\n copts = [\"-std=c++11\"],\n)\ncc_binary(\n name = \"c++_example2\",\n srcs = [\"c++_example2.cpp\"],\n copts = [\"-std=c++11\"],\n)\n"
},
{
"path": "codingStyleIdioms/3_RAII/RAII.cpp",
"content": "#include \n#include \n#include \nusing namespace std;\n// RAII 资源获取即初始化,例1\n\nenum class shape_type {\n circle,\n triangle,\n rectangle,\n};\n\n\nclass shape {\npublic:\n shape() { cout << \"shape\" << endl; }\n\n virtual void print() {\n cout << \"I am shape\" << endl;\n }\n\n virtual ~shape() {}\n};\n\nclass circle : public shape {\npublic:\n circle() { cout << \"circle\" << endl; }\n\n void print() {\n cout << \"I am circle\" << endl;\n }\n};\n\nclass triangle : public shape {\npublic:\n triangle() { cout << \"triangle\" << endl; }\n\n void print() {\n cout << \"I am triangle\" << endl;\n }\n};\n\nclass rectangle : public shape {\npublic:\n rectangle() { cout << \"rectangle\" << endl; }\n\n void print() {\n cout << \"I am rectangle\" << endl;\n }\n};\n\n// 利用多态 上转 如果返回值为shape,会存在对象切片问题。\nshape *create_shape(shape_type type) {\n switch (type) {\n case shape_type::circle:\n return new circle();\n case shape_type::triangle:\n return new triangle();\n case shape_type::rectangle:\n return new rectangle();\n }\n}\n\nclass shape_wrapper {\npublic:\n explicit shape_wrapper(shape *ptr = nullptr) : ptr_(ptr) {}\n\n ~shape_wrapper() {\n delete ptr_;\n }\n\n shape *get() const {\n return ptr_;\n }\n\nprivate:\n shape *ptr_;\n};\n\n\nvoid foo() {\n shape_wrapper ptr(create_shape(shape_type::circle));\n ptr.get()->print();\n}\n\nint main() {\n\n // 第一种方式\n shape *sp = create_shape(shape_type::circle);\n sp->print();\n delete sp;\n\n // 第二种方式 RAII\n foo();\n\n return 0;\n}\n"
},
{
"path": "codingStyleIdioms/3_RAII/RAII.md",
"content": "# C++惯用法之消除垃圾收集器-资源获取即初始化方法(RAII)\n\n## 0.导语\n\n在C语言中，有三种类型的内存分配:静态、自动和动态。静态变量是嵌入在源文件中的常数，因为它们有已知的大小并且从不改变，所以它们并不那么有趣。自动分配可以被认为是堆栈分配——当一个词法块进入时分配空间，当该块退出时释放空间。它最重要的特征与此直接相关。在C99之前，自动分配的变量需要在编译时知道它们的大小。这意味着任何字符串、列表、映射以及从这些派生的任何结构都必须存在于堆中的动态内存中。\n\n程序员使用四个基本操作明确地分配和释放动态内存:malloc、realloc、calloc和free。前两个不执行任何初始化，内存可能包含碎片。除了自由，他们都可能失败。在这种情况下，它们返回一个空指针，其访问是未定义的行为；在最好的情况下，你的程序会崩溃。在最坏的情况下，你的程序看起来会工作一段时间，在崩溃前处理垃圾数据。\n\n例如：\t\n\n```cpp\nint main() {\n char *str = (char *) malloc(7); \n strcpy(str, \"toptal\");\n printf(\"char array = \\\"%s\\\" @ %u\\n\", str, str);\n\n str = (char *) realloc(str, 11);\n strcat(str, \".com\");\n printf(\"char array = \\\"%s\\\" @ %u\\n\", str, str);\n\n free(str);\n \n return(0);\n}\n```\n\n输出：\n\n```cpp\nchar array = \"toptal\" @ 2762894960\nchar array = \"toptal.com\" @ 2762894960\n```\n\n尽管代码很简单，但它已经包含了一个反模式和一个有问题的决定。在现实生活中，你不应该直接写字节数，而应该使用sizeof函数。类似地，我们将char *数组精确地分配给我们需要的字符串大小的两倍(比字符串长度多一倍，以说明空终止)，这是一个相当昂贵的操作。一个更复杂的程序可能会构建一个更大的字符串缓冲区，允许字符串大小增长。\n\n## 1.RAII的发明：新希望\n\n至少可以说，所有手动管理都是令人不快的。 在80年代中期，Bjarne Stroustrup为他的全新语言C ++发明了一种新的范例。 他将其称为“资源获取就是初始化”，其基本见解如下：**可以指定对象具有构造函数和析构函数，这些构造函数和析构函数在适当的时候由编译器自动调用，这为管理给定对象的内存提供了更为方便的方法。** 需要，并且该技术对于不是内存的资源也很有用。\n\n意味着上面的例子在c++中更简洁：\n\n```cpp\nint main() {\n std::string str = std::string (\"toptal\");\n std::cout << \"string object: \" << str << \" @ \" << &str << \"\\n\";\n \n str += \".com\";\n std::cout << \"string object: \" << str << \" @ \" << &str << \"\\n\";\n \n return(0);\n}\n```\n\n输出：\n\n```cpp\nstring object: toptal @ 0x7fffa67b9400\nstring object: toptal.com @ 0x7fffa67b9400\n```\n\n在上述例子中，我们没有手动内存管理！构造string对象，调用重载方法，并在函数退出时自动销毁。不幸的是，同样的简单也会导致其他问题。让我们详细地看一个例子：\n\n```cpp\nvector read_lines_from_file(string &file_name) {\n\tvector lines;\n\tstring line;\n\t\n\tifstream file_handle (file_name.c_str());\n\twhile (file_handle.good() && !file_handle.eof() && file_handle.peek()!=EOF) {\n\t\tgetline(file_handle, line);\n\t\tlines.push_back(line);\n\t}\n\t\n\tfile_handle.close();\n\t\n\treturn lines;\n}\n\nint main(int argc, char* argv[]) {\n\t// get file name from the first argument\n\tstring file_name (argv[1]);\n\tint count = read_lines_from_file(file_name).size();\n\tcout << \"File \" << file_name << \" contains \" << count << \" lines.\";\n\t\n\treturn 0;\n}\n```\n\n输出：\n\n```cpp\nFile makefile contains 37 lines.\n```\n\n这看起来很简单。`vector`被填满、返回和调用。然而，作为关心性能的高效程序员，这方面的一些问题困扰着我们:在return语句中，由于使用了值语义，`vector`在销毁之前不久就被复制到一个新`vector`中。\n\n> 在现代C ++中，这不再是严格的要求了。 C ++ 11引入了移动语义的概念，其中将原点保留在有效状态（以便仍然可以正确销毁）但未指定状态。 对于编译器而言，返回调用是最容易优化以优化语义移动的情况，因为它知道在进行任何进一步访问之前不久将销毁源。 但是，该示例的目的是说明为什么人们在80年代末和90年代初发明了一大堆垃圾收集的语言，而在那个时候C ++ move语义不可用。\n\n对于数据量比较大的文件，这可能会变得昂贵。 让我们对其进行优化，只返回一个指针。 语法进行了一些更改，但其他代码相同：\n\n```cpp\nvector * read_lines_from_file(string &file_name) {\n\tvector * lines;\n\tstring line;\n\t\n\tifstream file_handle (file_name.c_str());\n\twhile (file_handle.good() && !file_handle.eof() && file_handle.peek()!=EOF) {\n\t\tgetline(file_handle, line);\n\t\tlines->push_back(line);\n\t}\n\t\n\tfile_handle.close();\n\t\n\treturn lines;\n}\nint main(int argc, char* argv[]) {\n\t// get file name from the first argument\n\tstring file_name (argv[1]);\n\tint count = read_lines_from_file(file_name).size();\n\tcout << \"File \" << file_name << \" contains \" << count << \" lines.\";\n\t\n\treturn 0;\n}\n```\n\n输出：\n\n```\nSegmentation fault (core dumped)\n```\n\n程序崩溃！我们只需要将上述的`lines`进行内存分配：\n\n```cpp\nvector * lines = new vector;\n```\n\n这样就可以运行了！\n\n不幸的是，尽管这看起来很完美，但它仍然有一个缺陷:它会泄露内存。在C++中，指向堆的指针在不再需要后必须手动删除；否则，一旦最后一个指针超出范围，该内存将变得不可用，并且直到进程结束时操作系统对其进行管理后才会恢复。惯用的现代C++将在这里使用`unique_ptr`，它实现了期望的行为。它删除指针超出范围时指向的对象。然而，这种行为直到C++11才成为语言的一部分。\n\n在这里，可以直接使用C++11之前的语法，只是把main中改一下即可：\n\n```cpp\nvector * read_lines_from_file(string &file_name) {\n\tvector * lines = new vector;\n\tstring line;\n\t\n\tifstream file_handle (file_name.c_str());\n\twhile (file_handle.good() && !file_handle.eof() && file_handle.peek()!=EOF) {\n\t\tgetline(file_handle, line);\n\t\tlines->push_back(line);\n\t}\n\t\n\tfile_handle.close();\n\t\n\treturn lines;\n}\n\nint main(int argc, char* argv[]) {\n\t// get file name from the first argument\n\tstring file_name (argv[1]);\n\tvector * file_lines = read_lines_from_file(file_name);\n\tint count = file_lines->size();\n\tdelete file_lines;\n\tcout << \"File \" << file_name << \" contains \" << count << \" lines.\";\n\t\n\treturn 0;\n}\n```\n\n手动去分配内存与释放内存。\n\n**不幸的是，随着程序扩展到上述范围之外，很快就变得更加难以推理指针应该在何时何地被删除。当一个函数返回指针时，你现在拥有它吗？您应该在完成后自己删除它，还是它属于某个稍后将被一次性释放的数据结构？一方面出错，内存泄漏，另一方面出错，你已经破坏了正在讨论的数据结构和其他可能的数据结构，因为它们试图取消引用现在不再有效的指针。**\n\n## 2.“使用垃圾收集器，flyboy！”\n\n垃圾收集器不是一项新技术。 它们由John McCarthy在1959年为Lisp发明。 1980年，随着Smalltalk-80的出现，垃圾收集开始成为主流。 但是，1990年代代表了该技术的真正发芽：在1990年至2000年之间，发布了多种语言，所有语言都使用一种或另一种垃圾回收：Haskell，Python，Lua，Java，JavaScript，Ruby，OCaml 和C＃是最著名的。\n\n什么是垃圾收集？ 简而言之，这是一组用于自动执行手动内存管理的技术。 它通常作为具有手动内存管理的语言（例如C和C ++）的库提供，但在需要它的语言中更常用。 最大的优点是程序员根本不需要考虑内存。 都被抽象了。 例如，相当于我们上面的文件读取代码的Python就是这样：\n\n```python\ndef read_lines_from_file(file_name):\n\tlines = []\n\twith open(file_name) as fp: \n\t\tfor line in fp:\n\t\t\tlines.append(line)\n\treturn lines\n\t\nif __name__ == '__main__':\n\timport sys\n\tfile_name = sys.argv[1]\n\tcount = len(read_lines_from_file(file_name))\n\tprint(\"File {} contains {} lines.\".format(file_name, count))\n```\n\n行数组是在第一次分配给它时出现的，并且不复制到调用范围就返回。 由于时间不确定，它会在超出该范围后的某个时间被垃圾收集器清理。 有趣的是，在Python中，用于非内存资源的RAII不是惯用语言。 允许-我们可以简单地编写`fp = open（file_name）`而不是使用with块，然后让GC清理。 但是建议的模式是在可能的情况下使用上下文管理器，以便可以在确定的时间释放它们。\n\n尽管简化了内存管理，但要付出很大的代价。 在引用计数垃圾回收中，所有变量赋值和作用域出口都会获得少量成本来更新引用。 在标记清除系统中，在GC清除内存的同时，所有程序的执行都以不可预测的时间间隔暂停。 这通常称为世界停止事件。 同时使用这两种系统的Python之类的实现都会受到两种惩罚。 这些问题降低了垃圾收集语言在性能至关重要或需要实时应用程序的情况下的适用性。 即使在以下玩具程序上，也可以看到实际的性能下降：\n\n```cpp\n$ make cpp && time ./c++ makefile\ng++ -o c++ c++.cpp\nFile makefile contains 38 lines.\nreal 0m0.016s\nuser 0m0.000s\nsys 0m0.015s\n\n$ time python3 python3.py makefile\nFile makefile contains 38 lines.\n\nreal 0m0.041s\nuser 0m0.015s\nsys 0m0.015s\n```\n\nPython版本的实时时间几乎是C ++版本的三倍。 尽管并非所有这些差异都可以归因于垃圾收集，但它仍然是可观的。\n\n## 3.所有权：RAII觉醒\n\n我们知道对象的生存期由其范围决定。 但是，有时我们需要创建一个对象，该对象与创建对象的作用域无关，这是有用的，或者很有用。 在C ++中，运算符new用于创建这样的对象。 为了销毁对象，可以使用运算符delete。 由new操作员创建的对象是动态分配的，即在动态内存（也称为堆或空闲存储）中分配。 因此，由new创建的对象将继续存在，直到使用delete将其明确销毁为止。\n\n使用new和delete时可能发生的一些错误是：\n\n- 对象（或内存）泄漏：使用new分配对象，而忘记删除该对象。\n\n- 过早删除（或悬挂引用）：持有指向对象的另一个指针，删除该对象，然而还有其他指针在引用它。\n\n- 双重删除：尝试两次删除一个对象。\n\n通常，范围变量是首选。 但是，RAII可以用作new和delete的替代方法，以使对象独立于其范围而存在。 这种技术包括将指针分配到在堆上分配的对象，并将其放在句柄/管理器对象中。 后者具有一个析构函数，将负责销毁该对象。 这将确保该对象可用于任何想要访问它的函数，并且该对象在句柄对象的生存期结束时将被销毁，而无需进行显式清理。\n\n来自C ++标准库的使用RAII的示例为std :: string和std :: vector。\n\n考虑这段代码：\n\n```cpp\nvoid fn(const std::string& str)\n{\n std::vector vec;\n for (auto c : str)\n vec.push_back(c);\n // do something\n}\n```\n\n当创建`vector`,并将元素推入`vector`时，您不必担心分配和取消分配此类元素内存。 `vector`使用new为其堆上的元素分配空间，并使用delete释放该空间。 作为vector的用户，您无需关心实现细节，并且会相信vector不会泄漏。 在这种情况下，向量是其元素的句柄对象。\n\n标准库中使用RAII的其他示例是std :: shared_ptr，std :: unique_ptr和std :: lock_guard。\n\n该技术的另一个名称是SBRM，是范围绑定资源管理的缩写。\n\n现在，我们将上述读取文件例子，进行修改：\n\n```cpp\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nunique_ptr> read_lines_from_file(string &file_name) {\n unique_ptr> lines(new vector);\n string line;\n\n ifstream file_handle (file_name.c_str());\n while (file_handle.good() && !file_handle.eof() && file_handle.peek()!=EOF) {\n getline(file_handle, line);\n lines->push_back(line);\n }\n\n file_handle.close();\n\n return lines;\n}\nint main(int argc, char* argv[]) {\n\t// get file name from the first argument\n\tstring file_name (argv[1]);\n\tint count = read_lines_from_file(file_name).get()->size();\n cout << \"File \" << file_name << \" contains \" << count << \" lines.\";\n\n\treturn 0;\n}\n```\n\n## 4.只有在最后，你才意识到RAII的真正力量。\n\n自从编译器发明以来，手动内存管理是程序员一直在想办法避免的噩梦。 RAII是一种很有前途的模式，但由于没有一些奇怪的解决方法，它根本无法用于堆分配的对象，因此在C ++中会受到影响。 因此，在90年代出现了垃圾收集语言的爆炸式增长，旨在使程序员生活更加愉快，即使以性能为代价。\n\n最后，RAII总结如下：\n\n- 资源在析构函数中被释放\n\n- 该类的实例是堆栈分配的\n- 资源是在构造函数中获取的。 \n\nRAII代表“资源获取是初始化”。\n\n常见的例子有：\n\n- 文件操作\n\n- 智能指针\n\n- 互斥量\n\n## 5.参考文章\n\n> 1.https://www.toptal.com/software/eliminating-garbage-collector#remote-developer-job\n\n> 2.https://stackoverflow.com/questions/2321511/what-is-meant-by-resource-acquisition-is-initialization-raii\n"
},
{
"path": "codingStyleIdioms/3_RAII/RAII_fstram.cpp",
"content": "//\n// Created by light on 19-12-9.\n//\n#include \n#include \n\n// RAII 资源获取即初始化,例2\n\n// C ++保证在对象超出范围时调用析构函数，而不管控制如何离开该范围。\n// 即使抛出异常，所有本地对象也会超出范围，因此它们的相关资源将被清除。\n\nvoid foo() {\n std::fstream file(\"bar.txt\"); // open a file \"bar.txt\"\n if (rand() % 2) {\n // if this exception is thrown, we leave the function, and so\n // file's destructor is called, which closes the file handle.\n throw std::exception();\n }\n // if the exception is not called, we leave the function normally, and so\n // again, file's destructor is called, which closes the file handle.\n}\n\nint main() {\n try {\n foo();\n } catch (std::exception) {\n puts(\"exception!\");\n }\n}"
},
{
"path": "codingStyleIdioms/3_RAII/c++_example.cpp",
"content": "//\n// Created by light on 19-12-12.\n//\n#include \nint main() {\n std::string str = std::string (\"toptal\");\n std::cout << \"string object: \" << str << \" @ \" << &str << \"\\n\";\n\n str += \".com\";\n std::cout << \"string object: \" << str << \" @ \" << &str << \"\\n\";\n\n return(0);\n}"
},
{
"path": "codingStyleIdioms/3_RAII/c++_example1.cpp",
"content": "//\n// Created by light on 19-12-12.\n//\n#include \n#include \n#include \n#include \n\nusing namespace std;\nvector read_lines_from_file(string &file_name) {\n vector lines;\n string line;\n\n ifstream file_handle (file_name.c_str());\n // file_handle.peek()!=EOF 解决多读一行问题\n while (file_handle.good() && !file_handle.eof() && file_handle.peek()!=EOF) {\n getline(file_handle, line);\n lines.push_back(line);\n }\n\n file_handle.close();\n\n return lines;\n}\nvector * read_lines_from_file1(string &file_name) {\n vector * lines;\n string line;\n\n ifstream file_handle (file_name.c_str());\n // file_handle.peek()!=EOF\n while (file_handle.good() && !file_handle.eof() && file_handle.peek()!=EOF) {\n getline(file_handle, line);\n lines->push_back(line);\n }\n\n file_handle.close();\n\n return lines;\n}\nvector * read_lines_from_file1_1(string &file_name) {\n vector * lines=new vector;\n string line;\n\n ifstream file_handle (file_name.c_str());\n while (file_handle.good() && !file_handle.eof() && file_handle.peek()!=EOF) {\n getline(file_handle, line);\n lines->push_back(line);\n }\n\n file_handle.close();\n\n return lines;\n}\nint main() {\n // get file name from the first argument\n string file_name (\"/home/light/CLionProjects/Morden_C++/CMakeLists.txt\");\n int count = read_lines_from_file(file_name).size();\n cout << \"File \" << file_name << \" contains \" << count << \" lines.\";\n\n cout<size();\n// cout << \"File \" << file_name << \" contains \" << count1 << \" lines.\";\n string file_name1 (\"/home/light/CLionProjects/Morden_C++/CMakeLists.txt\");\n int count1 = read_lines_from_file1_1(file_name1)->size();\n cout << \"File \" << file_name << \" contains \" << count1 << \" lines.\";\n return 0;\n}\n"
},
{
"path": "codingStyleIdioms/3_RAII/c++_example2.cpp",
"content": "//\n// Created by light on 19-12-12.\n//\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nunique_ptr> read_lines_from_file(string &file_name) {\n unique_ptr> lines(new vector);\n string line;\n\n ifstream file_handle (file_name.c_str());\n while (file_handle.good() && !file_handle.eof()) {\n getline(file_handle, line);\n lines->push_back(line);\n }\n\n file_handle.close();\n\n return lines;\n}\nint main() {\n // get file name from the first argument\n string file_name (\"/home/light/CLionProjects/Morden_C++/CMakeLists.txt\");\n int count = read_lines_from_file(file_name).get()->size();\n cout << \"File \" << file_name << \" contains \" << count << \" lines.\";\n cout<\n#include \n#include \nint main() {\n char *str = (char *) malloc(7);\n strcpy(str, \"toptal\");\n printf(\"char array = \\\"%s\\\" @ %u\\n\", str, str);\n\n str = (char *) realloc(str, 11);\n strcat(str, \".com\");\n printf(\"char array = \\\"%s\\\" @ %u\\n\", str, str);\n\n free(str);\n\n return(0);\n}"
},
{
"path": "codingStyleIdioms/4_copy-swap/BUILD",
"content": "# please run `bazel run //codingStyleIdioms/4_copy-swap:copy-swapAndADL`\n\nload(\"@rules_cc//cc:defs.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"copy-swapAndADL\",\n srcs = [\"copy-swapAndADL.cpp\"],\n copts = [\"-std=c++11\"],\n)\n"
},
{
"path": "codingStyleIdioms/4_copy-swap/README.md",
"content": "> 为什么我们需要复制和交换习惯？\n\n任何管理资源的类（包装程序，如智能指针）都需要实现big three。尽管拷贝构造函数和析构函数的目标和实现很简单。\n\n但是复制分配运算符无疑是最细微和最困难的。\n\n> 应该怎么做？需要避免什么陷阱？\n\ncopy-swap是解决方案，可以很好地协助赋值运算符实现两件事：避免代码重复，并提供强大的**异常保证**。\n\n>它是如何工作的？\n\n**从概念上讲，它通过使用拷贝构造函数的功能来创建数据的本地副本，然后使用交换功能获取复制的数据，将旧数据与新数据交换来工作。然后，临时副本将销毁，并随身携带旧数据。我们剩下的是新数据的副本。**\n\n为了使用copy-swap，我们需要三件事：\n\n- 一个有效的拷贝构造函数\n- 一个有效的析构函数（两者都是任何包装程序的基础，因此无论如何都应完整）以及交换功能。\n\n交换函数是一种不抛异常函数，它交换一个类的两个对象或者成员。我们可能很想使用std :: swap而不是提供我们自己的方法，但这是不可能的。 std :: swap在实现中使用了copy-constructor和copy-assignment运算符，我们最终将尝试根据自身定义赋值运算符！\n\n（不仅如此，对swap的无条件调用将使用我们的自定义swap运算符，从而跳过了std :: swap会导致的不必要的类构造和破坏。）\n\n具体例子如下：\n\n```cpp\nnamespace A {\n template\n class smart_ptr {\n public:\n smart_ptr() noexcept : ptr_(new T()) {\n\n }\n\n smart_ptr(const T &ptr) noexcept : ptr_(new T(ptr)) {\n\n }\n\n smart_ptr(smart_ptr &rhs) noexcept {\n ptr_ = rhs.release(); // 释放所有权,此时rhs的ptr_指针为nullptr\n }\n\n void swap(smart_ptr &rhs) noexcept { // noexcept == throw() 保证不抛出异常\n using std::swap;\n swap(ptr_, rhs.ptr_);\n }\n\n T *release() noexcept {\n T *ptr = ptr_;\n ptr_ = nullptr;\n return ptr;\n }\n\n T *get() const noexcept {\n return ptr_;\n }\n\n private:\n T *ptr_;\n };\n\n// 提供一个非成员swap函数for ADL(Argument Dependent Lookup)\n template\n void swap(A::smart_ptr &lhs, A::smart_ptr &rhs) noexcept {\n lhs.swap(rhs);\n }\n}\n// 注释开启,会引发ADL冲突\n//namespace std {\n// // 提供一个非成员swap函数for ADL(Argument Dependent Lookup)\n// template\n// void swap(A::smart_ptr &lhs, A::smart_ptr &rhs) noexcept {\n// lhs.swap(rhs);\n// }\n//\n//}\n\nint main() {\n\n using std::swap;\n A::smart_ptr s1(\"hello\"), s2(\"world\");\n // 交换前\n std::cout << *s1.get() << \" \" << *s2.get() << std::endl;\n swap(s1, s2); // 这里swap 能够通过Koenig搜索或者说ADL根据s1与s2的命名空间来查找swap函数\n // 交换后\n std::cout << *s1.get() << \" \" << *s2.get() << std::endl;\n s1=s2;\n}\n```\n\n现在为了让上述的`s1=s2`完成工作，必须实现赋值运算符。\n\n> 方法1\n\n为了避免自赋值,通常采用下面写法 。\n\n不好! \n\n不具备异常安全,只具备自我赋值安全性\n\n```cpp\nsmart_ptr &operator=(const smart_ptr &rhs) {\n if (*this != rhs) {\n delete ptr_;\n ptr_ = new T(rhs.ptr_); // 当new 发生异常,此时ptr_指向的而是一块被删除区域,而不是被赋值对象的区域\n return *this;\n }\n return *this;\n}\n```\n\n> 方法2\n\n如果new出现异常,ptr_会保持原装! 也可以处理自我赋值! 还是不够好!\n\n**这样就会导致代码膨胀，于是导致了另一个问题：代码冗余**\n\n```cpp\n// 方法2：如果new出现异常,ptr_会保持原装! 也可以处理自我赋值! 还是不够好!\nsmart_ptr &operator=(const smart_ptr &rhs) {\n T *origin = ptr_;\n ptr_ = new T(rhs.ptr_);\n delete origin;\n return *this;\n}\n```\n\n> 方法3\n\ncopy and swap 很好!\n\n```cpp\nsmart_ptr &operator=(smart_ptr &rhs) noexcept {\n smart_ptr tmp(rhs);\n swap(tmp);\n return *this;\n}\n```\n\n> 方法4\n\n改为传值，同方法3！\n\n```cpp\nsmart_ptr &operator=(smart_ptr rhs) noexcept {\n swap(rhs);\n return *this;\n}\n```\n\n> C++11 move\n\n我们在big three上加上move ctor与move assignment就构成了big five。\n\n此时再次拓展上述的代码：\n\n```cpp\n// move ctor\nsmart_ptr(smart_ptr &&rhs) noexcept {\n std::cout << \"move ctor\" << std::endl;\n ptr_ = rhs.ptr_;\n if (ptr_)\n rhs.ptr_ = nullptr;\n}\n\n// move assignment\nsmart_ptr &operator=(smart_ptr &&rhs) noexcept {\n std::cout << \"move assignment\" << std::endl;\n smart_ptr tmp(rhs);\n swap(rhs);\n return *this;\n}\n```\n\n**实际上，我们比那个不需要多写代码move assignment，copy-and-swap 技巧 和 move-and-swap 技巧是共享同一个函数的。**当copy构造为上述的方法4时，**对于C++ 11，编译器会依据参数是左值还是右值在拷贝构造函数和移动构造函数间进行选择：**\n\n```cpp\nsmart_ptr &operator=(smart_ptr rhs) noexcept {\n swap(rhs);\n return *this;\n}\n```\n\n所以当这个同上述写的\n\n```cpp\nsmart_ptr &operator=(smart_ptr &&rhs) noexcept{}\n```\n\n同时存在，就会出现error: ambiguous overload for ‘operator=’ 。\n\n调用处如下：\n\n```cpp\nA::smart_ptr s1(\"hello\"), s2(\"world\");\nA::smart_ptr s3 = s1;\nA::smart_ptr s4 = std::move(s1);\n```\n\n- 如果是 s3 = s1，这样就会调用拷贝构造函数来初始化other（因为s1是左值），赋值操作符会与新创建的对象交换数据，深度拷贝。这就是copy and swap 惯用法的定义：构造一个副本，与副本交换数据，并让副本在作用域内自动销毁。\n- 如果是s4 = std::move(s1)，这样就会调用移动构造函数来初始化rhs（因为std::move(s1)是右值），所以这里没有深度拷贝，只有高效的数据转移。\n\n因此也可以称呼它为“统一赋值操作符”，因为它合并了\"拷贝赋值\"与\"移动赋值\"。\n\n"
},
{
"path": "codingStyleIdioms/4_copy-swap/copy-swapAndADL.cpp",
"content": "//\n// Created by light on 19-12-9.\n//\n#include \n\n// copy and swap : https://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom\n// ADL : https://stackoverflow.com/questions/8111677/what-is-argument-dependent-lookup-aka-adl-or-koenig-lookup\n\nnamespace A {\n template\n class smart_ptr {\n public:\n smart_ptr() noexcept : ptr_(new T()) {\n\n }\n\n smart_ptr(const T &ptr) noexcept : ptr_(new T(ptr)) {\n\n }\n\n smart_ptr(smart_ptr &rhs) noexcept {\n std::cout << \"copy ctor\" << std::endl;\n ptr_ = rhs.release(); // 释放所有权,此时rhs的ptr_指针为nullptr\n }\n\n // 方法1：为了避免自赋值,通常采用下面写法 不好! 不具备异常安全,只具备自我赋值安全性\n// smart_ptr &operator=(const smart_ptr &rhs) {\n// if (*this != rhs) {\n// delete ptr_;\n// ptr_ = new T(rhs.ptr_); // 当new 发生异常,此时ptr_指向的而是一块被删除区域,而不是被赋值对象的区域\n// return *this;\n// }\n// return *this;\n// }\n // 方法2：如果new出现异常,ptr_会保持原装! 也可以处理自我赋值! 还是不够好!\n// smart_ptr &operator=(const smart_ptr &rhs) {\n// T *origin = ptr_;\n// ptr_ = new T(rhs.ptr_);\n// delete origin;\n// return *this;\n// }\n // 方法3：copy and swap 很好!\n// smart_ptr &operator=(smart_ptr &rhs) noexcept {\n// smart_ptr tmp(rhs);\n// swap(tmp);\n// return *this;\n// }\n\n // 方法4：同方法3,改为传值\n // 既适用于copy ctor也适用于 move ctor\n smart_ptr &operator=(smart_ptr rhs) noexcept {\n swap(rhs);\n return *this;\n }\n // move ctor\n smart_ptr(smart_ptr &&rhs) noexcept {\n std::cout << \"move ctor\" << std::endl;\n ptr_ = rhs.ptr_;\n if (ptr_)\n rhs.ptr_ = nullptr;\n }\n\n // move assignment\n// smart_ptr &operator=(smart_ptr &&rhs) noexcept {\n// std::cout << \"move assignment\" << std::endl;\n// smart_ptr tmp(rhs);\n// swap(rhs);\n// return *this;\n// }\n\n void swap(smart_ptr &rhs) noexcept { // noexcept == throw() 保证不抛出异常\n using std::swap;\n swap(ptr_, rhs.ptr_);\n }\n\n T *release() noexcept {\n T *ptr = ptr_;\n ptr_ = nullptr;\n return ptr;\n }\n\n T *get() const noexcept {\n return ptr_;\n }\n\n private:\n T *ptr_;\n };\n\n// 提供一个非成员swap函数for ADL(Argument Dependent Lookup)\n template\n void swap(A::smart_ptr &lhs, A::smart_ptr &rhs) noexcept {\n lhs.swap(rhs);\n }\n}\n// 注释开启,会引发ADL冲突\n//namespace std {\n// // 提供一个非成员swap函数for ADL(Argument Dependent Lookup)\n// template\n// void swap(A::smart_ptr &lhs, A::smart_ptr &rhs) noexcept {\n// lhs.swap(rhs);\n// }\n//\n//}\n\nint main() {\n\n using std::swap;\n A::smart_ptr s1(\"hello\"), s2(\"world\");\n // 交换前\n std::cout << *s1.get() << \" \" << *s2.get() << std::endl;\n swap(s1, s2); // 这里swap 能够通过Koenig搜索或者说ADL根据s1与s2的命名空间来查找swap函数\n // 交换后\n std::cout << *s1.get() << \" \" << *s2.get() << std::endl;\n// s1 = s2;\n\n A::smart_ptr![](\"./img/cpp.jpg\")
![](\"./img/wechat.jpg\")