From cdc586d7359bbf43e7e83ac2e2bb8a27c9c2d945 Mon Sep 17 00:00:00 2001 From: Estom Date: Wed, 14 Apr 2021 15:45:25 +0800 Subject: [PATCH] =?UTF-8?q?C++=20=E5=86=8D=E6=95=B4=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .vscode/settings.json | 3 +- C++/C++基础/0 编写一个C++程序.md | 1 - C++/C++基础/1 变量和基本类型.md | 311 ----------- C++/C++基础/1 数据类型.md | 146 +++++ C++/C++基础/1.1 基本类型.md | 25 + C++/C++基础/1.2 复合类型.md | 184 +++++++ C++/C++基础/1.3 自定义数据类型.md | 67 +++ C++/C++基础/1.4 类型修饰和处理.md | 241 +++++++++ C++/C++基础/12 关键词解释.md | 82 ++- .../4 模板与泛型编程.md => C++基础/13 多文件编程.md} | 0 ...符串、向量和数组.md => 2 STL字符串&向量.md} | 123 +---- .../{7 类.md => 7 自定义类型-类和结构体.md} | 15 +- C++/C++基础/8 自定义类型-枚举和联合.md | 64 +++ C++/mianshi.cpp | 3 +- C++/标准库/15 C库整理.md | 223 ++++++++ C++/标准库/5 字符串.md | 54 +- C++/标准库/5.1 字符串类封装.md | 138 +++++ C++/类设计者的工具/2 操作重载与类型转换.md | 22 - .../1 构造函数和析构函数.md | 0 C++/面向对象/2 运算符重载两种方式.md | 505 ++++++++++++++++++ C++/面向对象/3 类与对象.md | 50 ++ C++/{类设计者的工具 => 面向对象}/3.cpp | 0 C++/面向对象/4 继承与派生.md | 145 +++++ .../5 多态与虚函数.md} | 199 +------ C++/面向对象/6 模板与泛型编程.md | 0 .../image/2021-03-06-23-22-55.png | Bin .../image/2021-03-07-14-26-29.png | Bin .../image/2021-03-07-15-55-33.png | Bin .../image/2021-03-07-15-58-59.png | Bin .../image/2021-03-07-16-00-43.png | Bin C++/面试/10.强制类型转换.md | 4 + C++/面试/19 内存对齐.md | 29 + C++/面试/20 字符串类实现.md | 27 + C++/面试/20.cpp | 136 +++++ 工作日志/2021年4月13日-今日计划.md | 12 + 数据结构/6.9 | Bin 0 -> 121004 bytes 数据结构/6.9.cpp | 130 +++++ 37 files changed, 2232 insertions(+), 707 deletions(-) delete mode 100644 C++/C++基础/1 变量和基本类型.md create mode 100644 C++/C++基础/1 数据类型.md create mode 100644 C++/C++基础/1.1 基本类型.md create mode 100644 C++/C++基础/1.2 复合类型.md create mode 100644 C++/C++基础/1.3 自定义数据类型.md create mode 100644 C++/C++基础/1.4 类型修饰和处理.md rename C++/{类设计者的工具/4 模板与泛型编程.md => C++基础/13 多文件编程.md} (100%) rename C++/C++基础/{2 字符串、向量和数组.md => 2 STL字符串&向量.md} (51%) rename C++/C++基础/{7 类.md => 7 自定义类型-类和结构体.md} (97%) create mode 100644 C++/C++基础/8 自定义类型-枚举和联合.md create mode 100644 C++/标准库/15 C库整理.md create mode 100644 C++/标准库/5.1 字符串类封装.md delete mode 100644 C++/类设计者的工具/2 操作重载与类型转换.md rename C++/{类设计者的工具 => 面向对象}/1 构造函数和析构函数.md (100%) create mode 100644 C++/面向对象/2 运算符重载两种方式.md create mode 100644 C++/面向对象/3 类与对象.md rename C++/{类设计者的工具 => 面向对象}/3.cpp (100%) create mode 100644 C++/面向对象/4 继承与派生.md rename C++/{类设计者的工具/3 面向对象程序设计.md => 面向对象/5 多态与虚函数.md} (66%) create mode 100644 C++/面向对象/6 模板与泛型编程.md rename C++/{类设计者的工具 => 面向对象}/image/2021-03-06-23-22-55.png (100%) rename C++/{类设计者的工具 => 面向对象}/image/2021-03-07-14-26-29.png (100%) rename C++/{类设计者的工具 => 面向对象}/image/2021-03-07-15-55-33.png (100%) rename C++/{类设计者的工具 => 面向对象}/image/2021-03-07-15-58-59.png (100%) rename C++/{类设计者的工具 => 面向对象}/image/2021-03-07-16-00-43.png (100%) create mode 100644 C++/面试/19 内存对齐.md create mode 100644 C++/面试/20 字符串类实现.md create mode 100644 C++/面试/20.cpp create mode 100644 工作日志/2021年4月13日-今日计划.md create mode 100644 数据结构/6.9 create mode 100644 数据结构/6.9.cpp diff --git a/.vscode/settings.json b/.vscode/settings.json index 32207109..00b2c263 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -13,6 +13,7 @@ "xlocbuf": "cpp", "xlocmon": "cpp", "xlocnum": "cpp", - "xstring": "cpp" + "xstring": "cpp", + "xtree": "cpp" } } \ No newline at end of file diff --git a/C++/C++基础/0 编写一个C++程序.md b/C++/C++基础/0 编写一个C++程序.md index 3d00c7d8..af96e9ab 100644 --- a/C++/C++基础/0 编写一个C++程序.md +++ b/C++/C++基础/0 编写一个C++程序.md @@ -1,4 +1,3 @@ - ## 0 编译工具 ### Linux编译工具 diff --git a/C++/C++基础/1 变量和基本类型.md b/C++/C++基础/1 变量和基本类型.md deleted file mode 100644 index fcc93d8b..00000000 --- a/C++/C++基础/1 变量和基本类型.md +++ /dev/null @@ -1,311 +0,0 @@ -# 变量和基本类型 - -## 0 类型树 - -- 简单类型 - - 算术类型 - - 整型 int、long、bool、char - - 浮点型 float、double -- 复合类型 - - 引用&a - - 指针\*pointer - - 数组 a[] - - 字符串"hello world" -- 类类型 - - string - - vector - -## 1 基本内置类型 - -> 数据类型主要包含内置数据类型（算数类型（整型，浮点型），指针类型），自定义数据类型（vector=C 数组类型，string=C 字符串类型） - -### 算术类型 - -- 布尔型 - bool 1 - -- 字符型 - char 1 - wchar_t 2 - char16_t - char32_t - -- 整型 - short 2 - int 4 - long 4 - long long 8 - -- 浮点型 - float 4 - double 8 - long double 16 - -### 类型修饰符-signed 与 unsigned - -> 常见的类型修饰符：signed、unsigned、long、short、const、static、extern、auto、register、mutable、thread_local、volatile、restrict - -- signed 有符号 -- unsigned 无符号 - -### 类型转换 - -- 强制类型转换 - 可能会丢失精度。 -- 隐式类型转换 - 默认情况下会向上转换，即向位数更多的位置转换。 -- 避免无符号和有符号的混用。带符号的数会自动转换成无符号的数。 - -### 字面值常量 - -- 整型字面常量 - 不同进制指的是字面格式，其转化为存储格式时，都会变成二进制存储。不必担心十进制与二进制之间的运算。字面常量只是一种数字的表示方法。24，,024，,0x24。会自动选用尺寸最小的整型进行存储；负号是对字面值取相反数，不是字面值的一部分。 -- 浮点型字面值常量 - 默认情况下使用 double 存储。3.14,3.14E0,10e4 -- 字符和字符串的字面常量 - 'a'"adbd"字符串的字面值是由字符数组构成的。编译器会在每个字符串常量的末尾添加一个'\0' -- 转义序列 - \n\t\a\v\\\b\"\?\'\r\f - \7\0\12\115 -- 可以指定字面值常量的类型。字面值会有默认的常量类型。 - 常见前缀 u（Unicode 16）U（unicode32） L（宽字符） u8（utf-8） - 常见后缀 u/U（unsigned）,l/L（long）,ll/LL（longlong）,f/F（float）, - -- bool 字面值：false，true -- 指针字面值：nullptr - -## 2 变量 - -> 关于 C++中常见的描述总结：对象 object，存储数据并具有某种类型的内存空间。已经命名的对象叫变量。变量和对象通常通用。值表示只读的数据。变量和对象是可变的数据。 - -### 变量定义 - -- 类型说明符+名称+初始化。 -- 初始值：可以直接初始化、复制初始化。不等同于赋值。 -- 直接初始化：使用=进行初始化。 -- 列表初始化：使用{}进行初始化。 -- 默认初始化：变量没有被显示初始化。 - -### 初始化和赋值 - -- 初始化和赋值是两个不同点操作。使用等号能够表示赋值，也能够实现初始化。 - -``` - int d = 1;//直接初始化 - int e = {2};//直接初始化 - int f{3};//花括号列表初始化 - int g(4);//括号列表，列表初始化 -``` - -### 变量的声明(extern) - -- 分离式编译机制：声明和定义可以分离。声明使得程序可以被程序所知道，定义负责创建与名字关联的实体（变量空间）。多个文件可以独立编译。声明并没有申请对象空间（变量空间）。 -- extern 可以声明，而不进行定义。变量可以被声明很多次，但只能被定义一次。不能再函数体中对 extern 声明的变量进行修改，extern 声明的变量只能是外部变量。 -- 多次声明必须兼容，类型一致。 - -``` -extern int i;//声明，但没有申请对象空间。 -int j;//声明并定义了，申请了兑现该控件 -``` - -### 静态类型语言 - -- 编译阶段，进行类型检查。 - -### 标识符与关键字。 - -![](image/2021-03-03-17-45-17.png) - -### 作用域 - -- 名字在所有花括号之外，则成为全局作用域。 -- 名字在其他作用与内，则成为块作用域。 -- 内层作用域，外层作用域。 - -## 3 复合类型 - -### 引用 -- 由基本类型组合而来。不能单独存在。 -- int &ref=a.表示对 a 的引用。引用本身并非对象，只是已经存在的对象的别名 -- 引用必须在定义的时候被初始化。 -- 引用是变量的别名，具有同一个变量地址（变量空间）。 -- 允许多个连续的引用 - int &r=i,r2=i2.表示 r 是 i 的引用，但 r2 是 int -- 连续定义必须都加引用符号。 - int &r=i,&r2=i2; - > 编译过程解释：一般初始化的时候（变量定义），编译器会将一个值拷贝到新建的变量空间中，然后与变量绑定。引用变量在初始化的时候，不进行拷贝，而是将原来的变量空间与新的对象绑定在一起。 - -### 指针 - -- 实现了间接访问。本身是一个对象。与引用不同，指针有自己的变量空间。 -- 允许对指针进行复制和 copy。 -- int\* dp,dp1.其中 dp 是 int 指针，dp1 是 int 类型。 -- 不能定义指向引用的指针，因为引用不是对象，没有内存空间。 -- 连续定义，必须都加\*号 - -### 指针值的四种状态 - -- 指向一个对象； -- 指向紧邻对象所占空间的下一个位置； -- 空指针意味着指针没有指向任何对象； -- 无效指针，指针指向的位置被释放。 - -### 指针访问 - -- 利用指针运算符访问指针指向的对象（\*p） -- 空指针的生成方法 - -``` -int *p1 = nullptr; -``` - -### void\* - -- 可以存放任意对象的地址。 - -### 复合类型的声明 - -int \*p1,p2; -p1 是指向 int 的指针，p2 是 int 类型的。 - -### 指向指针的指针 - -int i=0; -int \*p1=&i; -int \*\*p2 = &p1 - -## 4 const 限定符 - -### 特点 - -- 它的值不能被改变。 -- 仅在文件内有效。多个文件出现了同名的 const 变量时，等同于在不同文件中分别定义了独立变量。 - -### 使用 - -- const 的值是常量表达式，则直接在头文件中定义`const a = 3*5`，include 这个头文件就能使用 const a 的值。 -- const 的初始值通过函数计算得出，不是常量表达式；const 变量需要在不同的文件间共享，需要在头文件中 extern 声明，在 cpp 文件中进行定义。 - ![](image/2021-03-04-10-42-02.png) - -### const 引用 - -- const 引用，可以引用一个常量、变量，生成一个只读的变量。 - -``` -int i =1; -const int &r2 =i; -``` - -### const 与指针 - -- “指向常量的指针” - > 指针指向的值不能修改。 - -``` -const double * cptr = π -``` - -![](image/2021-03-04-10-48-02.png) - -- 指向非常量的“指向常量的指针” - -``` -double a = 3; -const double *b = &a -``` - -- 指针常量。 - > 指针本身的地址不能被修改。 - -``` -int n = 0; -int *const nptr = &n; -``` - -- 顶层 const 表示指针本身是个常量。 -- 底层 const 表示指针所指向的对象是一个常量。 - -### 常量表达式 - -- 常量表达式值不会改变，并且在编译过程中就能得到计算结果的表达式。 -- 字面值是常量表达式 -- 用常量表达式初始化 const 变量也是常量表达式。 - -``` -const int max = 20;//是 -const int limt = max +1;//是 -int a =27//不是，左值不是常量表达式 -const int sz = get_size();//不是，右值不是常量表达式 -``` - -## 5 处理类型 - -### 类型别名——typedef - -- typedef 使用最后一个名词作为名字 - -``` -typedef double hello; -typedef double* p; -typedef int h[81]; -typedef　struct　tag -{ -int　iNum; -long　lLength; -}MyStruct;//定义了结构体；typedef struct tag MyStruct -``` - -### 类型别名——using - -- 类型别名和类型等价 - -``` -using SI = Sales_item; -``` - -### auto 类型说明符 - -- 编译器自动分析类型 - -``` -auto item = val1 +val2 -``` - -## 6 自定义数据结构 - -### 定义一个类型。 - -``` -struct data{ - std::string bookNo; - unsigned sold = 0; - double revenue = 0.0; -}; -``` - -### 类成员 - -- 数据成员 -- 成员函数 - -### 定义类的对象 - -``` -data a,b; -``` - -### 访问类对象 - -``` -a.sold =1; -``` -## 7 常用限定符说明 - -### 存储类别 -* auto 默认存储类别，自动变量int i = 3; -* static 静态存储类别的变量，静态变量static int m = 5; -* register 寄存器变量register n = 6; -* extern 声明外部链接属性 -### 类型限定 -* const限定：制度变量、常变量 const int i = 6;必须直接初始化，避免对重要手进行错误修改。 -* volatile限定：隐式存取变量。 \ No newline at end of file diff --git a/C++/C++基础/1 数据类型.md b/C++/C++基础/1 数据类型.md new file mode 100644 index 00000000..b3fbc293 --- /dev/null +++ b/C++/C++基础/1 数据类型.md @@ -0,0 +1,146 @@ +# 类型 + +> 类是一种类型，是对象的模板，而不是变量或对象。它内部本身不包含对象。只是声明了这种对象的存在。只有创建对象的时候，才会真正的创建对象内部的对象。 + + +## 1 类型 + +- 简单类型 + - 整型 `int、short、long、longlong、bool、char、size_t` + - 浮点型 `float、double、long double` +- 复合类型 + - 引用`&a` + - 指针`*pointer` + - 数组 `a[]` + - 字符串`"hello world"` +- 自定义类型 + - 类`class` + - 结构体`struct` + - 枚举`enum` + - 联合体`union` + + + +## 2 字面值常量 + +> 常量主要包括字面值常量和自定义常量。 + +### 整型字面常量 +* 不同进制指的是字面格式，其转化为存储格式时，都会变成二进制存储。不必担心十进制与二进制之间的运算。字面常量只是一种数字的表示方法。24，,024，,0x24。会自动选用尺寸最小的整型进行存储；负号是对字面值取相反数，不是字面值的一部分。 +```C +85 // 十进制 +0213 // 八进制 +0x4b // 十六进制 +30 // 整数 +30u // 无符号整数 +30l // 长整数 +30ul // 无符号长整数 +``` +### 浮点型字面值常量 +* 默认情况下使用 double 存储。3.14,3.14E0,10e4 +```C +3.14159 // 合法的 +314159E-5L // 合法的 +510E // 非法的：不完整的指数 +210f // 非法的：没有小数或指数 +.e55 // 非法的：缺少整数或分数 +``` +### 字符和字符串的字面常量 +* 'a'"adbd"字符串的字面值是由字符数组构成的。编译器会在每个字符串常量的末尾添加一个'\0' + + +### 转义序列 +```C +\n\t\a\v\\\b\"\?\'\r\f +\7\0\12\115 +``` + +### 可以指定字面值常量的类型。字面值会有默认的常量类型。 + +* 常见前缀 `u（Unicode 16）U（unicode32） L（宽字符） u8（utf-8）` +* 常见后缀 `u/U（unsigned）,l/L（long）,ll/LL（longlong）,f/F（float）` + +### bool字面值常量 + +```C +false，true +``` +### 指针字面值常量 + +```C +NULL//C中是NULL +nullptr//C++中是nullptr +``` + +### 自定义常量 +这些常量都不是字面值常量，而是用户自定义的常量。在 C++ 中，有两种简单的定义常量的方式： +* 使用 #define 预处理器。编译器常量，编译期间使用常量代替原来的值。 +* 使用 const 关键字。运行时常量，运行时值不可修改。 + +## 3 变量 + +> 关于 C++中常见的描述总结：对象 object，存储数据并具有某种类型的内存空间。已经命名的对象叫变量。变量和对象通常通用。值表示只读的数据。变量和对象是可变的数据。 + +### 变量的声明(extern) + +- 分离式编译机制：声明和定义可以分离。声明使得程序可以被程序所知道，定义负责创建与名字关联的实体（变量空间）。多个文件可以独立编译。声明并没有申请对象空间（变量空间）。 +- extern 可以声明，而不进行定义。变量可以被声明很多次，但只能被定义一次。不能再函数体中对 extern 声明的变量进行修改，extern 声明的变量只能是外部变量。 +- 函数不需要使用extern即可实现声明和定义分离。 +- 多次声明必须兼容，类型一致。 + +``` +extern int i;//声明，但没有申请对象空间。 +int j;//声明并定义了，申请了兑现该控件 +``` + +### 变量的定义和初始化 + +变量定义的时候，编译器会分配内存空间。并执行初始化函数。 + +- 默认初始化：变量没有被显示初始化。 +- 值初始化：() +- 直接初始化：使用(val)进行初始化。 +- 拷贝初始化：使用=进行初始化 +- 列表初始化：使用{}进行初始化。 + +``` +int d;//默认初始化 +int d();//值初始化 +int d(1);//直接初始化 +int d = 1;//复制初始化 +int e = {2};//复制初始化 +int f{3};//花括号列表初始化 +``` + +> 初始化相关的内容参考[初始化的方法](../面试/11.初始化的方法.md)。 +> +> 初始化和赋值是两个不同点操作。使用等号能够表示赋值，也能够实现初始化。 +> +> C++是静态类型语言。在编译阶段，进行类型检查。 + +## 4 标识符与关键字。 + +![](image/2021-03-03-17-45-17.png) + +## 5 作用域 + +### 作用域定义 + + +- 全局作用域：名字在所有花括号之外。 +- 块作用域：名字在其他作用域内。 + - 函数体作用域 + - 类作用域 + - 普通块作用域 + +### 作用域作用 +- 内层作用域，外层作用域。 +- 控制名称的可见性，防止出现明明冲突。 +- 在进行符号查找的时候先查找内部作用域，再查找外层作用域。直到发现符号。 + +## 6 C++中有两种类型的表达式 + +* 左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。 +* 右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。 + +* 变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。下面是一个有效的语句： \ No newline at end of file diff --git a/C++/C++基础/1.1 基本类型.md b/C++/C++基础/1.1 基本类型.md new file mode 100644 index 00000000..823f8a7b --- /dev/null +++ b/C++/C++基础/1.1 基本类型.md @@ -0,0 +1,25 @@ +# 基本内置类型 + +> 数据类型主要包含内置数据类型（算数类型（整型，浮点型），指针类型），自定义数据类型（vector=C 数组类型，string=C 字符串类型） + +## 1 基本类型 + +### 布尔型 + +* bool 1 + +### 字符型 +* char 1 +* wchar_t 2 +* char16_t +* char32_t +### 整型 +* short 2 +* int 4 +* long 4 +* long long 8 + +### 浮点型 +* float 4 +* double 8 +* long double 16 diff --git a/C++/C++基础/1.2 复合类型.md b/C++/C++基础/1.2 复合类型.md new file mode 100644 index 00000000..de37bf8f --- /dev/null +++ b/C++/C++基础/1.2 复合类型.md @@ -0,0 +1,184 @@ + +# 复合类型 + +## 1 引用 +- 由基本类型组合而来。不能单独存在。 +- int &ref=a.表示对 a 的引用。引用本身并非对象，只是已经存在的对象的别名 +- 引用必须在定义的时候被初始化。 +- 引用是变量的别名，具有同一个变量地址（变量空间）。 +- 允许多个连续的引用 + int &r=i,r2=i2.表示 r 是 i 的引用，但 r2 是 int +- 连续定义必须都加引用符号。 + int &r=i,&r2=i2; + > 编译过程解释：一般初始化的时候（变量定义），编译器会将一个值拷贝到新建的变量空间中，然后与变量绑定。引用变量在初始化的时候，不进行拷贝，而是将原来的变量空间与新的对象绑定在一起。 + +## 2 指针 + +### 指针的定义 +- 实现了间接访问。本身是一个对象。与引用不同，指针有自己的变量空间。 +- 允许对指针进行复制和 copy。 +- int\* dp,dp1.其中 dp 是 int 指针，dp1 是 int 类型。 +- 不能定义指向引用的指针，因为引用不是对象，没有内存空间。 +- 连续定义，必须都加\*号 + +### 指针值的四种状态 + +- 指向一个对象； +- 指向紧邻对象所占空间的下一个位置； +- 空指针意味着指针没有指向任何对象； +- 无效指针，指针指向的位置被释放。 + +### 指针访问 + +- 利用指针运算符访问指针指向的对象（\*p） +- 空指针的生成方法 + +``` +int *p1 = nullptr; +``` + +### `void*` + +- 可以存放任意对象的地址。 + +### 复合类型的声明 +``` +int *p1,p2; +``` +* p1 是指向 int 的指针，p2 是 int 类型的。 + +### 指向指针的指针 +``` +int i=0; +int *p1=&i; +int **p2 = &p1 +``` + + + +## 3 数组 + +### 定义和初始化内置数组 + +``` +int arr[10];//含有10个整型的数组 +int *arr[20];//含有20个整形指针的数组。指针数组 +int (*ptr)[10];指向含有是个整数的数组的指针。数组的指针（常量的指针和指针类型的常量类似） + +string arr[10];//含有10个string对象的数组C++11允许数组为对象类型。 +``` + +### 数组的初始化（仅有两种方法） + +``` +int arr[3]={1,2,3}; +int arr[]={1,2,3,4}; +char a3[]="c++"//自动添加表示字符串结束的空字符 +``` + +### 数组的遍历 + +- C++11 数组也可以使用容器遍历（集合遍历） + +``` +//下标遍历 + int m[5]={1,2,3,4,5}; + for(int i=0;i<5;i++){ + cout< 尽量不要使用 C 风格的字符串.C++风格的字符串可以完全替代 C 风格的字符串，并且可以使用字符数组代替 C 风格的字符串。 \ No newline at end of file diff --git a/C++/C++基础/1.3 自定义数据类型.md b/C++/C++基础/1.3 自定义数据类型.md new file mode 100644 index 00000000..6b313bd0 --- /dev/null +++ b/C++/C++基础/1.3 自定义数据类型.md @@ -0,0 +1,67 @@ +# 自定义数据类型 +> 自定义类型的变量，一般称为对象。 +## 类类型 +### 类型定义 +包括以下两类成员 +- 数据成员 +- 成员函数 +``` +class Data{ +public: + int m; + int n; + int hello(){ + return 1; + } +} +``` + +### 变量对象定义 +``` +Data a,b; +``` + +### 变量对象使用 +``` +a.m; +a.hello(); +``` + + +## 2 结构体类型 + +### 类型定义 +``` +struct data{ + std::string bookNo; + unsigned sold = 0; + double revenue = 0.0; +}; +``` + +### 变量对象定义 + +### 变量对象使用 + + +## 3 枚举类型 + +### 类型定义 + + +### 变量对象定义 + +### 变量对象使用 + + + +## 4 联合体类型 + + +### 类型定义 + + +### 变量对象定义 + +### 变量对象使用 + diff --git a/C++/C++基础/1.4 类型修饰和处理.md b/C++/C++基础/1.4 类型修饰和处理.md new file mode 100644 index 00000000..d0a0704a --- /dev/null +++ b/C++/C++基础/1.4 类型修饰和处理.md @@ -0,0 +1,241 @@ +# 类型的修饰和处理 + +> 目录 +> * [类型转换]() +> * [类型别名]() +> * [类型修饰]() + +## 1 类型转换 + +> [参考](../面试/10.强制类型转换.md) + +### 隐式类型转换 +### 强制类型转化 +* C风格类型转换 +* C++风格类型转换。 + +## 2 类型别名 + +### typedef + +- typedef 使用最后一个名词作为名字 + +``` +typedef double hello; +typedef double* p; +typedef int h[81]; +typedef　struct　tag +{ +int　iNum; +long　lLength; +}MyStruct;//定义了结构体；typedef struct tag MyStruct +``` + +### using + +- 类型别名和类型等价 + +``` +using si = Sales_item;//类的别名 +``` + + +## 3 类型修饰 + + +> 常见的类型修饰符：signed、unsigned、long、short、const、static、extern、auto、register、mutable、thread_local、volatile、restrict + + + +### 简单对比 +* auto 默认存储类别，自动变量int i = 3; +* static 静态存储类别的变量，静态变量static int m = 5; +* register 寄存器变量register n = 6; +* volatile限定：隐式存取变量。不会被优化，不会从寄存器中读取变量，而是直接从内存中读取变量。 +* extern 声明外部链接属性 +* const：制度变量、常变量 const int i = 6;必须直接初始化，避免对重要手进行错误修改。 +* mutable：可以修改类内部的变量值。 + + + +## 3.1 符号signed/unsigned + +- signed 有符号 +- unsigned 无符号 + + +## 3.2 自动变量auto + + +- 声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。 + +```C +auto f=3.14; //double +auto s("hello"); //const char* +auto z = new auto(9); // int* +auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型 +auto item = val1 +val2 +``` + + +## 3.3 声明修饰符extern + +1. extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 'extern' 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。 + +2. 当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。 + +3. extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候 +```C +//文件2 +#include + +int count ; +extern void write_extern(); + +int main() +{ + count = 5; + write_extern(); +} + +//文件1 +#include + +extern int count; + +void write_extern(void) +{ + std::cout << "Count is " << count << std::endl; +} +``` + +## 3.4 静态修饰符static +1. static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。 +2. static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。 +3. 在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。 + +```C +#include + +// 函数声明 +void func(void); + +static int count = 10; /* 全局变量 */ + +int main() +{ + while(count--) + { + func(); + } + return 0; +} +// 函数定义 +void func( void ) +{ + static int i = 5; // 局部静态变量 + i++; + std::cout << "变量 i 为 " << i ; + std::cout << " , 变量 count 为 " << count << std::endl; +} +``` + +## 3.5 寄存器内存register/volatile +* volatile内存变量。告诉编译器不需要优化volatile声明的变量，让程序可以直接从内存中读取变量。对于一般的变量编译器会对变量进行优化，将内存中的变量值放在寄存器中以加快读写效率。 +* register寄存器变量。register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。 +```C +{ + register int miles; +} +``` + + +## 3.6 线程变量thread_local + +* 使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 每个线程都有其自己的变量副本。 + +* thread_local 说明符可以与 static 或 extern 合并。 + +* 可以将 thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义。 + + +```C +thread_local int x; // 命名空间下的全局变量 +class X +{ + static thread_local std::string s; // 类的static成员变量 +}; +static thread_local std::string X::s; // X::s 是需要定义的 + +void foo() +{ + thread_local std::vector v; // 本地变量 +} +``` + +## 3.7 const 限定符 + +### 特点 + +- 它的值不能被改变。 +- 仅在文件内有效。多个文件出现了同名的 const 变量时，等同于在不同文件中分别定义了独立变量。 + +### 使用 + +- const 的值是常量表达式，则直接在头文件中定义`const a = 3*5`，include 这个头文件就能使用 const a 的值。 +- const 的初始值通过函数计算得出，不是常量表达式；const 变量需要在不同的文件间共享，需要在头文件中 extern 声明，在 cpp 文件中进行定义。 +![](image/2021-03-04-10-42-02.png) + +### const引用 + +- const 引用，可以引用一个常量、变量，生成一个只读的变量。 + +``` +int i =1; +const int &r2 =i; +``` + +### const指针 + +- “指向常量的指针” + > 指针指向的值不能修改。 + +``` +const double * cptr = π +``` + +![](image/2021-03-04-10-48-02.png) + +- 指向非常量的“指向常量的指针” + +``` +double a = 3; +const double *b = &a +``` + +- 指针常量。 + > 指针本身的地址不能被修改。 + +``` +int n = 0; +int *const nptr = &n; +``` + +- 顶层 const 表示指针本身是个常量。 +- 底层 const 表示指针所指向的对象是一个常量。 + +### 常量表达式 + +- 常量表达式值不会改变，并且在编译过程中就能得到计算结果的表达式。 +- 字面值是常量表达式 +- 用常量表达式初始化 const 变量也是常量表达式。 + +``` +const int max = 20;//是 +const int limt = max +1;//是 +int a =27//不是，左值不是常量表达式 +const int sz = get_size();//不是，右值不是常量表达式 +``` + +## 3.8 可变修饰符mutable +* mutable 说明符仅适用于类的对象。它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。 diff --git a/C++/C++基础/12 关键词解释.md b/C++/C++基础/12 关键词解释.md index db1cd61e..386f94e6 100644 --- a/C++/C++基础/12 关键词解释.md +++ b/C++/C++基础/12 关键词解释.md @@ -79,12 +79,13 @@ using SI = Sales_item; ## 6 auto ### 基本使用 -* 编译器自动分析类型 ``` auto item = val1 +val2 ``` +### 原理 +* 编译器自动分析类型 ## 7 decltype ### 基本使用 @@ -95,4 +96,81 @@ decltype(f()) sum =x; ### 原理 * 根据表达式推断类型，而不会计算表达式。类型推断。 -> 略过的constexp, \ No newline at end of file +> 略过的constexp, + + +## 8 volatile + +### 基本使用 + +``` +volatile data-definition; +``` + +### 原理 +关键字 volatile 是与 const 绝对对立的。它指示一个变量也许会被某种方式修改，这种方式按照正常程序流程分析是无法预知的（例如，一个变量也许会被一个中断服务程序所修改）。这个关键字使用下列语法定义： + +变量如果加了 volatile 修饰，则会从内存重新装载内容，而不是直接从寄存器拷贝内容。  + +volatile应用比较多的场合，在中断服务程序和cpu相关寄存器的定义。 + +## 9 extern "C" + +### 使用 + +```C +//moduleA头文件 +#ifndef __MODULE_A_H //对于模块A来说，这个宏是为了防止头文件的重复引用 +#define __MODULE_A_H +int fun(int, int); +#endif + +//moduleA实现文件moduleA.C //模块A的实现部分并没有改变 +#include"moduleA" +int fun(int a, int b) +{ +return a+b; +} + +//moduleB头文件 +#idndef __MODULE_B_H //很明显这一部分也是为了防止重复引用 +#define __MODULE_B_H +#ifdef __cplusplus //而这一部分就是告诉编译器，如果定义了__cplusplus(即如果是cpp文件， +extern "C"{ //因为cpp文件默认定义了该宏),则采用C语言方式进行编译 +#include"moduleA.h" +#endif +… //其他代码 + +#ifdef __cplusplus +} +#endif +#endif + +//moduleB实现文件 moduleB.cpp //B模块的实现也没有改变，只是头文件的设计变化了 +#include"moduleB.h" +int main() +{ +　　cout< 尽量不要使用 C 风格的字符串.C++风格的字符串可以完全替代 C 风格的字符串，并且可以使用字符数组代替 C 风格的字符串。 - -### 多维数组定义和初始化 - -* 列表初始化支持只初始化局部元素 -``` -int ia[2][3]={ - {1,2,3}, - {4,5,6} -};//等价 -int ib[2][3]={1,2,3,4,5,6}//等价 -``` -### 多维数组的引用 - - -``` -ia[2][3] -``` -### 多维数组的遍历 -* 两层for循环处理多维数组 -``` -int ia[row_cnt][col_cnt] -for(int i=0;i - 继承 > - 多态 -## 1 定义抽象数据类型（抽象） +## 1 类的构成——抽象 ### 概念 @@ -14,20 +14,20 @@ - 类的接口包括用户所能执行的操作；类的实现包括类的数据成员、负责接口实现的函数体以及定义类所需要的的各种私有函数。 - 封装实现了类的接口和实现的分离。 -### 设计类 +### 类成员 -- 定义包含数据成员和成员函数 +- 定义包含**数据成员**和**成员函数** - 定义在类内部的函数是隐式的 inline 函数！ -### this 指针 +### this指针 - this 指针。用来指明当前绑定的对象。只在依赖对象的函数中添加 this 指针。 -### 常量成员函数 +### 常量成员 - 常量成员函数。const 关键字放在成员函数的参数列表之后。常量函数的 this 指针指向常量对象。不能对常量对象内数据进行修改。 -``` +```C++ class A{ const int getM(){//表示返回值是const类型的 @@ -72,12 +72,13 @@ hello{ } ``` -## 2 访问控制与封装（封装） +## 2 访问控制——封装 ### 访问说明符 - public，对外部函数可见。 - private，被类成员访问，但不能被外部访问。private 部分封装了类的实现细节。 +- protect，对子类可见 ### 定义类 diff --git a/C++/C++基础/8 自定义类型-枚举和联合.md b/C++/C++基础/8 自定义类型-枚举和联合.md new file mode 100644 index 00000000..1000bda7 --- /dev/null +++ b/C++/C++基础/8 自定义类型-枚举和联合.md @@ -0,0 +1,64 @@ +# 复杂类型 + +> 除了类之外还有Union、Enum连个特殊的类型。 + + +## Union +### 概念 + +union即为联合，它是一种特殊的类。通过关键字union进行定义，一个union可以有多个数据成员。 + +``` +union Token{ + char cval; + int ival; + double dval; +}; +``` + +### 用法 + +1. 互斥赋值。在任意时刻，联合中只能有一个数据成员可以有值。当给联合中某个成员赋值之后，该联合中的其它成员就变成未定义状态了。 +``` + +Token token; + +token.cval = 'a'; + +token.ival = 1; + +token.dval = 2.5; +``` +2. 访问权限。联合可以为其成员指定public、protected和private等访问权限，默认情况下，其成员的访问权限为public。 +3. 为成员指定长度。联合的存储空间至少能够容纳其最大的数据成员。也可以为联合的成员指定长度。通过冒号操作符来实现成员长度的指定。 +```C +union U { + unsigned short int aa; + struct { + unsigned int bb : 7;//(bit 0-6) + unsigned int cc : 6;//(bit 7-12) + unsigned int dd : 3;//(bit 13-15) + }; +} u; +``` + +## Enum + +### 定义 + +* 枚举类型的定义：枚举类型(enumeration)是 C++ 中的一种派生数据类型，它是由用户定义的若干枚举常量的集合。枚举类型的定义格式为： +* 关键字enum——指明其后的标识符是一个枚举类型的名字。 +* 枚举常量表——由枚举常量构成。"枚举常量"或称"枚举成员"，是以标识符形式表示的整型量，表示枚举类型的取值。枚举常量表列出枚举类型的所有取值，各枚举常量之间以"，"间隔，且必须各不相同。取值类型与条件表达式相同。 +``` +enum <类型名> {<枚举常量表>}; +``` + +### 用法 + +* 用来声明一个两所有可能的取值。使用标识符表示其种类。 + +### 应用举例 +``` +enum color_set1 {RED, BLUE, WHITE, BLACK}; // 定义枚举类型color_set1 +enum week {Sun, Mon, Tue, Wed, Thu, Fri, Sat}; // 定义枚举类型week +``` \ No newline at end of file diff --git a/C++/mianshi.cpp b/C++/mianshi.cpp index 5e6ca791..ff9a549d 100644 --- a/C++/mianshi.cpp +++ b/C++/mianshi.cpp @@ -3,5 +3,6 @@ using namespace std; int main(){ - + int b =1; + return 0; } \ No newline at end of file diff --git a/C++/标准库/15 C库整理.md b/C++/标准库/15 C库整理.md new file mode 100644 index 00000000..d4596c7f --- /dev/null +++ b/C++/标准库/15 C库整理.md @@ -0,0 +1,223 @@ +> 目录 +> * cstring 字符串和内存复制 +> * cstdlib 字符串和内存分配 +> * cstdio 输入输出 +> * cmath 数学函数 +> * ctime 时间函数 + +## 1 头文件cstring + +``` +#include +``` + +| 函数 | 描述 | +|---|---| +| void *memchr(const void *str, int c, size_t n)|在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置。 | +| int memcmp(const void *str1, const void *str2, size_t n)|把 str1 和 str2 的前 n 个字节进行比较。 | +| void *memcpy(void *dest, const void *src, size_t n)|从 src 复制 n 个字符到 dest。 | +| void *memmove(void *dest, const void *src, size_t n)|另一个用于从 src 复制 n 个字符到 dest 的函数。 | +| void *memset(void *str, int c, size_t n)|复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。 | +| char *strcat(char *dest, const char *src)|把 src 所指向的字符串追加到 dest 所指向的字符串的结尾。 | +| char *strncat(char *dest, const char *src, size_t n)|把 src 所指向的字符串追加到 dest 所指向的字符串的结尾，直到 n 字符长度为止。 | +| char *strchr(const char *str, int c)|在参数 str 所指向的字符串中搜索第一次出现字符 c（一个无符号字符）的位置。 | +| int strcmp(const char *str1, const char *str2)|把 str1 所指向的字符串和 str2 所指向的字符串进行比较。 | +| int strncmp(const char *str1, const char *str2, size_t n)|把 str1 和 str2 进行比较，最多比较前 n 个字节。 | +| int strcoll(const char *str1, const char *str2)|把 str1 和 str2 进行比较，结果取决于 LC_COLLATE 的位置设置。 | +| char *strcpy(char *dest, const char *src)|把 src 所指向的字符串复制到 dest。 | +| char *strncpy(char *dest, const char *src, size_t n)|把 src 所指向的字符串复制到 dest，最多复制 n 个字符。 | +| size_t strcspn(const char *str1, const char *str2)|检索字符串 str1 开头连续有几个字符都不含字符串 str2 中的字符。 | +| char *strerror(int errnum)|从内部数组中搜索错误号 errnum，并返回一个指向错误消息字符串的指针。 | +| size_t strlen(const char *str)|计算字符串 str 的长度，直到空结束字符，但不包括空结束字符。 | +| char *strpbrk(const char *str1, const char *str2)|检索字符串 str1 中第一个匹配字符串 str2 中字符的字符，不包含空结束字符。也就是说，依次检验字符串 str1 中的字符，当被检验字符在字符串 str2 中也包含时，则停止检验，并返回该字符位置。 | +| char *strrchr(const char *str, int c)|在参数 str 所指向的字符串中搜索最后一次出现字符 c（一个无符号字符）的位置。 | +| size_t strspn(const char *str1, const char *str2)|检索字符串 str1 中第一个不在字符串 str2 中出现的字符下标。 | +| char *strstr(const char *haystack, const char *needle)|在字符串 haystack 中查找第一次出现字符串 needle（不包含空结束字符）的位置。 | +| char *strtok(char *str, const char *delim)|分解字符串 str 为一组字符串，delim 为分隔符。 | +| size_t strxfrm(char *dest, const char *src, size_t n)|根据程序当前的区域选项中的 LC_COLLATE 来转换字符串 src 的前 n 个字符，并把它们放置在字符串 dest 中。 | + +## 2 头文件cstdlib + +``` +#include +``` +### 字符串相关 +| 函数 | 描述 | +|---|----| +| double atof(const char *str)|把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型）。 | +| int atoi(const char *str)|把参数 str 所指向的字符串转换为一个整数（类型为 int 型）。 | +| long int atol(const char *str)|把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）。 | +| double strtod(const char *str, char **endptr)|把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型）。 | +| long int strtol(const char *str, char **endptr, int base)|把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）。 | +| unsigned long int strtoul(const char *str, char **endptr, int base)|把参数 str 所指向的字符串转换为一个无符号长整数（类型为 unsigned long int 型）。 | + +### 内存分配 +| 函数 | 描述 | +|---|----| +| void *calloc(size_t nitems, size_t size)|分配所需的内存空间，并返回一个指向它的指针。 | +| void free(void *ptr)|释放之前调用 calloc、malloc 或 realloc 所分配的内存空间。 | +| void *malloc(size_t size)|分配所需的内存空间，并返回一个指向它的指针。 | +| void *realloc(void *ptr, size_t size)|尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。 | + +### 随机数 +| 函数 | 描述 | +|---|----| +int rand(void)|返回一个范围在 0 到 RAND_MAX 之间的伪随机数。 +void srand(unsigned int seed)|该函数播种由函数 rand 使用的随机数发生器。 + +### 系统函数 + +| 函数 | 描述 | +|---|----| +void abort(void)|使一个异常程序终止。 +int atexit(void (*func)(void))|当程序正常终止时，调用指定的函数 func。 +void exit(int status)|使程序正常终止。 +char *getenv(const char *name)|搜索 name 所指向的环境字符串，并返回相关的值给字符串。 +int system(const char *string)|由 string 指定的命令传给要被命令处理器执行的主机环境。 + + +## 3 头文件cstdio + +```C +#include +``` +### 文件函数 + +* File access: + +| 函数 | 描述 | +|---|----| +fclose +Close file (function ) +fflush +Flush stream (function ) +fopen +Open file (function ) +freopen +Reopen stream with different file or mode (function ) +setbuf +Set stream buffer (function ) +setvbuf +Change stream buffering (function ) + +* Direct input/output: + +| 函数 | 描述 | +|---|----| +fread +Read block of data from stream (function ) +fwrite +Write block of data to stream (function ) + +* File positioning: + +| 函数 | 描述 | +|---|----| +fgetpos +Get current position in stream (function ) +fseek +Reposition stream position indicator (function ) +fsetpos +Set position indicator of stream (function ) +ftell +Get current position in stream (function ) +rewind +Set position of stream to the beginning (function ) + +* Error-handling: + +| 函数 | 描述 | +|---|----| +clearerr +Clear error indicators (function ) +feof +Check end-of-file indicator (function ) +ferror +Check error indicator (function ) +perror +Print error message (function ) + + +### 格式化输入输出函数 + +Formatted input/output: + +| 函数 | 描述 | +|---|----| +fprintf +Write formatted data to stream (function ) +fscanf +Read formatted data from stream (function ) +printf +Print formatted data to stdout (function ) +scanf +Read formatted data from stdin (function ) +snprintf +Write formatted output to sized buffer (function ) +sprintf +Write formatted data to string (function ) +sscanf +Read formatted data from string (function ) +vfprintf +Write formatted data from variable argument list to stream (function ) +vfscanf +Read formatted data from stream into variable argument list (function ) +vprintf +Print formatted data from variable argument list to stdout (function ) +vscanf +Read formatted data into variable argument list (function ) +vsnprintf +Write formatted data from variable argument list to sized buffer (function ) +vsprintf +Write formatted data from variable argument list to string (function ) +vsscanf +Read formatted data from string into variable argument list (function ) + + +### 字符输入输出函数 + +Character input/output: + + +| 函数 | 描述 | +|---|----| +fgetc +Get character from stream (function ) +fgets +Get string from stream (function ) +fputc +Write character to stream (function ) +fputs +Write string to stream (function ) +getc +Get character from stream (function ) +getchar +Get character from stdin (function ) +gets +Get string from stdin (function ) +putc +Write character to stream (function ) +putchar +Write character to stdout (function ) +puts +Write string to stdout (function ) +ungetc +Unget character from stream (function ) + + +## 5 头文件ctime + +``` +#include +``` + + +| 函数 | 描述 | +|---|----| +char *asctime(const struct tm *timeptr)|返回一个指向字符串的指针，它代表了结构 timeptr 的日期和时间。 +clock_t clock(void)|返回程序执行起（一般为程序的开头），处理器时钟所使用的时间。|char *ctime(const time_t *timer)|返回一个表示当地时间的字符串，当地时间是基于参数 timer。|double difftime(time_t time1, time_t time2)|返回 time1 和 time2 之间相差的秒数 (time1-time2)。 +struct tm *gmtime(const time_t *timer)|timer 的值被分解为 tm 结构，并用协调世界时（UTC）也被称为格林尼治标准时间（GMT）表示。 +struct tm *localtime(const time_t *timer)|timer 的值被分解为 tm 结构，并用本地时区表示。 +time_t mktime(struct tm *timeptr)|把 timeptr 所指向的结构转换为一个依据本地时区的 time_t 值。 +size_t strftime(char *str, size_t maxsize, const char *format, const struct tm *timeptr)|根据 format 中定义的格式化规则，格式化结构 timeptr 表示的时间，并把它存储在 str 中。 +time_t time(time_t *timer)|计算当前日历时间，并把它编码成 time_t 格式。 \ No newline at end of file diff --git a/C++/标准库/5 字符串.md b/C++/标准库/5 字符串.md index 35527fb5..de82148a 100644 --- a/C++/标准库/5 字符串.md +++ b/C++/标准库/5 字符串.md @@ -290,54 +290,20 @@ int main() ### 头文件 ``` #include -#include -``` -### 方法 - -| 函数 | 描述 | -|---|---| -| void *memchr(const void *str, int c, size_t n)|在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置。 | -| int memcmp(const void *str1, const void *str2, size_t n)|把 str1 和 str2 的前 n 个字节进行比较。 | -| void *memcpy(void *dest, const void *src, size_t n)|从 src 复制 n 个字符到 dest。 | -| void *memmove(void *dest, const void *src, size_t n)|另一个用于从 src 复制 n 个字符到 dest 的函数。 | -| void *memset(void *str, int c, size_t n)|复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。 | -| char *strcat(char *dest, const char *src)|把 src 所指向的字符串追加到 dest 所指向的字符串的结尾。 | -| char *strncat(char *dest, const char *src, size_t n)|把 src 所指向的字符串追加到 dest 所指向的字符串的结尾，直到 n 字符长度为止。 | -| char *strchr(const char *str, int c)|在参数 str 所指向的字符串中搜索第一次出现字符 c（一个无符号字符）的位置。 | -| int strcmp(const char *str1, const char *str2)|把 str1 所指向的字符串和 str2 所指向的字符串进行比较。 | -| int strncmp(const char *str1, const char *str2, size_t n)|把 str1 和 str2 进行比较，最多比较前 n 个字节。 | -| int strcoll(const char *str1, const char *str2)|把 str1 和 str2 进行比较，结果取决于 LC_COLLATE 的位置设置。 | -| char *strcpy(char *dest, const char *src)|把 src 所指向的字符串复制到 dest。 | -| char *strncpy(char *dest, const char *src, size_t n)|把 src 所指向的字符串复制到 dest，最多复制 n 个字符。 | -| size_t strcspn(const char *str1, const char *str2)|检索字符串 str1 开头连续有几个字符都不含字符串 str2 中的字符。 | -| char *strerror(int errnum)|从内部数组中搜索错误号 errnum，并返回一个指向错误消息字符串的指针。 | -| size_t strlen(const char *str)|计算字符串 str 的长度，直到空结束字符，但不包括空结束字符。 | -| char *strpbrk(const char *str1, const char *str2)|检索字符串 str1 中第一个匹配字符串 str2 中字符的字符，不包含空结束字符。也就是说，依次检验字符串 str1 中的字符，当被检验字符在字符串 str2 中也包含时，则停止检验，并返回该字符位置。 | -| char *strrchr(const char *str, int c)|在参数 str 所指向的字符串中搜索最后一次出现字符 c（一个无符号字符）的位置。 | -| size_t strspn(const char *str1, const char *str2)|检索字符串 str1 中第一个不在字符串 str2 中出现的字符下标。 | -| char *strstr(const char *haystack, const char *needle)|在字符串 haystack 中查找第一次出现字符串 needle（不包含空结束字符）的位置。 | -| char *strtok(char *str, const char *delim)|分解字符串 str 为一组字符串，delim 为分隔符。 | -| size_t strxfrm(char *dest, const char *src, size_t n)|根据程序当前的区域选项中的 LC_COLLATE 来转换字符串 src 的前 n 个字符，并把它们放置在字符串 dest 中。 | - -### 头文件 - -``` #include +#include ``` + ### 方法 -| 函数 | 描述 | -|---|----| -| double atof(const char *str)|把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型）。 | -| int atoi(const char *str)|把参数 str 所指向的字符串转换为一个整数（类型为 int 型）。 | -| long int atol(const char *str)|把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）。 | -| double strtod(const char *str, char **endptr)|把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型）。 | -| long int strtol(const char *str, char **endptr, int base)|把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）。 | -| unsigned long int strtoul(const char *str, char **endptr, int base)|把参数 str 所指向的字符串转换为一个无符号长整数（类型为 unsigned long int 型）。 | -| void *calloc(size_t nitems, size_t size)|分配所需的内存空间，并返回一个指向它的指针。 | -| void free(void *ptr)|释放之前调用 calloc、malloc 或 realloc 所分配的内存空间。 | -| void *malloc(size_t size)|分配所需的内存空间，并返回一个指向它的指针。 | -| void *realloc(void *ptr, size_t size)|尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。 | +| 名称 | 函数 & 目的 | +|---|---| +| strcpy(s1, s2); | 复制字符串 s2 到字符串 s1。 | +| strcat(s1, s2); | 连接字符串 s2 到字符串 s1 的末尾。连接字符串也可以用 + 号，例如:string str1 = "runoob";string str2 = "google";string str = str1 + str2; | +| strlen(s1); | 返回字符串 s1 的长度。 | +| strcmp(s1, s2); | 如果 s1 和 s2 是相同的，则返回 0；如果 s1s2 则返回值大于 0。 | +| strchr(s1, ch); | 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。 | +| strstr(s1, s2); | 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。 | ## 7 字符串分割的两种处理方式 diff --git a/C++/标准库/5.1 字符串类封装.md b/C++/标准库/5.1 字符串类封装.md new file mode 100644 index 00000000..af5316f3 --- /dev/null +++ b/C++/标准库/5.1 字符串类封装.md @@ -0,0 +1,138 @@ +```C +/* +* C++ string 类的实现 +* 1. 构造函数和析构函数 +* 2. 字符串长度 +* 3. 重载=运算符 +* 4. 重载+=运算符 +* 5. 重载<< >> 运算符 +* 6. 重载比较运算符 +* 7. 重载[]下标运算符 +*/ + +#include +#include +using namespace std; + +class MyString +{ +private: + char * str; + int length; +public: + // 长度 + int size ()const { + return length; + }; + char* getstr()const{ + return str; + } + // 默认构造函数 + MyString(); + // 字符串构造函数 + MyString(const char*); + // 复制构造函数 + MyString(const MyString& b); + + // 重载等号运算符 + MyString& operator=(const MyString &b); + // 重载+=运算符 + MyString& operator+=(const MyString &b); + // 重载比较运算符 + bool operator<(const MyString &b); + // 重载下标运算符 + char& operator[](const int &index) const ; + // 重载输入输出操作 + friend ostream& operator<<(ostream& ,const MyString &b); + ~MyString(); +}; + +MyString::MyString() +{ + str = new char[1]; + str[0]='\0'; + length = 0; +} + +MyString::MyString(const char* b){ + if(b){ + length = strlen(b); + str = new char[length+1]; + strcpy(str,b); + } + else{ + MyString(); + } +} +MyString::MyString(const MyString&b){ + length = b.size(); + if(length>0) + str = new char[length+1]; + else + MyString(); +} + +MyString& MyString::operator=(const MyString &b){ + if(&b == this){ + return *this; + } + delete[] str; + length = b.size(); + str = new char[length + 1]; + strcpy(str,b.getstr()); + return *this; +} + +MyString& MyString::operator+=(const MyString&b){ + if(b.size()==0){ + return *this; + } + char* temp = new char[length+b.length+1]; + strcpy(temp,str); + strcat(temp,b.getstr()); + delete[] str; + str = temp; + return *this; +} + +char& MyString::operator[](const int &index)const { + if(index>length)return str[length]; + return str[index]; +} + +bool MyString::operator<(const MyString &b){ + for(int i=0;ib.size())return false; + if(b[i]>str[i])return true; + if(b[i]:通过指针方位类成员的运算符。 +``` +6. 自增运算符（++）与自减运算符（--）由于自增和自减运算符是单目运算符，在重载时应该是没有参数的，但是又有前置与后置之分，例如++i与i++。为了隽星区分，C++做了规定； +```C +Time operator++() //前置 +Time operator++(int) //后置 +``` + + +## 2 成员函数重载 + +### 成员函数重载格式 + +* 将操作符重载为成员函数。 +* 此时类的对象作为操作符的第一个操作数。流输入输出运算符无法通过这样的方式重载，因为对象本身应该作为第二个操作数，只能通过友元函数的方式对操作进行重载。 + +```C++ +class MyString{ +public: + // 重载等号运算符 + MyString& operator=(const MyString &b); + // 重载+=运算符 + MyString& operator+=(const MyString &b); +} +``` + +## 3 友元重载 + +### 友元的格式 + C++中友元有三种，分别是友元函数，友元类，友元成员函数，这里介绍的是友元函数。 + +1. 创建友元函数的第一步是声明，友元函数的声明放在类的声明中，并且在前面加上friend关键字。例如； +```C +friend ostream& operator<<(ostream &os, const Time &t); +``` +2. 第二步是定义友元，友元可以直接在声明的时候进行定义，即内联的定义。也可以定义在类外，定义在类外时，不需要加类作用域运算符，也不需要有friend关键字。 + + +```C +//友元在类外定义的时候，不需要添加friend； +ostream & operator<<(ostream &os, const Time &t) +{ + os << "hours:" << t.hours << " " << "mintues:" << t.mintues << " "; + return os; +} +``` + +### 友元使用 +与普通的运算符重载成员函数一样，友元也可以直接调用 +```C +cout<> 运算符 +* 6. 重载比较运算符 +* 7. 重载[]下标运算符 +*/ + +#include +#include +using namespace std; + +class MyString +{ +private: + char * str; + int length; +public: + // 长度 + int size ()const { + return length; + }; + char* getstr()const{ + return str; + } + // 默认构造函数 + MyString(); + // 字符串构造函数 + MyString(const char*); + // 复制构造函数 + MyString(const MyString& b); + + // 重载等号运算符 + MyString& operator=(const MyString &b); + // 重载+=运算符 + MyString& operator+=(const MyString &b); + // 重载比较运算符 + bool operator<(const MyString &b); + // 重载下标运算符 + char& operator[](const int &index) const ; + // 重载输入输出操作 + friend ostream& operator<<(ostream& ,const MyString &b); + ~MyString(); +}; + +MyString::MyString() +{ + str = new char[1]; + str[0]='\0'; + length = 0; +} + +MyString::MyString(const char* b){ + if(b){ + length = strlen(b); + str = new char[length+1]; + strcpy(str,b); + } + else{ + MyString(); + } +} +MyString::MyString(const MyString&b){ + length = b.size(); + if(length>0) + str = new char[length+1]; + else + MyString(); +} + +MyString& MyString::operator=(const MyString &b){ + if(&b == this){ + return *this; + } + delete[] str; + length = b.size(); + str = new char[length + 1]; + strcpy(str,b.getstr()); + return *this; +} + +MyString& MyString::operator+=(const MyString&b){ + if(b.size()==0){ + return *this; + } + char* temp = new char[length+b.length+1]; + strcpy(temp,str); + strcat(temp,b.getstr()); + delete[] str; + str = temp; + return *this; +} + +char& MyString::operator[](const int &index)const { + if(index>length)return str[length]; + return str[index]; +} + +bool MyString::operator<(const MyString &b){ + for(int i=0;ib.size())return false; + if(b[i]>str[i])return true; + if(b[i] +using namespace std; +class complex{ +public: + complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }; +public: + friend complex operator+(const complex & A, const complex & B); + friend complex operator-(const complex & A, const complex & B); + friend complex operator*(const complex & A, const complex & B); + friend complex operator/(const complex & A, const complex & B); + friend istream & operator>>(istream & in, complex & A); + friend ostream & operator<<(ostream & out, complex & A); +private: + double m_real; //实部 + double m_imag; //虚部 +}; +//重载加法运算符 +complex operator+(const complex & A, const complex &B){ + complex C; + C.m_real = A.m_real + B.m_real; + C.m_imag = A.m_imag + B.m_imag; + return C; +} +//重载减法运算符 +complex operator-(const complex & A, const complex &B){ + complex C; + C.m_real = A.m_real - B.m_real; + C.m_imag = A.m_imag - B.m_imag; + return C; +} +//重载乘法运算符 +complex operator*(const complex & A, const complex &B){ + complex C; + C.m_real = A.m_real * B.m_real - A.m_imag * B.m_imag; + C.m_imag = A.m_imag * B.m_real + A.m_real * B.m_imag; + return C; +} +//重载除法运算符 +complex operator/(const complex & A, const complex & B){ + complex C; + double square = A.m_real * A.m_real + A.m_imag * A.m_imag; + C.m_real = (A.m_real * B.m_real + A.m_imag * B.m_imag)/square; + C.m_imag = (A.m_imag * B.m_real - A.m_real * B.m_imag)/square; + return C; +} +//重载输入运算符 +istream & operator>>(istream & in, complex & A){ + in >> A.m_real >> A.m_imag; + return in; +} +//重载输出运算符 +ostream & operator<<(ostream & out, complex & A){ + out << A.m_real <<" + "<< A.m_imag <<" i ";; + return out; +} +int main(){ + complex c1, c2, c3; + cin>>c1>>c2; + c3 = c1 + c2; + cout<<"c1 + c2 = "< +#include "mytime.h" + +using namespace std; + +//-------默认构造函数 +Time::Time() +{ + hours = mintues = 0; + cout << "调用默认构造函数" << endl; +} + +//------显式的构造函数 +Time::Time(int h, int m) :hours(h), mintues(m) +{ + cout << "调用显式构造函数" << endl; +} + +//------拷贝构造函数 +Time::Time(const Time &t) +{ + hours = t.hours; + mintues = t.mintues; + cout << "调用拷贝构造函数" << endl; +} + +//------析构函数 +Time::~Time() +{ + cout << "调用了析构函数" << endl; +} + +//-------小时相加 +void Time::AddHour(int h) +{ + hours += h; +} + +//------分钟相加 +void Time::AddMin(int m) +{ + mintues += m; + hours += mintues / 60; + mintues %= 60; +} + + +//------重载+号 +Time Time::operator+(const Time &t) const +{ + Time sum; + sum.mintues = mintues + t.mintues; + sum.hours = hours + t.hours + sum.mintues / 60; + sum.mintues = sum.mintues % 60; + return sum; +} + +//------重载-号 +Time Time::operator-(const Time &t) const +{ + Time diff; + + int time1 = hours * 60 + mintues; + int time2 = t.hours * 60 + t.mintues; + + diff.hours = (time1 - time2) / 60; + diff.mintues = (time1 - time2) % 60; + + return diff; +} + +//-------重载乘号 +Time Time::operator*(double n) const +{ + Time result; + long totalMintues = n*hours * 60 + n*mintues; + + result.hours = totalMintues / 60; + result.mintues = totalMintues % 60; + + return result; +} + + + +//-------友元输出操作符 +ostream & operator<<(ostream &os, const Time &t) //友元在类外定义的时候，不需要添加friend； +{ + os << "hours:" << t.hours << " " << "mintues:" << t.mintues << " "; + return os; +} + +//----------------------- +//main.cpp +//不用先生 +//------------------------ +#include +#include "mytime.h" + +using namespace std; + + +int main() +{ + + { + Time eat_breakfast(0, 45); + Time eat_lunch(1, 0); + Time eat_dinner(1, 30); + + + + Time swiming(0, 45); //非const对象，既可以调用const成员函数，也可以调用非const成员。 + const Time study(8, 5); //const对象只能调用const成员函数。 + + + // study_cut_swim; + Time study_cut_swim = study - swiming; //调用运算符重载后的Time类的减号； + + + Time Eat_time_day = eat_breakfast + eat_dinner + eat_lunch; //调用了重载以后的加法； + + cout << "学习比游泳多花" << study_cut_swim << endl; //调用友元输出运算符<< + cout << "每周吃饭所花费的时间为" << (7 * Eat_time_day) << endl; //调用了友元乘法以及输出运算符； + } + + + + system("pause"); + return 0; +} +``` diff --git a/C++/面向对象/3 类与对象.md b/C++/面向对象/3 类与对象.md new file mode 100644 index 00000000..bf6715a2 --- /dev/null +++ b/C++/面向对象/3 类与对象.md @@ -0,0 +1,50 @@ +# 面向对象程序设计 + +> 参考文献 +> * [多态的三种方式](https://blog.csdn.net/qq_41306849/article/details/109081625) +> * [虚继承和虚基类](http://c.biancheng.net/view/2280.html) + + +> 面向对象的基本概念 +> * 数据抽象和封装（在语法基础部分讲解过了） +> * 继承 +> * 多态（动态绑定） + + +## 1 面向对象程序设计 + +### 核心思想 +* 抽象：类的接口与实现分离。 +* 封装：隐藏内部实现细节。访问控制运算符public/private/protect +* 继承：定义相似的类型，对相似的关系建模。实现代码重用。 +* 多态：可以在以一定程度上忽略相似类型的区别。 + + +### 继承概念 + +> 继承、泛化 + +* 继承：联系在一起的类构成以中层次关系 +* 基类：层次关系的根部 +* 派生类：其他类则直接或间接地从基类继承而来。 + +* 派生类与基类的函数继承： + * 与类型相关的函数。基类与派生类类型不同，需要重写。 + * 与类型无关的函数。派生类直接继承，不需要修改。 + +* 类派生列表：派生类通过类派生列表，明确指出它的基类。 + +``` +class Dog:public Animal{ +public: + double price()const override; +} +``` + +* 派生类可以通过**override关键字**注明改写基类的函数。 + + + +### 多态（动态绑定） + +* 在运行时选择函数的版本。通过使用动态绑定，我们能用同一段代码分别处理Animal和Dog的对象。 diff --git a/C++/类设计者的工具/3.cpp b/C++/面向对象/3.cpp similarity index 100% rename from C++/类设计者的工具/3.cpp rename to C++/面向对象/3.cpp diff --git a/C++/面向对象/4 继承与派生.md b/C++/面向对象/4 继承与派生.md new file mode 100644 index 00000000..886571a2 --- /dev/null +++ b/C++/面向对象/4 继承与派生.md @@ -0,0 +1,145 @@ +# 继承与派生 +## 1 继承 + +### 定义基类 +``` +class Quote{ +public: + Quote() = default; + Quote(string book,double sales_price):book_no(book),price(sales_price){}; + string isbn()const{ + return this.book_no; + } + virtual double net_price(int n)const{ + return n*price; + } + virtual ~Quote()=default; +private: + string book_no; +protected: + double price; +}; +``` +### 定义派生类 +``` +class Bulk_quote:public Quote{ +public: + Bulk_quote()=default; + Bulk_quote(string,double,int,double); + double net_price(int n)const override; +private: + int mn_qty = 0; + double discount=0.0; +}; +Bulk_quote::Bulk_quote(string book,double p,int qty,double disc):Quote(book,p),min_qty(qty),discount(disc){}//委托基类构造函数 +``` + + +### 继承方式 + +* 单一继承：继承一个父类，这种继承称为单一继承，一般情况尽量使用单一继承，使用多重继承容易造成混乱易出问题 +* 多重继承：继承多个父类，类与类之间要用逗号隔开，类名之前要有继承权限，假使两个或两个基类都有某变量或函数，在子类中调用时需要加类名限定符如c.a::i = 1； +* 菱形继承：多重继承掺杂隔代继承1-n-1模式，此时需要用到虚继承，例如 B，C虚拟继承于A，D再多重继承B，C，否则会出错 + + +### 继承权限 +* 继承权限：继承方式规定了如何访问继承的基类的成员。继承方式指定了派生类成员以及类外对象对于从基类继承来的成员的访问权限 + +![](image/2021-03-07-14-26-29.png) + +### 注意事项 + +* 基类的静态成员变量，在整个继承体系中只存在该成员的唯一定义。 +* 派生类的声明中包含类名，但不能包含派生列表。 + +### final关键字 + +* 使用**关键字final**说明符防止类被继承 + + +* 使用**关键字final**说明符防止函数被重写 +``` +class A final{ + void f1(int) const; +}; +``` + + +## 2 访问控制与继承 + +### 访问控制 +* 派生类能够访问公有成员和受保护的成员。 +* 派生类不能访问私有成员。 + +public: +private: +protected: + +### 继承类型 + +* public 公有继承 +* private私有继承 + +### 默认的集成保护级别 + +* class关键字定义的派生类，默认是私有继承 +* struct关键字定义的派生类，默认是公有继承 + +## 3 类作用域与继承 + +### 作用域 +* 当存在继承关系是，派生类的作用域嵌套在基类的作用域内。如果一个名字在派生类的作用域内无法解析，编译器在外层的基类作用域中寻找改名字的定义。 + + +### 编译时名字查找 + +* 引用或指针的静态类型决定了该对象有哪些成员是可见的。一个基类的引用和指针只能访问基类的成员。即是动态对象是其派生类。 + +### 名字冲突与继承 +* 派生了重用定义在直接基类或间接基类中的名字，会屏蔽定义在外层作用域基类中的名字 + +### 访问隐藏的成员 + +* 通过作用域运算符来使用一个被隐藏的基类成员。 + + +## 4 类型转换与继承 +### 静态类型和动态类型 + +* 静态类型在编译时已知。是指针或者引用的类型。 +* 动态类型表示内存中的对象类型。动态类型直到运行时才可知。 + + +### 派生类到基类的类型转换。 + +* 把派生类对象当成基类对象来使用。将基类的指针或引用绑定到派生类对象。 + +### 基类到派生类的类型转换。 + +* 不存在从基类向派生类的隐式转换。 + + + +### 对象之间不存在类型转换 + +* 所谓的**类型转换只是指针或者引用的类型转换**，对象本身的类型，没有发生改变。 +* 但是派生类可以赋值给基类的对象。基类的拷贝构造函数和移动构造函数，接受一个引用对象。将派生类对象赋值给引用对象，实现基类的初始化。实际生成的是一个基类对象。 +* 这里并非多态，而是执行拷贝构造函数。创建了一个基类对象 + +``` +class A{ + +} +class B:public A{ + +} +B b(); +A a = b;//可以赋值给基类对象。执行拷贝构造函数。并非多态。 +A aa(b);//直接初始化，执行基类的拷贝构造函数。并非多态。 +``` + +### 转换规则总结 + +* 从派生类向基类的类型转换只对指针或引用有效。是指针或引用的类型转换，而不是其指向的对象的类型发生改变。 +* 基类向派生类不存在隐式类型转换 +* 派生类向基类的类型转换也可能会由于访问受限而变得不可行。 diff --git a/C++/类设计者的工具/3 面向对象程序设计.md b/C++/面向对象/5 多态与虚函数.md similarity index 66% rename from C++/类设计者的工具/3 面向对象程序设计.md rename to C++/面向对象/5 多态与虚函数.md index 405e579d..e60c0a37 100644 --- a/C++/类设计者的工具/3 面向对象程序设计.md +++ b/C++/面向对象/5 多态与虚函数.md @@ -1,119 +1,5 @@ -# 面向对象程序设计 -> 参考文献 -> * [多态的三种方式](https://blog.csdn.net/qq_41306849/article/details/109081625) -> * [虚继承和虚基类](http://c.biancheng.net/view/2280.html) - - -> 面向对象的基本概念 -> * 数据抽象和封装（在语法基础部分讲解过了） -> * 继承 -> * 多态（动态绑定） - - -## 1 OOP：概述 - -### 面向对象程序设计 - -* 核心思想： - * 数据抽象：类的接口与实现分离。 - * 继承：定义相似的类型，对相似的关系建模。实现代码重用。 - * 动态绑定：可以在以一定程度上忽略相似类型的区别。 - -### 继承概念（继承） - -* 继承：联系在一起的类构成以中层次关系 -* 基类：层次关系的根部 -* 派生类：其他类则直接或间接地从基类继承而来。 - -* 派生类与基类的函数继承： - * 与类型相关的函数。基类与派生类类型不同，需要重写。 - * 与类型无关的函数。派生类直接继承，不需要修改。 - -* 类派生列表：派生类通过类派生列表，明确指出它的基类。 - -``` -class Dog:public Animal{ -public: - double price()const override; -} -``` - -* 派生类可以通过**override关键字**注明改写基类的函数。 - - - -### 动态绑定（多态） - -* 在运行时选择函数的版本。通过使用动态绑定，我们能用同一段代码分别处理Animal和Dog的对象。 - -## 2 继承与多态详解 -## 2.1 继承 - -### 定义基类 -``` -class Quote{ -public: - Quote() = default; - Quote(string book,double sales_price):book_no(book),price(sales_price){}; - string isbn()const{ - return this.book_no; - } - virtual double net_price(int n)const{ - return n*price; - } - virtual ~Quote()=default; -private: - string book_no; -protected: - double price; -}; -``` -### 定义派生类 -``` -class Bulk_quote:public Quote{ -public: - Bulk_quote()=default; - Bulk_quote(string,double,int,double); - double net_price(int n)const override; -private: - int mn_qty = 0; - double discount=0.0; -}; -Bulk_quote::Bulk_quote(string book,double p,int qty,double disc):Quote(book,p),min_qty(qty),discount(disc){}//委托基类构造函数 -``` - - -### 继承方式 - -* 单一继承：继承一个父类，这种继承称为单一继承，一般情况尽量使用单一继承，使用多重继承容易造成混乱易出问题 -* 多重继承：继承多个父类，类与类之间要用逗号隔开，类名之前要有继承权限，假使两个或两个基类都有某变量或函数，在子类中调用时需要加类名限定符如c.a::i = 1； -* 菱形继承：多重继承掺杂隔代继承1-n-1模式，此时需要用到虚继承，例如 B，C虚拟继承于A，D再多重继承B，C，否则会出错 - - -### 继承权限 -* 继承权限：继承方式规定了如何访问继承的基类的成员。继承方式指定了派生类成员以及类外对象对于从基类继承来的成员的访问权限 - -![](image/2021-03-07-14-26-29.png) - -### 注意事项 - -* 基类的静态成员变量，在整个继承体系中只存在该成员的唯一定义。 -* 派生类的声明中包含类名，但不能包含派生列表。 - -### final关键字 - -* 使用**关键字final**说明符防止类被继承 - - -* 使用**关键字final**说明符防止函数被重写 -``` -class A final{ - void f1(int) const; -}; -``` - -## 2.2 多态 +## 1 多态 ### 多态分类 @@ -196,48 +82,7 @@ int main(){ //参考虚函数。 -## 2.3 类型转换 -### 静态类型和动态类型 - -* 静态类型在编译时已知。是指针或者引用的类型。 -* 动态类型表示内存中的对象类型。动态类型直到运行时才可知。 - - -### 派生类到基类的类型转换。 - -* 把派生类对象当成基类对象来使用。将基类的指针或引用绑定到派生类对象。 - -### 基类到派生类的类型转换。 - -* 不存在从基类向派生类的隐式转换。 - - - -### 对象之间不存在类型转换 - -* 所谓的**类型转换只是指针或者引用的类型转换**，对象本身的类型，没有发生改变。 -* 但是派生类可以赋值给基类的对象。基类的拷贝构造函数和移动构造函数，接受一个引用对象。将派生类对象赋值给引用对象，实现基类的初始化。实际生成的是一个基类对象。 -* 这里并非多态，而是执行拷贝构造函数。创建了一个基类对象 - -``` -class A{ - -} -class B:public A{ - -} -B b(); -A a = b;//可以赋值给基类对象。执行拷贝构造函数。并非多态。 -A aa(b);//直接初始化，执行基类的拷贝构造函数。并非多态。 -``` - -### 转换规则总结 - -* 从派生类向基类的类型转换只对指针或引用有效。是指针或引用的类型转换，而不是其指向的对象的类型发生改变。 -* 基类向派生类不存在隐式类型转换 -* 派生类向基类的类型转换也可能会由于访问受限而变得不可行。 - -## 3 虚函数 +## 2 虚函数 ### 虚函数的定义 * 虚函数：基类希望它的派生类自定义适合自身的版本。为了实现多态 @@ -319,45 +164,7 @@ int a： 继承A的成员 int b： B成员 ``` -## 4 访问控制与继承 - -### 访问控制 -* 派生类能够访问公有成员和受保护的成员。 -* 派生类不能访问私有成员。 - -public: -private: -protected: - -### 继承类型 - -* public 公有继承 -* private私有继承 - -### 默认的集成保护级别 - -* class关键字定义的派生类，默认是私有继承 -* struct关键字定义的派生类，默认是公有继承 - -## 5 继承中的类作用域 - -### 作用域 -* 当存在继承关系是，派生类的作用域嵌套在基类的作用域内。如果一个名字在派生类的作用域内无法解析，编译器在外层的基类作用域中寻找改名字的定义。 - - -### 编译时名字查找 - -* 引用或指针的静态类型决定了该对象有哪些成员是可见的。一个基类的引用和指针只能访问基类的成员。即是动态对象是其派生类。 - -### 名字冲突与继承 -* 派生了重用定义在直接基类或间接基类中的名字，会屏蔽定义在外层作用域基类中的名字 - -### 访问隐藏的成员 - -* 通过作用域运算符来使用一个被隐藏的基类成员。 - - -## 6 虚继承和虚基类 +## 3 虚继承和虚基类 ### 多继承 * 多继承（Multiple Inheritance）是指从多个直接基类中产生派生类的能力，多继承的派生类继承了所有父类的成员。尽管概念上非常简单，但是多个基类的相互交织可能会带来错综复杂的设计问题，命名冲突就是不可回避的一个。 diff --git a/C++/面向对象/6 模板与泛型编程.md b/C++/面向对象/6 模板与泛型编程.md new file mode 100644 index 00000000..e69de29b diff --git a/C++/类设计者的工具/image/2021-03-06-23-22-55.png b/C++/面向对象/image/2021-03-06-23-22-55.png similarity index 100% rename from C++/类设计者的工具/image/2021-03-06-23-22-55.png rename to C++/面向对象/image/2021-03-06-23-22-55.png diff --git a/C++/类设计者的工具/image/2021-03-07-14-26-29.png b/C++/面向对象/image/2021-03-07-14-26-29.png similarity index 100% rename from C++/类设计者的工具/image/2021-03-07-14-26-29.png rename to C++/面向对象/image/2021-03-07-14-26-29.png diff --git a/C++/类设计者的工具/image/2021-03-07-15-55-33.png b/C++/面向对象/image/2021-03-07-15-55-33.png similarity index 100% rename from C++/类设计者的工具/image/2021-03-07-15-55-33.png rename to C++/面向对象/image/2021-03-07-15-55-33.png diff --git a/C++/类设计者的工具/image/2021-03-07-15-58-59.png b/C++/面向对象/image/2021-03-07-15-58-59.png similarity index 100% rename from C++/类设计者的工具/image/2021-03-07-15-58-59.png rename to C++/面向对象/image/2021-03-07-15-58-59.png diff --git a/C++/类设计者的工具/image/2021-03-07-16-00-43.png b/C++/面向对象/image/2021-03-07-16-00-43.png similarity index 100% rename from C++/类设计者的工具/image/2021-03-07-16-00-43.png rename to C++/面向对象/image/2021-03-07-16-00-43.png diff --git a/C++/面试/10.强制类型转换.md b/C++/面试/10.强制类型转换.md index ceb9f8c0..77a3b50c 100644 --- a/C++/面试/10.强制类型转换.md +++ b/C++/面试/10.强制类型转换.md @@ -12,6 +12,10 @@ type-id(expression)//转换格式2 ``` +- 强制类型转换。可能会丢失精度。 +- 隐式类型转换。默认情况下会向上转换，即向位数更多的位置转换。 +- 避免无符号和有符号的混用。带符号的数会自动转换成无符号的数。 + ### C++强制类型转换 ``` diff --git a/C++/面试/19 内存对齐.md b/C++/面试/19 内存对齐.md new file mode 100644 index 00000000..856f9604 --- /dev/null +++ b/C++/面试/19 内存对齐.md @@ -0,0 +1,29 @@ + + +## 概述 + +### 概念 + +* 编译器为程序中的每个“数据单元”安排在适当的位置上。 + +### 原因 + +1. 平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。 +2. 性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。 + +补充观点：字节对齐主要是为了提高内存的访问效率，比如intel 32位cpu，每个总线周期都是从偶地址开始读取32位的内存数据，如果数据存放地址不是从偶数开始，则可能出现需要两个总线周期才能读取到想要的数据，因此需要在内存中存放数据时进行对齐。 + +### 规则 + +每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。 + +1. 数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。 +2. 结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。 +3. 结合1、2可推断：当#pragma pack的n值等于或超过所有数据成员长度的时候，这个n值的大小将不产生任何效果。 + + +### 结构体对齐规则 + +1. 结构体变量的起始地址能够被其最宽的成员大小整除 +2. 结构体每个成员相对于起始地址的偏移能够被其自身大小整除，如果不能则在前一个成员后面补充字节 +3. 结构体总体大小能够被最宽的成员的大小整除，如不能则在后面补充字节 \ No newline at end of file diff --git a/C++/面试/20 字符串类实现.md b/C++/面试/20 字符串类实现.md new file mode 100644 index 00000000..c773c692 --- /dev/null +++ b/C++/面试/20 字符串类实现.md @@ -0,0 +1,27 @@ +## 基本功能 + +1. 实现头文件的封装：MyString.h + +2. 缺省构造函数对字符串的初始化MyString() + +3. 使用构造函数初始化字符串的另外两种方式,动态指针+拷贝构造函数 ） + +4. 析构函数,释放动态申请的字符串空间 + +5. 重载输出运算符 << + +6. 重载赋值运算符 = + +7. 重载下标运算符 []，索引输出 + +## 拓展功能. + +1. 字符串长度的比较 + +2. 字符串的排序功能 + +3. 字符串的倒置 + +4. 字符串中指定两个字符的交换 + +5. 查找某字符串是否位于指定的字符串中(采用暴力查找) \ No newline at end of file diff --git a/C++/面试/20.cpp b/C++/面试/20.cpp new file mode 100644 index 00000000..c56b09ad --- /dev/null +++ b/C++/面试/20.cpp @@ -0,0 +1,136 @@ +/* +* C++ string 类的实现 +* 1. 构造函数和析构函数 +* 2. 字符串长度 +* 3. 重载=运算符 +* 4. 重载+=运算符 +* 5. 重载<< >> 运算符 +* 6. 重载比较运算符 +* 7. 重载[]下标运算符 +*/ + +#include +#include +using namespace std; + +class MyString +{ +private: + char * str; + int length; +public: + // 长度 + int size ()const { + return length; + }; + char* getstr()const{ + return str; + } + // 默认构造函数 + MyString(); + // 字符串构造函数 + MyString(const char*); + // 复制构造函数 + MyString(const MyString& b); + + // 重载等号运算符 + MyString& operator=(const MyString &b); + // 重载+=运算符 + MyString& operator+=(const MyString &b); + // 重载比较运算符 + bool operator<(const MyString &b); + // 重载下标运算符 + char& operator[](const int &index) const ; + // 重载输入输出操作 + friend ostream& operator<<(ostream& ,const MyString &b); + ~MyString(); +}; + +MyString::MyString() +{ + str = new char[1]; + str[0]='\0'; + length = 0; +} + +MyString::MyString(const char* b){ + if(b){ + length = strlen(b); + str = new char[length+1]; + strcpy(str,b); + } + else{ + MyString(); + } +} +MyString::MyString(const MyString&b){ + length = b.size(); + if(length>0) + str = new char[length+1]; + else + MyString(); +} + +MyString& MyString::operator=(const MyString &b){ + if(&b == this){ + return *this; + } + delete[] str; + length = b.size(); + str = new char[length + 1]; + strcpy(str,b.getstr()); + return *this; +} + +MyString& MyString::operator+=(const MyString&b){ + if(b.size()==0){ + return *this; + } + char* temp = new char[length+b.length+1]; + strcpy(temp,str); + strcat(temp,b.getstr()); + delete[] str; + str = temp; + return *this; +} + +char& MyString::operator[](const int &index)const { + if(index>length)return str[length]; + return str[index]; +} + +bool MyString::operator<(const MyString &b){ + for(int i=0;ib.size())return false; + if(b[i]>str[i])return true; + if(b[i]#+%-V6`<`+hS|mXssQLmv||~OU?gT`|`dsnITg> zr{DMQ_x1hdowfJc&sux!wb#D9mzk7a+Q*U^V@8~#qm1nbrNhoY$N%U;@#MKrOlFUy z{&e1cgXgF7su~*GZLMuBo7-x)*y?JVn_B|5jec8ON3*T5*;ZU$Y1`6L@6Sn3pO__8 zd!3Bc-)Lcjp{+IS-xzb785?0|vPnrvr*R{$1aKl_L(@U6BxI)#kxmkJQ`W?gp~G(A z%-1bRyj_ghI9te4k}J_j1V`ZZFt#^cB>876V_g#>@(GePHH>A)!Mu7eW1Z5(IK?a{ z;O`8eV9)vZAQSC4sZ%138s@FZsjm&xf;UKfFHX`~Od0*KGjD%Rn*bJ=z^}oXg0lo? z#9?PO_MBFM<84G+8T`*Y5g;V(EZ3gXDR2SuMHf!ORpE>{IBsKmJF&V_@zEDi7?JE^ zHT^k_LLc|_9u!W-xgi3CB=q&?6jktA8mMR=PHHd3M8sid_Wqne6R+1w{C=E-Yr+|E z5N=7nV0eiP;v`%%W%L97TfHQ&kTcA4L56VJaJJ%%IPA>2ddadp&T%8`7{dqY>*Fl# zgX8j-^Za}&w*p6fd#eWF365KS4o|!2(r?e?Et?;b$##?aWo@TIn(z*;zmnN5@^3$6T44c78m`5GW*))Nxbyerm{M z%Z=BJj*frJiRkw;wpx0FJ9S-JJ%F`S_5vbaw^-UyH)xP*<4aojv^|a1MB} z{waW^PFU{gHT~>**xj4)0w?K%AR!hs?d4h1H;Dv`vuwcs0xc^JnZr&rqz`Q?K-;=d z6?0TOs;VzuSLxdMHuYX!|Kl|IxO%G~7W~zRuJ5=)tHNB^;zTQYo`e(qu8?s7b-yb# zXEw_6-f@Lm&7RPL`@RY{O>q@IW7(At+~Z-)?2gfwUBU2(%kuCtS5JS(>#or96Bm(8 zD5d*^!Lo}2GL(Y$?z$SO!=~Zuco>7ni!;IOdB?IV4;1Yvg{UjUpec~%%pd@VfdRCwYy=#JNRP_v%Cer<2jXx?u;y^Efvxls0}E0i`j{Hs~i z;8uex_1|XkTpzT0LZ)h-$yi6=AcjaN{X8Utrb2uoOm-cFvQWn9lzXXTQusks z7BbC7*0u8x#o1+7_%3&Ba9n=S@>p?J%`p=KUHA{-@d|4FZyI(Y1bTjletVpz!SH5M z!{eeS3?@wbDYr2FQIK#UN_*ZpoI){S>3IPF46vJ$k3EePl*{=g_~K~BeP3bh*a~9z zLC3ctd^knSH0d{!ruSx|{92R;2f_!D?$i5I&QHG}89qCOufYlz{^4h%qkS~6XwtC9 z&SwvBJPc#u3klyd9zMJobt1$qxAj{d?f=VBuC`Ach;drkj=jvM20J?_`HEE2NX|rK zT)huvby0o)W<(|!M!$#O!{~SQI@2lrBaBT~Z*@BIL+;=pW|6>!1RMxo%}WHTSEMHs zKPV(7L!w_uxTM4d5va>V+CmZ+3keG(_6UhtQX)M9wNRjjfU=U*F&gT<)kt%r&qCa* zqGv==Kk~T*eM;n!=Fqu_0C+5Tz!ggWIW`fZJe2V(qzV2QhYQhbg(%hPrLuOBN1Cg8 z8MP`^yGa!<4`tjeRW%7!Tr^jRl2xswDqG}{=Bk1bs#cLIULMMDNLBNMDlYm*-gC}9 zq~;Zo?x*xmMS6(R14!>j&$46R$A>F;5cTpd9U@ThC}BEgs1n|F&!A)&6%ds7%nylC zDHv7~Xd=c6!N?`XWyDw@7+zvrNQ~)%0aXLxLSiHf#vWp1gMkYADLq@HhbT?k4QbbJ zGmzYQhywJo%MVt&f`7z-vLUFmI^mcX&>k8@HoYiVY7JIrc3)>Tbj;g%T_#;3bYuem z(Kg_}MeXlR{~^Xg_#lm_XxS$SEf(eFmlCG1qMA8+UYV(`e zKmBk8JR{c0IirJE>+UB;uh;Af+0CwC#_g2Fa{LD|x9Ia5b^=^O`VZWsVM_NWqrt&I zA=WBe@IZIi;Od?IqHEy+S8w3O6ExF}PIGk+n_Yz;cKjJVaXs8j8ZW!z*s@P)?}81* za8huvxYusDuzTeI^8^ocj0``l*B3IKyA{)Re;`Hd1P`0eKpx@2j$O_BY;?f`L2{rx z^7^A^Jh^-6emfVN5g)Z`|I&MZzxb}Rkt#gsI*jcPbg{rGuD|@;6`WH_i0(tVV*NRY z`M=kbWgE@7Yd5tvK*?q#9l=AR8C#GDK0TVzLuG(v2M>>C^igJ6AS=5#IOIZr(E(20 zNbp@(-ZQ}yNV(<>x(bg5Fm?{O{_+wQ{3F zho95^Q;iPcg9JnFXYlZ%4%*<%A}d03PJyd1Qy#@m$Q68LG-DF6X)ARfnv4QW>;rC0 z2=GDyc>(fo2S9>VS-B|2?1aW+*MmGZ-PK1&GhVz2#UayEsD=2;S0RBGJh&ZXf2xu7 zQ_q0WLyVB=-F(V9N09tbBu|WH+)g@r(^nUhrF)SX&6tYMCrBLA!Dz-VE?EWMv{OOG|Yw?zfZ-l=?5jW zmrn|$9Ojoq-Jc`{rgeW}2-r37WmoY2pYzJssQTqE5h?s#;P0;}Vl zNSW{@ku^dIqFnEvsjypT$&ptbPh@`Rt6hx6`sPkY%?l+>zxiwk*Vks=F}7a?^{bC4>Q+ zu>n2dsx#i;G7OFmxq9bh7al)#2uckq3L5A4~2 z_~^|DlU#5Bc?^{By;clMOExOb>$ha{sS0Ya_@|!~4{-Thb~JQ=L;ge#aft?k|6Bd+A-J5hyWznzr8U>hW}3J@8tU>T&>Sw}OT z@1_~t($kDS8O=B!ISl`6(QCm2;j|oB?qtEyU~;H<)n~!t^FBM)3RvFpV@E#627442 z0INRV1pep8)`JfROyRRydJ+^kP!}#Ni*qx>2N!d-&pSYZzYafwY#&Bmwc}#PI=YCZ zYuN6$3)HqZH0J~XCxvEM zzH$WUo|i1U?g#Z0zG>;+j)r-9x0>DEhbDMJi|-^gz1Qt6UHFlE;O*qH-ugGq!xP2z zkGuOBbEwSd*l(mNgP(*_Ji+50!?9#T(788!KCVeh3*YQ`C1m;&X3D(du(Iq1?)|S! zM>l_eJ1<7Io|?m$BV~)hfY9!bZLJP z6ol59altkxv@Q*(H24?o=qaFr5+il-Vu8U#YUx=57os&kp&kL){bN{+d$`opj=gAi zo9kE?v|DbZ&1&~2Hp{Mm;R(B?X9x*wE*$&KNO*#O!H&XX_=zi6z1I``AiN%1Inu~| zH6RLd^+FWXJ9dIw~FEt$T zz-f;CNvI^845h>0?h8!;9M>YA)K7qPTik=v)lnAw5}TJ})N6g+pO`zA7h4{Ut_UU0 zT`~3WkopFRo(}-Vz^^VqGY>oWqJ9=mqAf{pdI-Gm@w3#HhSs-`Vbxc0({Nkes$P)x zYgfT5Sj0`xXSwM)$gV;Qx-7dsq9m>!(GLfa%zNo^gf9!fKao0s?xj$V@cCjT61;G9 zP`i~S=Hpejaos77>P!sK2g-g)>z;mmxIqnafp{=V}=7fDukQ0RsGodg%`xAZ{ zFD|T$d84_3pW!N)H@fFC_&P%B4=Bj%KQ;keT3K zN8ho7NNMYZE&SC9s51C;$kcZ=jkt~luAX-SHgswB`7}>#1(%Eue;ZvyUYo93XOk1J zT<;p&&_bH;^NwRty$oWm;O}v#&C|Q!U5xL?Z734=-rNh{Mq)VUnF*;F4;Z)y(~5(e zjUiWBaP3FQE=<2CT-}Gwu7%-X(PzQ6$b4=KETy|X9drW+Ha_j@IUf7~_tv;O;6Ipq z3^lrgVa(gtVIjSk+(%Uozd`oVB#J41N+=1-VsK#RYbdtu{J5xS4aP5xa1p8vB2;(C zP~C?D%S}8!MX3Gig6$JpO-=TFLX@k@318#?$qP?J_OCj;}Ui>Y^K~5rrb4-{k>q z>A4bxDyVPQbpJr;w(O!CwKAx=is643G5tJ`X-m)9C?CF8#j`TfqZEye*JUW+dX7~> zuuqO!!Eul!{m0G)QTiex{bTfT__O1fZt?(#2;?CYbRQW#mZY&o{7d#Q!dh*w`}na`eaTqg(a5HWv@s3HjMJe$IpU8x- z#dUkBh-2Jj2&@W{k68IN8=hMK-XjNbG|IDbwrCq>wl{2s*-I-i0sMu-2c zkH>e&v;{a+{alBI&yPGnx=<^rYDC#+#>GPYN>YfBniaAZ{=8$-aCvA-;jaS=vCYJS zisnAs@h(JGaFHg6=<0TnI#_s-)fMzw!&lL)(3_sdk*k3mewoh)Se>z_#^vElE#MvH z_R;dX3v)AT%cbj3D7_VFSd1-E=n`xA*9Z!97j~{4@4>KkDm-j*fzWZ-R3cNO8O6AG8UBXo zzmRDu_^@KeVN(`TRC7f2xSmd52sZpjLci$?e*;t6u>hPeLe5p^!1I%Vy#Aeq^aLef zIGESJY3KILNlCcdNjvwQg?N0EipwZb-|)}KOZt2*jnrehms$h17>PC=6vb|1r) zPFm2@>p7BL9I~gm3kN;Hfo*1*B@18NMz`RzJ%vX){y>@|t`Eev(T0ob@Hdmmi6_k4 zuEI^>j|%8f(z&IVc3kcXz8H3*0ci9^uDT0h{)?je4OG1Y&n^Om{LYB6%hkK%VD>O3 z>x0>@!cPP9#RkU}{D7_x3ZWmP=5@LiMsv~?K3I~64$!jLZ_$1L_t!h9dIvqqas_|V zaWR?_K7dX~RcqaK_LVTnvv9y|=yzBi^QPd#KE3B9cW*Jv44mEl7CbTiR(N7Cds83z z!c#ba`z~$fWZeEKe6cOk7c}Og{6Y1j`F}o#G2B()9tcb-4)${(*#~D72uqH+>Q=AB z9<11!q5#-`3j2QudENdBvOh^kmALT)&0`oC+k-i>2XRe&BwO$AoiH$|1Pq_!Rb%(g_}>~4i@chUJ?k%n1L3){&SEqr>UpRqG{?V!`}4fgOC7;y zJJx#;PT$9d7V+S5*A>B^M?-ymXf6D79-c{JY zje5D!+H!*Xs42KA>cgd(@b5)l*D89SfNphUw#{_yJjQd~sm!&Qr+DeMKe-kTxWHV0 zNz~Ok-Ip!F2Yj-_4vT^Dw=WR!zx#>v>!JG`=60J{iM zh^x+{0Al-s$<4XBwX zCh#S9*d%5+JkFP`>+93*7kkk*ENj)6&7C%(_ym&KXyXXz2-SHDH^Vuk@;8b6QM#v$ z8?r-$`3_dCUAP+E4W}sHIYxRo#&$d3gCw+KjqODm%`X+#K3L0P<)X)_x5AIV$@`F8 zG8t>YSdk}i@#P9;j%D9RZ0?T}s#*q9j@4i#ChRlJFgzPO(I==5(tRnfhPP`QuED9( zamP#ax;{Vs&-$OLNYMY>3eo@Y61I+U`~Q#RlIZ@Y%jfa>U)0?(6^-8u=Z}qov3WF~ zqC$%Y#6qb}bVxR@{UAB*I=aHHC&#P)%&J@Si^FSUld=~}SRnQ8etg^nrwBPhc&2`C+RTw zVl-(WoJz%^%TM4oqx2WYAGSPN{bSr#{hlNEB3`I~eDLG&JGf^sJPTn6Fwavp^tQ!7 z_=6L|8!o!~*H$&<5Ap>aQT_EB;14wG*C|J2?%_D3sM{*bW&OEbp;qWy)2 zclRTB2g3C8LB#Vi5h3l<0ej)R>?haXkqi>7nG938$N zUKxTH_L9;Esk>>hja(}A_R!N~ImY-ia@m2cLMo~Qa?rBW1(~i=lx_Vsgaw@p+FP+LP1=(y#F5O<+ZC5;bea z%+G54$?@iuVzOzvKj;>!YNMQ=rehIRHb$t|=NoG4VY}GohVb$epVV=0NKcFT=&;>} z*kZ~dWBqZM3K8q@{5Rv6C+bu7p*>;@SKCluCcUCXfd<(Oxp+l3Ew+8aADDZDkTs4_ zlzkHK5ZhKM_10e^J)`YcXhgz`)!DEx7js1cEVNU@&zhVj!Hx zvou<=UBL}mHvR}(Hp>?N8S0{r#`_;KpuTXtiS;AnRSF`i#wwRy*||~eqPR>_o+yR;f|o;a-vH$E1f7OsESYY%u99;ee)( z;V4;PM*#pB0%ov&=EkKm;MV}bS2SA6D0j z7uS1u(FMF0_^Z+G;Inv*dfPk-saL`;&=p${R!IYX%tN!EZU!}|>qp^_TpHiI`S8gs z-i<)*6+_5LdqY$&1_b=X9hIwQuh{v7#vc^WRT{?8KzI?phd{In6bmX1|J_Nvhvnp; z94{x4sQyELi}5UU*+`cbA5dZ=&9fr8Uh@~wH^eWkRlIS1O1q}#r1mHziE}${jntM{ z9+uZcN@#j6jO1#1)Eqn39_~sxe-9#(#xy@>evHJAB*N3oc`Y^#{8VkI^Vbn= zf6^Zw#gIa*M{fAy_z!U^!n>757>`?#x5rs<#C#+G5Cx_5mfsQB-|`FYFH~U9mRE)_$&1OQx&U+92(@t% ze25xH(9ilRs74FsCz{UzekiL8lNZ`Fh&CO?ta7sb`ls|@ldptozy8XHC*7}?@fJt! z*Y8%GsQvmTn)&1J*JJM&^8KCI+g*>Rp(?~b;P&IHd?36=F8h&zt>#bh<`93ylDZIQ zbpe`d$Ckq-dgcIsSRbB`OMNiBr0`8{HSIxMl>HO$xkJd>DZ87O9v0GgpZ(8d6uP-I zH+(ra3j31M;A?I?y{9Kb1K|mAR-E+8xn8AaR9wprExEn}Q z7rGE{Hbu+;k>icn6THDZu^PL+)wB- z7n2j+FAP;@V@0JEFog9G;(rxmCQOe|5tex6G(@n{6B5RoiSYrQ!|Q}bYPc=D3k?T; zNQG?`^(?}6m|JzlOFRev3G_O0Qz0?oCPBHIn(2mS_aS|_iuhh15#J-|@Du28>Rad= z2>*n)2e*b)`}pMR-20641-jL;kD5ZJ?&BA4bf1W)2g2`jAPjQCV}oQGwiM5gjE?Sh zzR-2u3yfaH5_g=|po-x%mAgw;IQ&gCSi2OgL)367H*nlAhcE=Y6TYe0L&lcA$7hL| z;F07$ZSye_ew~8qN-#MvpMp>r%kzOqWBbX{`LGldPCQj#CslLtCR0Dcmo`=Xq&A|i zX8?eiG^woDZbkDE#^;lU2!Av9+YEnOF~BmR#!Ah2^j+#Y^7-ZDcRtzQK)Y4koT6LF zmR&og_(-L6cpwriki~@Pm!2YNM)ptM{Qyk2bu|N@eTBXdmmN-5A}+ z&Q&JLG4LVfqwMkirz>7a*C=Ab*dgQ)k8Kor)|riQznE;+75*NmF zLk_C`Ky%QQk%p+w%HXyHya*6<)Ij*p1X4blhnfaOP23NI5w(4WWqbG{IA{;d(1!>M zpAIvI5wSGUL`Be*n7jDkIx1Bj9plh-IA)jDIFayNJE9}Yc4{7($uzwpSPorOZu|I+17QH1GD!E2Q*AM(} zqVb;{i-TA7hfaR~NwnpETpoWvuGb>-{Hh{p)3D035D1y0X1C;ct|mH(t4z4a4Yg zTHHxTjQpo>kE376AEArv$m@4$Ki>~T+<*ID&Er~y?m%#RsXlSX@_pcYRUxV8GNX6mH#LG`+5LZTv5lJ z3HpQjCsH6Pg95B}QO8*PV2(Yid_?7!2)ju0=@<4ugTJY% zh2ayYf2_3qb~|U)^a(n)+&eoyU&Hl_a#N89F(E&k?!t-fVTEq+7B z-`3XBX3H)vFLk)f7Ba24y|H<7M^kNEV_>^2yVAV|W&9}L>TlcB)UwUiR@=PUuf)sO zIV(y$%l3N8D=WFCs+Pb>QB@iW zKZ(-dx3&4(JDLJE{1i^0rN!31rM9UFDgHw^{#F#CIsSTEc6C{?vZA{As^*q$vUS{U z-B-U2@BV0XbT;TB zoGWp9aBjd^3cqYyylq83{RmH>af{!!skX7Hqs@P=82OI+dRWwMThMB2sBO13x7ZrD z)Nb}KZui#(8e5u~&9<(wEznWhbWw-DZ95l+?VHdC3+infw+H;~w%UNLR?{N8O_%ew zwFIC`Np5QlG}!9!BS5y?&IO$eIMw#nc7I2G3!K-~QddiL(+>#+TIyPwZ0N&wVl1f7 zQS;S!avK{1=*MgPk$7d7`n?;Kx7$=oP_Ne>#i$vRH$D(uzF)3mN~m?r{8`|S#@oi^ z?KRQmj78_4ye~Tc#+dwPWAgSpqVb(~Mdw?`NrJ z>yaJ;oi_(RM}>4Q=t`XRNZTomFDW)q8ng&!7t&tPDxABJt^uvbxf|(L&{a0Z?j$_u zr}OdKVo0;o(Y`Fk`jIAj^8&_>Al(PL?M%jwBHac07S180M?hP$L6L3+wbF`olb~-Q zZAN+obn;o?5g&9u&gn?!f(CGABHaa=el~nX7|>lfvytut{Ta?&qz6GSSj1QX(ss~o zIPFMxflgVBzDC*x`V3Al;d2;!59fNMM?g>DtU;PBVQdo4dZewOr{Zit+6H9vp z45t^E5zwjUppU?}fnJ02W$5ez{T5Cy`1?SAfwKYWAyE3_!rMr9f&M4X*@OYDE`%*e z*MPR++yMPupts_D1N=Rp-^ckX(*2-6!I=e{2SMMa6ZMXO8qNhC?X`lQh0{!a11-aO z2z)Q-S8+as^d8W|I15M*=m$6#AaICmr63VJWjSD|ws=&x`NB0U6} zwi5k?v=#JPoM!0n0{u6fw?XF~&=+vt3CtkqD9-zlW~&f~I8RVtfS!fZ2z)MRDb5{e zuNQPH&RnFsK>r=*O7aQlk8$pWZT+ARoex`}XCG)7=YH5Q0$OkZ#w^ly(A_u}A>9W$ zh;tv=18TJ+*2#X*^*C=vx(4(nob`kUeGF$S>g@*&N-=R-ST8|aU4ZUCOXSG}_cI+5-JT~LgAkj@3Y8t2_e zcY&^PB7SzEF3>A*9znVW^vV**-T+%cf3XI?YY6@j=+d=lBV_HMSK`b>x)t=_aN2rc zC+PQahQaR#9md&-^a$vw9`q4(+CZ1$JVbgxD{vkGzXr4oCqudm^j4hD1G5M8`#Af- z?+5)2&L_zp&`)u`3=Av9dV%xqF6ak659bNkV+Xwg=i5lvfHvbS2EG;adYpsccY%Hd z=WR&$f&M$rOr-aK{uj~&Onv_!J$ux0kN^){; zQVq#=Wzsz)L)tVGW2c!GvDGPzam=kT7|ZoD8N0_|de^`nHe5nB3B4OhZ)AGr6jRTX zCX%co-(riNyI;# zwBQ9J>rSTht;q|9jO<3^J>(8%h-}~Al8*3!=C4SmPY!3@Jf%u zMe2x5tMW*@;+4nY@&0KW(?8#sW0-ys99-*u$zXWPV0zEM{%Sy;dn+PFRK1GE(XaU@ zQQOAa{zcoaY*3V9GooEGru4p0`UzK|w_n*iGr}Gj*KB4)`xH;%H5!4@c*>@+K3ID4 zF*h@Pf+@WsH8~~MRAX#S?$=`f8#4`4b{R||gW*1dX|I7jYQQKH9mC^TwM*5hXrx`j zj(d4r#w(A+{w?V*q9Y#mBz+Loo=7|5>4+>pNqVL=rN^3VzQLHAT$9vl@X9`%c)h8| z!0sYHjuYDv@$iN0N@S~=|5K6~pH*u_Z}NGX?3tLt5T7Cnyh;5A^3_X`@haDkvGSz% zUa4zFDx0x8g;_gIY*K@frM!-wA6pN}Z1JX zkpF9r`aQZS_J^?dMt=n&c>BP68@&8)>bR`$Vo!M=_R-+0<4*8)+^=%cwCaKAe1pt) zNqVQG4@r7J(xZ}wCH+Lw=?@BhS(4f%T`y^yq`M`(Thd1*{fVSuNk=3#eoN?`Drt_S zc1cw$yfWV)X{V&SB)wJAdnJ8D(j$_-B4lP3NqU8(4U)D=s@l^f^Zk+zN;)LzN0PE{3kkcVU6LM>)cBvWT+$tq-YMxLk`790 z{EomENV-GP-I5-W^kqqhBn?aYnWR?4C>=IQMGkv&880gT&$ttw_-EV+Km5Jo&cb}v z&D$EA>wOh?612rnwWS-1{Z0OWzX(sL@N}uEQa)eFGdS@ysBJ8pWhSlh2Z}n{+VHRl zk5KCHjE2pO<+cI`h37(!_L9aXKc(1&WMHcr>#izl!80RVuO_>jVRda2o~evAbbqqPU%NGi%}R{? zfsq$a-&)$X(9<-o%-_cDHdX|h@Yt!OqnSTqs;b@C z^R%>F)zPZJa8}!P#=b)(^1+mFHSWfmD*b`#=7!ql`X+z9v$M|MN>7o{D)^UOWU6fP z`&(I!smkBBrLnm-;8$+N2d|0}@X><`d0%-Xii?W_{{MtIfVycPdO0qK^FzD@85ewP=yrn;8q zt-Kr;K*+cI1HRhUR$pLyE261Ra5~!267iIfv3BOGt=m%H)Xc6$YD@cOpTDya_VqGf zok;za`8Lsi-(YO5fvbjFwy?S+UrRFwOfc4NY-tOySw@5>p26Y1x=~1;Yuwb@*4P}_ z#2m&=ZS;(|)VOII0vV|tMtZzS=v~Gw{w;N_=$(6w^c1zW33s%N?SZx?e>2`9p;U7n ze)s3s#;r;n#>IhT-=$@1D+A~Fe080jd3kwDH`cbpaX{nArMs>&ke652P}}AUwAD5S z+TC@|%36Fl^XUPfb1VC$3G$p(l!q*PMaviS{BtQ(-qO_W^p;dqwp99@xG$seHnN{g zrt&Xb{W5=ZJypkE_;T{gH~Kd>HbcWHmM>L58tYwKSFyHonGcUczO)V~$oH}3UrwGo zc;%OqZR~VzXEjrJ+Y1_7+I{GCe?Cn!q8r)9cx9qXS=ChErHBiJOrW8yWgBGceLM)! zA(x4=0$;^OgpA+stM}Kn`RNS;FGO^9Ge!ch6n%L4SeeG=gfct0%+f-wp2lVjM~qU; z`fdJ=wM{hTZ9GYxmASr(N*}v{>&UNb=?JiHkw#cG#S4081*~5thDHmvLAFKm_1E^$g#o^-W$1Np?`CF%;ReNH=fW&VD|F23W0+$DOaPHc;2VUXeUhDml2f zFL`*ufPBkNAiue@)7Oee@GThAc)tR(Q9~}(!}j2QZ{xY%2 zf3et2fP=#JKyBSsi}5}dU1;GFHZ3P-N#tL9Tip_DJr?s9wU!7;NtWi+v7&P~;4*LX zwt~Fe4f6FbBqLt|3;4FK;4gx0;Pr3Nlqo#knq16vEL*xk=*Pts++|3iD-xD$g2$4~ z6Pj9@H{<o1fwu6nrSd=dESmBtC1U8-_k)>;z?$s zN*RrKb+$IZQgD5`rPb&2ZQ1Cn>uAHfshupT-Fg?VI1}MB!Q6}VLZniuUHETYx4AXW%+GM_ge^N~v zVjBbjnP-^sAH47Z{`s{C2rjT2+wdZ5(wRby65Xa1EE2-1pmp;WbP`KiYM4qDD)u(T zKgWbAw6x;R&t_&i zeKL8Evba0NOnGV436!NiF|E+D;4ssZ@-L zY;3G;XDQd7vXgZA=pEy0a7%%u?BE<88AV1J83saJ(_D+YOexpRTn6?;UFQq~S2|Hw zG1I_xOjIJX44EX8lw=a)gbypcx7>i2p)sr`oHc_SVQdK0Zp5vZ_69a#NydH%n9O(t z&nDf5kDua9qYp5D4w5d={;S!96_z)^Fqz-N=Ok+0=SXm@5J=JV`dV91HM(`ekEYUZ z8;KJC)jIzv>&xIz7Pm24T5)~4nN2YAxR{gjI}?6fqPa!hLv{np#kmlrr%gOR;n`x3x6kmY9!9*#yg0KA(!5 z+0ul2gxtDRmYfT_%paqt-$la8lK%iQ5t9Y(W=UJynR&fo78OhWR=wcAM8OoT%}C%j z+ve>oE%mq7t5WbX8%-Rkzq9OsZ`o9GN$T(CkTZ-^n_F;gxw)C84yBUk%`7tEcoOC3)C06MLLh4;}}>N^~iHMPERE0#T$`YuOgPu!b4%B32JA=G@v5lzI9GM{r!=kzUGI;9XZaH(CKCBzJd z^x3FvH)lz~WWnp3-nnIqlr#y+JEw1tV4XtVzkB*M8Y{(+LaaU0+uQxptO*A0x%)Y* zgKkOCk}C^SMd5y4C@Y^Rc+Za!kfmv&bcoEQN&+o#H=-7UJ2hR{_z_7`njq5&qcodYTR;8ohummFb!RRSt@nD;1n1#P$Qmwq@FGqD-9W_k{DTn zVHXU9{Q|)#hSn{$gg8SmT!I0_nS$XlWWY>9WDAB@Fo0Mn7*#L?h7sf}!C5akz?>~O z8w?q^4Tq_ujsk|IE)wh-oxKU|SY((*9ayh(G5somGpMK`x=09}LnTdUnz*H&y38|^h3b8Q+N=D{zNlWy7Y21n1pXIyJk$z-+GSwL1DGJqR58t6 zeAYCwTjpcM?=mG^*0;!JSoTs$|J}iIOexIM(oLDytkG4>RhB((-ld znJFUgEG@6N#8>LBEOk^BxqLz(MF*5r!=|EAug_6d>|0&oCawCLcX=6`9$i}Dtg5akt7I8EyQI9j!gpac z`pM%ibyu+&dJ#Nbb+MxYwpKVxoakio%xY(uv&3D5aKy76tt&l6UKs(IInL3-Ck+sxU{CRaLS@dhr@W zQ-zq>Dt(pY2@Et3TdX69SzV?)>M2J^Ar#!Dh`*eZp(?A&5w!}oBpT**6s<+y$R4D& zYslPaWYr~Jr^i_d!$@Bx%Zn~1TXKD?FY$TTmshZ*dLe~!1&qc#OA%1%t19=cL$og& z2U1c|UdloFaY58ict(aHU5Uq;+Mp4Wc~q#DczLHfE8yrAI+FSnHlQKCNW?jD5u!FI zDA0@faPn5Vs!LY0LY*yQFn{$Wm|SU^aIc4>&ehAQ-ZhRYm$QPMr*nl=-qM1SQird| zg|9kSvXzm=>z6KHak6e-H4ZSk=g*HqqB^aoFNi9k%2c%2^%6PDUhJ-N(d@z;dXd9( zvE!0TUkO$i{w0Xz+WSWvoaqsC2nYs`6N|&bib{Q^WcyEbBf|S6MN0 z>gAX@O3UG1IV5RHV za+)o?4tIqE%MrU!FHu_r+JuP3er-gdwDBT7H!x3ZiOVfE9i@7aY!JDRmFa8|)Shy= z3|F#py^O+XeUWR;YUYh*qD8svBArL=5b;j)7^~1rMC{42fJKOkEA?WzQ-MQ^-Fyv& z-)YjS(jlUeyxUo|&Q|?&k! zXv2jNOFb`X1}QkjSC3bse0bqUywiXm2Jrg?e#<65UNm5-mn5Zs6FN-hZTOtg=HKkA z!<`*%8-123W$#Qhw5(i28M9#DLd`5Dl4L0&l5AN`#AvB>6E#_iIZd%(O#!14d($FM z`Rdh9^u1u1Ef&fpFxKlPqp*%GZlbn#JQ>}W};|QLd zZgH+d{UpKj8J5*TXC-!Y*vjiAr&vl$rJXnvJm z#hi$8P3SaBsiShOkDJL&oGTbSZL?sQ=Ia{fahrM3d6YDp2;suq>xGj%65L;?-iMq->l~7c&B7aQT`Le8iYg@iAR`dc< zJVU>$#@|pAH#%{%F6C`JFSKCb7h#)#rIq(I{lDP|o_krr3Iw7Ka_57Q6v4m+U6s4K z6!EEpJdU-vaww}pwCYR=1Ovev!_LROP@P#;j;L}Vq;*yib}>tFd8Kp8oGyn4`{L9H zUL~&AE?HgSF2>g*Cr0pHj>?Oj*qcp?;H@q%!`mtzTq)@~E8QM!Rk-cx5$v^P9>l&5 zTU%C&@YnN|YcHWTV+h3Xe2#VNm**{IQzD9r9Ay}hTw-bj+g;=&9zw+pr{dyBSEh<8 zofWVTS4I&<*sytUQKWO$IB8j!5y4rz0@ph_0BaUjD3%$)T3djtoCri|afzceFBca% zI&*a~>dwP;%^22FT-S_YEyKmk7*;+mU?NymT-V&OtfkBr!Mc<-j(NC1(FN%)_56qx zhNT)(XP+`l-M*mNo24d2viPjs)`r`V{HdjHBVL@Xuf?0Hsi~lP7+(1v6J7nkQtiGeOJ-gL@jjQp{54LBkTd6)3SL z(jl;uG7M+V6tFZCuPFTtm^0aENH(88iK-BFk{(Mos+tWw)_H(TnFh$DNqX_r^ax7| z0Gq}UCLJ+dB6$6T$cSRV4>O|b1&-=HRa& zPENm1q9^Bm*kC50xb03)pe0E;@IKdU<0B?TYat#>rmZ5Wp4rf-b=n+th*Q zYmpkFEmsKHJbH&@95hOoL^kr|dgU7;e}mWHskT79e^Yx-1Gx(Cc|umC#mn>}EjLvn zgYORDp*+%<3F-N`;L7Kt47|ok(zKTdHyD2xHSYlzR%A>Cjto1RVP~ zbrJdxWDic=!apN7l%QR+(A^^mFm_;2d4xR|g42~i>S|yH6JYKFX3sbn`dTKw@x<_= zLPYKRA!SYAjh_KSMnm~YBm50uauZ-a0mha9V?`zVfFaLQwfJQ@a30|tvOA~Ahp%#N zW6x_G!Yl%2NRt8vwgo)(VFF%&D&p)XFrqGT8uyV~(7SxV0@09=(PvmDOlYr>+QiB@ zG3WL|550)VJx^T}=eQRbyTUN#RUt(dPJv9csPZb!&%&#*YL!=WQ6#(?2P3^oz7$?1 zpF|(ZtK>`JRW%doIOUC3(GuZ}6*+}Db*-c~@^~EOgR4}uOpPq!?cm>T#Md4L2IC^S z*&6;Z^w4kkQE{@tqVXv~{t(}utn>+t8ehMJ6dgoF62JCEKU*pMLq)ua_Oq4dGr-VI z5Tlf_d2oZkD9tO$F`5*9;4tD)QuP`}N!;q$z}ORD(rJ+45{!B>*-${AIK`p#Y}GKT6|aEfU7)1S z2V7zGlqXeTl+@$kv~V_t?mr;!sjP4Wp!Pp&--h((55P zB{iU7l+-)m)T~r>#m-tJ?Mzn~CG~Z1hBO~eCXjZhx<1!1O3DY|zHC+31CXFV5Qma_ zOv5OtR7`E}8ctPRZ)+GOb*2?Druh)!aq4Q;FiPrs z;B;wHxMLqj>MaeUq~;>@`Vv@psfJNfw}3;xxGcsO5^?Gp)G$hF5<0dv9dRfhepSOLsc(bRmpi_NFK8Gg^&U96nh)_nCgMRI^IerH>M-P1RMaVU*POz}c5T z>Mt5bNfp{)VFIb^HH?z_Z*c5Om4(;BuGom$GEZTY)G2Tq{hGM&VFkMQbV!OrwQH}2 zQBunQ>eqTXejM)6FiL6y=8S&L!U0s0qN>t-c!!2jQgbnJb}dpC#*f~sG>npZ7@XXE zCFMXpXqr4!yUxUnE-*^!>)=?mm|qUO!s@A1gp9x_sSa>#D^*?b=Z!yT7$vn9YjRft zsV6jyk~$ruWJr_3z>X91w`v$A^(i=3ZT*UG;S!7qfl*SIgR@8L<@i!R&@f6W8R5{k zOnD>z%=R@6qon4bhZ*`z#9{n)`814@`UW`kKM;ge{MdL#!zig?aQd|s7A}s{%WE)S z3XGDv2b?Y~q7FkU4W~F%lw6dfFiL6^oPN#o=!Q7`0`Xe}l&?V}!$F=ZGXcZVGRR>Nho&*aiKZr%R0-wqoFK8GgwR|bo zCe8ElE&Qs6QBr>b$Er!uN~CJgQ)eUM1V%|Ug0lxbEi6O>c}f_mmn3W4LrDcTi(C3;`OD5;CkSNkyPgcK&D zINtc4hEY-zurjo2Qs{;_Qhp7ir2ZS6TrKA3$CWyvVU*NjTP(Ey)W?|q^umHq`J>VFDF=+U)C^6YA$9_`hOR~^O&sS zSQyYSO6njub}gdf$NU1sj=(6Xo!|^%-4%7|BNCNrW9C&2qonfCrhS@J{Mfiz!ziiO zh@8|?Yu71zQI{E~ zIMfXAYYn5MuCikePteOh(J)HtbO+`H%^UHfce933QV)RBr%6qhwnba`iH1>9?$ww9 zv{etqaeNriFiPq!aQ0y}G7z5MS)!CUlsArR7$sF>4sEg>7-1=)GRUD5-CQ)0)7C zf7CEa>eOPyhGt>>n7>uSD5+#8q_nkiifR(4s$I)9jFPGa$F5lzzg^$cFiPq#;Mg>& z_%VM$iNcT+ez~x2lP{P3bpm3JBKM-u3HT4Ki2^9nHinw~7A^cYfpen(=)(_?VsHzzecXU5fo zuWYjCQ8J#MyMRf938KH^`}vQ+98I7n??Q~h1bS`&hHO5WJ?hD0mZoQSRJ)MTo;;3d zda#g1Tsshkj-R8hhcrF$+qG&f<`!U1W)JE47BKr0=%N3?v?zg|TY#ajB#k#NJ_M#9 zfu4&?(WeRYJPAy30zLD}@IRh3J@Nfh2aGp?o(F&#N}%U;U^XPsGq)W7FCl@Rb-*+v z(9;Xd2~Cfgx==gR`058HkU-Cez|bady#Dfd8GoZ=y!d$l7;^$W=@;SuTP3ik0~o8O zCw_nZ4469;=sB|j|C=my&(-Xg4cL76VXS{y@1u$MsPyBYBQZ2^LczP}YWH7 z&UkvB1*SpM6Te+yU})@&r)R=C>_s&_@!ORHj1ide^i%`Gf1M7)>|}eS?*c#uJ(Fs%o6+>d zZ`W18+?GJkbHHRK&@;D|u{{a&v;&i+>51R(KLzHY1bWWgDBh?O{)ykNjlj?t9M8}9 z08^mZ6JO5}U=AhF^C2+Bnx6RWa@C2kGp;?rcoOJ&6Brshab=>djfemp&M8Zggm zdg8b1yTDM)kEdrrUB~*xMw~^E5E~66h(w zE!C9?^n3@HLz51R2>w%$I9nYR0025B2XJU(p)$#Py0yCoNiQlddfT36&PfvF%-W*P#=NVx766i_2 z8rK)7XuNf2IWQEffX?o)O$G%O(>UetY0p?~+PyBYh4h+TWczVvnjng|5=(z%z z=?V1Q4$S=t^gIuYErFio?UykFh_N%Cp3T76 zH9hg$br2XDJLBn@+l~Ev0zGxWyqrMKw}4rnK+h;JLkaX;ybJ420zI9;yq!SLUBI+z zdgfz9$L?42dT=eAK+m(l+@|S?-(L%FgpYxNs*}zeL16Aqpyy}6SQF@(b`xSXfu2TS z=zq?SXU~s;c}UX}KYoUR$xfi>l-;<7O`xX(nEV8Keh$o`1bR$C5%c4<>l|PPH9hhB zD*z0|{CIjE2Ii=yC%%6c{;P=j@$`HXm^U;%@$GpTnEC|vOb8+7H9hg|SqBWo{CM^} z0L+O5dfo+Q$2fX&_-{a9KX$$tRb#)gf?>dqb8Z&nJsG)V!v&J76ZM?B3vQv&napw; z>FI6OIk%G%uCrWnnS#AqIh(OeUw znXUq&ZLW{ed}oa2aE#^+F`8+w6|H$gjOHCNnnz+ZuaD9Ee2nI*7|r$=%_m|sSH);P z6rGhj!WYmWB|5At^gi~wLsMO~Trj6T%w4D1E~&Icw7pJ;Z(p?+uJ zgyv`b>v#SO7`mfXyKKDeq$fgwOsaO-kmr8pzh)DSQ|STFlz%9Ggnzhb)Q9TR8gNe~h~~30*i3CdiXNMTGX3~+ebI?pqYv#} zP^~X)(E#MsJa$Oy3!3Z5di_xEKik0KtuR=TB5&%4>aX*){_-{Zw{5|Hy4QP4o9oiV z=p1jZ`&;60NclP594^Y8bs;cbi4m>71RN_| zA-oa2$`Hcm>#X>=tIRu zu@)OAU*lfYVj~Mm#;kFC9`h8tP;%0FOkj%a<6-1G_Jk2$C5>a+&h->uT7we3E@UDO zF|QUoG|$IdD}_CmQjCqS$Kxm%4}*}(y7baZNe6jl>^pd1Vc*h(C#>Q)DMrR>K#SG7 z#^y#$+HuCt(Erldp&?GAJYLKT9~NCoQ8T`OiX7Ck@iFd8a}#466n!VvBmHxe=ASM2 zpRr>{GVU*8GztIM;_g?;)?0zm+D;6%2OQc_i&-68(E$F%MH^kq2#y++y65RV?8#hK zeSDEosns4YGUe*IK^v7c;-U{VW0M{@1U*QYF{4tBrae^7F?QHIX16T8dWYs!3=7|; z*1TNZv&iC~oA?8EG?#k=TE-p{!ZeJwR~H5W~QH)u>nAIclKnm1_dAro;ZZ_phWai!4O?(e8?!M`lW|MS$G!G497j;s=~ z5pO0Tm2U#mD!n1%;4^TjFR0FBhT%s4JGwnv?vP&>Xz?`RhCJ(8w^C)7S_2xbbK<6TuVb_;A4 zUL|`PAxoZ$KK>n;o57|PQtY3j%PIF?z_@^+IElN*meF#jrYAc_iHepgP0z`rh3*83 zXz2`e2IBAi*fh~g@uKC6_?e;?e`puAF8WZ>`3?@F)o+Ihu)1*Zm+tInBl3pmO`j+p{ZUxw17qE7e5HrV>*uLA6(6R=Tczukm17`@sT<6q-Ga~hfhVKN2?uYA`+rVi>(CR(-2sqZ6ilh2M z*h6i<5~|K56SU)tM5bn;!KKNogzAeSm?!#z_D0c%>We;LL|+hwRxJHce*SBupSK{& z^{H7~cSd+isa?9fO2xK|YK%VARli;JMLa!nFJVHX#0)?>j=<0Qq5S-}*i!>B>d&|~ z%imws?GZh%*QCecJk6d~Y-8#o-NWIp!a`w>EpA-|I!@6tOGOKDQv0xDjN)X1(-p;8 z4372GNU00K>5JlQ1ZOac(*cfscBE7fI9*Ykd%>|`su1xU>s9*Q&@sC~`Ss-**q+F% zbbpnPop`-0*9-cEN)f$rB3$14>er&T6Sba(Q$Li=gS-{!W$hXLN`yJhDjH|`t1vi< zlV6YWD9(y17$Z3{4wq~Fz6t-ETCZ894#9_X;ARf`JqMp8AAJl;4Bsop*|QP)cM_A1 zbg}`j@u62D57p8k)l$RK$YP#WW3UFf|4HwVvbUr?xFH66a-~Kp(T|TM#sXHd;Tw8E zM9TP8k(taf)XULhOwB(|&CmM(?NDk|+imE4@=DyX{J#{LR44T*^`z+2U!&I8xs3Xh zcHg2;mq&LNDZxQL%mo!bv>_D>qkgB}7XALM7=ZH6pEUo7s|k5=$!F;==bzX%srh-_ zk*n^ItG>|g_qL)HJnH^WbzdJN*LB@Dv67EG@=Wa{2bn+uaH0D>HA&T|r5SRw#&8Ed*PMm0GqLM~Rg}253NNoWKEyMnIfE zZIr-HoJ4;piO{Hx&?+s{#wpSCckcIn_s#6gdv^(SK+8L4?mfSA&OP_sbMJfaJbh(E z^U>u;%H>O^33$qyszUraVGrX?lANJ5s7ec?wLtpmL zU-8gSc<5_|(BJE!-|wMQEdp2fMGyT#A@n02`n-q!RS$jIL%&!Eox+-<*TTIX`b!@A zF%NyG5c+K|2RP=Tzv!Xg;hDLg;UK=tn&Cr#$pqfOgTJE`FS$|8!!ynCVM9jSy1_y;6rU_mzwb(X&-DY&uIHxhbnx>I${ovW1rR-_8}V{ zGzU*<`}k)~JDsSVKwcBaw$h#5&Luo21#5sgJVyD(47VZa4szzB;?E7xh3=UK_^RU1 zNZrM=FtZ;RtWuh5B(_*{caEa{T}*-Lg?2$bgHf4TK+B%{fLKtu@L%m9{Lj=`VkNPZOktz zp&a*}Lg>$W=&6T(8@}yWWARN7y;lhR84tbXq2Kb*f7?UfD}?^Ehu-ke-}2D^y@!6a z5c*Rd`ePpY8y@;|9{ROH=+`{-4G;Y_5B-{l{&XSqCq4945B=*Ndf!8Twh;PN4}IA~ zf5k(;;GthHg#Ltwe!qwQvWI@cLw}(V`kseA@1cLyL#O+Z+-P&75PIsN-|L~j^m{z?=RNc{J@l^?Lf`Sw@AlB2^U&#ed{_5Z z3!yhW^t(LtXFT-(;GuuB5c)+A{fLMDl!s2wr?|SmUI_g$5B)YaDU!3y=b!Y@pY_n+ zEQEf+L%-#rKjEQY_0ZoggudaSzvZE)9{P?!m%9lvmpI88zKb+`)GpG(k~vakN}L(o ziCyH~O0N;SNF%e_MOrdT-M@Q;?rO(z2lbl2SLLF^cS#G+tNAs&&G8$`H@*#9s?5jJ zYofi(n~JmAB`w@m@+ivulS&IkS^TfCvz(RE@(bGXv3Vaf-s7zfPe1U14bHa+M?zvkT?N^O?WCPkYgybX-W zPwwa!^QoiFRjxbn$vKNtZ-s#6@lSHNh+b2G78L38v&2kvo#YdZ*4pL$$_rp??%4c8w7KR`{u~tg5D&rUe}VF}953S2xw4Pn zt~!$rVJj`F&8- zwPQi~Gf=KeWI?$F3VrB)JwbW*GmuAml%V{5P%4!ZmB0O4)n*!$DRdF`!C16dgbHA2 zWyWF&ZB!m5_|!mAS*4)-7$~BWhSL3CgQA`q6K$RcMfo$V8Yg?r6n5t4{HoVi(B>wr zK|U{f{Q)TSF*5&mP+oE@w)it>00%N{&Ve$+ZKybZ0+cr#%kNOH%9PdXpMgSi-SGJw zD6TbbfTGqNdIJtD*1#Rc=w&SS3ff!)g)~4L+_=mT3F&t;I)8~aYtHDr=VviC&bZ$V z3SDh5oPP+En@+EP2+CWIUaO$EGCu~&b*EPf3Vn<`|CA`&6WU2T?!oC#IHU9HXmb&5 zu*KlIRVse~O3xXuH;Lk4eb=YK2VG3B4}qd`S~1EeK%x4F=qNceP(&q!DNx!`3r~x{ z&W=1SwE3pC7^8=d&TLfHBoD#)D%xDoZSYg&DNrstl+S{q>MV&~UnUCLnwk5XpwP!? z@eNR3gutfF+n_ATh%NYh;8{d|2kVDHaeegxP}KfH^g0j93C9{uQ074~SScuPIFwI; zB5KZ%#pv@QD33W3{uU^w9eKV9%28)@{v4DG=xx02TcF(U@VWcvPO>A1K$HQT_o?T(7$i zlw%+o2|otPy>g{~S0$D+uIJ3SCfZyiOxd$i8Gy3pU_C_?{BCB-=Ri?+RtpLL9Vn}g z?!N+xSsm~sV6&5MRW3T{-$0ug$Ls!-_&^vj7WGz=^nkqM$a5QQt~yrzyV$&wchmob zJokVi?jfI&lpg^_RY((UPEs4$Lr~6wa=)X+KLJJMW1>wDl-@^0b}1-74a!SeW-zRL z5)@S>OtkqtQSgiLv0nv6Wlf^Z?|^buM`Nr+P0FKY(97uc$7plI(f$7r#j($OKPzeu z8?5gIWeR)eMmYX;io_mwX>!q43yU#3A><(d!Lj%KLyGQ-*5N&G$_ZM zUS9yEOB+AbBPovEZ02!<=fpWr$#(x2dxN}d9;NO6f zIx_#AUjVw4_gy4l<%6JHx6xzTgV4wL;YZNsHHXhKC}bexbw37*yS{fpK_}UU@%v3M zcbshJr_knE?wLyFYoOdjFOp73_=})C2}Z_Seg%}*wajQ(`7KbcJAD2KlzSb^ze&9u zZ>c;l-hW{@e>W&cwN<%q#IQ3Ej5X@i1{5@t5?%!5Sx25dP@a3YE%Uzu<;W46@)_#o z$nzyoZt2(y_LY}GnUOfc8n1%#vcvgLKskXnAWC_@1&XR6DSCa!FJj!$K(tX6U0!#v zrqJe^w&B*5J}OsWUT6x~SAH068b@p`mO%M1ela$zgR+J;MxISjdQv(e&mJiBG5+(k zNBMbB+(`RnP`>J*{}m`-;Wkvd&-@Zb`TOko^^ZW=b5^T5C|`3d|Ib0$aoT(ql$*|& z`d0lC+K9S*Q_}MP1(a8HFV^kwZT3~ihPTni>{G-(9OzD)@A@KEE7*suB`h`v3jJj) zb`BK!7|J#%Ux(S>1FGot1So&~?P@h=vMkpL`MYTI4BFgwtoj-#6tc|-{skzaYT^_) zV>NFj9gL16^Sv*KO5pF&=nsQ37wfRq= zsB05Ki~kJDD~=XF^vjro4rLLPqmDc^P~50>9+a!^CI2B!FUwST%F(oiHpgI9q3KpX zNl2y(PMbZnxdAFk_pZvn#JA~2vbnp>qJGrbP6q00v$NGze@B~}{p7Ox)@pVV_4ihv z?mv?pV168ZhzHS{oy$?H*;oVDc9JIj)8gUy3d()3m{Ikail|m_Y`ULp_0s;d>eozL z>7dc?rfjR*kHMTDgAQr7-x;ITV7GfvE9rn)FvgngXggt>(ICOfn=4Ax>#=mdm*6y_ zgSHKP&o-26Or|?KvvT&KN7>5R`o_uCRkmDv;QT}E%*l<@we@vjCveWQlnRsZ_o$zW zfpU$+8eLU+4IYoT*&$RLC|$V}#+IXux8stnIgN zU~K4&i!@-gZ`_RX*otBAwi?M^+|xxAe0I$??w#e#k`7!kqpvtF&Z9;-ZD~v7w{0T9 zc(mC$lQC9H*yRewccc}!JG%@zB)zoR?Wkf99*lfIvm#3%ojfW3TESn8p-d+0C)>>d zW(*T^OAs4LhRiRF9OH-3YcL00oWnOd+O9L4P1n=a>V3Ut5+_%haNW4u!Q|YHQ}NRh z4A~W)B|Dz2r_}|vzR6Mq4b-HG0C;M)b{Xx5{-i+j8Z5ChPy~g2hO%&5ki2vJY$1X( zAr@^5Nf)ut>-G@@jGRkK%$2yF&iA5bf8~*QZGHoS*Pz7=t0yfyiC-P0EA@E>(tIl! z3|8V=J>rDgsj3nx3@b~vxpvfBk;1sZTGD!z)oPXulXcNpTwkS$`C|XxOswDK7x(wY zW@nJ}(;7zbIAihNUbR}CMXYPa@Od1yY?FzrRSJ%9jHsDPGse(>JOjARq!g2kJcA_a z$2%qEDZ|8-r#iz!;^5I{T2iR;oU-u>Q+z(|?t058&HZ_76kB;?S6jz;&WRE3Vu+Kd zy|TeJW-v__vAhMGWYsw}O|gXbS}XM>wz^rh9l!MC8wsIxxeoypkr~e2Nmkb4BCcMm zZLU9Zw$7@UB#1`1>cFrC=~JYV)~nT*De9iRb6`38<%w5N;a*RKNTW|^=34$o4h5r; z2n7z2yV0PYjvd4oFl9R_rr`qjmq!YA)z}mCZ|-T>0=*0(R#C(dJ-a)ozzRxcA;v^k z*~2954N5vYqaiLO`^aG0y{ONT+D4od$fks-{jzjzJ}z!}=@D8$fT#&6aT1%s-ymoAt<_iOEma)*mtP zrchUnJwfECR$JXG*v4!k;?b~)h*yq55jo6YOn{wZbF6@Bf23Fc1Fbz_C#~Nk3&WC% zkJ{zNUXJXpHuiX8>qQm|!dS-P9c&!6HH%yD(YQXVX0}h)z3S-#&M;cZ%ERbE`Q*xF zo>%V(MqBK>vF1DN5hlRz%e`|Oe1HSQ#CModdc3S;b`Is~ znLg5(ENKeCM#~hy+)J#^`pxZ~w6=!v*Di_OP(vJ!iYcIfD0(z=FiuFVjzg z9S9Rrrz*{MoSygi*zn;pxq`^mb;K$?Tw{W1{SZS-W7=slcHE&^29}@aIWYh{H%pMvF0f zkQn23S2AD_N>2;E>cqGpk|umvqwVF;p|>oS*&R`OoU?9*-1^)JNkdw8mS*{Og2HM1 zVxzqUWxehI8_E&u4_sE|76Ar1h$ta#<1G0(esdU^MIKB@ow$F>v8D~juq|W#6dN*I z0%;vU5X&yPrykylM!D9g9dcvaH-){7)@?wazV8b6-L z%~a$|6SUR{0hVra@&Orw@(U>?Uviv-l>B^f$Qlta)d?Yqwv2Tgy@&#)E!>osG#H)+ z-rU{Fx%N+ErT27&`)YLVo~Ln3BEJoHg|>FM^s~A-!*4Rsmwn*FBO6)#beJrDIw5mf zp5Vy4B!hDeD)DhhtZxG?v&FeQBx?)0$GJn&Y6~N(jo5{F0TFvVX-(YOJdiiJmgZqg zQ`(v42hGRTJstt#rDCUL48W6LKH!&?+FfPD!(eO4EN)X85`JkfkL$@4g~cUh9063B zzGzvnuZ3QEP-p3&-r7rxE4h3d9dPY92qmOOIFiGq2V8^;>jD|Bmc-+ZBGMh<1Q`Ew zxI_k5{$P8Y`689Xx{a9FC_8y6QigbJ+a1)g~HogDC62go03nd$!wYFYoV8( zPn7;!X>#7tNSJhU44{yD&6599oH$Dt==Dtq%A-o#Z8(2Ri|V2VR!{cooOUe=LF}LkQukt?+b4)BlQrzT58&pWqsE( zYW8BwtkpPg`^L;8 zbo_dYUUH4s91?FWy%iRU+&O0!j73^7CrFOK(taG7~4q~&@ zG9ot{ewU4zN(VKv_=%NAKjV!Pnupixcx09CM<3%Bjpg13&5`3siSQ@-$@}%gv$bR% zrXKkOJzbAgRy^!5++1!`#oL}eh)*N#K^k(K4Lvn6RxgE!+-In%=qw)NKqG-Ci`9b} z!s6@L`*4%f1Mg6CmaTM9)0GO21CJucG5{#F2GYAGm^K;d$!1&*hz-rW2C~c@PmS#q}5CM z>f#CpbRAQLo)&i|GYR-GJQpKOqsrwe%VECCsKQ2yq61WtqKV5(kK-F^XrN?_xIF=d zE9m=7vsqyet)6?}YPyVAu-R!&2UW9j1>UI)U44#d%taqLIVJXt2}sWGjh7iz$%AVngoUYJqk zMJh6=7R}~YwwQ%2M_FDOxk?qa$jDWSmn&C*x)!c*0T^ltLtINT*{NT~BIt~=4)Ai2 zv`!{vJM3~6M!P$RnWHBzOyF|0TXmyMS&KZqf@5es?6g0eA`QB-YZN(55TnTik5AiW zE-W#Na?mnNz(AF|Fz`h>8{{#sT=23N7Uo3V4BFTwEp+t6PH4P}8D?b+5FhQQ@hq*& z-;eJw)^<4@N7vOVv@s7E$LJGa2&}RgW(06?r*w{IGY%@TdaTKqJAkx`sV(UwxAf>T z8IBQ)anLeM5OT85rJ-Dgk)$M_BJwDE>Oq=72Gv*N(zV91?k~t6g-QF`xMOcG><8nF z*A$)8=+$F-U0XXE9R&(OmNg>rt@z0L7MPI(PumeI{DZj($PY|`kVt6Xd0 zK_F*71m$bVTRLjK(<)Qwfe#R4-)Xw(aWgxVYLRpCOwtyFo0ctr-L0n-Fg>)3S`T^H zGgJRw^zP;{;6iF=9xb^O${marQa65!>%rwXf)3xfm|9Q7+yFjf>fsq}f^!Zkvw5Z@ zti%@Ipz`|9bkJ&PPN;NwmthYV@q2{B>KaHUZKnXP=sZ-b9s96?<-ur{ZWCrL!^W{p zCN!LslA~*Cxi*Z zNEFgWPA-v?*M(g}4@L{A8&4F=l?4euflA6_*(dkV%3I!W!ZqZ6bZ2PGGqWTs9~;Ln z+Yxel;$ECFtCIx1qJg)lQafgNbRfxtUIFKIC!D; zvmRSK^x-4@4#Ly=k;TU>Ct_yNB%L%;fV|H-stFmpEVdz~^$%Newqr>9hpaJ~gR;7DtyK32Tu%CA79Q!r&xFgg8&hlp!(tmuF>5RoVe`{SZBO zAYeGITGjwe`SlaKEQvAdp>VfkAL}7YzdVU8U{My96s3pdzyc!L2?7}OK(LUS@!f${ zuEe%{X|s9EEy>3n)_S&Vi7jDqCYB`QZB9iw5^J0%={7N%C`&Rin&@VsjcXwNe6%QM zQpCnt7M2vH9VwHqANonsICvrT8&Q75@`2K3906l#Q>L7Pd1~D$b7K3`VXzM*z4N%a zDR&Y|`eE#~^t5Tr`nGrEHsoSdfxa4d!c7Kck+S@WF--{`S`MfmundZkEim6e^4ibG z2P%gWO69{4OXnS>1ChN~s(SgU+q z1%c6JQfzNJEC{WI6+epH@n{wvT`t9le+axo$?dEOqHIbqx$}5yx$P%HiXKjt;GyLx zIX0OxD#2`*<*Vg2*Y)N72M}g8@wXDe5hTrzY%dQyXjM3KOE0(g5Hg*q!_FUSj3(#~-gS*66bBR(CUMu}0eM4;)I&Dbu3) zG~SSg_X12ac536?I$K?-Z!lKTMPHIerM=HuxJq=HSAqefK@#uwo9RCPj_XI=OUIvs2wpn(U?PN!;x>h)~;$lOC0v z$sw(E@e1WcsJY)^X=}jMCavXHQmB$u`PBLbJF|gSX{(=XlcDf;yV=>k!unBjkf4%H zx|8(#l|g!bko3>sTMge-n?aK9f~*>$EKW?7eS1Qf3f?m6eph;eBS*RdD*^*As_XAh z_o99}JySt3uzJEP>tM`!Npo&#k@a^wX|ql5vTJqYh@`v{4Y>8E?^~!IpZD})>*vpI ztemN#)NSqj@;SC%TRnG53~lY~GKM#6h!Gvon8smxx6^7~N?QB!;;HqW2O;xaS*Kn* z&A6s)2Q`CQiLo1v1xpl_bb*l*=rU8Ct0e7R#yRr8_#~^a?anSs)c9xlr8|8x5xosm zIJ>f?l!Shd2Nm@*Yc&Tc#*kfEoEL*l4R98u8K?mk9hKX=?d9tQ6;suPZLHQ~l(OB7 z;!Bm@AlYqnKf;IYBZN8~SJ=l;fPGhYm9U}Aff&H^l zJJG-oC8=!pV7Gq~g?*C&&3fU@=EqZAI8%mGZ7+dfXtP$+QdQW>;B2=;E*fp(#qOO` zyM4SzG35<3-=wqKrguBi>}@qS`%xe7tb$Yn#DipWcN@0b>Z-q^&CPy-3K`;;REoC9*RxF%zAhyOWba>Pzfs=Xkjq@BX79XM%)%?uJS&@!npw zTAkgD1}IDhH$kYTn;)vxcqi(sdggHr70vP1O%xkJ{Z=koq5k@qO7K`uTOV)2)KTkv z=L+Vf#hT!jtEm1`Ptx-p5!f1fy?U_O!pO& z_K-tIIoBv;x6;92x6AMr)|e!~p!Ehkwn?$!S0a@Vb4zxi1z2@yv|5ZtDvDtc_;WKJ z@PX&Hpf^ZOI>dDA?jtd-_sx<2P!Ubm-69*smng$%W1XQNbl{L?mlHGF10gf%!`9TL z9sNYNPxb5u+=%QlvI{DA$NiLo(Oydrmf*UKf`Msr3IVf;LDn%_4D{$oq73KeVA9(@ zwwv_HkMSe~P@5XnbmHbyZp6Pt?ZGw{Or$)fAKrNm=`+1BF_D9GP`g)qpQwyqU?eaM z^fofNzp~|?Inh4KL3qO}j)5Z?o6x zXdN9tv|JaSMl+U|pEKRp`rR07Ci-u*1|VZO-c2eS$nOxm(nS6Y{lv_5A{kW=rHD63 z8!;@t$l&Q{xj8U1TJ<}{2E8P1ZXtlF3avCMd`c~pvcx?Bj0b4E*{dO5Q$eMjhyB3KF+@D+ z!7yEloK}XCsMllk8fHKWm+ono7B*TMC2V zJ#hXZcIM>9>Dv0bv=XhIw7yuD=QDsj!mK0B&H?L)F&|=B#CanD=5LR)!;;>T2@EO^ zx?h2Nor-!Xc7}3Si0%WiOA;@>qXmqIX1Q8o`tjfcs|~sxr3fDuUhrQH3|&kd3eO6qm&ZNn z=py-G>&al3XaC$zp2P9XN_d;V+Txo{Wr-{kd+RUS^8&PF!>GSa`v@}}6<#YjFUzZB zBB0LtC=R-=Z_J9U0;L#InIkw;QlVPm8dV2HK6E*bTUct5Ov(`!u_Tr_d8XCuaGSxT z%bUJaQmtW14waW7sk@}i#J2bLuy^mn^{_d?LCGN5nUO!{&qDG;q?8ForXdNR(vJgj zU#B5~z2xd=mM=Ac)}ajsW;;g4Op>rFtxkGu#K0EFz2uYA0xf5m1g6*qv`v<7oj?xO|7057r+WqYOR=1YPjxka`7)(t8FHY37?CbDVJXD@WPSxJ z8&6WONkICZ33a3cwcxdx{q@p4v(uyOa+kqqJ4y9aAH|Zm$gGn7yu8)J4lLawr)@Jz z5tMyJ_UtZBDo4sVq8ts3iONJ}tSR7>O@Gg%pw7}pYM1ZU9gNHOgV zI6|nq-&I0L)zl`6zkRr9Jf(FU!(mcFlBeEElAiVpb5@d{7z%eGKF(pR-VO51*xuTS zNSYcKv9@^_ZhP;9Btsl^i_>iP)S5)Kw+db?h6grXPb-@Is^ktED^VwbTsSa)va#Spu@LTv@K37wsvQnfXA&w!#U|h zKzx_`W(uE0Hv>3Txim;Gu{Nb@nFK;)Cg46vwyt(TY9ZWN=^&yaSkfU=-8uU!qP5H& z%#6`{cXxS*JyaaP8ijEmdfF@ZL-_|b@KNlQ{9)yz=0+gbolRmYgI?*?#JKccOxvI$ z)^kt2wClM`J5L-ev?hDp%z{z7zES5`c^k3en;vm=AuMNxI&+Xx!~mI-U2*zp=^8^< cb-I8nP5j^s8=B!+Ir~KC3T@yr@xJo^0J*}0F8}}l literal 0 HcmV?d00001 diff --git a/数据结构/6.9.cpp b/数据结构/6.9.cpp new file mode 100644 index 00000000..738c900a --- /dev/null +++ b/数据结构/6.9.cpp @@ -0,0 +1,130 @@ + +/** + * Your Trie object will be instantiated and called as such: + * Trie* obj = new Trie(); + * obj->insert(word); + * bool param_2 = obj->search(word); + * bool param_3 = obj->startsWith(prefix); + */ +#include +#include +#include +using namespace std; +struct Tree{ + Tree(){ + m=new map(); + is_word=false; + } + bool is_word=false; + map *m; +}; + +class Trie2 { +public: + /** Initialize your data structure here. */ + Tree* tree; + Trie2() { + tree=new Tree(); + } + + /** Inserts a word into the trie. */ + void insert(string word) { + Tree* temp; + temp=tree; + for(auto a:word){ + if((temp->m)->count(a)==0){ + (*(temp->m))[a]=new Tree(); + } + temp=(*(temp->m))[a]; + } + temp->is_word=true; + } + + /** Returns if the word is in the trie. */ + bool search(string word) { + Tree* temp=tree; + int i=0; + for(i=0;im)).count(word[i])>0){ + temp=(*(temp->m))[word[i]]; + } + else{ + break; + } + } + if(i==word.size() && temp->is_word)return true; + else return false; + } + + /** Returns if there is any word in the trie that starts with the given prefix. */ + bool startsWith(string prefix) { + Tree* temp=tree; + int i=0; + for(i=0;im)).count(prefix[i])>0){ + temp=(*(temp->m))[prefix[i]]; + } + else{ + break; + } + } + if(i==prefix.size())return true; + else return false; + } +}; +// 官方没有使用心得结构体 +// 使用向量存储映射而不是map效率更高。 +class Trie { +private: + vector children; + bool isEnd; + + Trie* searchPrefix(string prefix) { + Trie* node = this; + for (char ch : prefix) { + ch -= 'a'; + if (node->children[ch] == nullptr) { + return nullptr; + } + node = node->children[ch]; + } + return node; + } + +public: + Trie() : children(26), isEnd(false) {} + + void insert(string word) { + Trie* node = this; + for (char ch : word) { + ch -= 'a'; + if (node->children[ch] == nullptr) { + node->children[ch] = new Trie(); + } + node = node->children[ch]; + } + node->isEnd = true; + } + + bool search(string word) { + Trie* node = this->searchPrefix(word); + return node != nullptr && node->isEnd; + } + + bool startsWith(string prefix) { + return this->searchPrefix(prefix) != nullptr; + } +}; + +int main(){ + + Trie t; + string h = "hello"; + string s1 = "hel"; + string s2 = "hee"; + t.insert(h); + cout<