## File: README.md --- - [C++ 那些事](#c-那些事) - [重磅项目](#重磅项目) - [关于作者](#关于作者) - [项目运行](#项目运行) - [方式1: vscode + bazel](#方式1-vscode--bazel) - [方式2: docker](#方式2-docker) - [方式3: g++](#方式3-g) - [视频学习本项目](#视频学习本项目) - [飞书知识库](#飞书知识库) - [基础进阶](#基础进阶) - [实战系列](#实战系列) - [10 日狂练](#10-日狂练) - [重点实战练习](#重点实战练习) - [C++2.0 新特性](#c20-新特性) - [概况](#概况) - [C++11 新特性](#c11-新特性) - [C++14/17/20](#c141720) - [设计模式](#设计模式) - [STL 源码剖析](#stl-源码剖析) - [并发编程](#并发编程) - [C++ Concurrency in Action](#c-concurrency-in-action) - [多线程与多进程](#多线程与多进程) - [Threading In C++](#threading-in-c) - [C++ 惯用法](#c-惯用法) - [你最喜欢的 c++ 编程风格惯用法是什么?](#你最喜欢的-c-编程风格惯用法是什么) - [学习课程](#学习课程) - [极客时间《现代 C++ 实战 30 讲》](#极客时间现代-c-实战-30-讲) - [工具篇](#工具篇) - [容器快捷输出工具](#容器快捷输出工具) - [像 Python 一样简单输出（Jupyter Notebook）](#像-python-一样简单输出jupyter-notebook) - [观察编译过程变化](#观察编译过程变化) - [C++ 的 Debug 工具 dbg-macro](#c-的-debug-工具-dbg-macro) - [在 Linux 上的 Debug 工具 rr - 拥有回到过去的能力](#在-linux-上的-debug-工具-rr---拥有回到过去的能力) - [拓展部分](#拓展部分) - [一些问题](#一些问题) - [贡献者](#贡献者) # C++ 那些事 感谢各位对《C++ 那些事》的支持，现将内容也同步至B站，以视频的方式展示，可以打开网站直接阅读~欢迎大家 star、转发、PR。 在线个人博客：[光城的实验室](https://light-city.github.io/) 在线学习网站：[C++那些事](https://light-city.github.io/stories_things/) - 中文名：**C++ 那些事** - 英文名：**Stories About C Plus Plus** 这是一个适合初学者从**入门到进阶**的仓库，解决了**面试者与学习者**想要**深入 C++** 及如何**入坑 C++** 的问题。除此之外，本仓库拓展了更加深入的源码分析，多线程并发等的知识，是一个比较全面的 C++ 学习从入门到进阶提升的仓库。 > 🎯 **适合人群**: C++ 初学者、面试准备者、想系统学习 Modern C++ 的开发者 > 📚 **涵盖内容**: C++11/14/17/20 新特性、STL 源码剖析、设计模式、并发编程 > 🔧 **实践导向**: 配套完整代码示例和实战项目 ### 重磅项目 推出一系列重磅项目，带大家实战学习C++，配合本开源项目学习，成长飞快! 直通点：[戳这里](./proj/README.md) ### 关于作者 公众号已开放两大入口，分别是专辑与菜单，可以直接在微信公众号上阅读《C++ 那些事》内容，配上该仓库的代码，将会非常的爽，建议大家关注一波。 个人公众号：guangcity 或者扫下面的二维码，欢迎大家反馈及 C++ 交流，本人在微信创建了 C++ 那些事交流群，优质的 C++ 资源交流区，期待大家关注上面公众号，点击公众号右下角->联系我，拉你入群。 --- >关注我 如果觉得不错，关注我吧~ | 星球 | 微信公众号 | | --- | --- | ### 项目运行 #### 方式1: vscode + bazel #### 方式2: docker 新推出免开发环境，docker环境，大家可以pull下面镜像： ``` docker pull xingfranics/cplusplusthings:latest ``` #### 方式3: g++ ### 视频学习本项目 [第一期：Step By Step上手编译本项目](https://www.bilibili.com/video/BV1Rv4y1H7LB/?vd_source=bb6532dcd5b1d6b26125da900adb618e) [第二期：免开发环境docker](https://www.bilibili.com/video/BV1oz4y1a7Pu/?vd_source=bb6532dcd5b1d6b26125da900adb618e) [第三期：手把手共读HashTable，彻底搞懂C++ STL](https://www.bilibili.com/video/BV1o8411U7vy/?vd_source=bb6532dcd5b1d6b26125da900adb618e) [第四期：手把手共读STL之enable_shared_from_this](https://www.bilibili.com/video/BV1du4y1w7Mg/?spm_id_from=333.788&vd_source=bb6532dcd5b1d6b26125da900adb618e) [第五期：手把手共读STL之线程，从C++11 thread到C++20 jthread](https://www.bilibili.com/video/BV1DH4y1g7gS/?vd_source=bb6532dcd5b1d6b26125da900adb618e) [第六期：手把手共读STL之共读condition_variable、condition_variable_any](https://www.bilibili.com/video/BV13b421b7Am/?spm_id_from=333.999.0.0&vd_source=bb6532dcd5b1d6b26125da900adb618e) [第七期：手把手共读STL之Mutex](https://www.bilibili.com/video/BV1xm42157pq/?spm_id_from=333.999.0.0&vd_source=bb6532dcd5b1d6b26125da900adb618e) [第八期：手把手共读STL之RAII Lock](https://www.bilibili.com/video/BV1Ls421g7iq/?spm_id_from=333.788&vd_source=bb6532dcd5b1d6b26125da900adb618e) ### 飞书知识库 [互联网大厂面试实录](https://hmpy6adnp5.feishu.cn/docx/OitBdRB4KozIhTxQt7Ec7iFDnkc) [拿下offer之必备面经](https://hmpy6adnp5.feishu.cn/docx/B1aCdVTUgoyJGYxtWV7cdvgRnxv) ### 基础进阶 - [`const` 那些事](./basic_content/const) - [`static` 那些事](./basic_content/static) - [`this` 那些事](./basic_content/this) - [`inline` 那些事](./basic_content/inline) - [`sizeof` 那些事](./basic_content/sizeof) - [函数指针那些事](./basic_content/func_pointer) - [纯虚函数和抽象类那些事](./basic_content/abstract) - [`vptr_vtable` 那些事](./basic_content/vptr_vtable) - [`virtual` 那些事](./basic_content/virtual) - [`volatile` 那些事](./basic_content/volatile) - [`assert` 那些事](./basic_content/assert) - [位域那些事](./basic_content/bit) - [`extern` 那些事](./basic_content/extern) - [`struct` 那些事](./basic_content/struct) - [`struct` 与 `class` 那些事](./basic_content/struct_class) - [`union` 那些事](./basic_content/union) - [`c` 实现 `c++` 多态那些事](./basic_content/c_poly) - [`explicit` 那些事](./basic_content/explicit) - [`friend` 那些事](./basic_content/friend) - [`using` 那些事](./basic_content/using) - [`::` 那些事](./basic_content/maohao) - [`enum` 那些事](./basic_content/enum) - [`decltype` 那些事](./basic_content/decltype) - [引用与指针那些事](./basic_content/pointer_refer) - [宏那些事](./basic_content/macro) ### 实战系列 #### [10 日狂练](./practical_exercises/10_day_practice) - [day1-基本语法](practical_exercises/10_day_practice/day1) - [day2-递归、结构体、枚举、静态变量等](practical_exercises/10_day_practice/day2) - [day3-函数1](practical_exercises/10_day_practice/day3) - [day4-函数2](practical_exercises/10_day_practice/day4) - [day5-继承多态](practical_exercises/10_day_practice/day5) - [day6-虚函数与抽象类](practical_exercises/10_day_practice/day6) - [day7-运算符重载](practical_exercises/10_day_practice/day7) - [day8-模版与STL](practical_exercises/10_day_practice/day8) - [day9-异常](practical_exercises/10_day_practice/day9) - [day10-文件与流](practical_exercises/10_day_practice/day10) #### [重点实战练习](./practical_exercises/key_exercises/) - [中括号重载.cpp](./practical_exercises/key_exercises/bracket_overloading.cpp) - [时钟++运算符重载.cpp](./practical_exercises/key_exercises/clock.cpp) - [运算符重载之强制转换.cpp](./practical_exercises/key_exercises/operator_cast.cpp) - [重载圆括号的时钟.cpp](./practical_exercises/key_exercises/operator_circle.cpp) - [函数模板.cpp](./practical_exercises/key_exercises/func_temp.cpp) - [动态数组.cpp](./practical_exercises/key_exercises/array.cpp) - [字典插入与查找.cpp](./practical_exercises/key_exercises/map_insert_look.cpp) - [异常捕获.cpp](./practical_exercises/key_exercises/try.cpp) - [类模板之栈.cpp](./practical_exercises/key_exercises/stack.cpp) - [类模板特化之数组.cpp](./practical_exercises/key_exercises/array_template.cpp) - [继承与封装.cpp](./practical_exercises/key_exercises/override.cpp) - [读写文件综合题.cpp](./practical_exercises/key_exercises/read_file.cpp) - [输入输出运算符重载.cpp](./practical_exercises/key_exercises/io_operator_overload.cpp) - [输入输出重载.cpp](./practical_exercises/key_exercises/io_operator.cpp) - [输出格式.cpp](./practical_exercises/key_exercises/output.cpp) ### [C++2.0 新特性](./cpp2.0) #### 概况 C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。 #### [C++11 新特性](./cpp2.0/cpp11) - [Variadic Templates](./cpp2.0/cpp11/variadic) - Spaces in Template Expressions ```cpp vector //ok in each C++ version vector // before c++ 11 error error: ‘>>’ should be ‘> >’ within a nested template argument list,c++11后可以正常通过 ``` - [nullptr and nullptr_t](./cpp2.0/cpp11/nullptr.cpp) - [Automatic Type Deduction with auto](./cpp2.0/cpp11/auto.cpp) - [Uniform Initialization ](./cpp2.0/cpp11/uniform_initialization.cpp) - [initializer_list](./cpp2.0/cpp11/initializer.cpp) - [explicit for ctors taking more than one argument](./cpp2.0/cpp11/explicit.cpp) - [range-based for statement](./cpp2.0/cpp11/auto.cpp) ```cpp for(decl:col) { statement } ``` - [=default,=delete](./cpp2.0/cpp11/default_delete.cpp) 如果你自行定义了一个 `ctor`, 那么编译器就不会给你一个 `default ctor` 如果强制加上 `=default`, 就可以重新获得并使用 `default ctor`. - Alias(化名) Template (template typedef) - [alias.cpp](./cpp2.0/cpp11/alias.cpp) - [template_template.cpp](./cpp2.0/cpp11/template_template.cpp) - [template template parameter](./cpp2.0/template_template.cpp) - [type alias](./cpp2.0/cpp11/type_alias.cpp) - [noexcept](./cpp2.0/cpp11/noexcept.cpp) - [override](./cpp2.0/cpp11/override.cpp) - [final](./cpp2.0/cpp11/final.cpp) - [decltype](./cpp2.0/cpp11/decltype.cpp) - [lambda](./cpp2.0/cpp11/lambda.cpp) - [Rvalue reference](./cpp2.0/cpp11/rvalue.cpp) - [move aware class](./cpp2.0/cpp11/move.cpp) - 容器-结构与分类 - (1) 序列式容器包括：`array`(C++2.0 新引入),`vector`,`deque`,`list`,`forward_list`(C++2.0 新引入) - (2) 关联式容器包括：`set/multiset`,`map/multimap` - (3) 无序容器(C++2.0 新引入,更换原先 `hash_xxx` 为 `unordered_xxx`)包括：`unordered_map/unordered_multimap,unordered_set/unordered_multiset` - [Hash Function](./cpp2.0/cpp11/hash.cpp) - [tuple](./cpp2.0/cpp11/tuple.cpp) 学习资料：https://www.bilibili.com/video/av51863195?from=search&seid=3610634846288253061 #### C++14/17/20 待更新... ### 设计模式 - [单例模式](./design_pattern/singleton) - [生产消费者模式](./design_pattern/producer_consumer) ### [STL 源码剖析](./src_analysis/stl) **STL 源码剖析：gcc 4.9.1** - [array](./src_analysis/stl/array.md) - [deque](./src_analysis/stl/deque.md) - [queue and stack](./src_analysis/stl/queue_stack.md) - [list](./src_analysis/stl/list.md) - [vector](./src_analysis/stl/vector.md) - [typename](./src_analysis/stl/typename.md) - [traits](./src_analysis/stl/traits.md) - [iterator](./src_analysis/stl/iterator.md) - [谈谈 STL 设计之 EBO 优化](./src_analysis/stl/谈谈STL设计之EBO优化.md) - [rb_tree](./src_analysis/stl/rb_tree.md) - [set and multiset](./src_analysis/stl/set_multiset.md) - [map and multimap](./src_analysis/stl/map_multimap.md) - [hashtable](./src_analysis/stl/hashtable.md) - [myhashtable](./src_analysis/stl/myhashtable.md) - [unordered_map](./src_analysis/stl/unordered_map.md) ### [并发编程](./concurrency) #### C++ Concurrency in Action - [第一章](./concurrency/concurrency_v1/chapter1) - [第二章](./concurrency/concurrency_v1/chapter2) 学习资料：https://downdemo.gitbook.io/cpp-concurrency-in-action-2ed/ #### 多线程与多进程 ##### Threading In C++ - [介绍](./concurrency/Threading_In_CPlusPlus/1.thread) - [创建线程的五种类型](./concurrency/Threading_In_CPlusPlus/2.create_type) - [Join 与 Detachs](./concurrency/Threading_In_CPlusPlus/3.join_detach) - [mutex in C++ Threading](./concurrency/Threading_In_CPlusPlus/4.mutex) > 学习自： > > https://www.youtube.com/watch?v=eZ8yKZo-PGw&list=PLk6CEY9XxSIAeK-EAh3hB4fgNvYkYmghp&index=4 ### [C++ 惯用法](./codingStyleIdioms) ##### 你最喜欢的 c++ 编程风格惯用法是什么? - [1.类初始化列表](./codingStyleIdioms/1_classInitializers) - [2.枚举类替换命名空间](./codingStyleIdioms/2_enumclass) - [3.RAII (资源获取即初始化)](./codingStyleIdioms/3_RAII) - [4.copy and swap](./codingStyleIdioms/4_copy-swap) - [5.pImpl (指针指向具体实现)](./codingStyleIdioms/5_pImpl) ### 学习课程 #### [极客时间《现代 C++ 实战 30 讲》](https://time.geekbang.org/channel/home) - [堆、栈、RAII：C++ 里该如何管理资源？](./learn_class/modern_cpp_30/RAII) - [堆](./learn_class/modern_cpp_30/RAII/heap.cpp) - [栈](./learn_class/modern_cpp_30/RAII/stack.cpp) - [RAII](./learn_class/modern_cpp_30/RAII/RAII.cpp) - [自己动手，实现 C++ 的智能指针](./learn_class/modern_cpp_30/smart_ptr) - [auto_ptr、scope_ptr](./learn_class/modern_cpp_30/smart_ptr/auto_scope.cpp) - [unique_ptr](./learn_class/modern_cpp_30/smart_ptr/unique_ptr.cpp) - [shared_ptr](./learn_class/modern_cpp_30/smart_ptr/shared_ptr.cpp) - [右值和移动究竟解决了什么问题？](./learn_class/modern_cpp_30/reference) - [左值与右值](./learn_class/modern_cpp_30/reference/reference.cpp) - [延长声明周期](./learn_class/modern_cpp_30/reference/lifetime.cpp) - [引用折叠](./learn_class/modern_cpp_30/reference/collapses.cpp) - [完美转发](./learn_class/modern_cpp_30/reference/forward.cpp) - [不要返回本地变量的引用](./learn_class/modern_cpp_30/reference/don'treturnReference.cpp) - [容器 1](./learn_class/modern_cpp_30/container1) - [容器 2](./learn_class/modern_cpp_30/container2) - [异常](./learn_class/modern_cpp_30/exception) - [字面量、静态断言和成员函数说明符](./learn_class/modern_cpp_30/literalAssert) - [是不是应该返回对象？](./learn_class/modern_cpp_30/obj) - [编译期多态：泛型编程和模板入门](./learn_class/modern_cpp_30/compilerpoly) - [译期能做些什么？一个完整的计算世界](./learn_class/modern_cpp_30/compilercompute) - [SFINAE：不是错误的替换失败是怎么回事?](./learn_class/modern_cpp_30/SFINAE) - [constexpr：一个常态的世界](./learn_class/modern_cpp_30/constexpr) - [函数对象和 lambda：进入函数式编程](./learn_class/modern_cpp_30/functionLambda) - [内存模型和 atomic：理解并发的复杂性](./learn_class/modern_cpp_30/memorymodel_atomic) ### 工具篇 #### [容器快捷输出工具](./tool/output) 对吴老师的代码进行了修改，[点击此处直通代码](./tool/output/output_container.h) 输入： ```cpp map mp{ {1, 1}, {2, 4}, {3, 9}}; cout << mp << endl; ``` 输出结果显示： ```cpp { 1 => 1, 2 => 4, 3 => 9 } ``` #### 像 Python 一样简单输出（Jupyter Notebook） - [像 Python 一样玩 C/C++](./tool/像Python一样玩CC++.md) #### 观察编译过程变化 - [https://cppinsights.io](https://cppinsights.io/) #### C++ 的 Debug 工具 dbg-macro - [C++ 的 Debug 工具 dbg-macro](./tool/C++的Debug工具dbg-macro.md) #### 在 Linux 上的 Debug 工具 rr - 拥有回到过去的能力 - [用 rr 来进行 debug](./tool/用rr来进行debug.md) ### 拓展部分 #### 一些问题 - [C++ 中如何将 string 类型转换为 int 类型？](./extension/some_problem/string_int.md) --- ## File: basic_content/vptr_vtable/README.md # 深入浅出C++虚函数的vptr与vtable ## 关于作者： 个人公众号： ## 1.基础理论 为了实现虚函数，C ++使用一种称为虚拟表的特殊形式的后期绑定。该虚拟表是用于解决在动态/后期绑定方式的函数调用函数的查找表。虚拟表有时会使用其他名称，例如“vtable”，“虚函数表”，“虚方法表”或“调度表”。 虚拟表实际上非常简单，虽然用文字描述有点复杂。首先，**每个使用虚函数的类（或者从使用虚函数的类派生）都有自己的虚拟表**。该表只是编译器在编译时设置的静态数组。虚拟表包含可由类的对象调用的每个虚函数的一个条目。此表中的每个条目只是一个函数指针，指向该类可访问的派生函数。 其次，编译器还会添加一个隐藏指向基类的指针，我们称之为vptr。vptr在创建类实例时自动设置，以便指向该类的虚拟表。与this指针不同，this指针实际上是编译器用来解析自引用的函数参数，vptr是一个真正的指针。 因此，它使每个类对象的分配大一个指针的大小。这也意味着vptr由派生类继承，这很重要。 ## 2.实现与内部结构 下面我们来看自动与手动操纵vptr来获取地址与调用虚函数！ 开始看代码之前，为了方便大家理解，这里给出调用图： 代码全部遵循标准的注释风格，相信大家看了就会明白，不明白的话，可以留言！ ``` /* Detailed source-code truncated for AI context efficiency. */ ``` 运行结果： ``` 基类对象直接调用 Base::fun1() 基类引用指向基类实例 Base::fun1() 基类指针指向派生类实例并调用虚函数 Derived::fun1() 基类引用指向派生类实例并调用虚函数 Derived::fun1() ======================= vptr_addr:0x401130 func_addr:0x400ea8 Derived::fun1() ======================= vptr_addr:0x401130 func_addr:0x400ed4 DerivedClass::fun2() ``` 我们发现C++的动态多态性是通过虚函数来实现的。简单的说，通过virtual函数，指向子类的基类指针可以调用子类的函数。例如，上述通过基类指针指向派生类实例，并调用虚函数，将上述代码简化为： ```c++ Base *pt = new Derived(); // 基类指针指向派生类实例 cout<<"基类指针指向派生类实例并调用虚函数"<fun1(); ``` 其过程为：首先程序识别出fun1()是个虚函数，其次程序使用pt->vptr来获取Derived的虚拟表。第三，它查找Derived虚拟表中调用哪个版本的fun1()。这里就可以发现调用的是Derived::fun1()。因此pt->fun1()被解析为Derived::fun1()! 除此之外，上述代码大家会看到，也包含了手动获取vptr地址，并调用vtable中的函数，那么我们一起来验证一下上述的地址与真正在自动调用vtable中的虚函数，比如上述`pt->fun1()`的时候，是否一致！ 这里采用gdb调试，在编译的时候记得加上`-g`。 通过`gdb vptr`进入gdb调试页面，然后输入`b Derived::fun1`对fun1打断点，然后通过输入r运行程序到断点处，此时我们需要查看调用栈中的内存地址，通过`disassemable fun1`可以查看当前有关fun1中的相关汇编代码，我们看到了`0x0000000000400ea8`，然后再对比上述的结果会发现与手动调用的fun1一致，fun2类似，以此证明代码正确! gdb调试信息如下： ``` /* Detailed source-code truncated for AI context efficiency. */ ``` --- ## File: basic_content/volatile/README.md ## 关于作者： 个人公众号： ## 1.volatile 被 `volatile` 修饰的变量，在对其进行读写操作时，会引发一些**可观测的副作用**。而这些可观测的副作用，是由**程序之外的因素决定的**。 ## 2.volatile应用 （1）并行设备的硬件寄存器（如状态寄存器）。 假设要对一个设备进行初始化，此设备的某一个寄存器为0xff800000。 ```c++ int *output = (unsigned int *)0xff800000; //定义一个IO端口； int init(void) { int i; for(i=0;i< 10;i++) { *output = i; } } ``` 经过编译器优化后，编译器认为前面循环半天都是废话，对最后的结果毫无影响，因为最终只是将output这个指针赋值为 9，所以编译器最后给你编译编译的代码结果相当于： ```c++ int init(void) { *output = 9; } ``` 如果你对此外部设备进行初始化的过程是必须是像上面代码一样顺序的对其赋值，显然优化过程并不能达到目的。反之如果你不是对此端口反复写操作，而是反复读操作，其结果是一样的，编译器在优化后，也许你的代码对此地址的读操作只做了一次。然而从代码角度看是没有任何问题的。这时候就该使用volatile通知编译器这个变量是一个不稳定的，在遇到此变量时候不要优化。 （2）一个中断服务子程序中访问到的变量； ```c++ static int i=0; int main() { while(1) { if(i) dosomething(); } } /* Interrupt service routine */ void IRS() { i=1; } ``` 上面示例程序的本意是产生中断时，由中断服务子程序IRS响应中断，变更程序变量i，使在main函数中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远不会被调用。如果将变量i加上volatile修饰，则编译器保证对变量i的读写操作都不会被优化，从而保证了变量i被外部程序更改后能及时在原程序中得到感知。 （3）多线程应用中被多个任务共享的变量。 当多个线程共享某一个变量时，该变量的值会被某一个线程更改，应该用 volatile 声明。作用是防止编译器优化把变量从内存装入CPU寄存器中，当一个线程更改变量后，未及时同步到其它线程中导致程序出错。volatile的意思是让编译器每次操作该变量时一定要从内存中真正取出，而不是使用已经存在寄存器中的值。示例如下： ```c++ volatile bool bStop=false; //bStop 为共享全局变量 //第一个线程 void threadFunc1() { ... while(!bStop){...} } //第二个线程终止上面的线程循环 void threadFunc2() { ... bStop = true; } ``` 要想通过第二个线程终止第一个线程循环，如果bStop不使用volatile定义，那么这个循环将是一个死循环，因为bStop已经读取到了寄存器中，寄存器中bStop的值永远不会变成FALSE，加上volatile，程序在执行时，每次均从内存中读出bStop的值，就不会死循环了。 是否了解volatile的应用场景是区分C/C++程序员和嵌入式开发程序员的有效办法，搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，这些都要求用到volatile变量，不懂得volatile将会带来程序设计的灾难。 ## 3.volatile常见问题 下面的问题可以看一下面试者是不是真正了解volatile。 （1）一个参数既可以是const还可以是volatile吗？为什么？ 可以。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。 （2）一个指针可以是volatile吗？为什么？ 可以。尽管这并不常见。一个例子是当一个中断服务子程序修改一个指向一个buffer的指针时。 （3）下面的函数有什么错误？ ```c++ int square(volatile int *ptr) { return *ptr * *ptr; } ``` 这段代码有点变态，其目的是用来返回指针ptr指向值的平方，但是，由于ptr指向一个volatile型参数，编译器将产生类似下面的代码： ```c++ int square(volatile int *ptr) { int a,b; a = *ptr; b = *ptr; return a * b; } ``` 由于*ptr的值可能被意想不到地改变，因此a和b可能是不同的。结果，这段代码可能返回的不是你所期望的平方值！正确的代码如下： ```c++ long square(volatile int *ptr) { int a=*ptr; return a * a; } ``` ## 4.volatile使用 - volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素（操作系统、硬件、其它线程等）更改。所以使用 volatile 告诉编译器不应对这样的对象进行优化。 - volatile 关键字声明的变量，每次访问时都必须从内存中取出值（没有被 volatile 修饰的变量，可能由于编译器的优化，从 CPU 寄存器中取值） - const 可以是 volatile （如只读的状态寄存器） - 指针可以是 volatile 代码学习： - [noopt_vola.cpp](./noopt_vola.cpp) - [volatile.cpp](./volatile.cpp) --- ## File: basic_content/virtual/README.md # virtual那些事 ## 关于作者： 个人公众号： ## 1.虚函数与运行多态 对应的代码：[emp.cpp](./set1/emp.cpp) **虚函数的调用取决于指向或者引用的对象的类型，而不是指针或者引用自身的类型。** ## 2.vptr与vtable 见[vptr_vtable那些事](../vptr_vtable) ## 3.虚函数中默认参数 对应的代码：[default_arg.cpp](./set2/default_arg.cpp) **默认参数是静态绑定的，虚函数是动态绑定的。 默认参数的使用需要看指针或者引用本身的类型，而不是对象的类型**。 ## 4.可以不可以 （1） **静态函数可以声明为虚函数吗？** 原因主要有两方面： **静态函数不可以声明为虚函数，同时也不能被const 和 volatile关键字修饰** static成员函数不属于任何类对象或类实例，所以即使给此函数加上virutal也是没有任何意义 虚函数依靠vptr和vtable来处理。vptr是一个指针，在类的构造函数中创建生成，并且只能用this指针来访问它，静态成员函数没有this指针，所以无法访问vptr。 代码学习：[static_error.cpp ](./set3/static_error.cpp ) （2）**构造函数可以为虚函数吗？** 构造函数不可以声明为虚函数。同时除了inline|explicit之外，构造函数不允许使用其它任何关键字。 为什么构造函数不可以为虚函数？ 尽管虚函数表vtable是在编译阶段就已经建立的，但指向虚函数表的指针vptr是在运行阶段实例化对象时才产生的。 如果类含有虚函数，编译器会在构造函数中添加代码来创建vptr。 问题来了，如果构造函数是虚的，那么它需要vptr来访问vtable，可这个时候vptr还没产生。 因此，构造函数不可以为虚函数。 我们之所以使用虚函数，是因为需要在信息不全的情况下进行多态运行。而构造函数是用来初始化实例的，实例的类型必须是明确的。 因此，构造函数没有必要被声明为虚函数。 代码学习： - [copy_consrtuct.cpp](./set3/copy_consrtuct.cpp) - [vir_con.cpp](./set3/vir_con.cpp) （3）**析构函数可以为虚函数吗？** **析构函数可以声明为虚函数。如果我们需要删除一个指向派生类的基类指针时，应该把析构函数声明为虚函数。 事实上，只要一个类有可能会被其它类所继承， 就应该声明虚析构函数(哪怕该析构函数不执行任何操作)。** 代码学习： - [full_virde.cpp](./set3/full_virde.cpp) - [vir_de.cpp ](./set3/vir_de.cpp) （4）**虚函数可以为私有函数吗？** - 基类指针指向继承类对象，则调用继承类对象的函数； - int main()必须声明为Base类的友元，否则编译失败。 编译器报错： ptr无法访问私有函数。 当然，把基类声明为public， 继承类为private，该问题就不存在了。 代码学习： - [virtual_function.cpp](./set3/virtual_function.cpp) - [virtual_function1.cpp](./set3/virtual_function1.cpp) （5）**虚函数可以被内联吗？** **通常类成员函数都会被编译器考虑是否进行内联。 但通过基类指针或者引用调用的虚函数必定不能被内联。 当然，实体对象调用虚函数或者静态调用时可以被内联，虚析构函数的静态调用也一定会被内联展开。** - 虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。 - 内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。 - `inline virtual` 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 `Base::who()`），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。 代码学习： - [virtual_inline.cpp](./set3/virtual_inline.cpp) - [inline_virtual.cpp](./set3/inline_virtual.cpp) ## 5.RTTI与dynamic_cast RTTI（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)型。 在面向对象程序设计中，有时我们需要在运行时查询一个对象是否能作为某种多态类型使用。与Java的instanceof，以及C#的as、is运算符类似，C++提供了dynamic_cast函数用于动态转型。相比C风格的强制类型转换和C++ reinterpret_cast，dynamic_cast提供了类型安全检查，是一种基于能力查询(Capability Query)的转换，所以在多态类型间进行转换更提倡采用dynamic_cast。 代码学习： - [rtti.cpp](./set4/rtti.cpp) - [warn_rtti.cpp](./set4/warn_rtti.cpp) ## 6.纯虚函数和抽象类 见[纯虚函数和抽象类那些事](../abstract) --- ## File: basic_content/using/README.md # using那些事 ## 关于作者： 个人公众号： ## 基本使用 局部与全局using，具体操作与使用见下面案例： ```c++ #include #define isNs1 1 //#define isGlobal 2 using namespace std; void func() { cout<<"::func"<n = n （不能写成n = n)。 另外，在网上大家会看到this会被编译器解析成`A *const `，`A const * `，究竟是哪一个呢？下面通过断点调试分析： 现有如下例子： ```c++ #include #include using namespace std; class Person{ public: typedef enum { BOY = 0, GIRL }SexType; Person(char *n, int a,SexType s){ name=new char[strlen(n)+1]; strcpy(name,n); age=a; sex=s; } int get_age() const{ return this->age; } Person& add_age(int a){ age+=a; return *this; } ~Person(){ delete [] name; } private: char * name; int age; SexType sex; }; int main(){ Person p("zhangsan",20,Person::BOY); cout< struct Base { // public int v1; // public: //error int v2; //private: int v3; //void print(){ // c中不能在结构体中嵌入函数 // printf("%s\n","hello world"); //}; //error! }; void Base(){ printf("%s\n","I am Base func"); } //struct Base base1; //ok //Base base2; //error int main() { struct Base base; base.v1=1; //base.print(); printf("%d\n",base.v1); Base(); return 0; } ``` 最后输出： ``` 1 I am Base func ``` 完整代码见：[struct_func.c](./struct_func.c) ## 2.C++中struct 与C对比如下： - C++结构体中不仅可以定义数据，还可以定义函数。 - C++结构体中可以使用访问修饰符，如：public、protected、private 。 - C++结构体使用可以直接使用不带struct。 - C++继承 - 若结构体的名字与函数名相同，可以正常运行且正常的调用！但是定义结构体变量时候只能用带struct的！ 例如： > 情形1：不适用typedef定义结构体别名 未添加同名函数前： ```c++ struct Student { }; //Student(){} struct Student s; //ok Student s; //ok ``` 添加同名函数后： ```c++ struct Student { }; Student(){} struct Student s; //ok Student s; //error ``` > 情形二：使用typedef定义结构体别名 ```c++ typedef struct Base1 { int v1; int v3; public: //显示声明public int v2; void print(){ printf("%s\n","hello world"); }; }B; //void B() {} //error! 符号 "B" 已经被定义为一个 "struct Base1" 的别名 ``` > 前三种案例 ```c++ #include #include struct Base { int v1; // private: //error! int v3; public: //显示声明public int v2; void print(){ printf("%s\n","hello world"); }; }; int main() { struct Base base1; //ok Base base2; //ok Base base; base.v1=1; base.v3=2; base.print(); printf("%d\n",base.v1); printf("%d\n",base.v3); return 0; } ``` 完整代码见：[struct_func.cpp](struct_func.cpp) > 继承案例 ```c++ #include #include struct Base { int v1; // private: //error! int v3; public: //显示声明public int v2; virtual void print(){ printf("%s\n","Base"); }; }; struct Derived:Base { public: int v2; void print(){ printf("%s\n","Derived"); }; }; int main() { Base *b=new Derived(); b->print(); return 0; } ``` 完整代码见：[ext_struct_func.cpp](./ext_struct_func.cpp) > 同名函数 ```c++ #include #include struct Base { int v1; // private: //error! int v3; public: //显示声明public int v2; void print(){ printf("%s\n","hello world"); }; }; typedef struct Base1 { int v1; // private: //error! int v3; public: //显示声明public int v2; void print(){ printf("%s\n","hello world"); }; }B; void Base(){ printf("%s\n","I am Base func"); } //void B() {} //error! 符号 "B" 已经被定义为一个 "struct Base1" 的别名 int main() { struct Base base; //ok //Base base1; // error! base.v1=1; base.v3=2; base.print(); printf("%d\n",base.v1); printf("%d\n",base.v3); Base(); return 0; } ``` 完整代码见：[struct_func_func.cpp](./struct_func_func.cpp) ## 3.总结 ### C和C++中的Struct区别 | C | C++ | | ------------------------------------------------------ | ------------------------------------------------------------ | | 不能将函数放在结构体声明 | 能将函数放在结构体声明 | | 在C结构体声明中不能使用C++访问修饰符。 | public、protected、private 在C++中可以使用。 | | 在C中定义结构体变量，如果使用了下面定义必须加struct。 | 可以不加struct | | 结构体不能继承（没有这一概念）。 | 可以继承 | | 若结构体的名字与函数名相同，可以正常运行且正常的调用！ | 若结构体的名字与函数名相同，使用结构体，只能使用带struct定义！ | --- ## File: basic_content/static/README.md # static那些事 ## 关于作者 微信公众号： 当与不同类型一起使用时，Static关键字具有不同的含义。我们可以使用static关键字： **静态变量：** 函数中的变量，类中的变量 **静态类的成员：** 类对象和类中的函数 现在让我们详细看一下静态的这些用法： **静态变量** - 函数中的静态变量 当变量声明为static时，空间**将在程序的生命周期内分配**。即使多次调用该函数，静态变量的空间也**只分配一次**，前一次调用中的变量值通过下一次函数调用传递。这对于在C / C ++或需要存储先前函数状态的任何其他应用程序非常有用。 ```c++ #include #include using namespace std; void demo() { // static variable static int count = 0; cout << count << " "; // value is updated and // will be carried to next // function calls count++; } int main() { for (int i=0; i<5; i++) demo(); return 0; } ``` 输出： ``` 0 1 2 3 4 ``` 您可以在上面的程序中看到变量count被声明为static。因此，它的值通过函数调用来传递。每次调用函数时，都不会对变量计数进行初始化。 - 类中的静态变量 由于声明为static的变量只被初始化一次，因为它们在单独的静态存储中分配了空间，因此类中的静态变量**由对象共享**。对于不同的对象，不能有相同静态变量的多个副本。也是因为这个原因，静态变量不能使用构造函数初始化。 ```c++ #include using namespace std; class Apple { public: static int i; Apple() { // Do nothing }; }; int main() { Apple obj1; Apple obj2; obj1.i =2; obj2.i = 3; // prints value of i cout << obj1.i<<" "< extern char* msg; void sayHello() { printf("%s", msg); } ``` g++对于上面两个代码文件是可以正常编译并且打印Hello World!，但如果给source1.cpp中的msg加上static，则会导致undefined reference to 'msg'的编译错误： ```cpp // source1.cpp extern void sayHello(); static const char* msg = "Hello World!\n"; int main() { sayHello(); return 0; } ```