├── 01_C++的注释.ipynb ├── 19_C++的面向对象.ipynb ├── 02_C++的main函数.ipynb ├── 03_C++的打印.ipynb ├── 05_C++的变量.ipynb ├── 09_C++的转义字符.ipynb ├── 07_C++的标识符.ipynb ├── 06_C++的关键字.ipynb ├── 10_C++的数据输入.ipynb ├── 04_C++的常量.ipynb ├── 30_C++的函数对象.ipynb ├── 31_C++的谓词.ipynb ├── README.md ├── 23_C++的类中友元.ipynb ├── 32_C++的内建函数对象.ipynb ├── 21_C++的调用其他类.ipynb ├── 17_C++的内存模型.ipynb ├── 08_C++的数据类型.ipynb ├── 11_C++的运算符.ipynb ├── 18_C++的引用.ipynb ├── 20_C++的类中封装.ipynb ├── 24_C++的类中运算符重载.ipynb ├── 16_C++的结构体.ipynb └── 12_C++的程序流程结构.ipynb /01_C++的注释.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的注释" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 注释" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 在代码中的加一些说明和解释，这些说明和解释就叫注释。\n", 22 | "\n", 23 | "② 注释能方便自己和其他程序员阅读代码。\n", 24 | "\n", 25 | "③ C++的注释，有两种格式：\n", 26 | "\n", 27 | "1. 单行注释： // 描述信息 \n", 28 | " - note：通常放在一行代码的上方，或者一条语句的末尾，对该行代码说明。\n", 29 | "2. 多行注释： /* 描述信息 */ \n", 30 | " - note：编译器在编译代码时，会忽略注释的内容，即不会执行。" 31 | ] 32 | } 33 | ], 34 | "metadata": { 35 | "kernelspec": { 36 | "display_name": "Python 3.6.3", 37 | "language": "python", 38 | "name": "python3.6.3" 39 | }, 40 | "language_info": { 41 | "codemirror_mode": { 42 | "name": "ipython", 43 | "version": 3 44 | }, 45 | "file_extension": ".py", 46 | "mimetype": "text/x-python", 47 | "name": "python", 48 | "nbconvert_exporter": "python", 49 | "pygments_lexer": "ipython3", 50 | "version": "3.6.3" 51 | }, 52 | "toc": { 53 | "base_numbering": 1, 54 | "nav_menu": {}, 55 | "number_sections": false, 56 | "sideBar": true, 57 | "skip_h1_title": false, 58 | "title_cell": "Table of Contents", 59 | "title_sidebar": "Contents", 60 | "toc_cell": false, 61 | "toc_position": {}, 62 | "toc_section_display": true, 63 | "toc_window_display": true 64 | } 65 | }, 66 | "nbformat": 4, 67 | "nbformat_minor": 4 68 | } 69 | -------------------------------------------------------------------------------- /19_C++的面向对象.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的面向对象" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 面向对象三大特性" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① C++面向对象的三大特性为：封装、继承、多态。\n", 22 | "\n", 23 | "② C++认为万事万物皆为对象，对象上有其属性和行为。\n", 24 | "\n", 25 | "③ 例如：\n", 26 | "\n", 27 | "1. 人可以作为对象，属性有姓名、年龄、身高、体重......行为有走、跑、跳、吃饭、唱歌......\n", 28 | "2. 车也可以作为对象，属性有轮胎、方向盘、车灯......行为有载人、放音乐、放空调......\n", 29 | "3. 具有相同新值的对象，可以抽象为类，人属于人类，车属于车类。" 30 | ] 31 | } 32 | ], 33 | "metadata": { 34 | "kernelspec": { 35 | "display_name": "Python 3.6.3", 36 | "language": "python", 37 | "name": "python3.6.3" 38 | }, 39 | "language_info": { 40 | "codemirror_mode": { 41 | "name": "ipython", 42 | "version": 3 43 | }, 44 | "file_extension": ".py", 45 | "mimetype": "text/x-python", 46 | "name": "python", 47 | "nbconvert_exporter": "python", 48 | "pygments_lexer": "ipython3", 49 | "version": "3.6.3" 50 | }, 51 | "toc": { 52 | "base_numbering": 1, 53 | "nav_menu": {}, 54 | "number_sections": false, 55 | "sideBar": true, 56 | "skip_h1_title": false, 57 | "title_cell": "Table of Contents", 58 | "title_sidebar": "Contents", 59 | "toc_cell": false, 60 | "toc_position": {}, 61 | "toc_section_display": true, 62 | "toc_window_display": true 63 | } 64 | }, 65 | "nbformat": 4, 66 | "nbformat_minor": 4 67 | } 68 | -------------------------------------------------------------------------------- /02_C++的main函数.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的main函数" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. main函数" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① main函数是一个程序的入口\n", 22 | "\n", 23 | "② 每个程序都必须有这么一个函数，并且有且只有一个。" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "//下面11行代码的含义就是在屏幕中输出一个 Hello World\n", 33 | "\n", 34 | "#include\n", 35 | "using namespace std;\n", 36 | "\n", 37 | "int main() {\n", 38 | "\n", 39 | " cout << \"hello C++\" << endl; //屏幕显示“hello C++”\n", 40 | " system(\"pause\"); //按任意键继续，退出程序\n", 41 | "\n", 42 | " return 0;\n", 43 | "\n", 44 | "}" 45 | ] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "metadata": {}, 50 | "source": [ 51 | "运行结果： \n", 52 | " - hello C++ \n", 53 | " - 请按任意键继续. . ." 54 | ] 55 | } 56 | ], 57 | "metadata": { 58 | "kernelspec": { 59 | "display_name": "Python 3.6.3", 60 | "language": "python", 61 | "name": "python3.6.3" 62 | }, 63 | "language_info": { 64 | "codemirror_mode": { 65 | "name": "ipython", 66 | "version": 3 67 | }, 68 | "file_extension": ".py", 69 | "mimetype": "text/x-python", 70 | "name": "python", 71 | "nbconvert_exporter": "python", 72 | "pygments_lexer": "ipython3", 73 | "version": "3.6.3" 74 | }, 75 | "toc": { 76 | "base_numbering": 1, 77 | "nav_menu": {}, 78 | "number_sections": false, 79 | "sideBar": true, 80 | "skip_h1_title": false, 81 | "title_cell": "Table of Contents", 82 | "title_sidebar": "Contents", 83 | "toc_cell": false, 84 | "toc_position": {}, 85 | "toc_section_display": true, 86 | "toc_window_display": true 87 | } 88 | }, 89 | "nbformat": 4, 90 | "nbformat_minor": 4 91 | } 92 | -------------------------------------------------------------------------------- /03_C++的打印.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的打印" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 打印" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① cout << \"XXXX\" << endl; 会使得屏幕打印双引号里面的字符串。\n", 22 | "\n", 23 | "② system(\"pause\"); 会使得屏幕的打印界面暂停到该语句这里，按任意键后才会继续运行。" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "//下面11行代码的含义就是在屏幕中输出一个 Hello World\n", 33 | "\n", 34 | "#include\n", 35 | "using namespace std;\n", 36 | "\n", 37 | "int main() {\n", 38 | "\n", 39 | " cout << \"hello C++\" << endl; //屏幕显示“hello C++”\n", 40 | " system(\"pause\"); //按任意键继续，退出程序\n", 41 | "\n", 42 | " return 0;\n", 43 | "\n", 44 | "}" 45 | ] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "metadata": {}, 50 | "source": [ 51 | "运行结果： \n", 52 | " - hello C++\n", 53 | " - 请按任意键继续. . ." 54 | ] 55 | } 56 | ], 57 | "metadata": { 58 | "kernelspec": { 59 | "display_name": "Python 3.6.3", 60 | "language": "python", 61 | "name": "python3.6.3" 62 | }, 63 | "language_info": { 64 | "codemirror_mode": { 65 | "name": "ipython", 66 | "version": 3 67 | }, 68 | "file_extension": ".py", 69 | "mimetype": "text/x-python", 70 | "name": "python", 71 | "nbconvert_exporter": "python", 72 | "pygments_lexer": "ipython3", 73 | "version": "3.6.3" 74 | }, 75 | "toc": { 76 | "base_numbering": 1, 77 | "nav_menu": {}, 78 | "number_sections": false, 79 | "sideBar": true, 80 | "skip_h1_title": false, 81 | "title_cell": "Table of Contents", 82 | "title_sidebar": "Contents", 83 | "toc_cell": false, 84 | "toc_position": {}, 85 | "toc_section_display": true, 86 | "toc_window_display": true 87 | } 88 | }, 89 | "nbformat": 4, 90 | "nbformat_minor": 4 91 | } 92 | -------------------------------------------------------------------------------- /05_C++的变量.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的变量" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 变量" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 变量的作用就是就是给一段指定的内存空间起名，方便操作这段内存。\n", 22 | "\n", 23 | "② 语法：数据类型 变量名 = 初始值；\n", 24 | "\n", 25 | "③ 变量存在的意义：方便我们管理内存空间。\n", 26 | "\n", 27 | "④ 每一段内存都有一个地址编号。\n", 28 | "\n", 29 | "⑤ C++规定在创建一个常量或变量时，必须要指出相应的数据类型，否则无法给变量分配内存。" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [ 38 | "#include \n", 39 | "using namespace std;\n", 40 | "\n", 41 | "int main()\n", 42 | "{\n", 43 | "\n", 44 | " //变量创建的语法：数据类型 变量名 = 变量初始值\n", 45 | " int a = 10; \n", 46 | "\n", 47 | " cout << \"a = \" << a << endl; // 输出语句 cout << \"提示语\" << 变量 << endl; \n", 48 | "\n", 49 | " system(\"pause\");\n", 50 | "\n", 51 | " return 0;\n", 52 | "\n", 53 | "}" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "运行结果： \n", 61 | " - a = 10\n", 62 | " - 请按任意键继续. . ." 63 | ] 64 | } 65 | ], 66 | "metadata": { 67 | "kernelspec": { 68 | "display_name": "Python 3.6.3", 69 | "language": "python", 70 | "name": "python3.6.3" 71 | }, 72 | "language_info": { 73 | "codemirror_mode": { 74 | "name": "ipython", 75 | "version": 3 76 | }, 77 | "file_extension": ".py", 78 | "mimetype": "text/x-python", 79 | "name": "python", 80 | "nbconvert_exporter": "python", 81 | "pygments_lexer": "ipython3", 82 | "version": "3.6.3" 83 | }, 84 | "toc": { 85 | "base_numbering": 1, 86 | "nav_menu": {}, 87 | "number_sections": false, 88 | "sideBar": true, 89 | "skip_h1_title": false, 90 | "title_cell": "Table of Contents", 91 | "title_sidebar": "Contents", 92 | "toc_cell": false, 93 | "toc_position": {}, 94 | "toc_section_display": true, 95 | "toc_window_display": true 96 | } 97 | }, 98 | "nbformat": 4, 99 | "nbformat_minor": 4 100 | } 101 | -------------------------------------------------------------------------------- /09_C++的转义字符.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的转义字符" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 转义字符" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 用于表示一些不能显示出来的ASCII字符。\n", 22 | "\n", 23 | "② 我们常用的转义字符有：\\n、\\\\、\\t。" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "#include \n", 33 | "using namespace std;\n", 34 | "\n", 35 | "int main()\n", 36 | "{\n", 37 | "\n", 38 | " //换行符 \\n\n", 39 | "\n", 40 | " cout << \"hello world\\n\";\n", 41 | "\n", 42 | " //反斜杠 \\\\ 要输出反斜杠\\时，要在前面加上一个反斜杠\n", 43 | "\n", 44 | " cout << \"\\\\\" << endl;\n", 45 | "\n", 46 | " //水平制表符\\t 可以整齐的输出数据\n", 47 | " cout << \"aaaa\\thellowworld\" << endl;\n", 48 | " cout << \"aa\\thellowworld\" << endl;\n", 49 | " cout << \"aaaaaa\\thellowworld\" << endl;\n", 50 | "\n", 51 | " system(\"pause\");\n", 52 | "\n", 53 | " return 0;\n", 54 | "\n", 55 | "}" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "运行结果：\n", 63 | " - hello world\n", 64 | " - \\\n", 65 | " - aaaa hellowworld\n", 66 | " - aa hellowworld\n", 67 | " - aaaaaa hellowworld\n", 68 | " - 请按任意键继续. . ." 69 | ] 70 | } 71 | ], 72 | "metadata": { 73 | "kernelspec": { 74 | "display_name": "Python 3.6.3", 75 | "language": "python", 76 | "name": "python3.6.3" 77 | }, 78 | "language_info": { 79 | "codemirror_mode": { 80 | "name": "ipython", 81 | "version": 3 82 | }, 83 | "file_extension": ".py", 84 | "mimetype": "text/x-python", 85 | "name": "python", 86 | "nbconvert_exporter": "python", 87 | "pygments_lexer": "ipython3", 88 | "version": "3.6.3" 89 | }, 90 | "toc": { 91 | "base_numbering": 1, 92 | "nav_menu": {}, 93 | "number_sections": false, 94 | "sideBar": true, 95 | "skip_h1_title": false, 96 | "title_cell": "Table of Contents", 97 | "title_sidebar": "Contents", 98 | "toc_cell": false, 99 | "toc_position": {}, 100 | "toc_section_display": true, 101 | "toc_window_display": true 102 | } 103 | }, 104 | "nbformat": 4, 105 | "nbformat_minor": 4 106 | } 107 | -------------------------------------------------------------------------------- /07_C++的标识符.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的标识符" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 标识符" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 标识符就是 C++ 给变量、常量的命名。\n", 22 | "\n", 23 | "② 标识符有一套自己的命名规则：\n", 24 | "\n", 25 | "1. 标识符不能使关键字。\n", 26 | "2. 标识符只能由字母、数字、下划线组成。\n", 27 | "3. 第一个字符必须为字母或下划线。\n", 28 | "4. 标识符中字母区分大小写。\n", 29 | "\n", 30 | "③ 建议：给标识符命名时，争取做到见名知意，方便自己和他人的阅读。" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "#include \n", 40 | "using namespace std;\n", 41 | "\n", 42 | "int main()\n", 43 | "{\n", 44 | " //1、标识符不可以是关键字\n", 45 | " //int int = 10; //报错\n", 46 | " \n", 47 | " //2、标识符由字母、数字、下划线构成\n", 48 | " int abc = 10;\n", 49 | " int _abc = 20;\n", 50 | " int _123abc = 40;\n", 51 | " \n", 52 | " //3、标识符第一个字符只能是字母或下划线\n", 53 | " //int 123abc = 50; //报错\n", 54 | "\n", 55 | " //4、标识符区分大小写\n", 56 | " int aaa = 100;\n", 57 | " //cout << AAA << endl; //报错，AAA和aaa不是同一个名称\n", 58 | "\n", 59 | " //建议：给变量起名的时候，最好能够做到见名知意\n", 60 | " int num1 = 10;\n", 61 | " int num2 = 20;\n", 62 | " int sum = num1 + num2; //建议用num1、num2、sum表示加法，而不是用a、b、c来表示\n", 63 | " cout << sum << endl;\n", 64 | "\n", 65 | " system(\"pause\");\n", 66 | "\n", 67 | " return 0;\n", 68 | "\n", 69 | "}" 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "运行结果： \n", 77 | " - 30\n", 78 | " - 请按任意键继续. . ." 79 | ] 80 | } 81 | ], 82 | "metadata": { 83 | "kernelspec": { 84 | "display_name": "Python 3.6.3", 85 | "language": "python", 86 | "name": "python3.6.3" 87 | }, 88 | "language_info": { 89 | "codemirror_mode": { 90 | "name": "ipython", 91 | "version": 3 92 | }, 93 | "file_extension": ".py", 94 | "mimetype": "text/x-python", 95 | "name": "python", 96 | "nbconvert_exporter": "python", 97 | "pygments_lexer": "ipython3", 98 | "version": "3.6.3" 99 | }, 100 | "toc": { 101 | "base_numbering": 1, 102 | "nav_menu": {}, 103 | "number_sections": false, 104 | "sideBar": true, 105 | "skip_h1_title": false, 106 | "title_cell": "Table of Contents", 107 | "title_sidebar": "Contents", 108 | "toc_cell": false, 109 | "toc_position": {}, 110 | "toc_section_display": true, 111 | "toc_window_display": true 112 | } 113 | }, 114 | "nbformat": 4, 115 | "nbformat_minor": 4 116 | } 117 | -------------------------------------------------------------------------------- /06_C++的关键字.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的关键字" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 关键字" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 关键字是C++中预先保留的单词(标识符)。\n", 22 | "\n", 23 | "② 在定义变量或者常量的时候，不要用关键字。" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "## 1.1 int关键字" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "#include \n", 40 | "using namespace std;\n", 41 | "\n", 42 | "int main()\n", 43 | "{\n", 44 | "\n", 45 | " // int int = 10; // 错误，第二个int是关键字，不可以作为变量的名称\n", 46 | "\n", 47 | " system(\"pause\");\n", 48 | "\n", 49 | " return 0;\n", 50 | "\n", 51 | "}" 52 | ] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "运行结果： \n", 59 | " - 请按任意键继续. . ." 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "## 1.2 sizeof关键字" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "① sizeof关键字可以统计数据类型所占内存大小。\n", 74 | "\n", 75 | "② sizeof关键字，语法：sizeof ( 数据类型 / 变量 )" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "#include \n", 85 | "using namespace std;\n", 86 | "\n", 87 | "int main()\n", 88 | "{\n", 89 | "\n", 90 | " cout << \"short 类型所占内存空间为：\" << sizeof(short) << endl;\n", 91 | "\n", 92 | " system(\"pause\");\n", 93 | "\n", 94 | " return 0;\n", 95 | "\n", 96 | "}" 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": {}, 102 | "source": [ 103 | "运行结果： \n", 104 | " - short 类型所占内存空间为：2 \n", 105 | " - 请按任意键继续. . ." 106 | ] 107 | } 108 | ], 109 | "metadata": { 110 | "kernelspec": { 111 | "display_name": "Python 3.6.3", 112 | "language": "python", 113 | "name": "python3.6.3" 114 | }, 115 | "language_info": { 116 | "codemirror_mode": { 117 | "name": "ipython", 118 | "version": 3 119 | }, 120 | "file_extension": ".py", 121 | "mimetype": "text/x-python", 122 | "name": "python", 123 | "nbconvert_exporter": "python", 124 | "pygments_lexer": "ipython3", 125 | "version": "3.6.3" 126 | }, 127 | "toc": { 128 | "base_numbering": 1, 129 | "nav_menu": {}, 130 | "number_sections": false, 131 | "sideBar": true, 132 | "skip_h1_title": false, 133 | "title_cell": "Table of Contents", 134 | "title_sidebar": "Contents", 135 | "toc_cell": false, 136 | "toc_position": {}, 137 | "toc_section_display": true, 138 | "toc_window_display": true 139 | } 140 | }, 141 | "nbformat": 4, 142 | "nbformat_minor": 4 143 | } 144 | -------------------------------------------------------------------------------- /10_C++的数据输入.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的数据输入" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 数据输入" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 数据的输入，作用：用于从键盘获取数据。\n", 22 | "\n", 23 | "② 数据的输入，关键字：cin\n", 24 | "\n", 25 | "③ 数据饿输入，语法：cin >> 变量" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [ 34 | "#include \n", 35 | "using namespace std;\n", 36 | "#include //包含string的头文件\n", 37 | "int main()\n", 38 | "{\n", 39 | "\n", 40 | " //1、创建bool数据类型\n", 41 | " int a = 0;\n", 42 | " cout << \"请给整型变量 a 赋值：\" << endl;\n", 43 | " cin >> a;\n", 44 | " cout << \"整型变量a = \" << a << endl;\n", 45 | "\n", 46 | " //2、浮点型\n", 47 | " float f = 3.14f;\n", 48 | " cout << \"请给浮点型变量 f 赋值：\" << endl;\n", 49 | " cin >> f;\n", 50 | " cout << \"浮点型变量 f = \" << f << endl;\n", 51 | "\n", 52 | " //3、字符型\n", 53 | " char ch ; //仅仅声明了，没有初始化\n", 54 | " cout << \"请给字符型变量 ch 赋值：\" << endl;\n", 55 | " cin >> ch;\n", 56 | " cout << \"字符型变量 ch = \" << ch << endl;\n", 57 | "\n", 58 | " //4、字符型\n", 59 | " string str = \"hello\";\n", 60 | " cout << \"请给字符串 str 赋值：\" << endl;\n", 61 | " cin >> str;\n", 62 | " cout << \"字符型变量 str = \" << str << endl;\n", 63 | "\n", 64 | " //4、布尔型\n", 65 | " bool flag = false;\n", 66 | " cout << \"请给布尔类型 flag 赋值：\" << endl;\n", 67 | " cin >> flag; //布尔类型 只要是非0的值都代表真\n", 68 | " cout << \"布尔类型 flag = \" << flag << endl;\n", 69 | "\n", 70 | " system(\"pause\");\n", 71 | "\n", 72 | " return 0;\n", 73 | "\n", 74 | "}" 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": {}, 80 | "source": [ 81 | "运行结果： \n", 82 | " - 请给整型变量 a 赋值：\n", 83 | " - 23\n", 84 | " - 整型变量a = 23\n", 85 | " - 请给浮点型变量 f 赋值：\n", 86 | " - 23.4\n", 87 | " - 浮点型变量 f = 23.4\n", 88 | " - 请给字符型变量 ch 赋值：\n", 89 | " - w\n", 90 | " - 字符型变量 ch = w\n", 91 | " - 请给字符串 str 赋值：\n", 92 | " - asfg\n", 93 | " - 字符型变量 str = asfg\n", 94 | " - 请给布尔类型 flag 赋值：\n", 95 | " - 4562\n", 96 | " - 布尔类型 flag = 1\n", 97 | " - 请按任意键继续. . ." 98 | ] 99 | } 100 | ], 101 | "metadata": { 102 | "kernelspec": { 103 | "display_name": "Python 3.6.3", 104 | "language": "python", 105 | "name": "python3.6.3" 106 | }, 107 | "language_info": { 108 | "codemirror_mode": { 109 | "name": "ipython", 110 | "version": 3 111 | }, 112 | "file_extension": ".py", 113 | "mimetype": "text/x-python", 114 | "name": "python", 115 | "nbconvert_exporter": "python", 116 | "pygments_lexer": "ipython3", 117 | "version": "3.6.3" 118 | }, 119 | "toc": { 120 | "base_numbering": 1, 121 | "nav_menu": {}, 122 | "number_sections": false, 123 | "sideBar": true, 124 | "skip_h1_title": false, 125 | "title_cell": "Table of Contents", 126 | "title_sidebar": "Contents", 127 | "toc_cell": false, 128 | "toc_position": {}, 129 | "toc_section_display": true, 130 | "toc_window_display": true 131 | } 132 | }, 133 | "nbformat": 4, 134 | "nbformat_minor": 4 135 | } 136 | -------------------------------------------------------------------------------- /04_C++的常量.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的常量" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 常量" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 常量，用于记录程序中不可更改的数据。\n", 22 | "\n", 23 | "② C++定义常量两种方式，如下所示：\n", 24 | "\n", 25 | "1. #define 宏常量：#define 常量名 常量值 \n", 26 | " - note：通常在文件上方定义，表示一个常量。\n", 27 | "2. const修饰的变量 const 数据类型 常量名 = 常量值 \n", 28 | " - note：通常在变量定义前加关键字const，修饰该变量为常量，不可修改。" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "## 1.1 #define 常量名 常量值" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": null, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [ 44 | "#include \n", 45 | "using namespace std;\n", 46 | "\n", 47 | "#define Day 7 \n", 48 | "\n", 49 | "int main()\n", 50 | "{\n", 51 | "\n", 52 | " /*\n", 53 | " Day = 14; //错误，Day是常量，一旦修改就会报错\n", 54 | " cout << \"一周总共有：\" << Day << \"天\" << endl;\n", 55 | " */\n", 56 | "\n", 57 | " cout << \"一周总共有：\" << Day << \"天\" << endl;\n", 58 | "\n", 59 | " // 输出语句：cout << \"提示语\" << 变量 << endl; \n", 60 | "\n", 61 | " system(\"pause\");\n", 62 | "\n", 63 | " return 0;\n", 64 | "\n", 65 | "}" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "运行结果： \n", 73 | " - 一周总共有：7天 \n", 74 | " - 请按任意键继续. . ." 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": {}, 80 | "source": [ 81 | "## 1.2 const 数据类型 常量名 = 常量值" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": null, 87 | "metadata": {}, 88 | "outputs": [], 89 | "source": [ 90 | "#include \n", 91 | "using namespace std;\n", 92 | "\n", 93 | "int main()\n", 94 | "{\n", 95 | " /*\n", 96 | " const int month = 12;\n", 97 | " month = 24; //错误，const修饰的变量也称为常量\n", 98 | " */\n", 99 | "\n", 100 | " int month = 12;\n", 101 | " month = 24; //正确，这样可以修改变量的值\n", 102 | "\n", 103 | " cout << \"一年总共有：\" << month << \"个月\" << endl;\n", 104 | "\n", 105 | " system(\"pause\");\n", 106 | "\n", 107 | " return 0;\n", 108 | "\n", 109 | "}" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "运行结果： \n", 117 | " - 一年总共有：24个月 \n", 118 | " - 请按任意键继续. . ." 119 | ] 120 | } 121 | ], 122 | "metadata": { 123 | "kernelspec": { 124 | "display_name": "Python 3.6.3", 125 | "language": "python", 126 | "name": "python3.6.3" 127 | }, 128 | "language_info": { 129 | "codemirror_mode": { 130 | "name": "ipython", 131 | "version": 3 132 | }, 133 | "file_extension": ".py", 134 | "mimetype": "text/x-python", 135 | "name": "python", 136 | "nbconvert_exporter": "python", 137 | "pygments_lexer": "ipython3", 138 | "version": "3.6.3" 139 | }, 140 | "toc": { 141 | "base_numbering": 1, 142 | "nav_menu": {}, 143 | "number_sections": false, 144 | "sideBar": true, 145 | "skip_h1_title": false, 146 | "title_cell": "Table of Contents", 147 | "title_sidebar": "Contents", 148 | "toc_cell": false, 149 | "toc_position": {}, 150 | "toc_section_display": true, 151 | "toc_window_display": true 152 | } 153 | }, 154 | "nbformat": 4, 155 | "nbformat_minor": 4 156 | } 157 | -------------------------------------------------------------------------------- /30_C++的函数对象.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的函数对象" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 基本概念" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 重载函数调用操作符的类，其对象常称为函数对象。\n", 22 | "\n", 23 | "② 函数对象使用重载的()时，行为类似函数调用，也叫仿函数。\n", 24 | "\n", 25 | "③ 函数对象(仿函数)是一个类，不是一个函数。" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "# 2. 特点" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "① 函数对象在使用时，可以像普通函数那样调用，可以有参数。\n", 40 | "\n", 41 | "② 函数对象超出普通函数的概念，函数对象可以有自己的状态。\n", 42 | "\n", 43 | "③ 函数对象可以作为参数传递。\n", 44 | "\n", 45 | "④ 仿函数写法是非常灵活的，可以作为参数进行传递。" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": null, 51 | "metadata": {}, 52 | "outputs": [], 53 | "source": [ 54 | "#include\n", 55 | "using namespace std;\n", 56 | "\n", 57 | "class MyAdd\n", 58 | "{\n", 59 | "public:\n", 60 | " int operator()(int v1, int v2)\n", 61 | " {\n", 62 | " return v1 + v2;\n", 63 | " }\n", 64 | "};\n", 65 | "\n", 66 | "//1、函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值\n", 67 | "void test01()\n", 68 | "{\n", 69 | " MyAdd myAdd;\n", 70 | " cout << myAdd(10,10) << endl;\n", 71 | "}\n", 72 | "\n", 73 | "//2、函数对象超出普通函数的概念，函数对象可以有自己的状态\n", 74 | "class MyPrint\n", 75 | "{\n", 76 | "public:\n", 77 | " MyPrint()\n", 78 | " {\n", 79 | " this->count = 0;\n", 80 | " }\n", 81 | "\n", 82 | " void operator()(string test)\n", 83 | " {\n", 84 | " cout << test << endl;\n", 85 | " this->count++;\n", 86 | " }\n", 87 | " int count; //内部自己状态\n", 88 | "};\n", 89 | "\n", 90 | "void test02()\n", 91 | "{\n", 92 | " MyPrint myPrint;\n", 93 | " myPrint(\"hellow world\");\n", 94 | " myPrint(\"hellow world\");\n", 95 | " myPrint(\"hellow world\");\n", 96 | " myPrint(\"hellow world\");\n", 97 | "\n", 98 | " cout << \"myPrint调用次数为：\" << myPrint.count << endl;\n", 99 | "}\n", 100 | "\n", 101 | "//3、函数对象可以作为参数传递\n", 102 | "\n", 103 | "void doPrint(MyPrint &mp, string test)\n", 104 | "{\n", 105 | " mp(test);\n", 106 | "}\n", 107 | "\n", 108 | "void test03()\n", 109 | "{\n", 110 | " MyPrint myPrint;\n", 111 | " doPrint(myPrint,\"hellow world\");\n", 112 | "}\n", 113 | "\n", 114 | "int main() \n", 115 | "{\n", 116 | " test01();\n", 117 | " test02();\n", 118 | " test03();\n", 119 | "\n", 120 | " system(\"pause\");\n", 121 | "\n", 122 | " return 0;\n", 123 | "}" 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": {}, 129 | "source": [ 130 | "运行结果：\n", 131 | " - 20\n", 132 | " - hellow world\n", 133 | " - hellow world\n", 134 | " - hellow world\n", 135 | " - hellow world\n", 136 | " - myPrint调用次数为：4\n", 137 | " - hellow world\n", 138 | " - 请按任意键继续. . ." 139 | ] 140 | } 141 | ], 142 | "metadata": { 143 | "kernelspec": { 144 | "display_name": "Python 3.6.3", 145 | "language": "python", 146 | "name": "python3.6.3" 147 | }, 148 | "language_info": { 149 | "codemirror_mode": { 150 | "name": "ipython", 151 | "version": 3 152 | }, 153 | "file_extension": ".py", 154 | "mimetype": "text/x-python", 155 | "name": "python", 156 | "nbconvert_exporter": "python", 157 | "pygments_lexer": "ipython3", 158 | "version": "3.6.3" 159 | }, 160 | "toc": { 161 | "base_numbering": 1, 162 | "nav_menu": {}, 163 | "number_sections": false, 164 | "sideBar": true, 165 | "skip_h1_title": false, 166 | "title_cell": "Table of Contents", 167 | "title_sidebar": "Contents", 168 | "toc_cell": false, 169 | "toc_position": {}, 170 | "toc_section_display": true, 171 | "toc_window_display": true 172 | } 173 | }, 174 | "nbformat": 4, 175 | "nbformat_minor": 4 176 | } 177 | -------------------------------------------------------------------------------- /31_C++的谓词.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的谓词" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 简介" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 返回bool类型的仿函数称为谓词。\n", 22 | "\n", 23 | "② 如果operator()接受一个参数，那么叫做一元谓词。\n", 24 | "\n", 25 | "③ 如果operator()接受两个参数，那么叫做二元谓词。" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "# 2. 一元谓词" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": null, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "#include\n", 42 | "using namespace std;\n", 43 | "#include\n", 44 | "#include\n", 45 | "\n", 46 | "//仿函数 返回值类型是bool数据类型，称为谓词\n", 47 | "//一元谓词\n", 48 | "class GreaterFive\n", 49 | "{\n", 50 | "public:\n", 51 | " bool operator()(int val)\n", 52 | " {\n", 53 | " return val > 5;\n", 54 | " }\n", 55 | "};\n", 56 | "\n", 57 | "void test01()\n", 58 | "{\n", 59 | " vectorv;\n", 60 | " for (int i = 0; i < 10; i++)\n", 61 | " {\n", 62 | " v.push_back(i);\n", 63 | " }\n", 64 | "\n", 65 | " //查找容器中，有没有大于5的数字\n", 66 | " //GreaterFive() 匿名函数对象\n", 67 | " vector::iterator it = find_if(v.begin(), v.end(), GreaterFive());\n", 68 | " if (it == v.end())\n", 69 | " {\n", 70 | " cout << \"未找到\" << endl;\n", 71 | " }\n", 72 | " else\n", 73 | " {\n", 74 | " cout << \"找到大于5的数字为：\" << *it << endl;\n", 75 | " }\n", 76 | "}\n", 77 | "\n", 78 | "int main() \n", 79 | "{\n", 80 | " test01();\n", 81 | " \n", 82 | " system(\"pause\");\n", 83 | "\n", 84 | " return 0;\n", 85 | "}" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "运行结果： \n", 93 | " - 找到大于5的数字为：6\n", 94 | " - 请按任意键继续. . ." 95 | ] 96 | }, 97 | { 98 | "cell_type": "markdown", 99 | "metadata": {}, 100 | "source": [ 101 | "# 3. 二元谓词" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": null, 107 | "metadata": {}, 108 | "outputs": [], 109 | "source": [ 110 | "#include\n", 111 | "using namespace std;\n", 112 | "#include\n", 113 | "#include\n", 114 | "\n", 115 | "//仿函数 返回值类型是bool数据类型，称为谓词\n", 116 | "//二元谓词\n", 117 | "class MyCompare\n", 118 | "{\n", 119 | "public:\n", 120 | " bool operator()(int val1,int val2)\n", 121 | " {\n", 122 | " return val1 > val2;\n", 123 | " }\n", 124 | "};\n", 125 | "\n", 126 | "void test01()\n", 127 | "{\n", 128 | " vectorv;\n", 129 | " v.push_back(10);\n", 130 | " v.push_back(40);\n", 131 | " v.push_back(50);\n", 132 | " v.push_back(20);\n", 133 | " v.push_back(30);\n", 134 | "\n", 135 | " sort(v.begin(), v.end());\n", 136 | " for (vector::iterator it = v.begin(); it != v.end(); it++)\n", 137 | " {\n", 138 | " cout << *it << \" \";\n", 139 | " }\n", 140 | " cout << endl;\n", 141 | "\n", 142 | " //使用函数对象，改变算法策略，变为排序规则为从大到小\n", 143 | " sort(v.begin(), v.end(), MyCompare()); //MyCompare()为函数对象，是匿名函数\n", 144 | "\n", 145 | " cout << \"----\" << endl;\n", 146 | " for (vector::iterator it = v.begin(); it != v.end(); it++)\n", 147 | " {\n", 148 | " cout << *it << \" \";\n", 149 | " }\n", 150 | " cout << endl;\n", 151 | "}\n", 152 | "\n", 153 | "int main() {\n", 154 | "\n", 155 | " test01();\n", 156 | "\n", 157 | " system(\"pause\");\n", 158 | " \n", 159 | " return 0;\n", 160 | "\n", 161 | "}" 162 | ] 163 | }, 164 | { 165 | "cell_type": "markdown", 166 | "metadata": {}, 167 | "source": [ 168 | "运行结果： \n", 169 | " - 10 20 30 40 50\n", 170 | " - $----$\n", 171 | " - 50 40 30 20 10\n", 172 | " - 请按任意键继续. . ." 173 | ] 174 | } 175 | ], 176 | "metadata": { 177 | "kernelspec": { 178 | "display_name": "Python 3.6.3", 179 | "language": "python", 180 | "name": "python3.6.3" 181 | }, 182 | "language_info": { 183 | "codemirror_mode": { 184 | "name": "ipython", 185 | "version": 3 186 | }, 187 | "file_extension": ".py", 188 | "mimetype": "text/x-python", 189 | "name": "python", 190 | "nbconvert_exporter": "python", 191 | "pygments_lexer": "ipython3", 192 | "version": "3.6.3" 193 | }, 194 | "toc": { 195 | "base_numbering": 1, 196 | "nav_menu": {}, 197 | "number_sections": false, 198 | "sideBar": true, 199 | "skip_h1_title": false, 200 | "title_cell": "Table of Contents", 201 | "title_sidebar": "Contents", 202 | "toc_cell": false, 203 | "toc_position": {}, 204 | "toc_section_display": true, 205 | "toc_window_display": true 206 | } 207 | }, 208 | "nbformat": 4, 209 | "nbformat_minor": 4 210 | } 211 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 最全面的 C++ 笔记 2 | 3 | 笔记视频： 4 | 5 | 视频讲解【主讲方：黑马程序员】 6 | 7 | 1. https://www.bilibili.com/video/BV1et411b73Z?p=1 8 | 9 | ------------------------------------------------------------- 10 | ------------------------------------------------------------- 11 | 12 | 笔记备注（敲重点！敲重点！敲重点！）： 13 | 14 | 1. 在线观看笔记时，有时会出现图片（或公式）显示不完整，这是Github网站没有解析好，笔记下载到本地观看就正常了。（不会下载笔记的，百度查一下"Github如何下载文件"。） 15 | 2. Pycharm 的 Jupyter Notebook 打开笔记时，图片不会正常显示，笔记是用 Anaconda 的 Jupyter Notebook 打开的。（不会打开笔记的，百度查一下"Anaconda如何打开Jupyter Notebook文件"，或者我的主页Python仓库里面"00_Python编辑器"里面有写。） 16 | 3. 安装 Jupyter Notebook 的目录插件，可以快速通过目录，跳转到相应的章节，如下图所示。（不会安装目录的，百度查一下"Jupyter Notebook如何安装目录"，或者我的主页Python仓库里面"00_Python编辑器"里面有相关链接。） 17 | 18 | 补充说明：C++代码我是在VS2019中运行的，Jupyter Notebook仅是笔记文档。 19 | 20 | ![image](https://user-images.githubusercontent.com/60348867/199900750-6ee1becc-d5ce-49ac-81e9-83d4e276114f.png) 21 | 22 | ------------------------------------------------------------- 23 | ------------------------------------------------------------- 24 | 25 | 更多笔记： 26 | 27 | 我的Github主页，还有其他优秀视频的笔记，希望能帮助到你~ 28 | 29 | 1. https://github.com/AccumulateMore 30 | 31 | "♥我的笔记，希望对你有帮助♥" 32 | 33 | ♥小声哔哔：你的Star，是我更新的动力~♥ 34 | 35 | ------------------------------------------------------------- 36 | ------------------------------------------------------------- 37 | 38 | 搭建交流群，帮助孤单的自学者交流 39 | 40 | | 【深度学习 学习交流①群】 | 【深度学习 学习交流②群】 | 微信 | 41 | | -------- | -------- | -------- | 42 | | ![312f346ad393a2f617f21da7ffec9d8](https://github.com/AccumulateMore/CV/assets/60348867/c99750a2-89c0-45ed-bf42-e8f63a222d60)
| ![2f44c2648aaf04f393162501e9e4e0a](https://github.com/AccumulateMore/CV/assets/60348867/d6c44e7b-8349-4de3-b91b-ed62ee7c1544)
| ![2297947b9d8b74a0f219e8d3287a131](https://github.com/user-attachments/assets/1a90530d-e588-44de-8983-3b469d3ee55d)
| 43 | 44 | 超过200人，扫码入群方式失效，只能微信好友邀请入群。 45 | 46 | 看人之短，无一可交之人。看人之长，天下皆是吾师。 47 | 48 | 因为好友申请太多了，添加好友后，直接表达你的需求。 49 | 50 | | 需求示例 | 需求示例 | 需求示例 | 51 | | -------------------- | -------- | -------- | 52 | | 需要论文辅导（研0研1免费，半年掌握三年知识）
| 要进学习交流群
| 要数据集
| 53 | | 需要学习指导（不走弯路错路，快速拿到offer）
| 面试预演（简历拷打问题）
| 需要实习
| 54 | | 需要商业级项目（简历增添项目，提升核心竞争力）
| 指导改简历（从面试官角度出发）
| ......
| 55 | 56 | ------------------------------------------------------------- 57 | ------------------------------------------------------------- 58 | 59 | 帮你们就业，有意向的可以投简历 60 | 61 | 备注：初学者也可以根据市场上就业需求，去学习自己。 62 | 63 | 联影医疗 地点(可选)：上海、北京、深圳、武汉、广州、成都、西安、沈阳、三亚等 64 | 65 | 联影简介：上市千亿公司，在国家号召自主研发高端医疗器械背景下，发展前景十分广阔。 66 | 67 | ![deacdd636739624967e5ff635212b8ab](https://github.com/user-attachments/assets/2dc604b4-1830-4161-aa1e-9e1f7204167a) 68 | 69 | 岗位职责【图像方向】： 70 | 71 | 参与联影集团产品的AI算法开发工作或图形算法开发工作，负责下列至少一项工作： 72 | 73 | 1. 负责提供产品级高端算法解决方案，包括：联影通用软件平台、联影高级应用后处理工作站、联影智能uAl平台、联影机器人手术规划与导航、MR/CT/RT/MI/US事业部的算法需求、科研院所和医院的前瞻性研究项目等；参与创新技术的产品化工作。 74 | 2. 医学图像3D渲染算法和应用维护与开发，利用图像处理和人工智能技术，从事医学图像处理领域相关算法的设计和研发。 75 | 76 | 任职要求： 77 | 78 | 1. 熟悉机器视觉原理，熟悉以下领域之一：3D重建、立体视觉、SLAM、图像视频分类、目标检测、人体姿态估计。 79 | 2. 熟悉以下医学图像后处理算法之一：图形算法、重建算法、分割算法、检测算法、分类算法、配准算法、深度学习算法、流体力学算法、灌注算法、纹理分析算法等。 80 | 81 | 岗位职责【语音方向】： 82 | 83 | 1. 负责音频信号处理和识别相关算法的研究和实现，包含但不限于回声消除、麦克风阵列、盲源分离等技术。 84 | 2. 负责深度学习、神经网络等AI音频算法的研究和实现。 85 | 86 | 任职要求： 87 | 88 | 1. 扎实的数学理论及数字信号处理基础，掌握Matlab及C/C++语言编程。 89 | 2. 有语音、音频信号处理(降噪，回声消除、麦阵、音效等)相关经验。 90 | 3. 有深度学习、神经网络、智能语音识别相关研究。 91 | 92 | 岗位职责【大模型方向】： 93 | 94 | 1. 负责大语言模型方面的算法开发、优化、应用落地。 95 | 2. 负责相应AI解决方案设计，参与关键技术研发，攻关技术难点。 96 | 3. 负责设计和实现大语言模型相关的算法和模型实现，研究并设计新是算法和模型，解决大语言模型应用问题。 97 | 4. 负责开发和优化大语言模型的训练过程，设计并实现大语言模型的训练算法和策略，配置和优化训练的超参数和计算资源，保证模型的训练效果和效率。 98 | 5. 负责构建和管理大规模医疗文本数据集，用于模型预训练和微调，完成不用场景下的下游任务。 99 | 6. 负责进行大语言模型的评估和验证，设计评估指标和实验;设计和实施评估指标和实验，对训练好的大语言模型进行性能评估和分析。识别模型的弱点和改进空间，提出相应的改进策略和方法。 100 | 7. 参与高校、科研、医疗机构科研合作，协助科研成果落地转化。 101 | 102 | 任职要求： 103 | 104 | 1. 具有机器学习、自然语言处理、医学影像分析，或相关领域的学习和研究。 105 | 2. 有预训练大语言模型或GPT模型等相关研究开发经验。 106 | 3. 在机器学习（ICML、NeurlPS、ICLR等），计算机视觉（CVPR、ICCV、ECCV等），自然语言处理（ACL、EMNLP等）和医疗影像分析（MICCAI、IPMI）等顶级会议，或者顶级期刊（IEEE T-PAMI、IEEE TMI、Medical lmage Analysis）发表过相关论文。 107 | 4. 具有人工智能相关专业（计算机视觉、机器学习、医疗图像分析等）硕士及以上学位。 108 | 5. 能熟练使用英语。 109 | 110 | 补充：能内推简历的，也可以联系我，把岗位职责、任职要求发给我【你收公司内推奖金、ta们就业，双赢】。 111 | 112 | | 内推名企 | 内推名企 | 内推名企 | 内推名企 | 内推名企 | 内推名企 | 内推名企 | 内推名企 | 113 | | --------- | ----------- | --------- | --------- | --------- | --------- | --------- | --------- | 114 | | 阿里巴巴
| 腾讯
| 美团
| 京东
| 拼多多
| 百度
| 字节跳动
| 华为
| 115 | | 小米
| OPPO
| vivo
| 联想
| 浪潮集团
| 用友网络
| 商汤科技
| 旷视科技
| 116 | | 中兴通讯
| 海康威视
| 大华股份
| 科大讯飞
| 蔚来汽车
| 理想汽车
| 小鹏汽车
| 比亚迪
| 117 | | 中国移动
| 中国联通
| 中国电信
| 网易
| 快手
| 携程
| 同程旅行
| 顺丰科技
| 118 | | 京东方
| 深信服
| 金山办公
| 猿辅导
| 作业帮
| 得物
| 哔哩哔哩
| 虎牙直播
| 119 | | 斗鱼
| 喜马拉雅
| 滴滴
| 高德地图
| 金山云
| 智谱
| 普华永道
| 德勤
| 120 | | 安永
| 招商银行
| 工商银行
| 建设银行
| 农业银行
| 交通银行
| 平安科技
| 招联科技
| 121 | | 中金公司
| 广发证券
| 寒武纪
| 地平线
| 依图科技
| 云从科技
| 知乎
| 小红书
| 122 | | 小马智行
| 文远知行
| 商飞
| 大疆
| 航天科技
| 中航工业
| 中车集团
| 国家电网
| 123 | | 南方电网
| 三一重工
| 特斯拉
| 宁德时代
| 中创新航
| 比克电池
| GE医疗
| 西门子医疗
| 124 | 125 | ------------------------------------------------------------- 126 | ------------------------------------------------------------- 127 | 128 | 2021年我硕士毕业时，【简历】技能书写，可以借鉴（我的简历技巧10%） 129 | 130 | image 131 | 132 | 用了几个技巧，分享给大家： 133 | 134 | 1. 技能只写掌握了XX，没掌握不要写，掌握且更熟练的放前面，掌握但不熟练的放后面。 135 | 2. 写掌握某项技能时，后面要论证自己真的掌握了，提供相关经历，方便面试官切入询问。 136 | 3. 围绕算法岗展开技能阐述，从编程语言、到深度学习框架、到图像处理算法、服务器数据库存储图像等。 137 | 4. 只写岗位需要的技能，与算法岗不需要的硬件知识、组织能力等不要写，让简历更高匹配算法岗。 138 | 5. 掌握一种类别技能，只占一行，不要有的两行、有的一行，看着不整齐。 139 | 6. 面试官及HR会看着感觉整齐、可信、岗位匹配度高。 140 | 141 | 要知道，很多大公司HR经常一天要看几百份，甚至上千份简历，基本都是10秒内看一份简历。 142 | 143 | 就是这关键的10秒，HR就决定了是进入面试还是PASS。 144 | 145 | 我已经指导过上千位同学，即使市场大环境不好，很多同学都入职各家公司成功了。 146 | 147 | | 2024届年度 内推第一名 | 2024届年度 内推第一名 | 2024届年度 内推第一名 | 148 | | ------ | ------ | ------ | 149 | |
|
|
| 150 | |
一起沾沾喜气，好运是可以传染的
|
一起沾沾喜气，好运是可以传染的
|
一起沾沾喜气，好运是可以传染的
| 151 | 152 | 我的经验（希望对你有帮助）：拿offer最快的方式，就是不走弯路，不走错路。方向错了，努力没有意义。 153 | 154 | e94f93124ea5b9626bc1cecec9eda334 155 | 156 | ------------------------------------------------------------- 157 | ------------------------------------------------------------- 158 | 159 | "♥我们读书是为了成为提灯人去照亮黑暗，而不是为了自己有灯而沾沾自喜还要去吹灭别人的蜡烛♥" 160 | -------------------------------------------------------------------------------- /23_C++的类中友元.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的友元" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 友元简介" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 生活中你的家有客厅(Public)，有你的卧室(Private)，客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去，但是呢，你也可以允许你的好闺蜜进去。\n", 22 | "\n", 23 | "② 在程序里，有些私有属性，也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术。\n", 24 | "\n", 25 | "③ 友元的目的就是让一个函数或者类访问另一个类中私有成员。\n", 26 | "\n", 27 | "④ 友元的关键字为 friend。\n", 28 | "\n", 29 | "⑤ 友元的三种实现：\n", 30 | "\n", 31 | "1. 全局函数做友元。\n", 32 | "2. 类做友元。\n", 33 | "3. 成员函数做友元。" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": null, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "#include \n", 43 | "using namespace std;\n", 44 | "\n", 45 | "//建筑物类\n", 46 | "class Buiding\n", 47 | "{\n", 48 | " //goodfriend全局函数是Buiding类好朋友，可以访问Buiding中私有成员\n", 49 | " friend void goodfriend(Buiding* buiding);\n", 50 | "\n", 51 | "public:\n", 52 | " Buiding() //构造函数 赋初值\n", 53 | " {\n", 54 | " m_SittingRoom = \"客厅\";\n", 55 | " m_BedRoom = \"卧室\";\n", 56 | " }\n", 57 | "\n", 58 | "public:\n", 59 | " string m_SittingRoom; //客厅\n", 60 | "\n", 61 | "private:\n", 62 | " string m_BedRoom;\n", 63 | "};\n", 64 | "\n", 65 | "//全局函数\n", 66 | "void goodfriend(Buiding *buiding)\n", 67 | "{\n", 68 | " cout << \"好基友全局函数 正在访问：\" << buiding->m_SittingRoom << endl;\n", 69 | " cout << \"好基友全局函数 正在访问：\" << buiding->m_BedRoom << endl;\n", 70 | "\n", 71 | "}\n", 72 | "\n", 73 | "void test01()\n", 74 | "{\n", 75 | " Buiding building;\n", 76 | " goodfriend(&building);\n", 77 | "}\n", 78 | "\n", 79 | "int main()\n", 80 | "{\n", 81 | " test01();\n", 82 | "\n", 83 | " system(\"pause\");\n", 84 | "\n", 85 | " return 0;\n", 86 | "\n", 87 | "}" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "运行结果： \n", 95 | " - 好基友全局函数 正在访问：客厅 \n", 96 | " - 好基友全局函数 正在访问：卧室 \n", 97 | " - 请按任意键继续. . ." 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "# 2. 友元类" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": null, 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [ 113 | "#include \n", 114 | "using namespace std;\n", 115 | "\n", 116 | "//类做友元\n", 117 | "class Building; //声明\n", 118 | "\n", 119 | "class GoodGay\n", 120 | "{\n", 121 | "public:\n", 122 | " GoodGay();\n", 123 | "\n", 124 | " void visit(); //参观函数 访问Building中的属性\n", 125 | "\n", 126 | " Building* building;\n", 127 | "};\n", 128 | "\n", 129 | "class Building\n", 130 | "{\n", 131 | " //GoodGay类是本类的好朋友，可以访问本类的私有成员\n", 132 | " friend class GoodGay;\n", 133 | "\n", 134 | "public:\n", 135 | " Building();\n", 136 | "\n", 137 | "public:\n", 138 | " string m_SittingRoom; //客厅\n", 139 | "private:\n", 140 | " string m_BedRoom; //卧室\n", 141 | "};\n", 142 | "\n", 143 | "//类外写成员函数，写类名的作用域\n", 144 | "\n", 145 | "//Building构造函数\n", 146 | "Building::Building()\n", 147 | "{\n", 148 | " m_SittingRoom = \"客厅\";\n", 149 | " m_BedRoom = \"卧室\";\n", 150 | "}\n", 151 | "\n", 152 | "//GoodGay构造函数\n", 153 | "GoodGay::GoodGay()\n", 154 | "{\n", 155 | " //创建建筑物对象\n", 156 | " building = new Building; //这里会调用Building的构造函数\n", 157 | " //new是创建什么样的数据类型，就返回什么样的数据类型的指针 \n", 158 | "}\n", 159 | "\n", 160 | "void GoodGay::visit()\n", 161 | "{\n", 162 | " cout << \"好基友类正在访问：\" << building->m_SittingRoom << endl;\n", 163 | "\n", 164 | " cout << \"好基友类正在访问：\" << building->m_BedRoom << endl;\n", 165 | "\n", 166 | "}\n", 167 | "\n", 168 | "void test01()\n", 169 | "{\n", 170 | " GoodGay gg; //创建一个GoodGay的对象，会调用GoodGay构造函数，会创建一个building，然后调用building构造函数 \n", 171 | " gg.visit();\n", 172 | "}\n", 173 | "\n", 174 | "int main()\n", 175 | "{\n", 176 | " test01();\n", 177 | "\n", 178 | " system(\"pause\");\n", 179 | "\n", 180 | " return 0;\n", 181 | "\n", 182 | "}" 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": {}, 188 | "source": [ 189 | "运行结果： \n", 190 | " - 好基友类正在访问：客厅 \n", 191 | " - 好基友类正在访问：卧室 \n", 192 | " - 请按任意键继续. . ." 193 | ] 194 | }, 195 | { 196 | "cell_type": "markdown", 197 | "metadata": {}, 198 | "source": [ 199 | "# 3. 成员函数做友元" 200 | ] 201 | }, 202 | { 203 | "cell_type": "code", 204 | "execution_count": null, 205 | "metadata": {}, 206 | "outputs": [], 207 | "source": [ 208 | "#include \n", 209 | "using namespace std;\n", 210 | "\n", 211 | "class Building;\n", 212 | "class GoodGay\n", 213 | "{\n", 214 | "public:\n", 215 | " GoodGay();\n", 216 | "\n", 217 | " void visit(); //让visit函数可以访问Building中私有成员\n", 218 | " void visit2(); //让visit2函数不可以访问Buildinng中私有成员\n", 219 | "\n", 220 | " Building* building;\n", 221 | "};\n", 222 | "\n", 223 | "class Building\n", 224 | "{\n", 225 | " //告诉编译器，GoodGay类下的visit成员函数作为本类的好朋友，可以访问私有成员 \n", 226 | " friend void GoodGay::visit();\n", 227 | "\n", 228 | "public:\n", 229 | " Building();\n", 230 | "\n", 231 | "public:\n", 232 | " string m_SittingRoom; //客厅\n", 233 | "\n", 234 | "private:\n", 235 | " string m_BedRoom; //卧室\n", 236 | "};\n", 237 | "\n", 238 | "// 类外实现构造函数\n", 239 | "Building::Building()\n", 240 | "{\n", 241 | " m_SittingRoom = \"客厅\";\n", 242 | " m_BedRoom = \"卧室\";\n", 243 | "}\n", 244 | "\n", 245 | "GoodGay::GoodGay()\n", 246 | "{\n", 247 | " building = new Building;\n", 248 | "}\n", 249 | "\n", 250 | "// 类外实现成员函数\n", 251 | "void GoodGay::visit()\n", 252 | "{\n", 253 | " cout << \"visit 函数正在访问\" << building->m_SittingRoom << endl;\n", 254 | " cout << \"visit 函数正在访问\" << building->m_BedRoom << endl;\n", 255 | "\n", 256 | "}\n", 257 | "\n", 258 | "void GoodGay::visit2()\n", 259 | "{\n", 260 | " cout << \"visit2 函数正在访问\" << building->m_SittingRoom << endl;\n", 261 | " //cout << \"visit 函数正在访问\" << building->m_BedRoom << endl;\n", 262 | "\n", 263 | "}\n", 264 | "\n", 265 | "void test01()\n", 266 | "{\n", 267 | " GoodGay gg;\n", 268 | " gg.visit();\n", 269 | " gg.visit2();\n", 270 | "}\n", 271 | "\n", 272 | "int main()\n", 273 | "{\n", 274 | " test01();\n", 275 | " \n", 276 | " system(\"pause\");\n", 277 | "\n", 278 | " return 0;\n", 279 | "\n", 280 | "}" 281 | ] 282 | }, 283 | { 284 | "cell_type": "markdown", 285 | "metadata": {}, 286 | "source": [ 287 | "运行结果： \n", 288 | " - visit 函数正在访问客厅 \n", 289 | " - visit 函数正在访问卧室 \n", 290 | " - visit2 函数正在访问客厅 \n", 291 | " - 请按任意键继续. . ." 292 | ] 293 | } 294 | ], 295 | "metadata": { 296 | "kernelspec": { 297 | "display_name": "Python 3.6.3", 298 | "language": "python", 299 | "name": "python3.6.3" 300 | }, 301 | "language_info": { 302 | "codemirror_mode": { 303 | "name": "ipython", 304 | "version": 3 305 | }, 306 | "file_extension": ".py", 307 | "mimetype": "text/x-python", 308 | "name": "python", 309 | "nbconvert_exporter": "python", 310 | "pygments_lexer": "ipython3", 311 | "version": "3.6.3" 312 | }, 313 | "toc": { 314 | "base_numbering": 1, 315 | "nav_menu": {}, 316 | "number_sections": false, 317 | "sideBar": true, 318 | "skip_h1_title": false, 319 | "title_cell": "Table of Contents", 320 | "title_sidebar": "Contents", 321 | "toc_cell": false, 322 | "toc_position": { 323 | "height": "calc(100% - 180px)", 324 | "left": "10px", 325 | "top": "150px", 326 | "width": "341.333px" 327 | }, 328 | "toc_section_display": true, 329 | "toc_window_display": true 330 | } 331 | }, 332 | "nbformat": 4, 333 | "nbformat_minor": 4 334 | } 335 | -------------------------------------------------------------------------------- /32_C++的内建函数对象.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的内建函数对象" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 内建函数对象" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① STL内建来了一些函数对象：\n", 22 | "\n", 23 | "1. 算术仿函数\n", 24 | "2. 关系仿函数\n", 25 | "3. 逻辑仿函数\n", 26 | "\n", 27 | "② 用法：\n", 28 | "\n", 29 | "1. 这些仿函数所产生的对象，用法和一般函数完全相同。\n", 30 | "2. 使用内建函数对象，需要引入头文件 #include" 31 | ] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "metadata": {}, 36 | "source": [ 37 | "# 2. 算术仿函数" 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "① 功能描述：实现四则运算。\n", 45 | "\n", 46 | "② 其中negate是一元运算，其他都是二元运算。\n", 47 | "\n", 48 | "③ 仿函数原型：\n", 49 | "\n", 50 | "1. $template T plus$ //加法仿函数\n", 51 | "2. $template T minus$ //减法仿函数\n", 52 | "3. $template T multiplies$ //乘法仿函数\n", 53 | "4. $template T divides$ //除法仿函数\n", 54 | "5. $template T modulus$ //取模仿函数\n", 55 | "6. $template T negate$ //取反仿函数\n", 56 | "\n", 57 | "④ 使用内建函数对象时，需要引入头文件#include " 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": null, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [ 66 | "#include\n", 67 | "using namespace std;\n", 68 | "#include //内建函数对象头文件\n", 69 | "\n", 70 | "//内建函数对象 算术仿函数\n", 71 | "\n", 72 | "//negate 一元仿函数 取反仿函数\n", 73 | "void test01()\n", 74 | "{\n", 75 | " negaten;\n", 76 | "\n", 77 | " cout << n(50) << endl;\n", 78 | "}\n", 79 | "\n", 80 | "//plus 二元仿函数 加法\n", 81 | "void test02()\n", 82 | "{\n", 83 | " plusp; //写一个int就好了，不用写两个int，它默认是两个同类型的int相加\n", 84 | "\n", 85 | " cout << p(50,60) << endl;\n", 86 | "}\n", 87 | "\n", 88 | "int main() {\n", 89 | "\n", 90 | " test01();\n", 91 | " test02();\n", 92 | "\n", 93 | " system(\"pause\");\n", 94 | "\n", 95 | " return 0;\n", 96 | "\n", 97 | "}" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "运行结果：\n", 105 | " - -50\n", 106 | " - 110\n", 107 | " - 请按任意键继续. . ." 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "# 3. 关系仿函数" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "① 功能描述：实现关系对比。\n", 122 | "\n", 123 | "② 仿函数原型： \n", 124 | "\n", 125 | "1. $template bool equal_to$ //等于\n", 126 | "2. $template bool notequal_to$ //不等于\n", 127 | "3. $template<>class T> bool greater$ //大于\n", 128 | "4. $template bool greater_qual$ //大于等于\n", 129 | "5. $template bool less$ //小于\n", 130 | "6. $templatebool less_equal$ //小于等于 \n", 131 | "\n", 132 | "③ 关系仿函数中最常用的就是greater<>大于。" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": null, 138 | "metadata": {}, 139 | "outputs": [], 140 | "source": [ 141 | "#include\n", 142 | "using namespace std;\n", 143 | "#include //内建函数对象头文件\n", 144 | "#include\n", 145 | "#include\n", 146 | "\n", 147 | "\n", 148 | "//内建函数对象 关系仿函数\n", 149 | "//大于 greater\n", 150 | "class MyCompare\n", 151 | "{\n", 152 | " bool operator()(int v1, int v2)\n", 153 | " {\n", 154 | " return v1 > v2;\n", 155 | " }\n", 156 | "};\n", 157 | "\n", 158 | "void test01()\n", 159 | "{\n", 160 | " vectorv;\n", 161 | "\n", 162 | " v.push_back(10);\n", 163 | " v.push_back(20);\n", 164 | " v.push_back(30);\n", 165 | " v.push_back(40);\n", 166 | " v.push_back(50);\n", 167 | "\n", 168 | " for (vector::iterator it = v.begin();it!=v.end();it++)\n", 169 | " {\n", 170 | " cout << *it << \" \";\n", 171 | " }\n", 172 | " cout << endl;\n", 173 | "\n", 174 | " //降序\n", 175 | " \n", 176 | " //方式一：\n", 177 | " //sort(v.begin(), v.end(), MyCompare());\n", 178 | " \n", 179 | " //方式二：\n", 180 | " sort(v.begin(), v.end(), greater()); //greater()为编译器给提供的函数对象，为内建的函数对象\n", 181 | "\n", 182 | " for (vector::iterator it = v.begin(); it != v.end(); it++)\n", 183 | " {\n", 184 | " cout << *it << \" \";\n", 185 | " }\n", 186 | " cout << endl;\n", 187 | "}\n", 188 | "\n", 189 | "int main() {\n", 190 | "\n", 191 | " test01();\n", 192 | "\n", 193 | " system(\"pause\");\n", 194 | "\n", 195 | " return 0;\n", 196 | "\n", 197 | "}" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": {}, 203 | "source": [ 204 | "运行结果：\n", 205 | " - 10 20 30 40 50\n", 206 | " - 50 40 30 20 10\n", 207 | " - 请按任意键继续. . ." 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": {}, 213 | "source": [ 214 | "# 4. 逻辑仿函数" 215 | ] 216 | }, 217 | { 218 | "cell_type": "markdown", 219 | "metadata": {}, 220 | "source": [ 221 | "① 功能描述：实现关系对比\n", 222 | "\n", 223 | "② 仿函数原型：\n", 224 | "\n", 225 | "1. $template bool logical_and$ //逻辑与\n", 226 | "2. $template bool logical_or$ //逻辑或\n", 227 | "3. $template bool logical_not$ //逻辑非\n", 228 | "\n", 229 | "③ 逻辑仿函数实际应用较少，了解即可。" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": null, 235 | "metadata": {}, 236 | "outputs": [], 237 | "source": [ 238 | "#include\n", 239 | "using namespace std;\n", 240 | "#include //内建函数对象头文件\n", 241 | "#include\n", 242 | "#include\n", 243 | "\n", 244 | "\n", 245 | "//内建函数对象 逻辑仿函数\n", 246 | "//逻辑非 logical_not\n", 247 | "\n", 248 | "void test01()\n", 249 | "{\n", 250 | " vectorv;\n", 251 | "\n", 252 | " v.push_back(true);\n", 253 | " v.push_back(false);\n", 254 | " v.push_back(true);\n", 255 | " v.push_back(true);\n", 256 | " v.push_back(false);\n", 257 | "\n", 258 | " for (vector::iterator it = v.begin();it!=v.end();it++)\n", 259 | " {\n", 260 | " cout << *it << \" \";\n", 261 | " }\n", 262 | " cout << endl;\n", 263 | "\n", 264 | " //利用逻辑非 将容器v 搬运到 容器v2中，并执行取反操作\n", 265 | " vectorv2;\n", 266 | " v2.resize(v.size()); //目标容器要提前开辟一个空间\n", 267 | "\n", 268 | " transform(v.begin(),v.end(),v2.begin(),logical_not()); //第一个参数：原容器起始迭代器，第二个参数：原容器终止迭代器，第三个参数：目标容器起始迭代器\n", 269 | "\n", 270 | " for (vector::iterator it = v2.begin(); it != v2.end(); it++)\n", 271 | " {\n", 272 | " cout << *it << \" \";\n", 273 | " }\n", 274 | " cout << endl;\n", 275 | "}\n", 276 | "\n", 277 | "\n", 278 | "\n", 279 | "int main() {\n", 280 | "\n", 281 | " test01();\n", 282 | "\n", 283 | " system(\"pause\");\n", 284 | "\n", 285 | " return 0;\n", 286 | "\n", 287 | "}" 288 | ] 289 | }, 290 | { 291 | "cell_type": "markdown", 292 | "metadata": {}, 293 | "source": [ 294 | "运行结果：\n", 295 | " - 1 0 1 1 0\n", 296 | " - 0 1 0 0 1\n", 297 | " - 请按任意键继续. . ." 298 | ] 299 | } 300 | ], 301 | "metadata": { 302 | "kernelspec": { 303 | "display_name": "Python 3.6.3", 304 | "language": "python", 305 | "name": "python3.6.3" 306 | }, 307 | "language_info": { 308 | "codemirror_mode": { 309 | "name": "ipython", 310 | "version": 3 311 | }, 312 | "file_extension": ".py", 313 | "mimetype": "text/x-python", 314 | "name": "python", 315 | "nbconvert_exporter": "python", 316 | "pygments_lexer": "ipython3", 317 | "version": "3.6.3" 318 | }, 319 | "toc": { 320 | "base_numbering": 1, 321 | "nav_menu": {}, 322 | "number_sections": false, 323 | "sideBar": true, 324 | "skip_h1_title": false, 325 | "title_cell": "Table of Contents", 326 | "title_sidebar": "Contents", 327 | "toc_cell": false, 328 | "toc_position": {}, 329 | "toc_section_display": true, 330 | "toc_window_display": true 331 | } 332 | }, 333 | "nbformat": 4, 334 | "nbformat_minor": 4 335 | } 336 | -------------------------------------------------------------------------------- /21_C++的调用其他类.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的调用其他类" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 类中有其他的类" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": null, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "#include \n", 24 | "using namespace std;\n", 25 | "\n", 26 | "//点和圆关系案例\n", 27 | "\n", 28 | "//点类\n", 29 | "class Point\n", 30 | "{\n", 31 | "public:\n", 32 | " //设置x\n", 33 | " void setX(int x)\n", 34 | " {\n", 35 | " m_X = x;\n", 36 | " }\n", 37 | " //获取x\n", 38 | " int getX()\n", 39 | " {\n", 40 | " return m_X;\n", 41 | " }\n", 42 | " //设置y\n", 43 | " void setY(int y)\n", 44 | " {\n", 45 | " m_Y = y;\n", 46 | " }\n", 47 | " //获取y\n", 48 | " int getY()\n", 49 | " {\n", 50 | " return m_Y;\n", 51 | " }\n", 52 | "\n", 53 | "private:\n", 54 | " int m_X;\n", 55 | " int m_Y;\n", 56 | "};\n", 57 | "\n", 58 | "//圆类\n", 59 | "class Circle\n", 60 | "{\n", 61 | "public:\n", 62 | " //设置半径\n", 63 | " void setR(int r)\n", 64 | " {\n", 65 | " m_R = r;\n", 66 | " }\n", 67 | " //获取半径\n", 68 | " int getR()\n", 69 | " {\n", 70 | " return m_R;\n", 71 | " }\n", 72 | " //设置圆心\n", 73 | " void setCenter(Point center)\n", 74 | " {\n", 75 | " m_Center = center;\n", 76 | " }\n", 77 | " //获取圆心\n", 78 | " Point getCenter()\n", 79 | " {\n", 80 | " return m_Center;\n", 81 | " }\n", 82 | "private:\n", 83 | " int m_R; //半径\n", 84 | " Point m_Center; //圆心 //在类中可以让另一个类 作为本类中的成员\n", 85 | "};\n", 86 | "\n", 87 | "//判断点和圆关系\n", 88 | "void isInCircle(Circle& c, Point& p)\n", 89 | "{\n", 90 | " //计算两点之间距离 平方\n", 91 | " int distance =\n", 92 | " (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +\n", 93 | " (c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY()); //c.getCenter()返回的是圆心点center类\n", 94 | " //可以调用圆心点center类中的方法\n", 95 | "\n", 96 | " //计算半径的平方\n", 97 | " int rDistance = c.getR() * c.getR();\n", 98 | "\n", 99 | " //判断关系\n", 100 | " if (distance == rDistance)\n", 101 | " {\n", 102 | " cout << \"点在圆上\" << endl;\n", 103 | " }\n", 104 | " else if (distance > rDistance)\n", 105 | " {\n", 106 | " cout << \"点在圆外\" << endl;\n", 107 | " }\n", 108 | " else\n", 109 | " {\n", 110 | " cout << \"点在圆内\" << endl;\n", 111 | " }\n", 112 | "}\n", 113 | "\n", 114 | "int main()\n", 115 | "{\n", 116 | " //创建圆\n", 117 | " Circle c;\n", 118 | " c.setR(10);\n", 119 | " Point center;\n", 120 | " center.setX(10); //设置点的横坐标\n", 121 | " center.setY(0); //设置点的纵坐标\n", 122 | " c.setCenter(center); //设置点类传入圆类\n", 123 | "\n", 124 | " //创建点\n", 125 | " Point p;\n", 126 | " p.setX(10);\n", 127 | " p.setY(10);\n", 128 | "\n", 129 | " //判断关系\n", 130 | " isInCircle(c, p);\n", 131 | "\n", 132 | " system(\"pause\");\n", 133 | "\n", 134 | " return 0;\n", 135 | "\n", 136 | "}" 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": {}, 142 | "source": [ 143 | "运行结果: \n", 144 | " - 点在圆上 \n", 145 | " - 请按任意键继续. . ." 146 | ] 147 | }, 148 | { 149 | "cell_type": "markdown", 150 | "metadata": {}, 151 | "source": [ 152 | "# 2. 导入其他文件的类" 153 | ] 154 | }, 155 | { 156 | "cell_type": "markdown", 157 | "metadata": {}, 158 | "source": [ 159 | "## 2.1 point.h头文件" 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": null, 165 | "metadata": {}, 166 | "outputs": [], 167 | "source": [ 168 | "//这是point.h头文件\n", 169 | "\n", 170 | "#pragma once //防止头文件重复包含，防止头文件冲突\n", 171 | "#include //标准输入输出\n", 172 | "using namespace std; //标准命名空间\n", 173 | "\n", 174 | "//只要函数声明、变量声明\n", 175 | "//成员函数只需要声明就好了，末尾有分号。\n", 176 | "class Point\n", 177 | "{\n", 178 | "public:\n", 179 | " //设置x\n", 180 | " void setX(int x);\n", 181 | "\n", 182 | " //获取x\n", 183 | " int getX();\n", 184 | "\n", 185 | " //设置y\n", 186 | " void setY(int y);\n", 187 | "\n", 188 | " //获取y\n", 189 | " int getY();\n", 190 | "\n", 191 | "\n", 192 | "private:\n", 193 | " int m_X;\n", 194 | " int m_Y;\n", 195 | "};" 196 | ] 197 | }, 198 | { 199 | "cell_type": "markdown", 200 | "metadata": {}, 201 | "source": [ 202 | "## 2.2 point.cpp源文件" 203 | ] 204 | }, 205 | { 206 | "cell_type": "code", 207 | "execution_count": null, 208 | "metadata": {}, 209 | "outputs": [], 210 | "source": [ 211 | "//这是point.cpp源文件\n", 212 | "#include \"point.h\"\n", 213 | "\n", 214 | "//定义函数时，要加上作用域，\"双冒号::\"表示Point作用域下的函数\n", 215 | "void Point::setX(int x)\n", 216 | "{\n", 217 | " m_X = x;\n", 218 | "}\n", 219 | "//获取x\n", 220 | "int Point::getX()\n", 221 | "{\n", 222 | " return m_X;\n", 223 | "}\n", 224 | "//设置y\n", 225 | "void Point::setY(int y)\n", 226 | "{\n", 227 | " m_Y = y;\n", 228 | "}\n", 229 | "//获取y\n", 230 | "int Point::getY()\n", 231 | "{\n", 232 | " return m_Y;\n", 233 | "}" 234 | ] 235 | }, 236 | { 237 | "cell_type": "markdown", 238 | "metadata": {}, 239 | "source": [ 240 | "## 2.3 circle.h头文件" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": {}, 247 | "outputs": [], 248 | "source": [ 249 | "#pragma once \n", 250 | "#include //标准输出流\n", 251 | "using namespace std; //标准命名空间\n", 252 | "#include \"Point.h\" //一个类中用到另一个类，把另一个类包含的头文件包含进来\n", 253 | "\n", 254 | "//圆类\n", 255 | "class Circle\n", 256 | "{\n", 257 | "public:\n", 258 | " //设置半径\n", 259 | " void setR(int r);\n", 260 | "\n", 261 | " //获取半径\n", 262 | " int getR();\n", 263 | "\n", 264 | " //设置圆心\n", 265 | " void setCenter(Point center);\n", 266 | "\n", 267 | " //获取圆心\n", 268 | " Point getCenter();\n", 269 | "\n", 270 | "private:\n", 271 | " int m_R; //半径\n", 272 | " Point m_Center; //圆心 //在类中可以让另一个类 作为本类中的成员\n", 273 | "};" 274 | ] 275 | }, 276 | { 277 | "cell_type": "markdown", 278 | "metadata": {}, 279 | "source": [ 280 | "## 2.4 circle.cpp头文件" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": null, 286 | "metadata": {}, 287 | "outputs": [], 288 | "source": [ 289 | "//这是circle.cpp头文件\n", 290 | "\n", 291 | "#include \"circle.h\"\n", 292 | "\n", 293 | "//设置半径\n", 294 | "void Circle::setR(int r)\n", 295 | "{\n", 296 | " m_R = r;\n", 297 | "}\n", 298 | "\n", 299 | "//获取半径\n", 300 | "int Circle::getR()\n", 301 | "{\n", 302 | " return m_R;\n", 303 | "}\n", 304 | "\n", 305 | "//设置圆心\n", 306 | "void Circle::setCenter(Point center)\n", 307 | "{\n", 308 | " m_Center = center;\n", 309 | "}\n", 310 | "\n", 311 | "//获取圆心\n", 312 | "Point Circle::getCenter()\n", 313 | "{\n", 314 | " return m_Center;\n", 315 | "}" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": {}, 321 | "source": [ 322 | "## 2.5 main.cpp文件" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": null, 328 | "metadata": {}, 329 | "outputs": [], 330 | "source": [ 331 | "//这个是主文件 .cpp文件\n", 332 | "\n", 333 | "#include \n", 334 | "using namespace std;\n", 335 | "#include \"circle.h\" //想用点类，就要包含点类的头文件\n", 336 | "#include \"point.h\" //想用圆类，就要包含点类的头文件\n", 337 | "\n", 338 | "\n", 339 | "//判断点和圆关系\n", 340 | "void isInCircle(Circle& c, Point& p)\n", 341 | "{\n", 342 | " //计算两点之间距离 平方\n", 343 | " int distance =\n", 344 | " (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +\n", 345 | " (c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY()); //c.getCenter()返回的是圆心点center类\n", 346 | " //可以调用圆心点center类中的方法\n", 347 | "\n", 348 | " //计算半径的平方\n", 349 | " int rDistance = c.getR() * c.getR();\n", 350 | "\n", 351 | " //判断关系\n", 352 | " if (distance == rDistance)\n", 353 | " {\n", 354 | " cout << \"点在圆上\" << endl;\n", 355 | " }\n", 356 | " else if (distance > rDistance)\n", 357 | " {\n", 358 | " cout << \"点在圆外\" << endl;\n", 359 | " }\n", 360 | " else\n", 361 | " {\n", 362 | " cout << \"点在圆内\" << endl;\n", 363 | " }\n", 364 | "}\n", 365 | "\n", 366 | "int main()\n", 367 | "{\n", 368 | " //创建圆\n", 369 | " Circle c;\n", 370 | " c.setR(10);\n", 371 | " Point center;\n", 372 | " center.setX(10); //设置点的横坐标\n", 373 | " center.setY(0); //设置点的纵坐标\n", 374 | " c.setCenter(center); //设置点类传入圆类\n", 375 | "\n", 376 | " //创建点\n", 377 | " Point p;\n", 378 | " p.setX(10);\n", 379 | " p.setY(10);\n", 380 | " \n", 381 | " //判断关系\n", 382 | " isInCircle(c, p);\n", 383 | "\n", 384 | " system(\"pause\");\n", 385 | "\n", 386 | " return 0;\n", 387 | "\n", 388 | "}" 389 | ] 390 | } 391 | ], 392 | "metadata": { 393 | "kernelspec": { 394 | "display_name": "Python 3.6.3", 395 | "language": "python", 396 | "name": "python3.6.3" 397 | }, 398 | "language_info": { 399 | "codemirror_mode": { 400 | "name": "ipython", 401 | "version": 3 402 | }, 403 | "file_extension": ".py", 404 | "mimetype": "text/x-python", 405 | "name": "python", 406 | "nbconvert_exporter": "python", 407 | "pygments_lexer": "ipython3", 408 | "version": "3.6.3" 409 | }, 410 | "toc": { 411 | "base_numbering": 1, 412 | "nav_menu": {}, 413 | "number_sections": false, 414 | "sideBar": true, 415 | "skip_h1_title": false, 416 | "title_cell": "Table of Contents", 417 | "title_sidebar": "Contents", 418 | "toc_cell": false, 419 | "toc_position": {}, 420 | "toc_section_display": true, 421 | "toc_window_display": true 422 | } 423 | }, 424 | "nbformat": 4, 425 | "nbformat_minor": 4 426 | } 427 | -------------------------------------------------------------------------------- /17_C++的内存模型.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的内存模型" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 内存分区" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① C++在程序执行时，将内存大方向划分为4个区域。\n", 22 | "\n", 23 | "1. 代码区：存放函数体的二进制代码，由操作系统进行管理的。\n", 24 | "2. 全局区：存放全局变量和静态变量以及常量。\n", 25 | "3. 栈区：由编译器自动分配释放，存放函数的参数值、局部变量等。\n", 26 | "4. 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。\n", 27 | "\n", 28 | "② 内存四区的意义：不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程。" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "① 在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域：代码区、全局区。\n", 36 | "\n", 37 | "② 所有的写的代码(注释、变量、语句等)都会放到代码区中。\n", 38 | "\n", 39 | "③ 栈区中的数据由编译器决定数据的生成和死亡。\n", 40 | "\n", 41 | "④ 堆区中的数据由程序员决定数据的生存和死亡。" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "# 2. 内存四区" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "## 2.1 代码区" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "① 代码区：\n", 63 | "\n", 64 | "1. 存放CPU执行的机器指令。\n", 65 | "2. 代码区是共享的，共享的目的是对于频繁被执行的程序，只需要内存中有一份代码即可。\n", 66 | "3. 代码区是只读的，使其只读的原因是防止程序员意外地修改了它的指令。" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "## 2.2 全局区" 74 | ] 75 | }, 76 | { 77 | "cell_type": "markdown", 78 | "metadata": {}, 79 | "source": [ 80 | "① 全局区：\n", 81 | "\n", 82 | "1. 全局变量和静态变量存放在此，局部常量不放在全局区。\n", 83 | "2. 全局区还包含了常量区，字符串常量和其他常量也存放在此。\n", 84 | "3. 该区域的数据在程序结束后由操作系统释放。" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": null, 90 | "metadata": {}, 91 | "outputs": [], 92 | "source": [ 93 | "#include \n", 94 | "using namespace std;\n", 95 | "\n", 96 | "//全局变量\n", 97 | "int g_a = 10;\n", 98 | "int g_b = 20;\n", 99 | "\n", 100 | "//const修饰的全局常量\n", 101 | "const int c_g_a = 50;\n", 102 | "const int c_g_b = 60;\n", 103 | "\n", 104 | "int main()\n", 105 | "{\n", 106 | " //全局区\n", 107 | "\n", 108 | " //全局变量、静态变量、常量\n", 109 | "\n", 110 | " //创建普通局部变量\n", 111 | " int a = 30;\n", 112 | " int b = 40;\n", 113 | "\n", 114 | " cout << \"局部变量a的地址为：\" << (int)&a << endl;\n", 115 | " cout << \"局部变量b的地址为：\" << (int)&b << endl;\n", 116 | "\n", 117 | " cout << \"全局变量g_a的地址为：\" << (int)&g_a << endl;\n", 118 | " cout << \"全局变量g_b的地址为：\" << (int)&g_b << endl;\n", 119 | "\n", 120 | " //静态变量 在普通变量前面加static,属于静态变量\n", 121 | " static int s_a = 10;\n", 122 | " static int s_b = 10;\n", 123 | "\n", 124 | " cout << \"静态变量s_a的地址为：\" << (int)&s_a << endl;\n", 125 | " cout << \"静态变量s_b的地址为：\" << (int)&s_b << endl;\n", 126 | "\n", 127 | " //常量\n", 128 | " //字符串常量\n", 129 | " cout << \"字符串常量的地址为：\" << (int)&\"hello world\" << endl;\n", 130 | "\n", 131 | " //const修饰的变量\n", 132 | " //const修饰的局部变量,const修饰的局部变量\n", 133 | " cout << \"全局常量c_g_a的地址为：\" << (int)&c_g_a << endl;\n", 134 | " cout << \"全局常量c_g_a的地址为：\" << (int)&c_g_b << endl;\n", 135 | "\n", 136 | " const int c_l_a = 10; // c-const g-global l-local;\n", 137 | " const int c_l_b = 10;\n", 138 | " cout << \"局域常量c_l_a的地址为：\" << (int)&c_l_a << endl;\n", 139 | " cout << \"局域常量c_l_b的地址为：\" << (int)&c_l_a << endl;\n", 140 | "\n", 141 | " system(\"pause\");\n", 142 | "\n", 143 | " return 0;\n", 144 | "\n", 145 | "}" 146 | ] 147 | }, 148 | { 149 | "cell_type": "markdown", 150 | "metadata": {}, 151 | "source": [ 152 | "运行结果： \n", 153 | " - 局部变量a的地址为：14023100 \n", 154 | " - 局部变量b的地址为：14023088 \n", 155 | " - 全局变量g_a的地址为：4964352 \n", 156 | " - 全局变量g_b的地址为：4964356 \n", 157 | " - 静态变量s_a的地址为：4964360 \n", 158 | " - 静态变量s_b的地址为：4964364 \n", 159 | " - 字符串常量的地址为：4955128 \n", 160 | " - 全局常量c_g_a的地址为：4954928 \n", 161 | " - 全局常量c_g_a的地址为：4954932 \n", 162 | " - 局域常量c_l_a的地址为：14023076 \n", 163 | " - 局域常量c_l_b的地址为：14023076 \n", 164 | " - 请按任意键继续. . ." 165 | ] 166 | }, 167 | { 168 | "cell_type": "markdown", 169 | "metadata": {}, 170 | "source": [ 171 | "## 2.3 栈区" 172 | ] 173 | }, 174 | { 175 | "cell_type": "markdown", 176 | "metadata": {}, 177 | "source": [ 178 | "① 栈区\n", 179 | "\n", 180 | "1. 由编译器自动分配释放，存放函数的参数值、局部变量等。\n", 181 | "2. 不要返回局部变量的地址，栈区开辟的数据由编译器自动释放。" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": null, 187 | "metadata": {}, 188 | "outputs": [], 189 | "source": [ 190 | "#include \n", 191 | "using namespace std;\n", 192 | "\n", 193 | "//栈区数据注意事项：不要返回局部变量的地址\n", 194 | "//栈区的数据由编译器管理开辟和释放\n", 195 | "\n", 196 | "int* func(int b) //返回的是一个地址 int*；形参的数据也会放在栈区\n", 197 | "{\n", 198 | " int a = 10; //局部变量存放的数据10存放在栈区，栈区的数据在函数执行完后自动释放\n", 199 | " return &a; //返回局部变量的地址，即数据10的的地址\n", 200 | "}\n", 201 | "\n", 202 | "int main()\n", 203 | "{\n", 204 | " //接收func函数的返回值\n", 205 | " int* p = func(1); //用指针接收栈区上的数据10的地址，由于栈区上数据10已经被释放，所以对地址解引用会获得乱码的值。\n", 206 | "\n", 207 | " cout << *p << endl; //第一次可以 打印正确的数字，是因为编译器做了保留\n", 208 | " cout << *p << endl; //第二次这个数据就不在保留了。\n", 209 | "\n", 210 | " system(\"pause\");\n", 211 | "\n", 212 | " return 0;\n", 213 | "\n", 214 | "}" 215 | ] 216 | }, 217 | { 218 | "cell_type": "markdown", 219 | "metadata": {}, 220 | "source": [ 221 | "运行结果： \n", 222 | " - 10 \n", 223 | " - 1905325 \n", 224 | " - 请按任意键继续. . ." 225 | ] 226 | }, 227 | { 228 | "cell_type": "markdown", 229 | "metadata": {}, 230 | "source": [ 231 | "## 2.4 堆区" 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "metadata": {}, 237 | "source": [ 238 | "① 堆区：\n", 239 | "\n", 240 | "1. 由程序员分配释放，若程序员不释放，程序结束时由操作系统回收。\n", 241 | "2. 在C++中主要利用new在堆区开辟内存。" 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": null, 247 | "metadata": {}, 248 | "outputs": [], 249 | "source": [ 250 | "#include \n", 251 | "using namespace std;\n", 252 | "\n", 253 | "int* func() //返回的是一个地址 int*；形参的数据也会放在栈区\n", 254 | "{\n", 255 | " //利用new关键字，可以将数据开辟到堆区\n", 256 | " //指针本质也是变量，这里的指针是局部变量，局部变量的数据放在栈上，即指针保存的数据是放在堆区\n", 257 | " int * p = new int(10); //new关键字会返回一个地址，因此用栈上的指针来接收堆上数据的地址。\n", 258 | " return p;\n", 259 | "}\n", 260 | "int main()\n", 261 | "{\n", 262 | " //在堆区开辟数据\n", 263 | " int* p = func(); //堆区的地址返回给 *p 了，栈区数据是否，堆区数据没释放\n", 264 | "\n", 265 | " cout << *p << endl;\n", 266 | " cout << *p << endl;\n", 267 | " cout << *p << endl;\n", 268 | " cout << *p << endl;\n", 269 | "\n", 270 | " system(\"pause\");\n", 271 | "\n", 272 | " return 0;\n", 273 | "\n", 274 | "}" 275 | ] 276 | }, 277 | { 278 | "cell_type": "markdown", 279 | "metadata": {}, 280 | "source": [ 281 | "运行结果： \n", 282 | " - 10 \n", 283 | " - 10 \n", 284 | " - 10 \n", 285 | " - 10 \n", 286 | " - 请按任意键继续. . ." 287 | ] 288 | }, 289 | { 290 | "cell_type": "markdown", 291 | "metadata": {}, 292 | "source": [ 293 | "# 3. new操作符" 294 | ] 295 | }, 296 | { 297 | "cell_type": "markdown", 298 | "metadata": {}, 299 | "source": [ 300 | "① C++中利用new操作符在堆区开辟数据。\n", 301 | "\n", 302 | "② 堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符 delete。\n", 303 | "\n", 304 | "③ 语法：new 数据类型\n", 305 | "\n", 306 | "④ 利用new创建的数据，会返回该数据对应的类型的指针。" 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": null, 312 | "metadata": {}, 313 | "outputs": [], 314 | "source": [ 315 | "#include \n", 316 | "using namespace std;\n", 317 | "\n", 318 | "//1、new的基本语法\n", 319 | "\n", 320 | "int* func() //返回的是一个地址 int*；形参的数据也会放在栈区\n", 321 | "{\n", 322 | " //在堆区创建整型数据\n", 323 | " //new返回是该数据类型的指针\n", 324 | " int* p = new int(10);\n", 325 | " return p;\n", 326 | "}\n", 327 | "\n", 328 | "void test01()\n", 329 | "{\n", 330 | " int* p = func();\n", 331 | " cout << *p << endl;\n", 332 | " cout << *p << endl;\n", 333 | " cout << *p << endl;\n", 334 | " //堆区的数据，由程序员管理开辟，程序员管理释放\n", 335 | " //如果想释放堆区数据，利用关键字 delete\n", 336 | " delete p;\n", 337 | "\n", 338 | " // cout << *p << endl; //报错，内存已经被释放，再次访问就是非法操作，会报错\n", 339 | "}\n", 340 | "\n", 341 | "//2、在堆区利用new开辟数据\n", 342 | "void test02()\n", 343 | "{\n", 344 | " //创建10整型数据的数组，在堆区\n", 345 | " int* arr = new int[10];//10代表数组有10个元素\n", 346 | "\n", 347 | " for (int i = 0; i < 10; i++)\n", 348 | " {\n", 349 | " arr[i] = i + 100; //给10个元素赋值 100~109\n", 350 | " }\n", 351 | "\n", 352 | " for (int i = 0; i < 10; i++)\n", 353 | " {\n", 354 | " cout << arr[i] << endl; \n", 355 | " }\n", 356 | " //释放堆区数据\n", 357 | " //释放数组的时候，要加[]才可以\n", 358 | " delete[] arr;\n", 359 | "}\n", 360 | "\n", 361 | "int main()\n", 362 | "{\n", 363 | " test01();\n", 364 | " test02();\n", 365 | "\n", 366 | " system(\"pause\");\n", 367 | "\n", 368 | " return 0;\n", 369 | "\n", 370 | "}" 371 | ] 372 | }, 373 | { 374 | "cell_type": "markdown", 375 | "metadata": {}, 376 | "source": [ 377 | "运行结果： \n", 378 | " - 10 \n", 379 | " - 10 \n", 380 | " - 10 \n", 381 | " - 100 \n", 382 | " - 101 \n", 383 | " - 102 \n", 384 | " - 103 \n", 385 | " - 104 \n", 386 | " - 105 \n", 387 | " - 106 \n", 388 | " - 107 \n", 389 | " - 108 \n", 390 | " - 109 \n", 391 | " - 请按任意键继续. . ." 392 | ] 393 | } 394 | ], 395 | "metadata": { 396 | "kernelspec": { 397 | "display_name": "Python 3.6.3", 398 | "language": "python", 399 | "name": "python3.6.3" 400 | }, 401 | "language_info": { 402 | "codemirror_mode": { 403 | "name": "ipython", 404 | "version": 3 405 | }, 406 | "file_extension": ".py", 407 | "mimetype": "text/x-python", 408 | "name": "python", 409 | "nbconvert_exporter": "python", 410 | "pygments_lexer": "ipython3", 411 | "version": "3.6.3" 412 | }, 413 | "toc": { 414 | "base_numbering": 1, 415 | "nav_menu": {}, 416 | "number_sections": false, 417 | "sideBar": true, 418 | "skip_h1_title": false, 419 | "title_cell": "Table of Contents", 420 | "title_sidebar": "Contents", 421 | "toc_cell": false, 422 | "toc_position": {}, 423 | "toc_section_display": true, 424 | "toc_window_display": true 425 | } 426 | }, 427 | "nbformat": 4, 428 | "nbformat_minor": 4 429 | } 430 | -------------------------------------------------------------------------------- /08_C++的数据类型.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的数据类型" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 数据类型" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "## 1.1 整形" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "① 作用：整型变量表示的是整数类型的数据。\n", 29 | "\n", 30 | "② C++中能够表示整形的类型有以下几种方式，区别在于所占内存空间不同。\n", 31 | "\n", 32 | "③ 数据类型 占用空间 取值范围\n", 33 | "\n", 34 | "1. short(短整型) 2字节 -2^15-2^15-1\n", 35 | "2. int（整型） 4字节 -2^31-2^31-1\n", 36 | "3. long(长整型） Windows为4字节，Linux为4字节(32位)，8字节(64位) -2^31-2^31-1\n", 37 | "4. long long(长长整型) 8字节 -2^63-2^63-1" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [ 46 | "#include \n", 47 | "using namespace std;\n", 48 | "\n", 49 | "int main()\n", 50 | "{\n", 51 | " //1、短整型(-32768~32767)\n", 52 | " short num1 = 10;\n", 53 | " short num5 = 32768; //溢出了，打印出来是-23768\n", 54 | " short num6 = 32770; //溢出了，打印出来是-32766\n", 55 | "\n", 56 | " //2、整型\n", 57 | " int num2 = 10;\n", 58 | "\n", 59 | " //3、长整型\n", 60 | " long num3 = 10;\n", 61 | "\n", 62 | " //4、长长整型\n", 63 | " long long num4 = 10;\n", 64 | "\n", 65 | " cout << \"num1 = ：\" << num1 << endl;\n", 66 | " cout << \"num2 = ：\" << num2 << endl;\n", 67 | " cout << \"num3 = ：\" << num3 << endl;\n", 68 | " cout << \"num4 = ：\" << num4 << endl;\n", 69 | " cout << \"num5 = ：\" << num5 << endl;\n", 70 | " cout << \"num6 = ：\" << num6 << endl;\n", 71 | "\n", 72 | " system(\"pause\");\n", 73 | "\n", 74 | " return 0;\n", 75 | "\n", 76 | "}" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "运行结果： \n", 84 | " - num1 = ：10 \n", 85 | " - num2 = ：10 \n", 86 | " - num3 = ：10 \n", 87 | " - num4 = ：10 \n", 88 | " - num5 = ：-32768 \n", 89 | " - num6 = ：-32766 \n", 90 | " - 请按任意键继续. . ." 91 | ] 92 | }, 93 | { 94 | "cell_type": "markdown", 95 | "metadata": {}, 96 | "source": [ 97 | "## 1.2 实型(浮点型)" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "① 作用：用于表示小数。\n", 105 | "\n", 106 | "② 浮点型变量分为下面两种，两个的区别在于表示有效数字范围不同。\n", 107 | "\n", 108 | "1. 单精度float\n", 109 | "2. 双精度double\n", 110 | "\n", 111 | "③ 数据类型 占用字节 有效数字范围\n", 112 | "\n", 113 | "1. float 4字节 7位有效数字\n", 114 | "2. double 8字节 15-16位有效数字" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "### 1.2.1 单精度、双精度" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [ 130 | "#include \n", 131 | "using namespace std;\n", 132 | "\n", 133 | "int main()\n", 134 | "{\n", 135 | " //1、单精度 float\n", 136 | " //2、双精度 double\n", 137 | " //默认情况下，无论单精度还是双精度，都只会显示6位有效数字\n", 138 | " float f1 = 3.1415926; //默认为双精度，前面加float相当于把双精度转换为单精度\n", 139 | " float f2 = 3.1415926f; //后面加一个f，直接创建的是单精度\n", 140 | "\n", 141 | " cout << \"f1 = ：\" << f1 << endl;\n", 142 | "\n", 143 | " double d1 = 3.1415926;\n", 144 | "\n", 145 | " cout << \"d1 = ：\" << d1 << endl;\n", 146 | "\n", 147 | " cout << \"float 占用内存空间为\" << sizeof(float) << endl;\n", 148 | " cout << \"double 占用内层空间为\" << sizeof(double) << endl;\n", 149 | "\n", 150 | " system(\"pause\");\n", 151 | "\n", 152 | " return 0;\n", 153 | "\n", 154 | "}" 155 | ] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "metadata": {}, 160 | "source": [ 161 | "运行结果： \n", 162 | " - f1 = ：3.14159 \n", 163 | " - d1 = ：3.14159 \n", 164 | " - float 占用内存空间为4 \n", 165 | " - double 占用内层空间为8 \n", 166 | " - 请按任意键继续. . ." 167 | ] 168 | }, 169 | { 170 | "cell_type": "markdown", 171 | "metadata": {}, 172 | "source": [ 173 | "### 1.2.2 科学计数法" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": null, 179 | "metadata": {}, 180 | "outputs": [], 181 | "source": [ 182 | "#include \n", 183 | "using namespace std;\n", 184 | "\n", 185 | "int main()\n", 186 | "{\n", 187 | " //科学计数法\n", 188 | " float f3 = 3e2; // 3 * (10 ^ 2)\n", 189 | " cout << \"f3 = ：\" << f3 << endl;\n", 190 | "\n", 191 | " float f4 = 3e-2; // 3 * (0.1 ^ 2)\n", 192 | " cout << \"f4 = ：\" << f4 << endl;\n", 193 | "\n", 194 | " system(\"pause\");\n", 195 | "\n", 196 | " return 0;\n", 197 | "}" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": {}, 203 | "source": [ 204 | "运行结果： \n", 205 | " - f3 = ：300 \n", 206 | " - f4 = ：0.03 \n", 207 | " - 请按任意键继续. . ." 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": {}, 213 | "source": [ 214 | "## 1.3 字符型" 215 | ] 216 | }, 217 | { 218 | "cell_type": "markdown", 219 | "metadata": {}, 220 | "source": [ 221 | "① 字符型变量用于显示单个字符。\n", 222 | "\n", 223 | "② 语法：char ch = 'a';\n", 224 | "\n", 225 | "③ 在显示字符型变量时，用单引号字符括起来，不要用双引号。\n", 226 | "\n", 227 | "④ 单引号内只能有一个字符，不可以是字符串。\n", 228 | "\n", 229 | "⑤ C和C++中字符型变量只占用1个字节。\n", 230 | "\n", 231 | "⑥ 字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元。\n", 232 | "\n", 233 | "⑦ ASCII码大致由以下两部分组成：\n", 234 | "\n", 235 | "1. ASCII非打印控制字符：ASCII表上的数字0-31分配给了控制字符，用于控制像打印机等一些外围设备。\n", 236 | "2. ASCII打印字符：数字21-126分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。" 237 | ] 238 | }, 239 | { 240 | "cell_type": "code", 241 | "execution_count": null, 242 | "metadata": {}, 243 | "outputs": [], 244 | "source": [ 245 | "#include \n", 246 | "using namespace std;\n", 247 | "\n", 248 | "int main()\n", 249 | "{\n", 250 | "\n", 251 | " //1、字符型变量创建方式\n", 252 | " char ch = 'a';\n", 253 | " cout << ch << endl;\n", 254 | "\n", 255 | " //2、字符型变量所占内存大小\n", 256 | " cout << \"char字符型变量所占内存：\" << sizeof(char) << endl;\n", 257 | "\n", 258 | " //3、字符型变量常见错误\n", 259 | " char ch2 = 'b'; //创建字符型变量时候，要用单引号\n", 260 | " //char ch3 = \"b\"; //错误，创建字符型变量时候，不能用双引号\n", 261 | " //char ch4 = 'abcdef'; //错误，创建字符型变量时候，单引号内只能有一个字符\n", 262 | "\n", 263 | " //4、字符型变量对应ASCII编码\n", 264 | " cout << (int)ch << endl; // (int)ch 为字符'a'的ASCIII码值\n", 265 | "\n", 266 | " system(\"pause\");\n", 267 | "\n", 268 | " return 0;\n", 269 | "\n", 270 | "}" 271 | ] 272 | }, 273 | { 274 | "cell_type": "markdown", 275 | "metadata": {}, 276 | "source": [ 277 | "运行结果： \n", 278 | " - a \n", 279 | " - char字符型变量所占内存：1 \n", 280 | " - 97 \n", 281 | " - 请按任意键继续. . ." 282 | ] 283 | }, 284 | { 285 | "cell_type": "markdown", 286 | "metadata": {}, 287 | "source": [ 288 | "## 1.4 字符串型" 289 | ] 290 | }, 291 | { 292 | "cell_type": "markdown", 293 | "metadata": {}, 294 | "source": [ 295 | "① 用于表示一串字符。\n", 296 | "\n", 297 | "② 字符串型有两种风格\n", 298 | "\n", 299 | "③ C风格字符串：char 变量名[] = \"字符串值\"\n", 300 | "\n", 301 | "④ C++风格字符串：string 变量名 = \"字符串值\"" 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": null, 307 | "metadata": {}, 308 | "outputs": [], 309 | "source": [ 310 | "#include \n", 311 | "using namespace std;\n", 312 | "#include //用C++风格字符串时候，要包含这个头文件\n", 313 | "\n", 314 | "int main()\n", 315 | "{\n", 316 | "\n", 317 | " //1、C风格字符串\n", 318 | " //char 字符 = 这是一个字符\n", 319 | " //char 字符[] = 这是一个字符串\n", 320 | " //表示字符串时，等号后面，要用双引号\n", 321 | "\n", 322 | " char str[] = \"hello world\";\n", 323 | " cout << str << endl;\n", 324 | "\n", 325 | " //2、C++风格字符串\n", 326 | " string str2 = \"hello world\";\n", 327 | " cout << str2 << endl;\n", 328 | " \n", 329 | " system(\"pause\");\n", 330 | "\n", 331 | " return 0;\n", 332 | "\n", 333 | "}" 334 | ] 335 | }, 336 | { 337 | "cell_type": "markdown", 338 | "metadata": {}, 339 | "source": [ 340 | "运行结果： \n", 341 | " - hello world \n", 342 | " - hello world \n", 343 | " - 请按任意键继续. . ." 344 | ] 345 | }, 346 | { 347 | "cell_type": "markdown", 348 | "metadata": {}, 349 | "source": [ 350 | "## 1.5 布尔类型 bool" 351 | ] 352 | }, 353 | { 354 | "cell_type": "markdown", 355 | "metadata": {}, 356 | "source": [ 357 | "① 布尔数据类型代表真或假的值。\n", 358 | "\n", 359 | "② bool类型只有两个值：\n", 360 | "\n", 361 | "1. true -- 真 (本质是1)\n", 362 | "2. false -- 假(本质是0)\n", 363 | "\n", 364 | "③ bool类型占1个字节大小" 365 | ] 366 | }, 367 | { 368 | "cell_type": "code", 369 | "execution_count": null, 370 | "metadata": {}, 371 | "outputs": [], 372 | "source": [ 373 | "#include \n", 374 | "using namespace std;\n", 375 | "\n", 376 | "int main()\n", 377 | "{\n", 378 | "\n", 379 | " //1、创建bool数据类型\n", 380 | "\n", 381 | " bool flag1 = true; //true代表真\n", 382 | " cout << flag1 << endl;\n", 383 | " \n", 384 | " bool flag2 = false; //flag 代表假\n", 385 | " cout << flag2 << endl;\n", 386 | " \n", 387 | " //本质上 1代表真 0代表假\n", 388 | "\n", 389 | " //2、查看bool类型所占空间\n", 390 | " cout << \"bool所占内存空间：\" << sizeof(flag1) << endl;\n", 391 | " cout << \"bool所占内存空间：\" << sizeof(flag2) << endl;\n", 392 | "\n", 393 | " system(\"pause\");\n", 394 | "\n", 395 | " return 0;\n", 396 | "\n", 397 | "}" 398 | ] 399 | }, 400 | { 401 | "cell_type": "markdown", 402 | "metadata": {}, 403 | "source": [ 404 | "运行结果： \n", 405 | " - 1 \n", 406 | " - 0 \n", 407 | " - bool所占内存空间：1 \n", 408 | " - bool所占内存空间：1 \n", 409 | " - 请按任意键继续. . ." 410 | ] 411 | } 412 | ], 413 | "metadata": { 414 | "kernelspec": { 415 | "display_name": "Python 3.6.3", 416 | "language": "python", 417 | "name": "python3.6.3" 418 | }, 419 | "language_info": { 420 | "codemirror_mode": { 421 | "name": "ipython", 422 | "version": 3 423 | }, 424 | "file_extension": ".py", 425 | "mimetype": "text/x-python", 426 | "name": "python", 427 | "nbconvert_exporter": "python", 428 | "pygments_lexer": "ipython3", 429 | "version": "3.6.3" 430 | }, 431 | "toc": { 432 | "base_numbering": 1, 433 | "nav_menu": {}, 434 | "number_sections": false, 435 | "sideBar": true, 436 | "skip_h1_title": false, 437 | "title_cell": "Table of Contents", 438 | "title_sidebar": "Contents", 439 | "toc_cell": false, 440 | "toc_position": {}, 441 | "toc_section_display": true, 442 | "toc_window_display": true 443 | } 444 | }, 445 | "nbformat": 4, 446 | "nbformat_minor": 4 447 | } 448 | -------------------------------------------------------------------------------- /11_C++的运算符.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的运算符" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 运算符" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 运算符作用：用于执行代码的运算。\n", 22 | "\n", 23 | "② 运算符类型主要有四种：\n", 24 | "\n", 25 | "1. 算术运算符：用于处理四则运算。 \n", 26 | "2. 赋值运算符：用于将表达式的值赋给变量 \n", 27 | "3. 比较运算符：用于表达式的比较，并返回一个真值或假值。 \n", 28 | "4. 逻辑运算法：用于表达式的值返回真值或假值。" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "# 2. 算术运算符" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "## 2.1 加减乘除运算" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": null, 48 | "metadata": {}, 49 | "outputs": [], 50 | "source": [ 51 | "#include \n", 52 | "using namespace std;\n", 53 | "\n", 54 | "int main()\n", 55 | "{\n", 56 | "\n", 57 | " int a1 = 10;\n", 58 | " int b1 = 3;\n", 59 | "\n", 60 | " cout << a1 + b1 << endl;\n", 61 | " cout << a1 - b1 << endl;\n", 62 | " cout << a1 * b1 << endl;\n", 63 | " cout << a1 / b1 << endl; //两个整数相除，结果依然是整数，将小数部分去除\n", 64 | "\n", 65 | " int a2 = 10;\n", 66 | " int b2 = 20;\n", 67 | "\n", 68 | " cout << a2 / b2 << endl;\n", 69 | "\n", 70 | " int a3 = 10;\n", 71 | " int b3 = 0;\n", 72 | "\n", 73 | " //cout << a3 / b3 << endl; //两个数相除，除数不可以为0\n", 74 | "\n", 75 | " //两个小数可以相除\n", 76 | " double d1 = 0.51; //如果d1为0.5，运算结果为整数2\n", 77 | " double d2 = 0.25;\n", 78 | " \n", 79 | " cout << d1 / d2 << endl; //运算结果也可以是小数\n", 80 | "\n", 81 | " system(\"pause\");\n", 82 | "\n", 83 | " return 0;\n", 84 | "\n", 85 | "}" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "运行结果： \n", 93 | " - 13 \n", 94 | " - 7 \n", 95 | " - 30 \n", 96 | " - 3 \n", 97 | " - 0 \n", 98 | " - 2.04 \n", 99 | " - 请按任意键继续. . ." 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "## 2.2 取模运算" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "#include \n", 116 | "using namespace std;\n", 117 | "\n", 118 | "int main()\n", 119 | "{\n", 120 | " //取摸运算本质 就是求余数\n", 121 | " int a1 = 10;\n", 122 | " int b1 = 3;\n", 123 | "\n", 124 | " cout << a1 % b1 << endl;\n", 125 | "\n", 126 | " /*两个数相除，除数不可以为0，所以也做不了取模运算\n", 127 | " int a2 = 10;\n", 128 | " int b2 = 0;\n", 129 | "\n", 130 | " cout << a2 % b2 << endl; //\n", 131 | " */\n", 132 | "\n", 133 | " /*两个小数是不可以做取模运算的\n", 134 | " double d1 = 3.14;\n", 135 | " double d2 = 1.1;\n", 136 | "\n", 137 | " cout << d1 % d2 << endl;\n", 138 | " */\n", 139 | "\n", 140 | " system(\"pause\");\n", 141 | "\n", 142 | " return 0;\n", 143 | "\n", 144 | "}" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "运行结果： \n", 152 | " - 1 \n", 153 | " - 请按任意键继续. . ." 154 | ] 155 | }, 156 | { 157 | "cell_type": "markdown", 158 | "metadata": {}, 159 | "source": [ 160 | "## 2.3 递增递减运算" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": null, 166 | "metadata": {}, 167 | "outputs": [], 168 | "source": [ 169 | "#include \n", 170 | "using namespace std;\n", 171 | "\n", 172 | "int main()\n", 173 | "{\n", 174 | " //1、前置递增\n", 175 | "\n", 176 | " int a = 10;\n", 177 | " ++a;\n", 178 | " cout << \"a=\" << a << endl;\n", 179 | "\n", 180 | " //2、后置递增\n", 181 | "\n", 182 | " int b = 15;\n", 183 | " b++;\n", 184 | " cout << \"b=\" << b << endl;\n", 185 | "\n", 186 | " //3、前置和后置的区别\n", 187 | " //前置递增，先让变量+1 然后进行表达式运算\n", 188 | " int a2 = 10;\n", 189 | " int b2 = ++a2 * 10;\n", 190 | " cout << \"a2= \" << a2 << endl;\n", 191 | " cout << \"b2= \" << b2 << endl;\n", 192 | "\n", 193 | " //后置递增，先进行表达式运算，后让变量+1\n", 194 | " int a3 = 10;\n", 195 | " int b3 = a3++ * 10;\n", 196 | " cout << \"a3= \" << a3 << endl;\n", 197 | " cout << \"b3= \" << b3 << endl;\n", 198 | "\n", 199 | " system(\"pause\");\n", 200 | "\n", 201 | " return 0;\n", 202 | "\n", 203 | "}" 204 | ] 205 | }, 206 | { 207 | "cell_type": "markdown", 208 | "metadata": {}, 209 | "source": [ 210 | "运行结果： \n", 211 | " - a=11 \n", 212 | " - b=16 \n", 213 | " - a2= 11 \n", 214 | " - b2= 110 \n", 215 | " - a3= 11 \n", 216 | " - b3= 100 \n", 217 | " - 请按任意键继续. . ." 218 | ] 219 | }, 220 | { 221 | "cell_type": "markdown", 222 | "metadata": {}, 223 | "source": [ 224 | "# 3. 赋值运算符" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": null, 230 | "metadata": {}, 231 | "outputs": [], 232 | "source": [ 233 | "#include \n", 234 | "using namespace std;\n", 235 | "\n", 236 | "int main()\n", 237 | "{\n", 238 | "\n", 239 | " // = 赋值\n", 240 | " int a = 10;\n", 241 | " a = 100;\n", 242 | " cout << \"a= \" << a << endl;\n", 243 | "\n", 244 | " // += 加等于\n", 245 | " int b = 10;\n", 246 | " b = 10;\n", 247 | " b += 2;\n", 248 | " cout << \"b= \" << b << endl;\n", 249 | "\n", 250 | " // -= 减等于\n", 251 | " int c = 10;\n", 252 | " c = 10;\n", 253 | " c -= 2;\n", 254 | " cout << \"c= \" << c << endl;\n", 255 | "\n", 256 | " // *= 乘等于\n", 257 | " int d = 10;\n", 258 | " d = 10;\n", 259 | " d *= 2;\n", 260 | " cout << \"d= \" << d << endl;\n", 261 | "\n", 262 | " // /= 除等于\n", 263 | " int e = 10;\n", 264 | " e = 10;\n", 265 | " e /= 2;\n", 266 | " cout << \"e= \" << e << endl;\n", 267 | " \n", 268 | " // %= 模等于\n", 269 | " int f = 10;\n", 270 | " f = 10;\n", 271 | " f %= 2;\n", 272 | " cout << \"f= \" << f << endl;\n", 273 | "\n", 274 | " system(\"pause\");\n", 275 | "\n", 276 | " return 0;\n", 277 | "\n", 278 | "}" 279 | ] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": {}, 284 | "source": [ 285 | "运行结果： \n", 286 | " - a= 100 \n", 287 | " - b= 12 \n", 288 | " - c= 8 \n", 289 | " - d= 20 \n", 290 | " - e= 5 \n", 291 | " - f= 0 \n", 292 | " - 请按任意键继续. . ." 293 | ] 294 | }, 295 | { 296 | "cell_type": "markdown", 297 | "metadata": {}, 298 | "source": [ 299 | "# 4. 比较运算符" 300 | ] 301 | }, 302 | { 303 | "cell_type": "markdown", 304 | "metadata": {}, 305 | "source": [ 306 | "① 作用：用于表达式的比较，并返回一个真值或假值。" 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": null, 312 | "metadata": {}, 313 | "outputs": [], 314 | "source": [ 315 | "#include \n", 316 | "using namespace std;\n", 317 | "\n", 318 | "int main()\n", 319 | "{\n", 320 | " //比较运算符\n", 321 | " \n", 322 | " // ==\n", 323 | " int a = 10;\n", 324 | " int b = 20;\n", 325 | " cout << (a == b) << endl;\n", 326 | "\n", 327 | " // !=\n", 328 | " cout << (a != b) << endl;\n", 329 | "\n", 330 | " // >\n", 331 | " cout << (a > b) << endl;\n", 332 | "\n", 333 | " // <\n", 334 | " cout << (a < b) << endl;\n", 335 | "\n", 336 | " // >=\n", 337 | " cout << (a >= b) << endl;\n", 338 | " \n", 339 | " // <=\n", 340 | " cout << (a <= b) << endl;\n", 341 | "\n", 342 | " system(\"pause\");\n", 343 | "\n", 344 | " return 0;\n", 345 | "\n", 346 | "}" 347 | ] 348 | }, 349 | { 350 | "cell_type": "markdown", 351 | "metadata": {}, 352 | "source": [ 353 | "运行结果： \n", 354 | " - 0 \n", 355 | " - 1 \n", 356 | " - 0 \n", 357 | " - 1 \n", 358 | " - 0 \n", 359 | " - 1 \n", 360 | " - 请按任意键继续. . ." 361 | ] 362 | }, 363 | { 364 | "cell_type": "markdown", 365 | "metadata": {}, 366 | "source": [ 367 | "# 5. 逻辑运算符" 368 | ] 369 | }, 370 | { 371 | "cell_type": "markdown", 372 | "metadata": {}, 373 | "source": [ 374 | "① 作用：用于根据表达式的值返回真值或假值。\n", 375 | "\n", 376 | "1. !a 表示非，如果a为假，则!a为真；如果a为真，则!a为假。\n", 377 | "2. a&&b 表示与，如果a和b都为真，则结果为真，否则为假。\n", 378 | "3. a||b 表示或，如果a和b有一个为真，则结果为真，二者都为假时，结果为假。" 379 | ] 380 | }, 381 | { 382 | "cell_type": "code", 383 | "execution_count": null, 384 | "metadata": {}, 385 | "outputs": [], 386 | "source": [ 387 | "#include \n", 388 | "using namespace std;\n", 389 | "\n", 390 | "int main()\n", 391 | "{\n", 392 | " //逻辑运算符\n", 393 | "\n", 394 | " // !=\n", 395 | " int a = 10;\n", 396 | " int b = 30;\n", 397 | "\n", 398 | " cout << (!a) << endl; //在C++中除了0，都为真\n", 399 | " cout << (!!a) << endl;\n", 400 | "\n", 401 | " // &&\n", 402 | " a = 10;\n", 403 | " b = 30;\n", 404 | "\n", 405 | " cout << (a && b) << endl;\n", 406 | "\n", 407 | " a = 0;\n", 408 | " b = 10;\n", 409 | " cout << (a && b) << endl;\n", 410 | "\n", 411 | " // ||\n", 412 | " a = 10;\n", 413 | " b = 30;\n", 414 | " cout << (a || b) << endl;\n", 415 | "\n", 416 | " a = 0;\n", 417 | " b = 10;\n", 418 | " cout << (a || b) << endl;\n", 419 | "\n", 420 | " a = 0;\n", 421 | " b = 0;\n", 422 | " cout << (a || b) << endl;\n", 423 | "\n", 424 | " system(\"pause\");\n", 425 | "\n", 426 | " return 0;\n", 427 | "\n", 428 | "}" 429 | ] 430 | }, 431 | { 432 | "cell_type": "markdown", 433 | "metadata": {}, 434 | "source": [ 435 | "运行结果： \n", 436 | " - 0 \n", 437 | " - 1 \n", 438 | " - 1 \n", 439 | " - 0 \n", 440 | " - 1 \n", 441 | " - 1 \n", 442 | " - 0 \n", 443 | " - 请按任意键继续. . ." 444 | ] 445 | } 446 | ], 447 | "metadata": { 448 | "kernelspec": { 449 | "display_name": "Python 3.6.3", 450 | "language": "python", 451 | "name": "python3.6.3" 452 | }, 453 | "language_info": { 454 | "codemirror_mode": { 455 | "name": "ipython", 456 | "version": 3 457 | }, 458 | "file_extension": ".py", 459 | "mimetype": "text/x-python", 460 | "name": "python", 461 | "nbconvert_exporter": "python", 462 | "pygments_lexer": "ipython3", 463 | "version": "3.6.3" 464 | }, 465 | "toc": { 466 | "base_numbering": 1, 467 | "nav_menu": {}, 468 | "number_sections": false, 469 | "sideBar": true, 470 | "skip_h1_title": false, 471 | "title_cell": "Table of Contents", 472 | "title_sidebar": "Contents", 473 | "toc_cell": false, 474 | "toc_position": {}, 475 | "toc_section_display": true, 476 | "toc_window_display": true 477 | } 478 | }, 479 | "nbformat": 4, 480 | "nbformat_minor": 4 481 | } 482 | -------------------------------------------------------------------------------- /18_C++的引用.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的引用" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 引用" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "## 1.1 引用基本语法" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "① 作用：给变量起别名。\n", 29 | "\n", 30 | "② 语法：数据类型 &别名 = 原名" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "#include \n", 40 | "using namespace std;\n", 41 | "\n", 42 | "int main()\n", 43 | "{\n", 44 | " //引用基本语法\n", 45 | " //数据类型 &别名 = 原名\n", 46 | "\n", 47 | " int a = 10;\n", 48 | " //创建引用\n", 49 | " int& b = a;\n", 50 | "\n", 51 | " b = 100;\n", 52 | "\n", 53 | " cout << \"a= \" << a << endl;\n", 54 | " cout << \"b= \" << a << endl;\n", 55 | "\n", 56 | " system(\"pause\");\n", 57 | "\n", 58 | " return 0;\n", 59 | "\n", 60 | "}" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "运行结果： \n", 68 | " - a= 100 \n", 69 | " - b= 100 \n", 70 | " - 请按任意键继续. . ." 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": {}, 76 | "source": [ 77 | "## 1.2 引用注意事项" 78 | ] 79 | }, 80 | { 81 | "cell_type": "markdown", 82 | "metadata": {}, 83 | "source": [ 84 | "① 引用必须初始化。\n", 85 | "\n", 86 | "② 引用在初始化后，不可以改变。" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": null, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [ 95 | "#include \n", 96 | "using namespace std;\n", 97 | "\n", 98 | "int main()\n", 99 | "{\n", 100 | " //1、引用必须初始化\n", 101 | " int a = 10;\n", 102 | " int &b = a; // int &b; 是错误的，必须要初始化\n", 103 | "\n", 104 | " //2、引用在初始化后，不可以改变\n", 105 | " int c = 20;\n", 106 | " b = c; // 赋值操作，而不是更改引用。把 c = 20 的数据20给了 b 指向的内存的数据，而 a、b 的指向的内存是一样的。\n", 107 | " // 这里并不是 b 指向 c 的内存。\n", 108 | "\n", 109 | " cout << \"a = \" << a << endl; //a内存中数据变了\n", 110 | " cout << \"b = \" << b << endl;\n", 111 | " cout << \"c = \" << c << endl;\n", 112 | "\n", 113 | " system(\"pause\");\n", 114 | "\n", 115 | " return 0;\n", 116 | "\n", 117 | "}" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "运行结果： \n", 125 | " - a = 20 \n", 126 | " - b = 20 \n", 127 | " - c = 20 \n", 128 | " - 请按任意键继续. . ." 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "## 1.3 引用做函数参数" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "① 函数传参时，可以利用引用的技术让形参修饰实参。\n", 143 | "\n", 144 | "② 可以简化指针修改实参。" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": null, 150 | "metadata": {}, 151 | "outputs": [], 152 | "source": [ 153 | "#include \n", 154 | "using namespace std;\n", 155 | "\n", 156 | "//1、值传递\n", 157 | "void mySwap01(int a,int b)\n", 158 | "{\n", 159 | " int temp = a;\n", 160 | " a = b;\n", 161 | " b = temp;\n", 162 | "}\n", 163 | "\n", 164 | "//2、地址传递\n", 165 | "void mySwap02(int * a, int * b)\n", 166 | "{\n", 167 | " int temp = *a;\n", 168 | " *a = *b;\n", 169 | " *b = temp;\n", 170 | "}\n", 171 | "\n", 172 | "//2、引用传递\n", 173 | "//这里面的&a的实参为a(恰巧为a，恰巧一样)的别名，对&a中的a操作修改，就是对实参a修改\n", 174 | "void mySwap03(int &a, int &b) \n", 175 | "{\n", 176 | " int temp = a;\n", 177 | " a = b;\n", 178 | " b = temp;\n", 179 | "}\n", 180 | "\n", 181 | "int main()\n", 182 | "{\n", 183 | " int a = 10;\n", 184 | " int b = 20;\n", 185 | "\n", 186 | " mySwap01(a, b); //值传递，形参不会修饰实参\n", 187 | " \n", 188 | " cout << \"a = \" << a << endl;\n", 189 | " cout << \"b = \" << b << endl;\n", 190 | "\n", 191 | " mySwap02(&a, &b); //地址传递，形参会修饰实参\n", 192 | "\n", 193 | " cout << \"a = \" << a << endl;\n", 194 | " cout << \"b = \" << b << endl;\n", 195 | "\n", 196 | " mySwap03(a, b); //引用传递，形参会修饰实参\n", 197 | "\n", 198 | " cout << \"a = \" << a << endl;\n", 199 | " cout << \"b = \" << b << endl;\n", 200 | "\n", 201 | " system(\"pause\");\n", 202 | "\n", 203 | " return 0;\n", 204 | "\n", 205 | "}" 206 | ] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "metadata": {}, 211 | "source": [ 212 | "运行结果： \n", 213 | " - a = 10 \n", 214 | " - b = 20 \n", 215 | " - a = 20 \n", 216 | " - b = 10 \n", 217 | " - a = 10 \n", 218 | " - b = 20 \n", 219 | " - 请按任意键继续. . ." 220 | ] 221 | }, 222 | { 223 | "cell_type": "markdown", 224 | "metadata": {}, 225 | "source": [ 226 | "## 1.4 引用做函数返回值" 227 | ] 228 | }, 229 | { 230 | "cell_type": "markdown", 231 | "metadata": {}, 232 | "source": [ 233 | "① 引用是可以作为函数的返回值存在的。\n", 234 | "\n", 235 | "② 不要返回局部变量引用。\n", 236 | "\n", 237 | "③ 函数调用可以作为左值。" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": null, 243 | "metadata": {}, 244 | "outputs": [], 245 | "source": [ 246 | "#include \n", 247 | "using namespace std;\n", 248 | "\n", 249 | "//引用做函数的返回值\n", 250 | "//1、不要返回局部变量的引用\n", 251 | "int& test01()\n", 252 | "{\n", 253 | " int a = 10; //局部变量存放在四区中的栈区\n", 254 | " return a;\n", 255 | "}\n", 256 | "\n", 257 | "//2、函数的调用可以作为左值\n", 258 | "int& test02()\n", 259 | "{\n", 260 | " static int a = 10; //加上关键字static，变成静态变量，存放在全局区，全局区上的数据在程序结束后释放掉\n", 261 | " return a; //函数的返回值是a的一个引用\n", 262 | "}\n", 263 | "\n", 264 | "int main()\n", 265 | "{\n", 266 | " /*\n", 267 | " int& ref = test01();\n", 268 | " cout << \"ref = \" << ref << endl; //第一次结果正确，是因为编译器做了保留\n", 269 | " cout << \"ref = \" << ref << endl; //第一次结果正确，是因为栈区a的内存已经释放\n", 270 | " */\n", 271 | "\n", 272 | " \n", 273 | " int& ref = test02(); //由于返回的是a的引用，所以要用引用来接收，这里用ref来接收，ref为原名a的别名\n", 274 | " cout << \"ref = \" << ref << endl; \n", 275 | " cout << \"ref = \" << ref << endl; \n", 276 | " cout << \"ref = \" << ref << endl; \n", 277 | "\n", 278 | " test02() = 1000; //对a的引用进行操作，相当于原名a赋值赋值为1000\n", 279 | " cout << \"ref = \" << ref << endl; //通过原名a的别名ref访问1000\n", 280 | " cout << \"ref = \" << ref << endl;\n", 281 | "\n", 282 | " system(\"pause\");\n", 283 | "\n", 284 | " return 0;\n", 285 | "\n", 286 | "}" 287 | ] 288 | }, 289 | { 290 | "cell_type": "markdown", 291 | "metadata": {}, 292 | "source": [ 293 | "运行结果： \n", 294 | " - ref = 10 \n", 295 | " - ref = 10 \n", 296 | " - ref = 10 \n", 297 | " - ref = 1000 \n", 298 | " - ref = 1000 \n", 299 | " - 请按任意键继续. . ." 300 | ] 301 | }, 302 | { 303 | "cell_type": "markdown", 304 | "metadata": {}, 305 | "source": [ 306 | "## 1.5 引用本质" 307 | ] 308 | }, 309 | { 310 | "cell_type": "markdown", 311 | "metadata": {}, 312 | "source": [ 313 | "① 引用的本质在C++内部实现是一个指针常量。\n", 314 | "\n", 315 | "② C++推荐引用计数，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了。" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": null, 321 | "metadata": {}, 322 | "outputs": [], 323 | "source": [ 324 | "#include \n", 325 | "using namespace std;\n", 326 | "\n", 327 | "//发现是引用，转换为 int* const ref = &a;\n", 328 | "void func(int& ref)\n", 329 | "{\n", 330 | " ref = 100; //ref是引用，转换为 * ref = 100;\n", 331 | "}\n", 332 | "\n", 333 | "int main()\n", 334 | "{\n", 335 | " int a = 10;\n", 336 | "\n", 337 | " //自动转换为 int * const ref = &a; 指针常量是指针不可改，引用不可更改别名。\n", 338 | " //虽然指针常量指向的地址不可以更改，但是地址中的值可以更改。\n", 339 | " int& ref = a;\n", 340 | "\n", 341 | " ref = 20; //内部发现ref是引用，自动帮我们转换为 *ref = 20; 解引用找到相应的数据改为20\n", 342 | "\n", 343 | " cout << \"a：\" << a << endl;\n", 344 | " cout << \"ref：\" << ref << endl;\n", 345 | "\n", 346 | " func(a);\n", 347 | "\n", 348 | " system(\"pause\");\n", 349 | "\n", 350 | " return 0;\n", 351 | "\n", 352 | "}" 353 | ] 354 | }, 355 | { 356 | "cell_type": "markdown", 357 | "metadata": {}, 358 | "source": [ 359 | "运行结果： \n", 360 | " - a：20 \n", 361 | " - ref：20 \n", 362 | " - 请按任意键继续. . ." 363 | ] 364 | }, 365 | { 366 | "cell_type": "markdown", 367 | "metadata": {}, 368 | "source": [ 369 | "## 1.6 常量引用" 370 | ] 371 | }, 372 | { 373 | "cell_type": "markdown", 374 | "metadata": {}, 375 | "source": [ 376 | "① 作用：常量引用主要用来修饰形参，防止误操作。\n", 377 | "\n", 378 | "② 在函数形参列表中，可以加const修饰形参，防止形参改变实参。" 379 | ] 380 | }, 381 | { 382 | "cell_type": "code", 383 | "execution_count": null, 384 | "metadata": {}, 385 | "outputs": [], 386 | "source": [ 387 | "#include \n", 388 | "using namespace std;\n", 389 | "\n", 390 | "void showValue(const int& val)\n", 391 | "{\n", 392 | " // val = 1000; 报错，不能修改了\n", 393 | " cout << \"val = \" << val << endl;\n", 394 | "}\n", 395 | "\n", 396 | "int main()\n", 397 | "{\n", 398 | " //常量引用\n", 399 | " //使用场景：用来修饰形参，防止误操作\n", 400 | "\n", 401 | " /*\n", 402 | " int a = 10;\n", 403 | " int& ref = 10; //报错，引用必须引一块合法的内存空间\n", 404 | " */\n", 405 | "\n", 406 | " //加上const之后，编译器代码修改为 int temp = 10; const in & ref = temp \n", 407 | " const int& ref = 10;\n", 408 | " //ref = 20; //加入const之后变为只读，不可以修改\n", 409 | "\n", 410 | " int a = 100;\n", 411 | " showValue(a);\n", 412 | " cout << \"a = \" << a << endl;\n", 413 | "\n", 414 | " system(\"pause\");\n", 415 | " \n", 416 | " return 0;\n", 417 | "\n", 418 | "}" 419 | ] 420 | }, 421 | { 422 | "cell_type": "markdown", 423 | "metadata": {}, 424 | "source": [ 425 | "运行结果： \n", 426 | " - val = 100 \n", 427 | " - a = 100 \n", 428 | " - 请按任意键继续. . ." 429 | ] 430 | } 431 | ], 432 | "metadata": { 433 | "kernelspec": { 434 | "display_name": "Python 3.6.3", 435 | "language": "python", 436 | "name": "python3.6.3" 437 | }, 438 | "language_info": { 439 | "codemirror_mode": { 440 | "name": "ipython", 441 | "version": 3 442 | }, 443 | "file_extension": ".py", 444 | "mimetype": "text/x-python", 445 | "name": "python", 446 | "nbconvert_exporter": "python", 447 | "pygments_lexer": "ipython3", 448 | "version": "3.6.3" 449 | }, 450 | "toc": { 451 | "base_numbering": 1, 452 | "nav_menu": {}, 453 | "number_sections": false, 454 | "sideBar": true, 455 | "skip_h1_title": false, 456 | "title_cell": "Table of Contents", 457 | "title_sidebar": "Contents", 458 | "toc_cell": false, 459 | "toc_position": {}, 460 | "toc_section_display": true, 461 | "toc_window_display": true 462 | } 463 | }, 464 | "nbformat": 4, 465 | "nbformat_minor": 4 466 | } 467 | -------------------------------------------------------------------------------- /20_C++的类中封装.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的封装" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 封装" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "## 1.1 封装属性和行为" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "① 封装是C++面向对象三大特性之一。\n", 29 | "\n", 30 | "② 封装的意义一：\n", 31 | "\n", 32 | "1. 将属性和行为作为一个整体，表现生活中的事物。\n", 33 | "2. 将属性和行为加以权限控制。" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": null, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "#include \n", 43 | "using namespace std;\n", 44 | "\n", 45 | "const double PI = 3.14;\n", 46 | "\n", 47 | "//设计一个圆类，求圆的周长\n", 48 | "//圆求周长的公式： 2 * PI * 半径\n", 49 | "\n", 50 | "//class 代表设计一个类，类后面紧跟着的就是类名称\n", 51 | "class Circle\n", 52 | "{\n", 53 | " //访问权限\n", 54 | " //公共权限\n", 55 | " public: //是冒号，不是分号\n", 56 | "\n", 57 | " //属性\n", 58 | " //半径\n", 59 | " int m_r;\n", 60 | "\n", 61 | " //行为\n", 62 | " //获取圆的周长\n", 63 | " double calculateZC()\n", 64 | " {\n", 65 | " return 2 * PI * m_r;\n", 66 | " }\n", 67 | "};\n", 68 | "\n", 69 | "int main()\n", 70 | "{\n", 71 | " //通过圆类 创建具体的圆(对象)\n", 72 | " //实例化 （通过一个类 创建一个对象的过程）\n", 73 | " Circle c1;\n", 74 | " //给圆对象 的属性进行赋值\n", 75 | " c1.m_r = 10;\n", 76 | "\n", 77 | " // 2 * PI * 10 = 62.8\n", 78 | " cout << \"圆的周长为：\" << c1.calculateZC() << endl;\n", 79 | "\n", 80 | " system(\"pause\");\n", 81 | " \n", 82 | " return 0;\n", 83 | "\n", 84 | "}" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "运行结果： \n", 92 | " - 圆的周长为：62.8" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "## 1.2 封装权限" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "① 类在设计时，可以把属性和行为放在不同的权限下，加以控制。\n", 107 | "\n", 108 | "② 封装的意义二：\n", 109 | "\n", 110 | "1. public 公共权限\n", 111 | "2. protected 保护权限\n", 112 | "3. private 私有权限" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": null, 118 | "metadata": {}, 119 | "outputs": [], 120 | "source": [ 121 | "#include \n", 122 | "using namespace std;\n", 123 | "\n", 124 | "//访问权限\n", 125 | "//三种\n", 126 | "//公共权限 public 类内可以访问成员 类外可以访问成员\n", 127 | "//保护权限 protected 类内可以访问成员 类外不可以访问成员 子类可以访问父类中的保护内容\n", 128 | "//私有权限 private 类内可以访问权限 类外不可以访问成员 子类不可以访问父类中的私有内容\n", 129 | "\n", 130 | "class Person\n", 131 | "{\n", 132 | "//公共权限\n", 133 | "public: \n", 134 | " string m_Name; //姓名\n", 135 | "\n", 136 | "protected:\n", 137 | " string m_Car; //汽车\n", 138 | "\n", 139 | "private:\n", 140 | " int m_Password; //银行卡密码\n", 141 | "\n", 142 | "public:\n", 143 | " void func()\n", 144 | " {\n", 145 | " m_Name = \"李四\";\n", 146 | " m_Car = \"奔驰\"; //保护权限内容，在类外访问不到\n", 147 | " m_Password = 123;\n", 148 | " }\n", 149 | "};\n", 150 | "\n", 151 | "int main()\n", 152 | "{\n", 153 | " //实例化具体对象\n", 154 | " Person p1;\n", 155 | " p1.m_Name = \"李四\";\n", 156 | " p1.m_Car = \"奔驰\"; //保护权限内容，在类外访问不到\n", 157 | " p1.m_Password = 123; //私有权限内容，在类外访问不到\n", 158 | "\n", 159 | " p1.func(); //公共权限内容，在类可以访问\n", 160 | "\n", 161 | " system(\"pause\");\n", 162 | "\n", 163 | " return 0;\n", 164 | "\n", 165 | "}" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "## 1.3 struct 和 class 区别" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "① 在C++中struct和class唯一的区别就在于默认的访问权限不同。\n", 180 | "\n", 181 | "② 区别：\n", 182 | "\n", 183 | "1. struct 默认权限为公共。\n", 184 | "2. class 默认权限为私有。" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": null, 190 | "metadata": {}, 191 | "outputs": [], 192 | "source": [ 193 | "#include \n", 194 | "using namespace std;\n", 195 | "\n", 196 | "//访问权限\n", 197 | "//三种\n", 198 | "//公共权限 public 类内可以访问成员 类外可以访问成员\n", 199 | "//保护权限 protected 类内可以访问成员 类外不可以访问成员 子类可以访问父类中的保护内容\n", 200 | "//私有权限 private 类内可以访问权限 类外不可以访问成员 子类不可以访问父类中的私有内容\n", 201 | "\n", 202 | "class C1\n", 203 | "{\n", 204 | " int m_A; // 默认权限是私有\n", 205 | "};\n", 206 | "\n", 207 | "struct C2\n", 208 | "{\n", 209 | " int m_A; //默认权限 是公共\n", 210 | "};\n", 211 | "\n", 212 | "int main()\n", 213 | "{\n", 214 | " //struct 和 class 区别\n", 215 | " //struct 默认权限是 公共 public\n", 216 | " //class 默认权限是 私有 private\n", 217 | " C1 c1;\n", 218 | " c1.m_A = 100; //私有权限，不能访问\n", 219 | "\n", 220 | " C2 c2;\n", 221 | " c2.m_A = 100; //公共权限，可以访问\n", 222 | "\n", 223 | " system(\"pause\");\n", 224 | " \n", 225 | " return 0;\n", 226 | "\n", 227 | "}" 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "## 1.4 成员属性设置为私有" 235 | ] 236 | }, 237 | { 238 | "cell_type": "markdown", 239 | "metadata": {}, 240 | "source": [ 241 | "① 优点1：将所有成员属性设置为私有，可以自己控制读写权限。\n", 242 | "\n", 243 | "② 优点2：可以通过写权限，检测数据的有效性。" 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": null, 249 | "metadata": {}, 250 | "outputs": [], 251 | "source": [ 252 | "#include \n", 253 | "using namespace std;\n", 254 | "#include \n", 255 | "\n", 256 | "//成员属性设置为私有\n", 257 | "//1、可以自己控制读写权限\n", 258 | "//2、对于写可以检测数据的有效性\n", 259 | "\n", 260 | "class Person\n", 261 | "{\n", 262 | "public:\n", 263 | " //设置姓名\n", 264 | " void setName(string name)\n", 265 | " {\n", 266 | " m_Name = name;\n", 267 | " }\n", 268 | " //获取姓名\n", 269 | " string getName()\n", 270 | " {\n", 271 | " return m_Name;\n", 272 | " }\n", 273 | "\n", 274 | " //获取年龄\n", 275 | " int getAge()\n", 276 | " {\n", 277 | " m_Age = 0; //初始化为0岁\n", 278 | " return m_Age;\n", 279 | " }\n", 280 | "\n", 281 | " void setLover(string lover)\n", 282 | " {\n", 283 | " m_Lover = lover;\n", 284 | " }\n", 285 | "\n", 286 | "private:\n", 287 | " //姓名 可读可写\n", 288 | " string m_Name;\n", 289 | " //年龄 只读\n", 290 | " int m_Age;\n", 291 | " //情人 只写\n", 292 | " string m_Lover;\n", 293 | "};\n", 294 | "\n", 295 | "int main()\n", 296 | "{\n", 297 | " Person p;\n", 298 | " p.setName(\"张三\");\n", 299 | "\n", 300 | " cout << \"姓名为：\" << p.getName() << endl;\n", 301 | "\n", 302 | " cout << \"年龄为：\" << p.getName() << endl;\n", 303 | "\n", 304 | " //p.m_Age = 18; //私有权限，不可以改\n", 305 | " p.getAge();\n", 306 | " cout << \"姓名为：\" << p.getAge() << endl;\n", 307 | "\n", 308 | " p.setLover(\"小李\");\n", 309 | "\n", 310 | " system(\"pause\");\n", 311 | "\n", 312 | " return 0;\n", 313 | "\n", 314 | "}" 315 | ] 316 | }, 317 | { 318 | "cell_type": "markdown", 319 | "metadata": {}, 320 | "source": [ 321 | "运行结果： \n", 322 | " - 姓名为：张三 \n", 323 | " - 年龄为：0 \n", 324 | " - 请按任意键继续. . ." 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": null, 330 | "metadata": {}, 331 | "outputs": [], 332 | "source": [ 333 | "#include \n", 334 | "using namespace std;\n", 335 | "#include \n", 336 | "\n", 337 | "//成员属性设置为私有\n", 338 | "//1、可以自己控制读写权限\n", 339 | "//2、对于写可以检测数据的有效性\n", 340 | "\n", 341 | "class Person\n", 342 | "{\n", 343 | "public:\n", 344 | " //设置姓名\n", 345 | " void setName(string name)\n", 346 | " {\n", 347 | " m_Name = name;\n", 348 | " }\n", 349 | " //获取姓名\n", 350 | " string getName()\n", 351 | " {\n", 352 | " return m_Name;\n", 353 | " }\n", 354 | "\n", 355 | " //获取年龄 可读可写 \n", 356 | " int getAge()\n", 357 | " {\n", 358 | " return m_Age;\n", 359 | " }\n", 360 | "\n", 361 | " //设置年龄 如果想修改（年龄的范围必须是0~150之间）\n", 362 | " void setAge(int age)\n", 363 | " {\n", 364 | " if (age < 0 || age>150)\n", 365 | " {\n", 366 | " m_Age = 0; //强制改为0\n", 367 | " cout << \"你这个老妖精！\" << endl;\n", 368 | " return; //强制退出\n", 369 | " }\n", 370 | " m_Age = age;\n", 371 | " }\n", 372 | "\n", 373 | " void setLover(string lover)\n", 374 | " {\n", 375 | " m_Lover = lover;\n", 376 | " }\n", 377 | "\n", 378 | "private:\n", 379 | " //姓名 可读可写\n", 380 | " string m_Name;\n", 381 | " //年龄 只读\n", 382 | " int m_Age;\n", 383 | " //情人 只写\n", 384 | " string m_Lover;\n", 385 | "};\n", 386 | "\n", 387 | "int main()\n", 388 | "{\n", 389 | " Person p;\n", 390 | " p.setName(\"张三\");\n", 391 | "\n", 392 | " cout << \"姓名为：\" << p.getName() << endl;\n", 393 | "\n", 394 | "\n", 395 | " //p.m_Age = 18; //私有权限，不可以类外改\n", 396 | " p.setAge(1000); \n", 397 | " cout << \"年龄为：\" << p.getAge() << endl;\n", 398 | "\n", 399 | " //设置情人为苍井女士\n", 400 | " p.setLover(\"小李\"); //有这个函数可以设置\n", 401 | " //cout << \"情人为：\" << p.getLover() << endl; //没有这个函数，不能获得\n", 402 | "\n", 403 | " system(\"pause\");\n", 404 | "\n", 405 | " return 0;\n", 406 | "\n", 407 | "}" 408 | ] 409 | }, 410 | { 411 | "cell_type": "markdown", 412 | "metadata": {}, 413 | "source": [ 414 | "运行结果： \n", 415 | " - 姓名为：张三 \n", 416 | " - 你这个老妖精！ \n", 417 | " - 年龄为：0 \n", 418 | " - 请按任意键继续. . ." 419 | ] 420 | }, 421 | { 422 | "cell_type": "markdown", 423 | "metadata": {}, 424 | "source": [ 425 | "## 1.5 设计学生类" 426 | ] 427 | }, 428 | { 429 | "cell_type": "markdown", 430 | "metadata": {}, 431 | "source": [ 432 | "案例描述：设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号。" 433 | ] 434 | }, 435 | { 436 | "cell_type": "code", 437 | "execution_count": null, 438 | "metadata": {}, 439 | "outputs": [], 440 | "source": [ 441 | "#include \n", 442 | "using namespace std;\n", 443 | "#include\n", 444 | "\n", 445 | "//设计学生类\n", 446 | "class Student\n", 447 | "{\n", 448 | "public: //公共权限\n", 449 | "\n", 450 | " //类中的属性和行为 我们统一称为成员\n", 451 | " // 属性 成员属性 成员变量\n", 452 | " // 行为 成员函数 成员方法\n", 453 | " \n", 454 | " //属性\n", 455 | " string m_Name; //姓名\n", 456 | " int m_Id; //学号\n", 457 | "\n", 458 | " //行为\n", 459 | " //显示姓名和学号\n", 460 | " void showStudent()\n", 461 | " {\n", 462 | " cout << \"姓名：\" << m_Name << \" 学号：\" << m_Id << endl;\n", 463 | " }\n", 464 | "\n", 465 | " //给姓名赋值的行为\n", 466 | " void setName(string name)\n", 467 | " {\n", 468 | " m_Name = name;\n", 469 | " }\n", 470 | "};\n", 471 | "\n", 472 | "int main()\n", 473 | "{\n", 474 | " //创建一个具体学生 实例化对象\n", 475 | " Student s1;\n", 476 | " //给s1对象 进行属性赋值操作\n", 477 | " s1.m_Name = \"张三\";\n", 478 | " s1.m_Id = 1;\n", 479 | "\n", 480 | " s1.showStudent();\n", 481 | "\n", 482 | " Student s2;\n", 483 | " s2.m_Name = \"李四\";\n", 484 | " s2.m_Id = 2;\n", 485 | " s2.showStudent();\n", 486 | "\n", 487 | " Student s3;\n", 488 | " s3.setName(\"王五\");\n", 489 | " s3.m_Id = 3;\n", 490 | " s3.showStudent();\n", 491 | "\n", 492 | " system(\"pause\");\n", 493 | "\n", 494 | " return 0;\n", 495 | "\n", 496 | "}" 497 | ] 498 | }, 499 | { 500 | "cell_type": "markdown", 501 | "metadata": {}, 502 | "source": [ 503 | "运行结果： \n", 504 | " - 姓名：张三 学号：1 \n", 505 | " - 姓名：李四 学号：2 \n", 506 | " - 姓名：王五 学号：3 \n", 507 | " - 请按任意键继续. . ." 508 | ] 509 | }, 510 | { 511 | "cell_type": "markdown", 512 | "metadata": {}, 513 | "source": [ 514 | "## 1.6 设计立方体类" 515 | ] 516 | }, 517 | { 518 | "cell_type": "markdown", 519 | "metadata": {}, 520 | "source": [ 521 | "案例描述：设计立方体类(Cube)，求出立方体的面积和体积，分别用全局函数和成员函数判断两个立方体是否相等。" 522 | ] 523 | }, 524 | { 525 | "cell_type": "code", 526 | "execution_count": null, 527 | "metadata": {}, 528 | "outputs": [], 529 | "source": [ 530 | "#include \n", 531 | "using namespace std;\n", 532 | "\n", 533 | "//立方体类设计\n", 534 | "//1、创建立方体类\n", 535 | "//2、设计属性\n", 536 | "//3、获取立方体面积和体积\n", 537 | "//4、分别利用全局函数和成员函数 判断两个立方体是否相等\n", 538 | "\n", 539 | "class Cube\n", 540 | "{\n", 541 | "public:\n", 542 | " //设置长\n", 543 | " void setL(int l)\n", 544 | " {\n", 545 | " m_L = l;\n", 546 | " }\n", 547 | "\n", 548 | " //获取长\n", 549 | " int getL()\n", 550 | " {\n", 551 | " return m_L;\n", 552 | " }\n", 553 | "\n", 554 | " //设置宽\n", 555 | " void setW(int w)\n", 556 | " {\n", 557 | " m_W = w;\n", 558 | " }\n", 559 | "\n", 560 | " //获取宽\n", 561 | " int getW()\n", 562 | " {\n", 563 | " return m_W;\n", 564 | " }\n", 565 | "\n", 566 | " //设置高\n", 567 | " void setH(int h)\n", 568 | " {\n", 569 | " m_H = h;\n", 570 | " }\n", 571 | "\n", 572 | " //获取高\n", 573 | " int getH()\n", 574 | " {\n", 575 | " return m_H;\n", 576 | " }\n", 577 | "\n", 578 | " //获取立方体面积\n", 579 | " int calculateS()\n", 580 | " {\n", 581 | " return 2 * m_L * m_W + 2 * m_W * m_H + 2 * m_L * m_H;\n", 582 | " }\n", 583 | "\n", 584 | " //获取立方体体积\n", 585 | " int calculateV()\n", 586 | " {\n", 587 | " return m_L * m_W * m_H;\n", 588 | " }\n", 589 | "\n", 590 | " //利用成员函数判断两个立方体是否相等\n", 591 | " bool isSameByClass(Cube c) //成员函数只需要传入一个类为参数\n", 592 | " {\n", 593 | " if (m_L == c.getL() && m_W == c.getW() && m_H == c.getH()) //类内可以访问成员函数：m_L、m_W、m_H\n", 594 | " {\n", 595 | " return true;\n", 596 | " }\n", 597 | " else\n", 598 | " {\n", 599 | " return false;\n", 600 | " }\n", 601 | " }\n", 602 | "\n", 603 | "\n", 604 | "private:\n", 605 | " int m_L; //长\n", 606 | " int m_W; //宽\n", 607 | " int m_H; //高\n", 608 | "};\n", 609 | "\n", 610 | "//利用全局函数判断，两个立方体是否相等\n", 611 | "bool isSame(Cube c1, Cube c2) //值传递会拷贝一份数据，通过引用传递用原始数据，不会拷贝数据\n", 612 | "{\n", 613 | " if (c1.getL() == c2.getL() && c1.getW() == c2.getW()\n", 614 | " && c1.getH() == c2.getH())\n", 615 | " {\n", 616 | " return true;\n", 617 | " }\n", 618 | " else\n", 619 | " {\n", 620 | " return false;\n", 621 | " }\n", 622 | "}\n", 623 | "\n", 624 | "int main()\n", 625 | "{\n", 626 | " //创建立方体对象\n", 627 | " Cube c1;\n", 628 | " c1.setL(10);\n", 629 | " c1.setW(10);\n", 630 | " c1.setH(10);\n", 631 | "\n", 632 | " cout << \"c1的面积为：\" << c1.calculateS() << endl; \n", 633 | " cout << \"c1的体积为：\" << c1.calculateV() << endl; \n", 634 | "\n", 635 | " Cube c2;\n", 636 | " c2.setL(10);\n", 637 | " c2.setW(10);\n", 638 | " c2.setH(11);\n", 639 | "\n", 640 | " bool ret = isSame(c1, c2);\n", 641 | " if (ret)\n", 642 | " {\n", 643 | " cout << \"利用全局函数判断：c1和c2是相等的\" << endl;\n", 644 | " }\n", 645 | " else\n", 646 | " {\n", 647 | " cout << \"利用全局函数判断：c1和c2是不相等的\" << endl;\n", 648 | " }\n", 649 | "\n", 650 | "\n", 651 | " //利用成员函数判断\n", 652 | " ret = c1.isSameByClass(c2);\n", 653 | " if (ret)\n", 654 | " {\n", 655 | " cout << \"利用成员函数判断：c1和c2是相等的\" << endl;\n", 656 | " }\n", 657 | " else\n", 658 | " {\n", 659 | " cout << \"利用成员函数判断：c1和c2是不相等的\" << endl;\n", 660 | " }\n", 661 | "\n", 662 | " system(\"pause\");\n", 663 | "\n", 664 | " return 0;\n", 665 | "\n", 666 | "}" 667 | ] 668 | }, 669 | { 670 | "cell_type": "markdown", 671 | "metadata": {}, 672 | "source": [ 673 | "运行结果： \n", 674 | " - c1的面积为：600 \n", 675 | " - c1的体积为：1000 \n", 676 | " - 利用全局函数判断：c1和c2是不相等的 \n", 677 | " - 利用成员函数判断：c1和c2是不相等的 \n", 678 | " - 请按任意键继续. . ." 679 | ] 680 | } 681 | ], 682 | "metadata": { 683 | "kernelspec": { 684 | "display_name": "Python 3.6.3", 685 | "language": "python", 686 | "name": "python3.6.3" 687 | }, 688 | "language_info": { 689 | "codemirror_mode": { 690 | "name": "ipython", 691 | "version": 3 692 | }, 693 | "file_extension": ".py", 694 | "mimetype": "text/x-python", 695 | "name": "python", 696 | "nbconvert_exporter": "python", 697 | "pygments_lexer": "ipython3", 698 | "version": "3.6.3" 699 | }, 700 | "toc": { 701 | "base_numbering": 1, 702 | "nav_menu": {}, 703 | "number_sections": false, 704 | "sideBar": true, 705 | "skip_h1_title": false, 706 | "title_cell": "Table of Contents", 707 | "title_sidebar": "Contents", 708 | "toc_cell": false, 709 | "toc_position": {}, 710 | "toc_section_display": true, 711 | "toc_window_display": true 712 | } 713 | }, 714 | "nbformat": 4, 715 | "nbformat_minor": 4 716 | } 717 | -------------------------------------------------------------------------------- /24_C++的类中运算符重载.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++ 运算符重载" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 运算符重载简介" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 运算符重载：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。\n", 22 | "\n", 23 | "② 对于内置的数据类型的表达式的运算符是不可能改变的。" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "# 2. 加号运算符重载" 31 | ] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "metadata": {}, 36 | "source": [ 37 | "① 加号运算符作用：实现两个自定义数据类型相加的运算。" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [ 46 | "#include \n", 47 | "using namespace std;\n", 48 | "\n", 49 | "//加号运算符重载\n", 50 | "class Person\n", 51 | "{\n", 52 | "public:\n", 53 | "\n", 54 | " //1、成员函数重载+号\n", 55 | " Person operator+(Person& p)\n", 56 | " {\n", 57 | " Person temp;\n", 58 | " temp.m_A = this->m_A + p.m_A;\n", 59 | " temp.m_B = this->m_B + p.m_B;\n", 60 | " return temp;\n", 61 | " }\n", 62 | " int m_A;\n", 63 | " int m_B;\n", 64 | "};\n", 65 | "\n", 66 | "/*\n", 67 | "//全局函数重载+号\n", 68 | "Person operator+(Person &p1, Person &p2)\n", 69 | "{\n", 70 | " Person temp;\n", 71 | " temp.m_A = p1.m_A + p2.m_A;\n", 72 | " temp.m_B = p1.m_B + p2.m_B;\n", 73 | " return temp;\n", 74 | "}\n", 75 | "*/\n", 76 | "\n", 77 | "//函数重载的版本\n", 78 | "Person operator+(Person& p1, int num)\n", 79 | "{\n", 80 | " Person temp;\n", 81 | " temp.m_A = p1.m_A + num;\n", 82 | " temp.m_B = p1.m_B + num;\n", 83 | " return temp;\n", 84 | "}\n", 85 | "\n", 86 | "void test01()\n", 87 | "{\n", 88 | " Person p1;\n", 89 | " p1.m_A = 10;\n", 90 | " p1.m_B = 10;\n", 91 | " Person p2;\n", 92 | " p2.m_A = 10;\n", 93 | " p2.m_B = 10;\n", 94 | "\n", 95 | " //成员函数重载本质调用 \n", 96 | " //Person p3 = p1.operator+(p2);\n", 97 | " \n", 98 | " //全局函数重载本质调用 \n", 99 | " //Person p3 = operator+(p1,p2);\n", 100 | " \n", 101 | " Person p3 = p1 + p2; //重载本质被简化后的形式\n", 102 | "\n", 103 | " //运算符重载，也可以发生函数重载\n", 104 | "\n", 105 | " Person p4 = p1 + 10; //Person + int\n", 106 | "\n", 107 | " cout << \"p3.m_A：\" << p3.m_A << endl;\n", 108 | " cout << \"p3.m_B：\" << p3.m_B << endl;\n", 109 | "\n", 110 | " cout << \"p4.m_A：\" << p4.m_A << endl;\n", 111 | " cout << \"p4.m_B：\" << p4.m_B << endl;\n", 112 | "\n", 113 | "}\n", 114 | "\n", 115 | "\n", 116 | "int main()\n", 117 | "{\n", 118 | " test01();\n", 119 | "\n", 120 | " system(\"pause\");\n", 121 | "\n", 122 | " return 0;\n", 123 | "\n", 124 | "}" 125 | ] 126 | }, 127 | { 128 | "cell_type": "markdown", 129 | "metadata": {}, 130 | "source": [ 131 | "运行结果： \n", 132 | " - p3.m_A：20 \n", 133 | " - p3.m_B：20 \n", 134 | " - p4.m_A：20 \n", 135 | " - p4.m_B：20 \n", 136 | " - 请按任意键继续. . ." 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": {}, 142 | "source": [ 143 | "# 3. 左移运算符重载" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "① 左移运算符重载：可以输出自定义数据类型。\n", 151 | "\n", 152 | "② 重载左移运算符配合友元可以实现自定义数据类型。" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": null, 158 | "metadata": {}, 159 | "outputs": [], 160 | "source": [ 161 | "#include \n", 162 | "using namespace std;\n", 163 | "\n", 164 | "//左移运算符\n", 165 | "class Person\n", 166 | "{\n", 167 | "\n", 168 | " friend ostream& operator<<(ostream& out, Person& p);\t\n", 169 | "\n", 170 | "public:\n", 171 | " Person(int a, int b)\n", 172 | " {\n", 173 | " m_A = a;\n", 174 | " m_B = b;\n", 175 | " }\n", 176 | "\n", 177 | " /*\n", 178 | " //利用成员函数重载 左移运算符 p.operator<<(cout) 简化版本 p << cout\n", 179 | " //成员函数不能利用重载<<运算符，因为无法实现cout在左侧\n", 180 | " //当不知道返回值是什么类型的时候，可以先写个void，以后再改\n", 181 | " void operator<<(Person& p)\n", 182 | " {\n", 183 | " \n", 184 | " }\n", 185 | " */\n", 186 | " \n", 187 | "private:\n", 188 | " int m_A;\n", 189 | " int m_B;\n", 190 | "};\n", 191 | "\n", 192 | "//只能利用全局函数重载左移运算符\n", 193 | "//如果返回类型为void，那么就无法无限追加，也没有办法在后面添加换行符\n", 194 | "ostream & operator<<(ostream &cout, Person &p) //本质 operator << (cout , p) , 简化 cout << p\n", 195 | " //cout是别名，这里可以取out、kn...\n", 196 | " //cout为ostream输出流数据类型 \n", 197 | "{\n", 198 | " cout << \"m_A= \" << p.m_A << \" m_B=\" << p.m_B;\n", 199 | " return cout;\n", 200 | "}\n", 201 | "\n", 202 | "void test01()\n", 203 | "{\n", 204 | " Person p(10,10);\n", 205 | "\n", 206 | " cout << p << \" hello world\" << endl;\n", 207 | "}\n", 208 | "\n", 209 | "\n", 210 | "int main()\n", 211 | "{\n", 212 | " test01();\n", 213 | "\n", 214 | " system(\"pause\");\n", 215 | "\n", 216 | " return 0;\n", 217 | "\n", 218 | "}" 219 | ] 220 | }, 221 | { 222 | "cell_type": "markdown", 223 | "metadata": {}, 224 | "source": [ 225 | "运行结果： \n", 226 | " - m_A= 10 m_B=10 hello world \n", 227 | " - 请按任意键继续. . ." 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "# 4. 递增运算符" 235 | ] 236 | }, 237 | { 238 | "cell_type": "markdown", 239 | "metadata": {}, 240 | "source": [ 241 | "① 递增运算符重载：通过重载递增运算符，实现自己的整型数据。\n", 242 | "\n", 243 | "② 前置递增返回的是引用，后置递增返回的是值。" 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": null, 249 | "metadata": {}, 250 | "outputs": [], 251 | "source": [ 252 | "#include \n", 253 | "using namespace std;\n", 254 | "\n", 255 | "//重载递增运算符\n", 256 | "\n", 257 | "class MyInteger\n", 258 | "{\n", 259 | " friend ostream& operator<<(ostream& cout, MyInteger myint);\n", 260 | "\n", 261 | "public:\n", 262 | " MyInteger()\n", 263 | " {\n", 264 | " m_Num = 0;\n", 265 | " }\n", 266 | " \n", 267 | " //重载前置++运算符,返回引用是为了一直对一个数据进行递增操作,而返回值并不是一直对一个数据进行递增操作 \n", 268 | " MyInteger& operator++()\n", 269 | " {\n", 270 | " //先进行++运算\n", 271 | " m_Num++;\n", 272 | "\n", 273 | " //再将自身做一个返回\n", 274 | " return *this; //把自身做一个返回\n", 275 | " }\n", 276 | "\n", 277 | " //重载后置++运算符 int代表占位参数，可以用于区分前置和后置递增\n", 278 | " //后置递增不能返回引用，因为temp是局部变量，如果返回temp，当程序运行完后变量就释放了，再调用temp就是非法操作了 \n", 279 | " MyInteger operator++(int)\n", 280 | " {\n", 281 | " //先记录当时结果\n", 282 | " MyInteger temp = *this;\n", 283 | " //后 递增\n", 284 | " m_Num++;\n", 285 | " //最后将记录结果做返回\n", 286 | " return temp;\n", 287 | " }\n", 288 | "private:\n", 289 | " int m_Num;\n", 290 | "};\n", 291 | "\n", 292 | "//只能利用全局函数重载左移运算符\n", 293 | "ostream & operator<<(ostream &cout, MyInteger myint) //本质 operator << (cout , p) , 简化 cout << p\n", 294 | " //cout是别名，这里可以取out、kn...\n", 295 | " //cout为ostream输出流数据类型 \n", 296 | "{\n", 297 | " cout << myint.m_Num;\n", 298 | "\n", 299 | " return cout;\n", 300 | "}\n", 301 | "\n", 302 | "void test01()\n", 303 | "{\n", 304 | " MyInteger myint;\n", 305 | "\n", 306 | " cout << ++(++myint) << endl;\n", 307 | " cout << myint << endl;\n", 308 | "}\n", 309 | "\n", 310 | "void test02()\n", 311 | "{\n", 312 | " MyInteger myint;\n", 313 | "\n", 314 | " cout << myint++ << endl;\n", 315 | " cout << myint << endl;\n", 316 | "\n", 317 | "}\n", 318 | "\n", 319 | "int main()\n", 320 | "{\n", 321 | " test01();\n", 322 | " test02();\n", 323 | "\n", 324 | " /*\n", 325 | " int a = 0;\n", 326 | " cout << ++(++a) << endl; //运行结果为2\n", 327 | " cout << a << endl; //运行结果为2，表示一直对一个数据进行递增\n", 328 | " */\n", 329 | "\n", 330 | " system(\"pause\");\n", 331 | "\n", 332 | " return 0;\n", 333 | "\n", 334 | "}" 335 | ] 336 | }, 337 | { 338 | "cell_type": "markdown", 339 | "metadata": {}, 340 | "source": [ 341 | "运行结果： \n", 342 | " - 2 \n", 343 | " - 2 \n", 344 | " - 0 \n", 345 | " - 1 \n", 346 | " - 请按任意键继续. . ." 347 | ] 348 | }, 349 | { 350 | "cell_type": "markdown", 351 | "metadata": {}, 352 | "source": [ 353 | "# 5. 赋值运算符" 354 | ] 355 | }, 356 | { 357 | "cell_type": "markdown", 358 | "metadata": {}, 359 | "source": [ 360 | "① C++编译器至少给一个类添加4个函数：\n", 361 | "\n", 362 | "1. 默认构造函数(无参，函数体为空)\n", 363 | "2. 默认析构函数(无参，函数体为空)\n", 364 | "3. 默认拷贝构造函数，对属性进行值拷贝\n", 365 | "4. 赋值运算符operator=，对属性进行值拷贝\n", 366 | "5. 如果类中有属性指向堆区，做赋值操作时也会出现浅拷贝问题。" 367 | ] 368 | }, 369 | { 370 | "cell_type": "code", 371 | "execution_count": null, 372 | "metadata": {}, 373 | "outputs": [], 374 | "source": [ 375 | "#include \n", 376 | "using namespace std;\n", 377 | "\n", 378 | "//重载赋值运算符\n", 379 | "\n", 380 | "class Person\n", 381 | "{\n", 382 | "public:\n", 383 | " Person(int age)\n", 384 | " {\n", 385 | " m_Age = new int(age);\n", 386 | " }\n", 387 | " \n", 388 | " ~Person()\n", 389 | " {\n", 390 | " if (m_Age != NULL)\n", 391 | " {\n", 392 | " delete m_Age;\n", 393 | " m_Age = NULL;\n", 394 | " }\n", 395 | " }\n", 396 | "\n", 397 | " //重载 赋值运算符\n", 398 | " //如果返回的是值，而不是引用，是创建一个拷贝函数，返回的是一个副本，而不是自身\n", 399 | " Person& operator=(Person& p)\n", 400 | " {\n", 401 | " //编译器默认是提供浅拷贝\n", 402 | " //m_Age = p.m_Age;\n", 403 | "\n", 404 | " //浅拷贝带来的问题是，当创建数据在堆区时，析构代码导致内存重复释放，报错\n", 405 | "\n", 406 | " //应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝\n", 407 | " if (m_Age != NULL)\n", 408 | " {\n", 409 | " delete m_Age;\n", 410 | " m_Age = NULL;\n", 411 | " }\n", 412 | "\n", 413 | " //深拷贝\n", 414 | " m_Age = new int(*p.m_Age);\n", 415 | "\n", 416 | " //返回对象本身\n", 417 | " return *this;\n", 418 | " }\n", 419 | "\n", 420 | " int *m_Age;\n", 421 | "};\n", 422 | "\n", 423 | "void test01()\n", 424 | "{\n", 425 | " Person p1(18);\n", 426 | "\n", 427 | " Person p2(20);\n", 428 | "\n", 429 | " Person p3(23);\n", 430 | "\n", 431 | " p3 = p2 = p1; //赋值操作\n", 432 | "\n", 433 | " cout << \"p1的年龄为：\" << *p1.m_Age << endl;\n", 434 | "\n", 435 | " cout << \"p2的年龄为：\" << *p2.m_Age << endl;\n", 436 | "\n", 437 | " cout << \"p3的年龄为：\" << *p3.m_Age << endl;\n", 438 | "\n", 439 | "\n", 440 | "}\n", 441 | "\n", 442 | "int main()\n", 443 | "{\n", 444 | " test01();\n", 445 | "\n", 446 | " /*\n", 447 | " \n", 448 | " int a = 10;\n", 449 | " int b = 20;\n", 450 | " int c = 30;\n", 451 | " \n", 452 | " c = b = a;\n", 453 | "\n", 454 | " cout << \"a= \" << a << endl;\n", 455 | " cout << \"b= \" << b << endl;\n", 456 | " cout << \"c= \" << c << endl;\n", 457 | " */\n", 458 | "\n", 459 | " system(\"pause\");\n", 460 | "\n", 461 | " return 0;\n", 462 | "\n", 463 | "}" 464 | ] 465 | }, 466 | { 467 | "cell_type": "markdown", 468 | "metadata": {}, 469 | "source": [ 470 | "运行结果： \n", 471 | " - p1的年龄为：18 \n", 472 | " - p2的年龄为：18 \n", 473 | " - p3的年龄为：18 \n", 474 | " - 请按任意键继续. . ." 475 | ] 476 | }, 477 | { 478 | "cell_type": "markdown", 479 | "metadata": {}, 480 | "source": [ 481 | "# 6. 关系重载运算符" 482 | ] 483 | }, 484 | { 485 | "cell_type": "code", 486 | "execution_count": null, 487 | "metadata": {}, 488 | "outputs": [], 489 | "source": [ 490 | "#include \n", 491 | "using namespace std;\n", 492 | "#include\n", 493 | "\n", 494 | "//重载关系运算符\n", 495 | "\n", 496 | "class Person\n", 497 | "{\n", 498 | "public:\n", 499 | " Person(string name, int age)\n", 500 | " {\n", 501 | " m_Name = name;\n", 502 | " m_Age = age;\n", 503 | " }\n", 504 | "\n", 505 | " //重载 == 号\n", 506 | " bool operator==(Person& p)\n", 507 | " {\n", 508 | " if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)\n", 509 | " {\n", 510 | " return true;\n", 511 | " }\n", 512 | " return false;\n", 513 | " }\n", 514 | "\n", 515 | " bool operator!=(Person& p)\n", 516 | " {\n", 517 | " if (this->m_Name != p.m_Name && this->m_Age != p.m_Age)\n", 518 | " {\n", 519 | " return true;\n", 520 | " }\n", 521 | " return false;\n", 522 | " }\n", 523 | "\n", 524 | " string m_Name;\n", 525 | " int m_Age;\n", 526 | "};\n", 527 | "\n", 528 | "void test01()\n", 529 | "{\n", 530 | " Person p1(\"Tom\", 17);\n", 531 | "\n", 532 | " Person p2(\"Jerry\", 18);\n", 533 | "\n", 534 | " if (p1 == p2)\n", 535 | " {\n", 536 | " cout << \"p1和p2是相等的！\" << endl;\n", 537 | " }\n", 538 | " else\n", 539 | " {\n", 540 | " cout << \"p1和p2是不相等的！\" << endl;\n", 541 | "\n", 542 | " }\n", 543 | "\n", 544 | " if (p1 != p2)\n", 545 | " {\n", 546 | " cout << \"p1和p2是不相等的！\" << endl;\n", 547 | " }\n", 548 | " else\n", 549 | " {\n", 550 | " cout << \"p1和p2是相等的！\" << endl;\n", 551 | "\n", 552 | " }\n", 553 | "\n", 554 | "\n", 555 | "}\n", 556 | "\n", 557 | "int main()\n", 558 | "{\n", 559 | " test01();\n", 560 | " \n", 561 | " system(\"pause\");\n", 562 | "\n", 563 | " return 0;\n", 564 | "\n", 565 | "}" 566 | ] 567 | }, 568 | { 569 | "cell_type": "markdown", 570 | "metadata": {}, 571 | "source": [ 572 | "运行结果： \n", 573 | " - p1和p2是不相等的！ \n", 574 | " - p1和p2是不相等的！ \n", 575 | " - 请按任意键继续. . ." 576 | ] 577 | }, 578 | { 579 | "cell_type": "markdown", 580 | "metadata": {}, 581 | "source": [ 582 | "# 7. 函数调用运算符重载" 583 | ] 584 | }, 585 | { 586 | "cell_type": "markdown", 587 | "metadata": {}, 588 | "source": [ 589 | "① 函数调用运算符()也可以重载。\n", 590 | "\n", 591 | "② 由于重载后使用的方式非常像函数的调用，因此称为仿函数。\n", 592 | "\n", 593 | "③ 仿函数没有固定写法，非常灵活。" 594 | ] 595 | }, 596 | { 597 | "cell_type": "code", 598 | "execution_count": null, 599 | "metadata": {}, 600 | "outputs": [], 601 | "source": [ 602 | "#include \n", 603 | "using namespace std;\n", 604 | "#include\n", 605 | "\n", 606 | "//函数调用运算符重载\n", 607 | "\n", 608 | "//打印输出类\n", 609 | "class MyPrint\n", 610 | "{\n", 611 | "public:\n", 612 | "\n", 613 | " //重载函数调用运算符\n", 614 | " void operator()(string test)\n", 615 | " {\n", 616 | " cout << test << endl;\n", 617 | " }\n", 618 | "\n", 619 | "};\n", 620 | "\n", 621 | "//正常函数\n", 622 | "void MyPrint02(string test)\n", 623 | "{\n", 624 | " cout << test << endl;\n", 625 | "}\n", 626 | "\n", 627 | "void test01()\n", 628 | "{\n", 629 | " MyPrint myPrint;\n", 630 | "\n", 631 | " myPrint(\"hello world\");\n", 632 | "\n", 633 | "}\n", 634 | "\n", 635 | "//仿函数非常灵活，没有固定的写法\n", 636 | "//加法类\n", 637 | "class MyAdd\n", 638 | "{\n", 639 | "public:\n", 640 | " int operator()(int num1, int num2)\n", 641 | " {\n", 642 | " return num1 + num2;\n", 643 | " }\n", 644 | "};\n", 645 | "\n", 646 | "void test02()\n", 647 | "{\n", 648 | " MyAdd myadd;\n", 649 | " int ret = myadd(100,100);\n", 650 | " cout << \"ret = \" << ret << endl;\n", 651 | "\n", 652 | " //匿名函数对象\n", 653 | " cout << MyAdd()(100, 100) << endl;\n", 654 | "\n", 655 | " // MyAdd()为创建一个匿名对象，匿名对象的特点为当前行执行完立即释放\n", 656 | "}\n", 657 | "\n", 658 | "int main()\n", 659 | "{\n", 660 | " test01();\n", 661 | "\n", 662 | " MyPrint02(\"hello world\"); //由于使用起来非常类似于函数调用，因此称为仿函数\n", 663 | "\n", 664 | " test02();\n", 665 | "\n", 666 | " system(\"pause\");\n", 667 | "\n", 668 | " return 0;\n", 669 | "\n", 670 | "}" 671 | ] 672 | }, 673 | { 674 | "cell_type": "markdown", 675 | "metadata": {}, 676 | "source": [ 677 | "运行结果： \n", 678 | " - hello world \n", 679 | " - hello world \n", 680 | " - ret = 200 \n", 681 | " - 200 \n", 682 | " - 请按任意键继续. . ." 683 | ] 684 | } 685 | ], 686 | "metadata": { 687 | "kernelspec": { 688 | "display_name": "Python 3.6.3", 689 | "language": "python", 690 | "name": "python3.6.3" 691 | }, 692 | "language_info": { 693 | "codemirror_mode": { 694 | "name": "ipython", 695 | "version": 3 696 | }, 697 | "file_extension": ".py", 698 | "mimetype": "text/x-python", 699 | "name": "python", 700 | "nbconvert_exporter": "python", 701 | "pygments_lexer": "ipython3", 702 | "version": "3.6.3" 703 | }, 704 | "toc": { 705 | "base_numbering": 1, 706 | "nav_menu": {}, 707 | "number_sections": false, 708 | "sideBar": true, 709 | "skip_h1_title": false, 710 | "title_cell": "Table of Contents", 711 | "title_sidebar": "Contents", 712 | "toc_cell": false, 713 | "toc_position": {}, 714 | "toc_section_display": true, 715 | "toc_window_display": true 716 | } 717 | }, 718 | "nbformat": 4, 719 | "nbformat_minor": 4 720 | } 721 | -------------------------------------------------------------------------------- /16_C++的结构体.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的结构体" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 结构体" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① 结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。\n", 22 | "\n", 23 | "② 语法：struct 结构体名 { 结构体成员列表 }\n", 24 | "\n", 25 | "③ 通过结构体创建变量的方式有三种：\n", 26 | "\n", 27 | "1. struct 结构体名 变量名\n", 28 | "2. struct 结构体名 变量名 = { 成员1值，成员2值 }\n", 29 | "3. 定义结构体时顺便创建变量\n", 30 | "\n", 31 | "④ 结构体变量利用点.访问成员" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "#include \n", 41 | "using namespace std;\n", 42 | "#include \n", 43 | "//自定义数据类型，一些类型的集合组成一个类型\n", 44 | "//语法 struct 类型名称 { 成员列表 }\n", 45 | "//结构体定义的时候，struct关键字不能省略\n", 46 | "//1、创建学生数据类型：学生包括(姓名，年龄，分数)\n", 47 | "struct Student\n", 48 | "{\n", 49 | " //成员列表\n", 50 | "\n", 51 | " //姓名\n", 52 | " string name;\n", 53 | " //年龄\n", 54 | " int age;\n", 55 | " //分数\n", 56 | " int score;\n", 57 | "};\n", 58 | "\n", 59 | "int main()\n", 60 | "{\n", 61 | " //2.1 struct Student s1 s1类似结构体的实例值，类似变量赋值：int a = 10 → 属性 变量 变量值\n", 62 | " //结构体创建的时候，struct 关键字可以省略；上面结构体定义的时候 struct 可以省略\n", 63 | " struct Student s1;\n", 64 | " //给s1属性赋值，通过点.访问结构体变量中的属性\n", 65 | " s1.name = \"张三\";\n", 66 | " s1.age = 18;\n", 67 | " s1.score = 100;\n", 68 | "\n", 69 | " cout << \"姓名：\" << s1.name << \"年龄:\" << s1.age << \"分数：\" << s1.score << endl;\n", 70 | "\n", 71 | " //2.2 struct Student s2 = { ... }\n", 72 | " struct Student s2 = { \"李四\",19,80 };\n", 73 | " cout << \"姓名：\" << s2.name << \"年龄:\" << s2.age << \"分数：\" << s2.score << endl;\n", 74 | " \n", 75 | " system(\"pause\");\n", 76 | "\n", 77 | " return 0;\n", 78 | "\n", 79 | "}" 80 | ] 81 | }, 82 | { 83 | "cell_type": "markdown", 84 | "metadata": {}, 85 | "source": [ 86 | "运行结果： \n", 87 | " - 姓名：张三年龄:18分数：100 \n", 88 | " - 姓名：李四年龄:19分数：80 \n", 89 | " - 请按任意键继续. . ." 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": null, 95 | "metadata": {}, 96 | "outputs": [], 97 | "source": [ 98 | "#include \n", 99 | "using namespace std;\n", 100 | "#include \n", 101 | "//自定义数据类型，一些类型的集合组成一个类型\n", 102 | "struct Student\n", 103 | "{\n", 104 | " //成员列表\n", 105 | "\n", 106 | " //姓名\n", 107 | " string name;\n", 108 | " //年龄\n", 109 | " int age;\n", 110 | " //分数\n", 111 | " int score;\n", 112 | "}s3; //2.3 创建结构体的时候，顺便创建个结构体变量\n", 113 | "\n", 114 | "int main()\n", 115 | "{\n", 116 | " //2.3 \n", 117 | " s3.name = \"王五\";\n", 118 | " s3.age = 20;\n", 119 | " s3.score = 60;\n", 120 | "\n", 121 | " cout << \"姓名：\" << s3.name << \"年龄:\" << s3.age << \"分数：\" << s3.score << endl;\n", 122 | "\n", 123 | " system(\"pause\");\n", 124 | "\n", 125 | " return 0;\n", 126 | "\n", 127 | "}" 128 | ] 129 | }, 130 | { 131 | "cell_type": "markdown", 132 | "metadata": {}, 133 | "source": [ 134 | "运行结果： \n", 135 | " - 姓名：王五年龄:20分数：60 \n", 136 | " - 请按任意键继续. . ." 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": {}, 142 | "source": [ 143 | "## 1.1 结构体定义和使用" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "① 作用：将自定义的结构体放入到数组中方便维护。\n", 151 | "\n", 152 | "② 语法：struct 结构体名 数组名[元素个数] = { {},{},...,{} }" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": null, 158 | "metadata": {}, 159 | "outputs": [], 160 | "source": [ 161 | "#include \n", 162 | "using namespace std;\n", 163 | "#include \n", 164 | "//自定义数据类型，一些类型的集合组成一个类型\n", 165 | "struct Student\n", 166 | "{\n", 167 | " //成员列表\n", 168 | "\n", 169 | " //姓名\n", 170 | " string name;\n", 171 | " //年龄\n", 172 | " int age;\n", 173 | " //分数\n", 174 | " int score;\n", 175 | "}; \n", 176 | "\n", 177 | "int main()\n", 178 | "{\n", 179 | " //2、创建结构体数组\n", 180 | " struct Student stuArray[3] =\n", 181 | " {\n", 182 | " {\"张三\",18,100},\n", 183 | " {\"李四\",28,99},\n", 184 | " {\"王五\",38,66}\n", 185 | " };\n", 186 | "\n", 187 | " //3、给结构体数组中的元素赋值\n", 188 | " stuArray[2].name = \"赵六\";\n", 189 | " stuArray[2].age = 80;\n", 190 | " stuArray[2].score = 60;\n", 191 | "\n", 192 | " //4、遍历结构体数组\n", 193 | " for (int i = 0; i < 3; i++)\n", 194 | " {\n", 195 | " cout << \"姓名：\" << stuArray[i].name << \"年龄：\" << stuArray[i].age << \"分数：\" << stuArray[i].score << endl;\n", 196 | " }\n", 197 | "\n", 198 | " system(\"pause\");\n", 199 | "\n", 200 | " return 0;\n", 201 | "\n", 202 | "}" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "运行结果： \n", 210 | " - 姓名：张三年龄：18分数：100 \n", 211 | " - 姓名：李四年龄：28分数：99 \n", 212 | " - 姓名：赵六年龄：80分数：60\n", 213 | " - 请按任意键继续. . ." 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "metadata": {}, 219 | "source": [ 220 | "## 1.2 结构体数组" 221 | ] 222 | }, 223 | { 224 | "cell_type": "markdown", 225 | "metadata": {}, 226 | "source": [ 227 | "① 作用：将自定义的结构体放入到数组中方便维护。\n", 228 | "\n", 229 | "② 语法：struct 结构体名 数组名[元素个数] = { {},{},...,{} }" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": null, 235 | "metadata": {}, 236 | "outputs": [], 237 | "source": [ 238 | "#include \n", 239 | "using namespace std;\n", 240 | "#include \n", 241 | "//自定义数据类型，一些类型的集合组成一个类型\n", 242 | "struct Student\n", 243 | "{\n", 244 | " //成员列表\n", 245 | "\n", 246 | " //姓名\n", 247 | " string name;\n", 248 | " //年龄\n", 249 | " int age;\n", 250 | " //分数\n", 251 | " int score;\n", 252 | "};\n", 253 | "\n", 254 | "int main()\n", 255 | "{\n", 256 | " //2、创建结构体数组\n", 257 | " struct Student stuArray[3] =\n", 258 | " {\n", 259 | " {\"张三\",18,100},\n", 260 | " {\"李四\",28,99},\n", 261 | " {\"王五\",38,66}\n", 262 | " };\n", 263 | "\n", 264 | " //3、给结构体数组中的元素赋值\n", 265 | " stuArray[2].name = \"赵六\";\n", 266 | " stuArray[2].age = 80;\n", 267 | " stuArray[2].score = 60;\n", 268 | "\n", 269 | " //4、遍历结构体数组\n", 270 | " for (int i = 0; i < 3; i++)\n", 271 | " {\n", 272 | " cout << \"姓名：\" << stuArray[i].name << \"年龄：\" << stuArray[i].age << \"分数：\" << stuArray[i].score << endl;\n", 273 | " }\n", 274 | "\n", 275 | " system(\"pause\");\n", 276 | "\n", 277 | " return 0;\n", 278 | "\n", 279 | "}" 280 | ] 281 | }, 282 | { 283 | "cell_type": "markdown", 284 | "metadata": {}, 285 | "source": [ 286 | "运行结果： \n", 287 | " - 姓名：张三年龄：18分数：100 \n", 288 | " - 姓名：李四年龄：28分数：99 \n", 289 | " - 姓名：赵六年龄：80分数：60 \n", 290 | " - 请按任意键继续. . ." 291 | ] 292 | }, 293 | { 294 | "cell_type": "markdown", 295 | "metadata": {}, 296 | "source": [ 297 | "## 1.3 结构体指针" 298 | ] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "metadata": {}, 303 | "source": [ 304 | "① 作用：通过指针访问结构体中的成员。\n", 305 | "\n", 306 | "② 利用操作符 · > 可以通过结构体指针访问结构体属性。" 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": null, 312 | "metadata": {}, 313 | "outputs": [], 314 | "source": [ 315 | "#include \n", 316 | "using namespace std;\n", 317 | "#include \n", 318 | "\n", 319 | "//结构体指针\n", 320 | "\n", 321 | "//定义学生结构体\n", 322 | "struct Student\n", 323 | "{\n", 324 | " string name; //姓名\n", 325 | " int age; //年龄\n", 326 | " int score; //分数\n", 327 | "};\n", 328 | "\n", 329 | "int main()\n", 330 | "{\n", 331 | " // 1、创建学生结构体变量，这里的 struct 可以省略\n", 332 | " struct Student s = { \"张三\",18,100 };\n", 333 | "\n", 334 | " //2、通过指针指向结构体变量\n", 335 | " struct Student* p = &s; //对s取地址， tudent * p 类似 int * p，这里的 struct 可以省略\n", 336 | "\n", 337 | " //3、通过指针访问结构体变量中的数据\n", 338 | " //通过结构体指针 访问结构体中的属性，需要利用'->'\n", 339 | " cout << \"姓名：\" << p->name << \"年龄：\" << p->age << \"分数：\" << p->score << endl;\n", 340 | "\n", 341 | " system(\"pause\");\n", 342 | "\n", 343 | " return 0;\n", 344 | "\n", 345 | "}" 346 | ] 347 | }, 348 | { 349 | "cell_type": "markdown", 350 | "metadata": {}, 351 | "source": [ 352 | "运行结果： \n", 353 | "- 姓名：张三年龄：18分数：100 \n", 354 | "- 请按任意键继续. . ." 355 | ] 356 | }, 357 | { 358 | "cell_type": "markdown", 359 | "metadata": {}, 360 | "source": [ 361 | "## 1.4 结构体嵌套结构体" 362 | ] 363 | }, 364 | { 365 | "cell_type": "markdown", 366 | "metadata": {}, 367 | "source": [ 368 | "① 结构体中的成员可以是另一个结构体。" 369 | ] 370 | }, 371 | { 372 | "cell_type": "code", 373 | "execution_count": null, 374 | "metadata": {}, 375 | "outputs": [], 376 | "source": [ 377 | "#include \n", 378 | "using namespace std;\n", 379 | "#include \n", 380 | "\n", 381 | "//因为老师的结构体里有学生的结构体，所以学生结构体要在老师结构体前面先定义\n", 382 | "//定义学生结构体\n", 383 | "struct student\n", 384 | "{\n", 385 | " string name; //姓名\n", 386 | " int age; //年龄\n", 387 | " int score; //分数\n", 388 | "}; \n", 389 | "\n", 390 | "//定义老师结构体\n", 391 | "struct teacher\n", 392 | "{\n", 393 | " int id; //教师编号\n", 394 | " string name; //教师姓名\n", 395 | " int age; //年龄\n", 396 | " struct student stu; //学生结构体\n", 397 | "};\n", 398 | "\n", 399 | "int main()\n", 400 | "{\n", 401 | " //结构体嵌套结构体\n", 402 | " //创建老师\n", 403 | " teacher t;\n", 404 | " t.id = 10000;\n", 405 | " t.name = \"老王\";\n", 406 | " t.age = 50;\n", 407 | " t.stu.name = \"小王\";\n", 408 | " t.stu.age = 20;\n", 409 | " t.stu.score = 60;\n", 410 | "\n", 411 | " cout << \"老师姓名：\" << t.name << \"老师编号：\" << t.id << \"老师年龄：\" << t.age\n", 412 | " << \"老师辅导的学生姓名：\" << t.stu.name << \"学生年龄：\" << t.stu.age \n", 413 | " << \"学生考试分数：\" << t.stu.score << endl;\n", 414 | "\n", 415 | " system(\"pause\");\n", 416 | "\n", 417 | " return 0;\n", 418 | "\n", 419 | "}" 420 | ] 421 | }, 422 | { 423 | "cell_type": "markdown", 424 | "metadata": {}, 425 | "source": [ 426 | "运行结果： \n", 427 | " - 老师姓名：老王 老师编号：10000 老师年龄：50 老师辅导的学生姓名：小王 学生年龄：20 学生考试分数：60\n", 428 | " - 请按任意键继续. . ." 429 | ] 430 | }, 431 | { 432 | "cell_type": "markdown", 433 | "metadata": {}, 434 | "source": [ 435 | "## 1.5 结构体做函数参数" 436 | ] 437 | }, 438 | { 439 | "cell_type": "markdown", 440 | "metadata": {}, 441 | "source": [ 442 | "① 作用：将结构体作为参数向函数中传递，传递方式有两种。\n", 443 | "\n", 444 | "② 传递方式有两种：\n", 445 | "\n", 446 | "1. 值传递\n", 447 | "2. 地址传递" 448 | ] 449 | }, 450 | { 451 | "cell_type": "code", 452 | "execution_count": null, 453 | "metadata": {}, 454 | "outputs": [], 455 | "source": [ 456 | "#include \n", 457 | "using namespace std;\n", 458 | "#include \n", 459 | "\n", 460 | "//定义学生结构体\n", 461 | "struct student\n", 462 | "{\n", 463 | " string name; //姓名\n", 464 | " int age; //年龄\n", 465 | " int score; //分数\n", 466 | "};\n", 467 | "\n", 468 | "//定义老师结构体\n", 469 | "struct teacher\n", 470 | "{\n", 471 | " int id; //教师编号\n", 472 | " string name; //教师姓名\n", 473 | " int age; //年龄\n", 474 | " struct student stu; //学生结构体\n", 475 | "};\n", 476 | "\n", 477 | "//打印学生信息的函数\n", 478 | "//1、值传递\n", 479 | "void printStudent1(struct student s)\n", 480 | "{\n", 481 | " cout << \"子函数 值传递前 姓名：\" << s.name << \"年龄：\" << s.age << \"分数：\" << s.score << endl;\n", 482 | "\n", 483 | " s.age = 100;\n", 484 | "}\n", 485 | "\n", 486 | "//2、地址传递\n", 487 | "void printStudent2(struct student* p)\n", 488 | "{\n", 489 | " cout << \"子函数 地址传递前 姓名：\" << p->name << \"年龄：\" << p->age << \"分数：\" << p->score << endl;\n", 490 | "\n", 491 | " p->score = 90;\n", 492 | "}\n", 493 | "\n", 494 | "int main()\n", 495 | "{\n", 496 | " //结构体做函数参数\n", 497 | " //将学生传入到一个参数中，打印学生身上的所有信息\n", 498 | "\n", 499 | " //创建结构体变量\n", 500 | " struct student s;\n", 501 | " s.name = \"张三\";\n", 502 | " s.age = 20;\n", 503 | " s.score = 85;\n", 504 | "\n", 505 | " cout << \"main函数 传递前 姓名：\" << s.name << \"年龄：\" << s.age << \"分数：\" << s.score << endl;\n", 506 | "\n", 507 | " printStudent1(s);\n", 508 | "\n", 509 | " cout << \"子函数 值传递后 姓名：\" << s.name << \"年龄：\" << s.age << \"分数：\" << s.score << endl;\n", 510 | "\n", 511 | " printStudent2(&s);\n", 512 | "\n", 513 | " cout << \"子函数 地址传递后 姓名：\" << s.name << \"年龄：\" << s.age << \"分数：\" << s.score << endl;\n", 514 | "\n", 515 | "\n", 516 | " cout << \"main函数 传递后 姓名：\" << s.name << \"年龄：\" << s.age << \"分数：\" << s.score << endl;\n", 517 | "\n", 518 | " system(\"pause\");\n", 519 | "\n", 520 | " return 0;\n", 521 | "\n", 522 | "}" 523 | ] 524 | }, 525 | { 526 | "cell_type": "markdown", 527 | "metadata": {}, 528 | "source": [ 529 | "运行结果： \n", 530 | " - main函数 传递前 姓名：张三年龄：20分数：85 \n", 531 | " - 子函数 值传递前 姓名：张三年龄：20分数：85 \n", 532 | " - 子函数 值传递后 姓名：张三年龄：20分数：85 \n", 533 | " - 子函数 地址传递前 姓名：张三年龄：20分数：85 \n", 534 | " - 子函数 地址传递后 姓名：张三年龄：20分数：90 \n", 535 | " - main函数 传递后 姓名：张三年龄：20分数：90 \n", 536 | " - 请按任意键继续. . ." 537 | ] 538 | }, 539 | { 540 | "cell_type": "markdown", 541 | "metadata": {}, 542 | "source": [ 543 | "## 1.6 结构体中const使用" 544 | ] 545 | }, 546 | { 547 | "cell_type": "markdown", 548 | "metadata": {}, 549 | "source": [ 550 | "① 作用：const来防止误操作。" 551 | ] 552 | }, 553 | { 554 | "cell_type": "code", 555 | "execution_count": null, 556 | "metadata": {}, 557 | "outputs": [], 558 | "source": [ 559 | "#include \n", 560 | "using namespace std;\n", 561 | "#include \n", 562 | "\n", 563 | "//const 的使用场景\n", 564 | "\n", 565 | "struct student\n", 566 | "{\n", 567 | " //姓名\n", 568 | " string name;\n", 569 | " //年龄\n", 570 | " int age;\n", 571 | " //分数\n", 572 | " int score;\n", 573 | "};\n", 574 | "\n", 575 | "//将函数中形参设置为指针，用地址传递，而不是值传递，可以减少内存空间，而且不会复制新的副本\n", 576 | "//值传递需要复制新的副本，如果有成千上万个学生调用结构体，会复制成千上个副本\n", 577 | "void printStudents(const student* s)\n", 578 | "{\n", 579 | " s->age = 150; //报错，因为假如const之后，一旦有修改的操作就会报错，可以防止我们的误操作。\n", 580 | " cout << \"姓名：\" << s->name << \"年龄：\" << s->age << \"分数：\" << s->score << endl;\n", 581 | "}\n", 582 | "\n", 583 | "\n", 584 | "int main()\n", 585 | "{\n", 586 | " //创建结构体变量\n", 587 | " struct student s = { \"张三\",15,70 };\n", 588 | "\n", 589 | " //通过函数打印结构体变量信息\n", 590 | " printStudents(&s);\n", 591 | "\n", 592 | " cout << \"main中张三年龄为：\" << s.age << endl;\n", 593 | "\n", 594 | " system(\"pause\");\n", 595 | "\n", 596 | " return 0;\n", 597 | "\n", 598 | "}" 599 | ] 600 | }, 601 | { 602 | "cell_type": "markdown", 603 | "metadata": {}, 604 | "source": [ 605 | "## 1.7 结构体案例(一)" 606 | ] 607 | }, 608 | { 609 | "cell_type": "markdown", 610 | "metadata": {}, 611 | "source": [ 612 | "案例描述：学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下：设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员，学生的成员有姓名、考试分数、创建数组存放3名老师，通过函数给每个老师及所带的学生赋值。最终打印出老师数据以及老师所带的学生数据。" 613 | ] 614 | }, 615 | { 616 | "cell_type": "code", 617 | "execution_count": null, 618 | "metadata": {}, 619 | "outputs": [], 620 | "source": [ 621 | "#include \n", 622 | "using namespace std;\n", 623 | "#include \n", 624 | "#include \n", 625 | "\n", 626 | "//学生结构体定义\n", 627 | "struct Student\n", 628 | "{\n", 629 | " //姓名\n", 630 | " string sName;\n", 631 | " //学生数组\n", 632 | " int score;\n", 633 | "};\n", 634 | "\n", 635 | "//老师结构体\n", 636 | "struct Teacher\n", 637 | "{\n", 638 | " //姓名\n", 639 | " string tName;\n", 640 | " //学生数组\n", 641 | " struct Student sArray[5];\n", 642 | "};\n", 643 | "\n", 644 | "//给老师和学生赋值的函数\n", 645 | "void allocateSpace(struct Teacher tArray[], int len) //接收数组的两种方式：一用指针，二用数组名 struct Teacher tArray[]\n", 646 | "{\n", 647 | " string nameSeed = \"ABCDE\";\n", 648 | " //给老师开始赋值\n", 649 | " for (int i = 0; i < len; i++)\n", 650 | " {\n", 651 | " tArray[i].tName = \"Teacher_\";\n", 652 | " tArray[i].tName += nameSeed[i];\n", 653 | "\n", 654 | " //通过循环给每名老师所带的学生赋值\n", 655 | " for (int j = 0; j < 5; j++)\n", 656 | " {\n", 657 | " tArray[i].sArray[j].sName = \"Student_\";\n", 658 | " tArray[i].sArray[j].sName += nameSeed[j];\n", 659 | "\n", 660 | " int random = rand() % 61 + 40; // 40 ~ 100\n", 661 | " tArray[i].sArray[j].score = random; //\n", 662 | "\n", 663 | " }\n", 664 | " }\n", 665 | "}\n", 666 | "\n", 667 | "//打印所有信息\n", 668 | "void printInfo(struct Teacher tArray[], int len)\n", 669 | "{\n", 670 | " for (int i = 0;i\n", 766 | "using namespace std;\n", 767 | "\n", 768 | "//1、设计英雄结构体\n", 769 | "struct Hero\n", 770 | "{\n", 771 | " //姓名\n", 772 | " string name;\n", 773 | " //年龄\n", 774 | " int age;\n", 775 | " //性别\n", 776 | " string sex;\n", 777 | "};\n", 778 | "\n", 779 | "//冒泡排序，实现年龄升序排列\n", 780 | "void bubbleSort(struct Hero heroArray[], int len)\n", 781 | "{\n", 782 | " for (int i = 0; i < len - 1; i++)\n", 783 | " {\n", 784 | " for (int j = 0; j < len - i - 1; j++)\n", 785 | " {\n", 786 | " //如果j下标的年龄大于j+1下标的元素的年龄，交换两个元素\n", 787 | " if (heroArray[j].age > heroArray[j + 1].age)\n", 788 | " {\n", 789 | " struct Hero temp = heroArray[j]; //创建一个临时结构体变量\n", 790 | " heroArray[j] = heroArray[j + 1];\n", 791 | " heroArray[j + 1] = temp;\n", 792 | " }\n", 793 | " }\n", 794 | " }\n", 795 | "}\n", 796 | "\n", 797 | "void printHero(struct Hero heroArray[], int len)\n", 798 | "{\n", 799 | " for (int i = 0; i < len; i++)\n", 800 | " {\n", 801 | " cout << \"姓名：\" << heroArray[i].name << \" 年龄：\" << heroArray[i].age\n", 802 | " << \" 性别：\" << heroArray[i].sex << endl;\n", 803 | " }\n", 804 | "}\n", 805 | "\n", 806 | "int main()\n", 807 | "{\n", 808 | "\n", 809 | " //2、创建数组存放5名英雄\n", 810 | " struct Hero heroArray[5] =\n", 811 | " {\n", 812 | " {\"刘备\",23,\"男\"},\n", 813 | " {\"关羽\",22,\"男\"},\n", 814 | " {\"张飞\",20,\"男\"},\n", 815 | " {\"赵云\",21,\"女\"},\n", 816 | " {\"貂蝉\",19,\"女\"},\n", 817 | " };\n", 818 | "\n", 819 | " int len = sizeof(heroArray) / sizeof(heroArray[0]);\n", 820 | " cout << \"排序前的打印结果\" << endl;\n", 821 | " for (int i = 0; i < len; i++)\n", 822 | " {\n", 823 | " cout << \"姓名：\" << heroArray[i].name << \" 年龄：\" << heroArray[i].age\n", 824 | " << \" 性别：\" << heroArray[i].sex << endl;\n", 825 | " }\n", 826 | "\n", 827 | " //3、对数组进行排序，按照年龄进行升序排序\n", 828 | " bubbleSort(heroArray, len);\n", 829 | "\n", 830 | " //4、将排序后结果打印输出\n", 831 | " cout << \"排序后的打印结果\" << endl;\n", 832 | " printHero(heroArray,len);\n", 833 | "\n", 834 | "\n", 835 | " system(\"pause\");\n", 836 | "\n", 837 | " return 0;\n", 838 | "\n", 839 | "}" 840 | ] 841 | }, 842 | { 843 | "cell_type": "markdown", 844 | "metadata": {}, 845 | "source": [ 846 | "运行结果： \n", 847 | " - 排序前的打印结果 \n", 848 | " - 姓名：刘备 年龄：23 性别：男 \n", 849 | " - 姓名：关羽 年龄：22 性别：男 \n", 850 | " - 姓名：张飞 年龄：20 性别：男 \n", 851 | " - 姓名：赵云 年龄：21 性别：女 \n", 852 | " - 姓名：貂蝉 年龄：19 性别：女 \n", 853 | " - 排序后的打印结果 \n", 854 | " - 姓名：貂蝉 年龄：19 性别：女 \n", 855 | " - 姓名：张飞 年龄：20 性别：男 \n", 856 | " - 姓名：赵云 年龄：21 性别：女 \n", 857 | " - 姓名：关羽 年龄：22 性别：男 \n", 858 | " - 姓名：刘备 年龄：23 性别：男 \n", 859 | " - 请按任意键继续. . ." 860 | ] 861 | } 862 | ], 863 | "metadata": { 864 | "kernelspec": { 865 | "display_name": "Python 3.6.3", 866 | "language": "python", 867 | "name": "python3.6.3" 868 | }, 869 | "language_info": { 870 | "codemirror_mode": { 871 | "name": "ipython", 872 | "version": 3 873 | }, 874 | "file_extension": ".py", 875 | "mimetype": "text/x-python", 876 | "name": "python", 877 | "nbconvert_exporter": "python", 878 | "pygments_lexer": "ipython3", 879 | "version": "3.6.3" 880 | }, 881 | "toc": { 882 | "base_numbering": 1, 883 | "nav_menu": {}, 884 | "number_sections": false, 885 | "sideBar": true, 886 | "skip_h1_title": false, 887 | "title_cell": "Table of Contents", 888 | "title_sidebar": "Contents", 889 | "toc_cell": false, 890 | "toc_position": {}, 891 | "toc_section_display": true, 892 | "toc_window_display": true 893 | } 894 | }, 895 | "nbformat": 4, 896 | "nbformat_minor": 4 897 | } 898 | -------------------------------------------------------------------------------- /12_C++的程序流程结构.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# C++的程序流程结构" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# 1. 程序流程结构" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "① C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构\n", 22 | "\n", 23 | "1. 顺序结构：程序按顺序执行，不发生跳转\n", 24 | "2. 选择结构：依据条件是否满足，有选择的执行相应功能\n", 25 | "3. 循环结构：依据条件是否满足，循环多次执行某段代码" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "# 2. 选择结构" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "## 2.1 单行 if 语句" 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "① 单行if语句，格式：if(条件){条件满足执行的语句}" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [ 55 | "#include \n", 56 | "using namespace std;\n", 57 | "\n", 58 | "int main()\n", 59 | "{\n", 60 | "\n", 61 | " // 选择结构 单行if语句\n", 62 | " // 用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出\n", 63 | "\n", 64 | " //1、用户输入分数\n", 65 | " int score = 0;\n", 66 | "\n", 67 | " cout << \"请输入一个分数：\" << endl; //在C++中除了0，都为真\n", 68 | " cin >> score;\n", 69 | "\n", 70 | " //2、打印用户输入的分数\n", 71 | "\n", 72 | " cout << \"您输入的分数为 ：\" << score << endl;\n", 73 | "\n", 74 | " //3、判断分数是否大于600，如果大于，那么输出\n", 75 | " //注意事项，if条件后面不要加分号。加了分号条件不管满足还是不满足，后面的都会运行\n", 76 | " if (score > 600)\n", 77 | " {\n", 78 | " cout << \"恭喜您考上了一本大学\" << endl;\n", 79 | " }\n", 80 | "\n", 81 | " system(\"pause\");\n", 82 | "\n", 83 | " return 0;\n", 84 | "\n", 85 | "}" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "运行结果： \n", 93 | " - 请输入一个分数： \n", 94 | " - 611 \n", 95 | " - 您输入的分数为 ：611 \n", 96 | " - 恭喜您考上了一本大学 \n", 97 | " - 请按任意键继续. . ." 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "## 2.2 单行 else 语句" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "① 单行else语句，格式：if(条件){条件满足执行的语句} else{条件不满足执行的语句}" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": null, 117 | "metadata": {}, 118 | "outputs": [], 119 | "source": [ 120 | "#include \n", 121 | "using namespace std;\n", 122 | "\n", 123 | "int main()\n", 124 | "{\n", 125 | "\n", 126 | " // 选择结构 多行if语句\n", 127 | " // 输入考试分数，如果分数大于600，视为考上一本大学，在屏幕上输出\n", 128 | " // 如果没考上一本大学，打印未考上一本大学\n", 129 | "\n", 130 | " //1、输入考试分数\n", 131 | " int score = 0;\n", 132 | " cout << \"请输入一个考试分数\" << endl;\n", 133 | " cin >> score;\n", 134 | "\n", 135 | " //2、提示用户输入的分数\n", 136 | " cout << \"您输入的分数为：\" << score << endl;\n", 137 | "\n", 138 | " //3、判断 如果大于600，打印考上一本，否则打印未考上一本大学\n", 139 | " if (score > 600) //大于600分，执行下面大括号中内容\n", 140 | " {\n", 141 | " cout << \"恭喜您考上了一本大学\" << endl;\n", 142 | " }\n", 143 | " else //不大于600分，执行else后大括号中内容\n", 144 | " {\n", 145 | " cout << \"未考上一本大学\" << endl;\n", 146 | " }\n", 147 | "\n", 148 | " system(\"pause\");\n", 149 | "\n", 150 | " return 0;\n", 151 | "\n", 152 | "}" 153 | ] 154 | }, 155 | { 156 | "cell_type": "markdown", 157 | "metadata": {}, 158 | "source": [ 159 | "运行结果： \n", 160 | " - 请输入一个考试分数 \n", 161 | " - 490 \n", 162 | " - 您输入的分数为：490 \n", 163 | " - 未考上一本大学 \n", 164 | " - 请按任意键继续. . ." 165 | ] 166 | }, 167 | { 168 | "cell_type": "markdown", 169 | "metadata": {}, 170 | "source": [ 171 | "## 2.3 多条件的 if 语句" 172 | ] 173 | }, 174 | { 175 | "cell_type": "markdown", 176 | "metadata": {}, 177 | "source": [ 178 | "① 多条件的if语句，格式：if(条件1){条件1满足执行的语句}else if(条件){条件2满足执行的语句}....else{都不满足时执行的语句}" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "metadata": {}, 185 | "outputs": [], 186 | "source": [ 187 | "#include \n", 188 | "using namespace std;\n", 189 | "\n", 190 | "int main()\n", 191 | "{\n", 192 | " // 选择结构 多条件if语句\n", 193 | " // 输入一个考试分数，\n", 194 | " // 如果分数大于600，视为考上一本大学，在屏幕上输出\n", 195 | " // 如果分数大于500，视为考上二本大学，在屏幕上输出\n", 196 | " // 如果分数大于400，视为考上三本大学，在屏幕上输出\n", 197 | " // 如果小于等于400，视为未考上本科，屏幕上输出\n", 198 | "\n", 199 | " //1、输入考试分数\n", 200 | " int score = 0;\n", 201 | " cout << \"请输入一个考试分数\" << endl;\n", 202 | " cin >> score;\n", 203 | "\n", 204 | " //2、提示用户输入的分数\n", 205 | " cout << \"您输入的分数为：\" << score << endl;\n", 206 | "\n", 207 | " //3、判断 \n", 208 | " // 如果大于600，考上一本\n", 209 | " // 如果大于500，考上二本\n", 210 | " // 如果大于400，考上三本\n", 211 | " // 如果小于等于400，未考上本科\n", 212 | " if (score > 600) \n", 213 | " {\n", 214 | " cout << \"恭喜您考上了一本大学\" << endl;\n", 215 | " }\n", 216 | " else if (score > 500) \n", 217 | " {\n", 218 | " cout << \"恭喜您考上了二本大学\" << endl;\n", 219 | " }\n", 220 | " else if (score > 400) \n", 221 | " {\n", 222 | " cout << \"恭喜您考上了三本大学\" << endl;\n", 223 | " }\n", 224 | " else \n", 225 | " {\n", 226 | " cout << \"未考上本科大学\" << endl;\n", 227 | " }\n", 228 | " \n", 229 | " system(\"pause\");\n", 230 | " \n", 231 | " return 0;\n", 232 | "\n", 233 | "}" 234 | ] 235 | }, 236 | { 237 | "cell_type": "markdown", 238 | "metadata": {}, 239 | "source": [ 240 | "运行结果： \n", 241 | " - 请输入一个考试分数 \n", 242 | " - 430 \n", 243 | " - 您输入的分数为：430 \n", 244 | " - 恭喜您考上了三本大学 \n", 245 | " - 请按任意键继续. . ." 246 | ] 247 | }, 248 | { 249 | "cell_type": "markdown", 250 | "metadata": {}, 251 | "source": [ 252 | "## 2.4 嵌套 if 语句" 253 | ] 254 | }, 255 | { 256 | "cell_type": "markdown", 257 | "metadata": {}, 258 | "source": [ 259 | "① 嵌套if语句，在if语句中可以嵌套使用if语句，达到更精确的条件判断。" 260 | ] 261 | }, 262 | { 263 | "cell_type": "code", 264 | "execution_count": null, 265 | "metadata": {}, 266 | "outputs": [], 267 | "source": [ 268 | "#include \n", 269 | "using namespace std;\n", 270 | "\n", 271 | "int main()\n", 272 | "{\n", 273 | "\n", 274 | " // 选择结构 嵌套if语句\n", 275 | "\n", 276 | " //1、提示高考分数\n", 277 | " int score = 0;\n", 278 | " cout << \"请输入一个考试分数\" << endl;\n", 279 | " cin >> score;\n", 280 | "\n", 281 | " //2、提示用户输入的分数\n", 282 | " cout << \"您输入的分数为：\" << score << endl;\n", 283 | "\n", 284 | " //3、判断 \n", 285 | " if (score > 600) \n", 286 | " {\n", 287 | " cout << \"恭喜您考上了一本大学\" << endl;\n", 288 | " if (score > 700)\n", 289 | " {\n", 290 | " cout << \"您能考上了北京大学\" << endl;\n", 291 | " }\n", 292 | " else if (score > 650)\n", 293 | " {\n", 294 | " cout << \"您能考上了清华大学\" << endl;\n", 295 | " }\n", 296 | " else\n", 297 | " {\n", 298 | " cout << \"您能考上了人名大学\" << endl;\n", 299 | " }\n", 300 | " }\n", 301 | " else if (score > 500)\n", 302 | " {\n", 303 | " cout << \"恭喜您考上了二本大学\" << endl;\n", 304 | " }\n", 305 | " else if (score > 400)\n", 306 | " {\n", 307 | " cout << \"恭喜您考上了三本大学\" << endl;\n", 308 | " }\n", 309 | " else\n", 310 | " {\n", 311 | " cout << \"未考上本科大学\" << endl;\n", 312 | " }\n", 313 | "\n", 314 | " system(\"pause\");\n", 315 | "\n", 316 | " return 0;\n", 317 | "\n", 318 | "}" 319 | ] 320 | }, 321 | { 322 | "cell_type": "markdown", 323 | "metadata": {}, 324 | "source": [ 325 | "运行结果： \n", 326 | " - 请输入一个考试分数 \n", 327 | " - 670 \n", 328 | " - 您输入的分数为：670 \n", 329 | " - 恭喜您考上了一本大学 \n", 330 | " - 您能考上了清华大学 \n", 331 | " - 请按任意键继续. . ." 332 | ] 333 | }, 334 | { 335 | "cell_type": "markdown", 336 | "metadata": {}, 337 | "source": [ 338 | "## 2.5 三目运算符" 339 | ] 340 | }, 341 | { 342 | "cell_type": "markdown", 343 | "metadata": {}, 344 | "source": [ 345 | "① 作用：通过三目运算符实现简单的判断。\n", 346 | "\n", 347 | "② 语法：表达式1 ? 表达式2 : 表达式3\n", 348 | "\n", 349 | "1. 如果表达式1的值为真，执行表达式2，并返回表达式2的结果。\n", 350 | "2. 如果表达式1的值为假，执行表达式3，并返回表达式3的结果。\n", 351 | "\n", 352 | "③ 三目运算符可以用在显示语句中，cout << \"c = \" << c == 1 ? \"男\" : \"女\" << endl。" 353 | ] 354 | }, 355 | { 356 | "cell_type": "code", 357 | "execution_count": null, 358 | "metadata": {}, 359 | "outputs": [], 360 | "source": [ 361 | "#include \n", 362 | "using namespace std;\n", 363 | "\n", 364 | "int main()\n", 365 | "{\n", 366 | " // 创建三个变量 a b c\n", 367 | " // 将a和b做比较，将变量大的值赋值给变量c\n", 368 | "\n", 369 | " int a = 10;\n", 370 | " int b = 20;\n", 371 | " int c = 0;\n", 372 | "\n", 373 | " c = (a > b ? a : b); //可以将运算的结果的变量的值赋值给变量\n", 374 | "\n", 375 | " cout << \"c = \" << c << endl;\n", 376 | "\n", 377 | " //在C++中三目运算符返回的是变量，可以继续赋值\n", 378 | " (a > b ? a : b) = 100;\n", 379 | " cout << \"a = \" << a << endl; //可以将运算的结果右值作为变量来赋值\n", 380 | " cout << \"b = \" << b << endl;\n", 381 | "\n", 382 | " system(\"pause\");\n", 383 | "\n", 384 | " return 0;\n", 385 | "\n", 386 | "}" 387 | ] 388 | }, 389 | { 390 | "cell_type": "markdown", 391 | "metadata": {}, 392 | "source": [ 393 | "运行结果： \n", 394 | " - c = 20 \n", 395 | " - a = 10 \n", 396 | " - b = 100 \n", 397 | " - 请按任意键继续. . ." 398 | ] 399 | }, 400 | { 401 | "cell_type": "markdown", 402 | "metadata": {}, 403 | "source": [ 404 | "## 2.6 switch 语句" 405 | ] 406 | }, 407 | { 408 | "cell_type": "markdown", 409 | "metadata": {}, 410 | "source": [ 411 | "① switch语句用于执行多条件分支语句。\n", 412 | "\n", 413 | "② switch语句中表达式类型只能是整型或者字符型。\n", 414 | "\n", 415 | "③ case里如果没有break，那么程序会一直向下执行。\n", 416 | "\n", 417 | "④ 与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间。" 418 | ] 419 | }, 420 | { 421 | "cell_type": "code", 422 | "execution_count": null, 423 | "metadata": {}, 424 | "outputs": [], 425 | "source": [ 426 | "#include \n", 427 | "using namespace std;\n", 428 | "\n", 429 | "int main()\n", 430 | "{\n", 431 | " //1、提示用户给电影评分\n", 432 | " cout << \"请给电影进行评分\" << endl;\n", 433 | "\n", 434 | " //2、用户开始进行打分\n", 435 | " int score = 0;\n", 436 | " cin >> score;\n", 437 | " cout << \"您打的分数为：\" << score << endl;\n", 438 | "\n", 439 | " //3、根据用户输入的分数来提示用户最后的结果\n", 440 | " switch (score)\n", 441 | " {\n", 442 | " case 10:\n", 443 | " cout << \"您认为是经典的电影\" << endl; \n", 444 | " break;\n", 445 | " case 9:\n", 446 | " cout << \"您认为是经典的电影\" << endl;\n", 447 | " break;\n", 448 | " case 8:\n", 449 | " cout << \"您认为电影非常好\" << endl;\n", 450 | " break;\n", 451 | " case 7:\n", 452 | " cout << \"您认为电影还行\" << endl;\n", 453 | " break;\n", 454 | " case 6:\n", 455 | " cout << \"您认为电影一般\" << endl;\n", 456 | " break;\n", 457 | " default: //前面都不满足，就会执行default语句\n", 458 | " cout << \"您认为电影是烂片\" << endl;\n", 459 | " break;\n", 460 | " }\n", 461 | "\n", 462 | " //if 和 switch 区别：\n", 463 | " //switch 缺点，判断的时候只能是整型或者字符型，不可以是一个区间。\n", 464 | " //switch 优点，结构清晰，执行效率高。\n", 465 | " system(\"pause\");\n", 466 | "\n", 467 | " return 0;\n", 468 | "\n", 469 | "}" 470 | ] 471 | }, 472 | { 473 | "cell_type": "markdown", 474 | "metadata": {}, 475 | "source": [ 476 | "运行结果： \n", 477 | " - 请给电影进行评分 \n", 478 | " - 8 \n", 479 | " - 您打的分数为：8 \n", 480 | " - 您认为电影非常好 \n", 481 | " - 请按任意键继续. . ." 482 | ] 483 | }, 484 | { 485 | "cell_type": "markdown", 486 | "metadata": {}, 487 | "source": [ 488 | "## 2.7 三只小猪称体重" 489 | ] 490 | }, 491 | { 492 | "cell_type": "markdown", 493 | "metadata": {}, 494 | "source": [ 495 | "题目：现有三只小猪ABC，请分别输入三只小猪的体重，并且判断哪只小猪最重。" 496 | ] 497 | }, 498 | { 499 | "cell_type": "code", 500 | "execution_count": null, 501 | "metadata": {}, 502 | "outputs": [], 503 | "source": [ 504 | "#include \n", 505 | "using namespace std;\n", 506 | "\n", 507 | "int main()\n", 508 | "{\n", 509 | " //三只小猪称体重，判断哪只最重\n", 510 | "\n", 511 | " //1、创建三只小猪的体重变量\n", 512 | " int num1 = 0;\n", 513 | " int num2 = 0;\n", 514 | " int num3 = 0;\n", 515 | "\n", 516 | " //2、让用户输入三只小猪的重量\n", 517 | " cout << \"请输入小猪A的体重\" << endl;\n", 518 | " cin >> num1;\n", 519 | "\n", 520 | " cout << \"请输入小猪B的体重\" << endl;\n", 521 | " cin >> num2;\n", 522 | "\n", 523 | " cout << \"请输入小猪C的体重\" << endl;\n", 524 | " cin >> num3;\n", 525 | "\n", 526 | " cout << \"小猪A的体重为：\" << num1 << endl;\n", 527 | " cout << \"小猪B的体重为：\" << num2 << endl;\n", 528 | " cout << \"小猪C的体重为：\" << num3 << endl;\n", 529 | "\n", 530 | " //3、判断哪只最重\n", 531 | " //先判断A和B重量\n", 532 | " if (num1 > num2) //A比B重\n", 533 | " {\n", 534 | " if (num1 > num3) //A比C重\n", 535 | " {\n", 536 | " cout << \"小猪A最重\" << endl;\n", 537 | " }\n", 538 | " else\n", 539 | " {\n", 540 | " cout << \"小猪C最重\" << endl;\n", 541 | " }\n", 542 | " }\n", 543 | " else //B比A重\n", 544 | " {\n", 545 | " if (num2 > num3) //B比C重\n", 546 | " {\n", 547 | " cout << \"小猪B最重\" << endl;\n", 548 | " }\n", 549 | " else //C比B重\n", 550 | " {\n", 551 | " cout << \"小猪C最重\" << endl;\n", 552 | " }\n", 553 | " }\n", 554 | "\n", 555 | " system(\"pause\");\n", 556 | " \n", 557 | " return 0;\n", 558 | "\n", 559 | "}" 560 | ] 561 | }, 562 | { 563 | "cell_type": "markdown", 564 | "metadata": {}, 565 | "source": [ 566 | "运行结果： \n", 567 | " - 请输入小猪A的体重 \n", 568 | " - 100 \n", 569 | " - 请输入小猪B的体重 \n", 570 | " - 230 \n", 571 | " - 请输入小猪C的体重 \n", 572 | " - 300 \n", 573 | " - 小猪A的体重为：100 \n", 574 | " - 小猪B的体重为：230 \n", 575 | " - 小猪C的体重为：300 \n", 576 | " - 小猪C最重 \n", 577 | " - 请按任意键继续. . ." 578 | ] 579 | }, 580 | { 581 | "cell_type": "markdown", 582 | "metadata": {}, 583 | "source": [ 584 | "# 3. 循环结构" 585 | ] 586 | }, 587 | { 588 | "cell_type": "markdown", 589 | "metadata": {}, 590 | "source": [ 591 | "## 3.1 while 语句" 592 | ] 593 | }, 594 | { 595 | "cell_type": "markdown", 596 | "metadata": {}, 597 | "source": [ 598 | "① 作用：满足循环条件时，执行循环语句。\n", 599 | "\n", 600 | "② 语法：while(循环条件) {循环语句}。\n", 601 | "\n", 602 | "③ 解释：只要循环条件的结果为真，就执行循环语句。" 603 | ] 604 | }, 605 | { 606 | "cell_type": "code", 607 | "execution_count": null, 608 | "metadata": {}, 609 | "outputs": [], 610 | "source": [ 611 | "#include \n", 612 | "using namespace std;\n", 613 | "\n", 614 | "int main()\n", 615 | "{\n", 616 | " //while循环\n", 617 | " //在屏幕中打印 0~9 这10个数字\n", 618 | " int num = 0;\n", 619 | "\n", 620 | " //while()中填入循环条件\n", 621 | " //在写循环的时候，一定要避免死循环的出现\n", 622 | " while (num < 10) //如果循环条件写1，为表示死循环，一直循环下去\n", 623 | " {\n", 624 | " cout << num << endl;\n", 625 | " num++;\n", 626 | " }\n", 627 | "\n", 628 | " // 在执行循环语句时候，程序必须提供跳出循环的出口，否则出现死循环。\n", 629 | "\n", 630 | " system(\"pause\");\n", 631 | "\n", 632 | " return 0;\n", 633 | "\n", 634 | "}" 635 | ] 636 | }, 637 | { 638 | "cell_type": "markdown", 639 | "metadata": {}, 640 | "source": [ 641 | "运行结果： \n", 642 | " - 0 \n", 643 | " - 1 \n", 644 | " - 2 \n", 645 | " - 3 \n", 646 | " - 4 \n", 647 | " - 5 \n", 648 | " - 6 \n", 649 | " - 7 \n", 650 | " - 8 \n", 651 | " - 9 \n", 652 | " - 请按任意键继续. . ." 653 | ] 654 | }, 655 | { 656 | "cell_type": "markdown", 657 | "metadata": {}, 658 | "source": [ 659 | "## 3.2 do while 语句" 660 | ] 661 | }, 662 | { 663 | "cell_type": "markdown", 664 | "metadata": {}, 665 | "source": [ 666 | "① 满足循环条件，执行循环语句。\n", 667 | "\n", 668 | "② 语法：do{循环语句} while(循环条件);\n", 669 | "\n", 670 | "③ 与while的区别在于 do...while会先执行一次循环语句，再判断循环条件。" 671 | ] 672 | }, 673 | { 674 | "cell_type": "code", 675 | "execution_count": null, 676 | "metadata": {}, 677 | "outputs": [], 678 | "source": [ 679 | "#include \n", 680 | "using namespace std;\n", 681 | "\n", 682 | "int main()\n", 683 | "{\n", 684 | " //do...while语句\n", 685 | " //在屏幕中输出 0 到 9 这10个数字\n", 686 | "\n", 687 | " int num = 0;\n", 688 | " do\n", 689 | " {\n", 690 | " cout << num << endl;\n", 691 | " num++;\n", 692 | " } \n", 693 | " while (num < 10);\n", 694 | "\n", 695 | " //do...while和while循环区别在于 do...while会先执行一次循环语句\n", 696 | " system(\"pause\");\n", 697 | "\n", 698 | " return 0;\n", 699 | "\n", 700 | "}" 701 | ] 702 | }, 703 | { 704 | "cell_type": "markdown", 705 | "metadata": {}, 706 | "source": [ 707 | "运行结果： \n", 708 | " - 0 \n", 709 | " - 1 \n", 710 | " - 2 \n", 711 | " - 3 \n", 712 | " - 4 \n", 713 | " - 5 \n", 714 | " - 6 \n", 715 | " - 7 \n", 716 | " - 8 \n", 717 | " - 9 \n", 718 | " - 请按任意键继续. . ." 719 | ] 720 | }, 721 | { 722 | "cell_type": "markdown", 723 | "metadata": {}, 724 | "source": [ 725 | "## 3.3 for 语句" 726 | ] 727 | }, 728 | { 729 | "cell_type": "markdown", 730 | "metadata": {}, 731 | "source": [ 732 | "① for循环，满足循环条件，执行循环语句。\n", 733 | "\n", 734 | "② for(起始表达式(①)；条件表达式②；末尾表达式③) { 循环语句④ }\n", 735 | "\n", 736 | "1. 先执行①，初始化\n", 737 | "2. 再执行②，进行判断\n", 738 | "3. 再执行④，进行一次循环\n", 739 | "4. 再执行③，执行一次末尾表达式\n", 740 | "\n", 741 | "③ for循环中的表达式，要用分号进行分隔。\n", 742 | "\n", 743 | "④ while、for...while、for都是开发中常用的循环语句，for循环结构比较清晰，比较常用。" 744 | ] 745 | }, 746 | { 747 | "cell_type": "code", 748 | "execution_count": null, 749 | "metadata": {}, 750 | "outputs": [], 751 | "source": [ 752 | "#include \n", 753 | "using namespace std;\n", 754 | "\n", 755 | "int main()\n", 756 | "{\n", 757 | " //for循环\n", 758 | " //从数字0 打印到 数字9\n", 759 | "\n", 760 | " for (int i = 0; i < 10; i++)\n", 761 | " {\n", 762 | " cout << i << endl;\n", 763 | " }\n", 764 | "\n", 765 | " /*\n", 766 | " 第二种方式\n", 767 | " int i = 0\n", 768 | " for (; i < 10; i++)\n", 769 | " {\n", 770 | " cout << i << endl;\n", 771 | " }\n", 772 | " */\n", 773 | "\n", 774 | "\n", 775 | " /*\n", 776 | " 第三种方式\n", 777 | " int i = 0\n", 778 | " for (; ; i++)\n", 779 | " {\n", 780 | " if(i >= 10)\n", 781 | " {\n", 782 | " break;\n", 783 | " }\n", 784 | " cout << i << endl;\n", 785 | " }\n", 786 | " */\n", 787 | "\n", 788 | " /*\n", 789 | " 第四种方式\n", 790 | " int i = 0\n", 791 | " for (; ; )\n", 792 | " {\n", 793 | " if(i >= 10)\n", 794 | " {\n", 795 | " break;\n", 796 | " }\n", 797 | " cout << i << endl;\n", 798 | " i++;\n", 799 | " }\n", 800 | " */\n", 801 | "\n", 802 | " system(\"pause\");\n", 803 | "\n", 804 | " return 0;\n", 805 | "\n", 806 | "}" 807 | ] 808 | }, 809 | { 810 | "cell_type": "markdown", 811 | "metadata": {}, 812 | "source": [ 813 | "运行结果： \n", 814 | " - 0 \n", 815 | " - 1 \n", 816 | " - 2 \n", 817 | " - 3 \n", 818 | " - 4 \n", 819 | " - 5 \n", 820 | " - 6 \n", 821 | " - 7 \n", 822 | " - 8 \n", 823 | " - 9 \n", 824 | " - 请按任意键继续. . ." 825 | ] 826 | }, 827 | { 828 | "cell_type": "markdown", 829 | "metadata": {}, 830 | "source": [ 831 | "## 3.4 for 嵌套" 832 | ] 833 | }, 834 | { 835 | "cell_type": "markdown", 836 | "metadata": {}, 837 | "source": [ 838 | "① 在循环体中再嵌套一层循环，可以解决一些实际问题，例如我们想在屏幕中打印十行十列的星图，就需要利用嵌套循环。" 839 | ] 840 | }, 841 | { 842 | "cell_type": "code", 843 | "execution_count": null, 844 | "metadata": {}, 845 | "outputs": [], 846 | "source": [ 847 | "#include \n", 848 | "using namespace std;\n", 849 | "\n", 850 | "int main()\n", 851 | "{\n", 852 | " //利用嵌套循环实现星图\n", 853 | " //外层执行一次，内层执行一周\n", 854 | " //外层循环\n", 855 | " for (int i = 0; i < 10; i++)\n", 856 | " {\n", 857 | " //内层循环\n", 858 | " for (int j = 0; j < 10; j++)\n", 859 | " {\n", 860 | " cout << \"*\";\n", 861 | " }\n", 862 | " cout << endl;\n", 863 | " }\n", 864 | "\n", 865 | " system(\"pause\");\n", 866 | " return 0;\n", 867 | "\n", 868 | "}" 869 | ] 870 | }, 871 | { 872 | "cell_type": "markdown", 873 | "metadata": {}, 874 | "source": [ 875 | "运行结果： \n", 876 | " \n", 877 | " **********\n", 878 | " ********** \n", 879 | " **********\n", 880 | " **********\n", 881 | " **********\n", 882 | " **********\n", 883 | " **********\n", 884 | " **********\n", 885 | " **********\n", 886 | " **********\n", 887 | " 请按任意键继续. . ." 888 | ] 889 | }, 890 | { 891 | "cell_type": "markdown", 892 | "metadata": {}, 893 | "source": [ 894 | "## 3.5 猜数字" 895 | ] 896 | }, 897 | { 898 | "cell_type": "markdown", 899 | "metadata": {}, 900 | "source": [ 901 | "① 案例描述：系统随机生成一个1到100之间的数字，玩家进行猜测，如果猜错，提示玩家数字过大或过小，如果猜对恭喜玩家胜利，并且退出游戏。" 902 | ] 903 | }, 904 | { 905 | "cell_type": "code", 906 | "execution_count": null, 907 | "metadata": {}, 908 | "outputs": [], 909 | "source": [ 910 | "#include \n", 911 | "using namespace std;\n", 912 | "#include //time系统时间头文件\n", 913 | "\n", 914 | "int main()\n", 915 | "{\n", 916 | " //添加随机数种子，作用利用当前系统时间生成随机数，防止每次随机数都一样\n", 917 | " srand((unsigned int)time(NULL));\n", 918 | "\n", 919 | " //1、系统生成随机数\n", 920 | " int num = rand() % 100 + 1; //rand()%100 生成 0+1 ~ 99+1 随机数\n", 921 | " //cout << num << endl; //不显示生成的随机数是多少\n", 922 | "\n", 923 | " //2、玩家进行猜测\n", 924 | " int val = 0; //玩家输入的数据\n", 925 | "\n", 926 | " while (1)\n", 927 | " {\n", 928 | " cin >> val;\n", 929 | "\n", 930 | " //3、判断玩家的判断\n", 931 | " if (val > num)\n", 932 | " {\n", 933 | " cout << \"猜测过大\" << endl;\n", 934 | " }\n", 935 | " else if (val < num)\n", 936 | " {\n", 937 | " cout << \"猜测过小\" << endl;\n", 938 | " }\n", 939 | " else\n", 940 | " {\n", 941 | " cout << \"猜测您猜对了\" << endl;\n", 942 | " break; //break在循环中，可以利用该关键字来退出当前循环\n", 943 | " }\n", 944 | " }\n", 945 | " \n", 946 | "\n", 947 | " system(\"pause\");\n", 948 | "\n", 949 | " return 0;\n", 950 | "\n", 951 | "}" 952 | ] 953 | }, 954 | { 955 | "cell_type": "markdown", 956 | "metadata": {}, 957 | "source": [ 958 | "运行结果： \n", 959 | " - 32 \n", 960 | " - 猜测过小 \n", 961 | " - 60 \n", 962 | " - 猜测过大 \n", 963 | " - 54 \n", 964 | " - 猜测过大 \n", 965 | " - 40 \n", 966 | " - 猜测过大 \n", 967 | " - 38 \n", 968 | " - 猜测过大 \n", 969 | " - 35 \n", 970 | " - 猜测过大 \n", 971 | " - 33 \n", 972 | " - 猜测您猜对了 \n", 973 | " - 请按任意键继续. . ." 974 | ] 975 | }, 976 | { 977 | "cell_type": "markdown", 978 | "metadata": {}, 979 | "source": [ 980 | "## 3.6 水仙花数" 981 | ] 982 | }, 983 | { 984 | "cell_type": "markdown", 985 | "metadata": {}, 986 | "source": [ 987 | "案例描述：水仙花数是指一个3位数，它的每个位上的数字的3次幂之和等于它本身\n", 988 | "\n", 989 | "例如：1^3 + 5^3 + 3^3 = 153\n", 990 | "\n", 991 | "题目：请利用 do...while语句，求出所有3位数中的水仙花数" 992 | ] 993 | }, 994 | { 995 | "cell_type": "code", 996 | "execution_count": null, 997 | "metadata": {}, 998 | "outputs": [], 999 | "source": [ 1000 | "#include \n", 1001 | "using namespace std;\n", 1002 | "\n", 1003 | "int main()\n", 1004 | "{\n", 1005 | " //1、先打印所有的三位数字\n", 1006 | " int num = 100;\n", 1007 | "\n", 1008 | " do\n", 1009 | " {\n", 1010 | " //2、从所有三位数中找到水仙花数\n", 1011 | " int a = 0; //个位\n", 1012 | " int b = 0; //十位\n", 1013 | " int c = 0; //百位\n", 1014 | "\n", 1015 | " a = num % 10; //获取数字的个位\n", 1016 | " b = num / 10 % 10; //获取数字的十位\n", 1017 | " c = num / 100; //获取数字的百位\n", 1018 | " if (a * a * a + b * b * b + c*c*c== num) //如果是水仙花数，才打印\n", 1019 | " {\n", 1020 | " cout << num << endl;\n", 1021 | " }\n", 1022 | " num++;\n", 1023 | " } while (num < 1000);\n", 1024 | "\n", 1025 | " system(\"pause\");\n", 1026 | "\n", 1027 | " return 0;\n", 1028 | "\n", 1029 | "}" 1030 | ] 1031 | }, 1032 | { 1033 | "cell_type": "markdown", 1034 | "metadata": {}, 1035 | "source": [ 1036 | "运行结果： \n", 1037 | " - 153 \n", 1038 | " - 370 \n", 1039 | " - 371 \n", 1040 | " - 407 \n", 1041 | " - 请按任意键继续. . ." 1042 | ] 1043 | }, 1044 | { 1045 | "cell_type": "markdown", 1046 | "metadata": {}, 1047 | "source": [ 1048 | "## 3.7 敲桌子" 1049 | ] 1050 | }, 1051 | { 1052 | "cell_type": "markdown", 1053 | "metadata": {}, 1054 | "source": [ 1055 | "案例分析：从1开始数到数字100，如果数字个位含有7，或者数字十位含有7，或者该数字是7的倍数，我们打印敲桌子，其余数字直接打印输出。" 1056 | ] 1057 | }, 1058 | { 1059 | "cell_type": "code", 1060 | "execution_count": null, 1061 | "metadata": {}, 1062 | "outputs": [], 1063 | "source": [ 1064 | "#include \n", 1065 | "using namespace std;\n", 1066 | "\n", 1067 | "int main()\n", 1068 | "{\n", 1069 | " //敲桌子案例\n", 1070 | " for (int i = 1; i <= 100; i++)\n", 1071 | " {\n", 1072 | " //2、从100个数字中找到特殊数字，打印“敲桌子”\n", 1073 | " //如果是7的倍数、个位有7、或者十位有7，打印敲桌子\n", 1074 | " if (i % 7 == 0 || i % 10 == 7 || i/10 == 7) //如果是特殊数字，打印敲桌子\n", 1075 | " {\n", 1076 | " cout << \"敲桌子\" << endl;\n", 1077 | " }\n", 1078 | " else //如果不是特殊数字，才打印数字\n", 1079 | " {\n", 1080 | " cout << i << endl;\n", 1081 | " }\n", 1082 | " }\n", 1083 | "\n", 1084 | " system(\"pause\");\n", 1085 | " return 0;\n", 1086 | "\n", 1087 | "}" 1088 | ] 1089 | }, 1090 | { 1091 | "cell_type": "markdown", 1092 | "metadata": {}, 1093 | "source": [ 1094 | "运行结果： \n", 1095 | " - 1 \n", 1096 | " - 2 \n", 1097 | " - 3 \n", 1098 | " - 4 \n", 1099 | " - 5 \n", 1100 | " - 6 \n", 1101 | " - 敲桌子 \n", 1102 | " - 8 \n", 1103 | " - 9 \n", 1104 | " - 10 \n", 1105 | " - 11 \n", 1106 | " - 12 \n", 1107 | " - 13 \n", 1108 | " - 敲桌子 \n", 1109 | " - 15 \n", 1110 | " - 16 \n", 1111 | " - 敲桌子 \n", 1112 | " - 18 \n", 1113 | " - 19 \n", 1114 | " - 20 \n", 1115 | " - 敲桌子 \n", 1116 | " - 22 \n", 1117 | " - 23 \n", 1118 | " - 24 \n", 1119 | " - 25 \n", 1120 | " - 26 \n", 1121 | " - 敲桌子 \n", 1122 | " - 敲桌子 \n", 1123 | " - 29 \n", 1124 | " - 30 \n", 1125 | " - 31 \n", 1126 | " - 32 \n", 1127 | " - 33 \n", 1128 | " - 34 \n", 1129 | " - 敲桌子 \n", 1130 | " - 36 \n", 1131 | " - 敲桌子 \n", 1132 | " - 38 \n", 1133 | " - 39 \n", 1134 | " - 40 \n", 1135 | " - 41 \n", 1136 | " - 敲桌子 \n", 1137 | " - 43 \n", 1138 | " - 44 \n", 1139 | " - 45 \n", 1140 | " - 46 \n", 1141 | " - 敲桌子 \n", 1142 | " - 48 \n", 1143 | " - 敲桌子 \n", 1144 | " - 50 \n", 1145 | " - 51 \n", 1146 | " - 52 \n", 1147 | " - 53 \n", 1148 | " - 54 \n", 1149 | " - 55 \n", 1150 | " - 敲桌子 \n", 1151 | " - 敲桌子 \n", 1152 | " - 58 \n", 1153 | " - 59 \n", 1154 | " - 60 \n", 1155 | " - 61 \n", 1156 | " - 62 \n", 1157 | " - 敲桌子 \n", 1158 | " - 64 \n", 1159 | " - 65 \n", 1160 | " - 66 \n", 1161 | " - 敲桌子 \n", 1162 | " - 68 \n", 1163 | " - 69 \n", 1164 | " - 敲桌子 \n", 1165 | " - 敲桌子 \n", 1166 | " - 敲桌子 \n", 1167 | " - 敲桌子 \n", 1168 | " - 敲桌子 \n", 1169 | " - 敲桌子 \n", 1170 | " - 敲桌子 \n", 1171 | " - 敲桌子 \n", 1172 | " - 敲桌子 \n", 1173 | " - 敲桌子 \n", 1174 | " - 80 \n", 1175 | " - 81 \n", 1176 | " - 82 \n", 1177 | " - 83 \n", 1178 | " - 敲桌子 \n", 1179 | " - 85 \n", 1180 | " - 86 \n", 1181 | " - 敲桌子 \n", 1182 | " - 88 \n", 1183 | " - 89 \n", 1184 | " - 90 \n", 1185 | " - 敲桌子 \n", 1186 | " - 92 \n", 1187 | " - 93 \n", 1188 | " - 94 \n", 1189 | " - 95 \n", 1190 | " - 96 \n", 1191 | " - 敲桌子 \n", 1192 | " - 敲桌子 \n", 1193 | " - 99 \n", 1194 | " - 100 \n", 1195 | " - 请按任意键继续. . ." 1196 | ] 1197 | }, 1198 | { 1199 | "cell_type": "markdown", 1200 | "metadata": {}, 1201 | "source": [ 1202 | "## 3.8 乘法口诀" 1203 | ] 1204 | }, 1205 | { 1206 | "cell_type": "markdown", 1207 | "metadata": {}, 1208 | "source": [ 1209 | "案例描述：利用嵌套循环，实现九九乘法表。" 1210 | ] 1211 | }, 1212 | { 1213 | "cell_type": "code", 1214 | "execution_count": null, 1215 | "metadata": {}, 1216 | "outputs": [], 1217 | "source": [ 1218 | "#include \n", 1219 | "using namespace std;\n", 1220 | "\n", 1221 | "int main()\n", 1222 | "{\n", 1223 | " //乘法口诀表\n", 1224 | " for (int i = 1; i <= 9; i++)\n", 1225 | " {\n", 1226 | " for (int j = 1; j <= i; j++)\n", 1227 | " {\n", 1228 | " cout << j << \"*\" << i << \"=\" << j * i << \" \";\n", 1229 | " }\n", 1230 | " cout << endl;\n", 1231 | " }\n", 1232 | "\n", 1233 | " system(\"pause\");\n", 1234 | " return 0;\n", 1235 | "\n", 1236 | "}" 1237 | ] 1238 | }, 1239 | { 1240 | "cell_type": "markdown", 1241 | "metadata": {}, 1242 | "source": [ 1243 | "运行结果：\n", 1244 | " \n", 1245 | " 1*1=1\n", 1246 | " 1*2=2 2*2=4\n", 1247 | " 1*3=3 2*3=6 3*3=9\n", 1248 | " 1*4=4 2*4=8 3*4=12 4*4=16 \n", 1249 | " 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25\n", 1250 | " 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 \n", 1251 | " 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49\n", 1252 | " 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 \n", 1253 | " 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 \n", 1254 | " 请按任意键继续. . ." 1255 | ] 1256 | }, 1257 | { 1258 | "cell_type": "markdown", 1259 | "metadata": {}, 1260 | "source": [ 1261 | "# 4. 跳转语句" 1262 | ] 1263 | }, 1264 | { 1265 | "cell_type": "markdown", 1266 | "metadata": {}, 1267 | "source": [ 1268 | "## 4.1 break 语句" 1269 | ] 1270 | }, 1271 | { 1272 | "cell_type": "markdown", 1273 | "metadata": {}, 1274 | "source": [ 1275 | "① 用于跳出选择结构或者循环结构。\n", 1276 | "\n", 1277 | "② break使用时机：\n", 1278 | "\n", 1279 | "1. 出现在switch条件语句中，作用是终止case并跳出switch。\n", 1280 | "2. 出现在循环语句中，作用是跳出当前的循环语句。\n", 1281 | "3. 出现在嵌套循环中，跳出最近的内层循环语句。\n", 1282 | "\n", 1283 | "③ break如果使用在switch-case中，并且case前面有一大段代码，就会报错，把前面一大堆代码用括号括起来{}，编译器认为是一段代码，就不会报错了。" 1284 | ] 1285 | }, 1286 | { 1287 | "cell_type": "code", 1288 | "execution_count": null, 1289 | "metadata": {}, 1290 | "outputs": [], 1291 | "source": [ 1292 | "#include \n", 1293 | "using namespace std;\n", 1294 | "\n", 1295 | "int main()\n", 1296 | "{\n", 1297 | " //break的使用时机\n", 1298 | "\n", 1299 | " //1、出现在switch语句中\n", 1300 | " cout << \"请选择副本难度\" << endl;\n", 1301 | " cout << \"1、普通\" << endl;\n", 1302 | " cout << \"2、中等\" << endl;\n", 1303 | " cout << \"3、困难\" << endl;\n", 1304 | "\n", 1305 | " int select = 0; \n", 1306 | " cin >> select; //等待用户输入\n", 1307 | "\n", 1308 | " switch (select)\n", 1309 | " {\n", 1310 | " case 1:\n", 1311 | " cout << \"您选择的是普通难度\" << endl;\n", 1312 | " break; //退出switch语句\n", 1313 | " case 2:\n", 1314 | " cout << \"您选择的是中等难度\" << endl;\n", 1315 | " break;\n", 1316 | " case 3:\n", 1317 | " cout << \"您选择的是困难难度\" << endl;\n", 1318 | " break;\n", 1319 | " }\n", 1320 | "\n", 1321 | " //2、出现在循环语句中\n", 1322 | " for (int i=0; i < 10; i++)\n", 1323 | " {\n", 1324 | " //如果i等于5，退出循环，不再打印\n", 1325 | " if (i == 5)\n", 1326 | " {\n", 1327 | " break; //退出循环\n", 1328 | " }\n", 1329 | " cout << i << endl;\n", 1330 | " }\n", 1331 | " \n", 1332 | " //3、出现在嵌套循环语句中\n", 1333 | " for (int i = 0; i < 10; i++)\n", 1334 | " {\n", 1335 | " for (int j = 0; j < 10; j++)\n", 1336 | " {\n", 1337 | " if (j == 5)\n", 1338 | " {\n", 1339 | " break; //退出内存循环\n", 1340 | " }\n", 1341 | " cout << \"*\";\n", 1342 | " }\n", 1343 | " cout << endl;\n", 1344 | " }\n", 1345 | " system(\"pause\");\n", 1346 | " return 0;\n", 1347 | "\n", 1348 | "}" 1349 | ] 1350 | }, 1351 | { 1352 | "cell_type": "markdown", 1353 | "metadata": {}, 1354 | "source": [ 1355 | "运行结果： \n", 1356 | " - 请选择副本难度 \n", 1357 | " - 1、普通 \n", 1358 | " - 2、中等 \n", 1359 | " - 3、困难 \n", 1360 | " - 2 \n", 1361 | " - 您选择的是中等难度 \n", 1362 | " - 0 \n", 1363 | " - 1 \n", 1364 | " - 2 \n", 1365 | " - 3 \n", 1366 | " - 4 \n", 1367 | " - $*****$ \n", 1368 | " - $*****$ \n", 1369 | " - $*****$ \n", 1370 | " - $*****$ \n", 1371 | " - $*****$ \n", 1372 | " - $*****$ \n", 1373 | " - $*****$ \n", 1374 | " - $*****$ \n", 1375 | " - $*****$ \n", 1376 | " - 请按任意键继续. . ." 1377 | ] 1378 | }, 1379 | { 1380 | "cell_type": "markdown", 1381 | "metadata": {}, 1382 | "source": [ 1383 | "## 4.2 continue 语句" 1384 | ] 1385 | }, 1386 | { 1387 | "cell_type": "markdown", 1388 | "metadata": {}, 1389 | "source": [ 1390 | "① 在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环。" 1391 | ] 1392 | }, 1393 | { 1394 | "cell_type": "code", 1395 | "execution_count": null, 1396 | "metadata": {}, 1397 | "outputs": [], 1398 | "source": [ 1399 | "#include \n", 1400 | "using namespace std;\n", 1401 | "\n", 1402 | "int main()\n", 1403 | "{\n", 1404 | " //continue的使用时机\n", 1405 | " \n", 1406 | " for (int i = 0; i <= 100; i++)\n", 1407 | " {\n", 1408 | " // 如果是奇数就输出，如果是偶数就不输出\n", 1409 | " if (i % 2 == 0) \n", 1410 | " {\n", 1411 | " continue; //continue可以筛选条件，执行到此就不再向下执行了，直接执行下一次循环\n", 1412 | " }\n", 1413 | " cout << i << endl;\n", 1414 | " \n", 1415 | " }\n", 1416 | "\n", 1417 | " system(\"pause\");\n", 1418 | "\n", 1419 | " return 0;\n", 1420 | "\n", 1421 | "}" 1422 | ] 1423 | }, 1424 | { 1425 | "cell_type": "markdown", 1426 | "metadata": {}, 1427 | "source": [ 1428 | "运行结果： \n", 1429 | " - 1 \n", 1430 | " - 3 \n", 1431 | " - 5 \n", 1432 | " - 7 \n", 1433 | " - 9 \n", 1434 | " - 11 \n", 1435 | " - 13 \n", 1436 | " - 15 \n", 1437 | " - 17 \n", 1438 | " - 19 \n", 1439 | " - 21 \n", 1440 | " - 23 \n", 1441 | " - 25 \n", 1442 | " - 27 \n", 1443 | " - 29 \n", 1444 | " - 31 \n", 1445 | " - 33 \n", 1446 | " - 35 \n", 1447 | " - 37 \n", 1448 | " - 39 \n", 1449 | " - 41 \n", 1450 | " - 43 \n", 1451 | " - 45 \n", 1452 | " - 47 \n", 1453 | " - 49 \n", 1454 | " - 51 \n", 1455 | " - 53 \n", 1456 | " - 55 \n", 1457 | " - 57 \n", 1458 | " - 59 \n", 1459 | " - 61 \n", 1460 | " - 63 \n", 1461 | " - 65 \n", 1462 | " - 67 \n", 1463 | " - 69 \n", 1464 | " - 71 \n", 1465 | " - 73 \n", 1466 | " - 75 \n", 1467 | " - 77 \n", 1468 | " - 79 \n", 1469 | " - 81 \n", 1470 | " - 83 \n", 1471 | " - 85 \n", 1472 | " - 87 \n", 1473 | " - 89 \n", 1474 | " - 91 \n", 1475 | " - 93 \n", 1476 | " - 95 \n", 1477 | " - 97 \n", 1478 | " - 99 \n", 1479 | " - 请按任意键继续. . ." 1480 | ] 1481 | }, 1482 | { 1483 | "cell_type": "markdown", 1484 | "metadata": {}, 1485 | "source": [ 1486 | "## 4.3 goto 语句" 1487 | ] 1488 | }, 1489 | { 1490 | "cell_type": "markdown", 1491 | "metadata": {}, 1492 | "source": [ 1493 | "① 可以无条件跳转语句。\n", 1494 | "\n", 1495 | "② 语法：goto 标记；\n", 1496 | "\n", 1497 | "1. 如果标记名称存在，执行到goto语句时，会跳转到标记的位置。\n", 1498 | "\n", 1499 | "③ 在程序中不建议使用goto语句，以免造成程序流程混乱。" 1500 | ] 1501 | }, 1502 | { 1503 | "cell_type": "code", 1504 | "execution_count": null, 1505 | "metadata": {}, 1506 | "outputs": [], 1507 | "source": [ 1508 | "#include \n", 1509 | "using namespace std;\n", 1510 | "\n", 1511 | "int main()\n", 1512 | "{\n", 1513 | " //continue的使用时机\n", 1514 | " \n", 1515 | " cout << \"1\" << endl;\n", 1516 | " \n", 1517 | " goto FLAG; //这里是分号\n", 1518 | " \n", 1519 | " cout << \"2\" << endl;\n", 1520 | "\n", 1521 | " cout << \"3\" << endl;\n", 1522 | "\n", 1523 | " cout << \"4\" << endl;\n", 1524 | "\n", 1525 | " FLAG: //这里是冒号\n", 1526 | "\n", 1527 | " cout << \"5\" << endl;\n", 1528 | "\n", 1529 | " cout << \"6\" << endl;\n", 1530 | "\n", 1531 | " system(\"pause\");\n", 1532 | "\n", 1533 | " return 0;\n", 1534 | "\n", 1535 | "}" 1536 | ] 1537 | }, 1538 | { 1539 | "cell_type": "markdown", 1540 | "metadata": {}, 1541 | "source": [ 1542 | "运行结果： \n", 1543 | " - 1 \n", 1544 | " - 5 \n", 1545 | " - 6 \n", 1546 | " - 请按任意键继续. . ." 1547 | ] 1548 | } 1549 | ], 1550 | "metadata": { 1551 | "kernelspec": { 1552 | "display_name": "Python 3.6.3", 1553 | "language": "python", 1554 | "name": "python3.6.3" 1555 | }, 1556 | "language_info": { 1557 | "codemirror_mode": { 1558 | "name": "ipython", 1559 | "version": 3 1560 | }, 1561 | "file_extension": ".py", 1562 | "mimetype": "text/x-python", 1563 | "name": "python", 1564 | "nbconvert_exporter": "python", 1565 | "pygments_lexer": "ipython3", 1566 | "version": "3.6.3" 1567 | }, 1568 | "toc": { 1569 | "base_numbering": 1, 1570 | "nav_menu": {}, 1571 | "number_sections": false, 1572 | "sideBar": true, 1573 | "skip_h1_title": false, 1574 | "title_cell": "Table of Contents", 1575 | "title_sidebar": "Contents", 1576 | "toc_cell": false, 1577 | "toc_position": { 1578 | "height": "calc(100% - 180px)", 1579 | "left": "10px", 1580 | "top": "150px", 1581 | "width": "384px" 1582 | }, 1583 | "toc_section_display": true, 1584 | "toc_window_display": true 1585 | } 1586 | }, 1587 | "nbformat": 4, 1588 | "nbformat_minor": 4 1589 | } 1590 | --------------------------------------------------------------------------------