c++ 高级operator

Author: lppgo

000_1_10-文件和stream/main.cpp

@@ -0,0 +1,44 @@
+#include <fstream>
+#include <iostream>
+
+using namespace std;
+
+int main() {
+    char data[100];
+
+    // 以写模式打开文件
+    ofstream outfile;
+    outfile.open("app.txt");
+
+    cout << "write to the file ..." << endl;
+    cout << "Input your name:" << endl;
+    cin.getline(data, 100);  // 100-1
+
+    // 向文件写入用户输入的数据
+    outfile << data << endl;
+
+    cout << "Input your age:" << endl;
+    cin >> data;
+    cin.ignore();  // 它的一个常用功能就是用来清除以回车结束的输入缓冲区的内容，消除上一次输入对下一次输入的影响
+    // 再次向用户写入输入的数据
+    outfile << data << endl;
+
+    // 关闭打开的文件
+    outfile.close();
+
+    // 以读模式打开文件
+    ifstream infile;
+    infile.open("app.txt");
+
+    cout << "Reading from the file" << endl;
+    infile >> data;
+    cout << data << endl;
+
+    // 再次从文件读取数据，并显示
+    infile >> data;
+    cout << data << endl;
+
+    infile.close();
+
+    return 0;
+}

000_1_10-文件和stream/readme.md

@@ -0,0 +1,83 @@
+[toc]
+
+# 1: file & stream
+
+- iostream 标准库，它提供了 cin 和 cout 方法分别用于从标准输入读取流和向标准输出写入流。
+- 本教程介绍如何从文件读取流和向文件写入流。这就需要用到 C++ 中另一个标准库 fstream
+- 标准库`fstream`;
+
+  | 数据类型   | describe                                                                                       |
+  | :--------- | :--------------------------------------------------------------------------------------------- |
+  | `ofstream` | 该类型表示输出文件流，用于创建文件并向文件写入信息                                             |
+  | `ifstream` | 该类型表示输入文件流，用于从文件读取信息                                                       |
+  | `fstream`  | 表示文件流，同时具有 ofstream 和 ifstream 的功能，可以创建文件，向文件写入信息，从文件读取信息 |
+
+- 要在 C++中进行文件处理，必须在 C++源码中包含头文件`<iostream>`和`<fstream>`;
+
+# 2: open file
+
+- 在从文件读取信息或者向文件写入信息之前，必须先打开文件。ofstream 和 fstream 对象都可以用来打开文件进行写操作，如果只需要打开文件进行读操作，则使用 ifstream 对象;
+- 下面是 open() 函数的标准语法，open() 函数是 fstream、ifstream 和 ofstream 对象的一个成员;
+
+```cpp
+void open(const char* filename,ios::openmode mode);
+// 在这里，open() 成员函数的第一参数指定要打开的文件的名称和位置，第二个参数定义文件被打开的模式
+```
+
+| 模式标志     | 描述                                                                 | other |
+| :----------- | :------------------------------------------------------------------- | :---- |
+| `ios::app`   | 追加模式，所有的写入都 append 到文件末尾                             |       |
+| `ios::ate`   | 文件打开后定位到文件末尾                                             |       |
+| `ios::in`    | 打开文件用于读取                                                     |       |
+| `ios::out`   | 打开文件用于写入                                                     |
+| `ios::trunc` | 如果该文件已经存在，其内容将在打开文件之前被截断，即把文件长度设为 0 |
+
+- 您可以把以上两种或两种以上的模式结合使用。那么您可以使用下面的语法：
+
+  ```cpp
+  ofstream outfile;
+  outfile.open("file.dat", ios::out | ios::trunc ); // 如果您想要以写入模式打开文件，并希望截断文件，以防文件已存在
+
+  ifstream  afile;
+  afile.open("file.dat", ios::out | ios::in ); // 打开一个文件用于读写
+  ```
+
+# 3: close file
+
+- 当 C++ 程序终止时，它会自动关闭刷新所有流，释放所有分配的内存，并关闭所有打开的文件。但程序员应该养成一个好习惯，在程序终止前关闭所有打开的文件。
+
+- 下面是 close() 函数的标准语法，close() 函数是 fstream、ifstream 和 ofstream 对象的一个成员 : `void close();`
+
+# 4: write file
+
+- 在 c++中，我们使用`流插入运算符(<<)`向文件写入信息；
+- `<<`就像输出到屏幕一样，不同的是使用的 ofstream 或者 fstream，而不是 cout 对象；
+
+# 5: read file
+
+- 在 c++中，我们使用`流提取运算符(>>)从文件读取信息`;
+- 就像使用该运算符从键盘输入信息一样。唯一不同的是，在这里您使用的是 ifstream 或 fstream 对象，而不是 cin 对象;
+
+# 6：文件位置指针
+
+- `istream`和`ostream`都提供了用于重新定义文件位置指针的成员函数，这些成员函数包括关于 istream 的`seekg` (seek get)和关于
+  ostream 的`seekp` (seek put);
+- seekg 和 seekp 的参数通常都是一个长整型，第二个参数可以用于指定查找方向。
+  - `ios::beg` : 从 stream 流的开头开始定位；
+  - `ios::end` : 从流的末尾开始定位；
+- 文件位置指针是一个整数，制定了从文件起始位置到指针所在位置的字节数
+- 下面是关于定位 "get" 文件位置指针的实例：
+
+  ```cpp
+    // 定位到 fileObject 的第 n 个字节（假设是 ios::beg）
+    fileObject.seekg( n );
+
+    // 把文件的读指针从 fileObject 当前位置向后移 n 个字节
+    fileObject.seekg( n, ios::cur );
+
+    // 把文件的读指针从 fileObject 末尾往回移 n 个字节
+    fileObject.seekg( n, ios::end );
+
+    // 定位到 fileObject 的末尾
+    fileObject.seekg( 0, ios::end );
+  ```

000_1_11-异常处理/main.cpp

@@ -0,0 +1,24 @@
+#include <exception>
+#include <iostream>
+
+using namespace std;
+
+struct CustomException : public exception {
+    const char* what() const throw() {
+        return "C++ customException";
+    };
+};
+
+int main() {
+    try {
+        throw CustomException();
+
+    } catch (CustomException& e1) {
+        cout << "CustomException caught ... " << endl;
+        cout << "e1 : " << e1.what() << endl;
+    } catch (const std::exception& e2) {
+        std::cerr << "e2 : " << e2.what() << std::endl;
+    }
+
+    return 0;
+}

000_1_11-异常处理/readme.md

@@ -0,0 +1,74 @@
+[toc]
+
+# 1: C++异常处理
+
+- 异常提供了一种转移程序控制权的方式。C++ 异常处理涉及到三个关键字：`try`、`catch`、`throw`;
+
+  - **throw**: 当出现问题的时候，程序会抛出异常;
+  - **try**: try 块中的代码标识将被激活的特定异常，它后面通常耕者一个或者多 catch 块;
+  - **catch**: `catch`用于异常捕获，在你想要处理问题的地方，通过异常处理程序捕获异常;
+
+- 如果有一个代码块抛出一个异常，捕获异常的方法会使用`try`,`catch`关键字。try 块中方式可能抛出异常的代码，try 块中的代码被称为保护代码；
+- 如果 try 块在不同的情境下会抛出不同的异常，这个时候可以尝试罗列多个 catch 语句，用于捕获不同类型的异常；
+
+# 2: try/catch 语句
+
+```cpp
+try{
+    // 保护代码
+}catch(ExceptionName1 e1){
+    // catch 块
+}catch(ExceptionName2 e2){
+    // catch 块
+}
+```
+
+# 3：throw 抛出异常
+
+- 您可以使用`throw`语句在代码块的任何地方抛出异常；
+- throw 语句的操作可以是任意的表达式，表达式结果的类型决定了抛出的异常类型;
+
+```cpp
+double division(int a,int b){
+    if (b==0){
+        throw "Division by zero condition!";
+    }
+    return (a/b);
+};
+```
+
+# 4: try/catch 捕获异常
+
+- catch 块跟在 try 块后面，用于捕获异常；
+- 您可以指定想要捕捉的异常类型，这是由 catch 关键字后的括号内的异常声明决定的；
+- 如果您想让 catch 块能够处理 try 块抛出的任何类型的异常，则必须在异常声明的括号内使用省略号 ...;
+
+# 5: C++标准的异常
+
+- C++提供了一系列标准的异常，定义在**<exception>**中，我们可以在程序中使用这些标准的异常，他们是以父类子类层次结构组织起来的；
+
+- 如下所示：
+  ![](https://www.runoob.com/wp-content/uploads/2015/05/exceptions_in_cpp.png)
+
+- 下表是对上面层次结构中出现的每个异常的说明：
+  |**Exception 异常**|**Description**|**Other**|
+  |:--|:--|:--|
+  |std::exception |该异常是所有标准 C++ 异常的父类。||
+  |std::bad_alloc |该异常可以通过 new 抛出。||
+  |std::bad_cast |该异常可以通过 dynamic_cast 抛出。||
+  |std::bad_exception |这在处理 C++ 程序中无法预期的异常时非常有用。||
+  |std::bad_typeid |该异常可以通过 typeid 抛出。||
+  |std::logic_error |理论上可以通过读取代码来检测到的异常。||
+  |std::domain_error |当使用了一个无效的数学域时，会抛出该异常。||
+  |std::invalid_argument |当使用了无效的参数时，会抛出该异常。||
+  |std::length_error |当创建了太长的 std::string 时，会抛出该异常。||
+  |std::out_of_range |该异常可以通过方法抛出，例如 std::vector 和 std::bitset<>::operator[]()。||
+  |std::runtime_error |理论上不可以通过读取代码来检测到的异常。||
+  |std::overflow_error |当发生数学上溢时，会抛出该异常。||
+  |std::range_error |当尝试存储超出范围的值时，会抛出该异常。||
+  |std::underflow_error |当发生数学下溢时，会抛出该异常。||
+
+# 6: 定义新的异常
+
+- 您可以通过继承和重载 exception 类来定义新的异常；
+- 下面的实例演示了如何使用 std::exception 类来实现自己的异常：

000_1_12-动态内存/main.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+using namespace std;
+
+class Box {
+   public:
+    Box() {
+        cout << "invoking box construct " << endl;
+    };
+    ~Box() {
+        cout << "invoking box destructor" << endl;
+    };
+};
+
+int main() {
+    Box* myBoxArray = new Box[5];  //
+
+    delete[] myBoxArray;  // 删除数组
+
+    return 0;
+}

000_1_12-动态内存/readme.md

@@ -0,0 +1,95 @@
+[toc]
+
+# C++动态内存
+
+## 1：C++动态内存
+
+- 了解动态内存在 C++中如何工作的是成为一名合格的 C++程序员必不可少的，C++程序中的动态内存分为 2 个部分:
+  - **堆 heap：** 在程序运行时用于动态分配内存；
+  - **栈 stack：** 在函数内部声明的变量都将用栈内存；
+- 很多时候，你无法提前与之需要多少内存来存储某个定义变量中的特定信息，所需内存大小需要在运行时才能确定；
+- 在 C++中，你可以使用特殊的运算符 **`new`** 为给定类型的变量在 runtime 时分配堆内存，这会返回分配的内存地址，即`new`运算符；
+- 如果你不再需要动态分配的内存空间，可以使用 **`delete`** 运算符，删除之前由`new`运算符分配的内存;
+
+## 2: new 和 delete
+
+### 2.1 new
+
+```cpp
+double* pvalue = NULL; // 初始化为null指针
+pvalue = new double;   // 为变量申请内存空间
+
+// 如果自由存储区已被用完，可能无法成功分配内存；所以建议检查 new 是否返回null指针，并采取以下适当操作：
+double* pvalue =NULL;
+if (!(pvalue = new double)){
+    cout<<"Error: out of memory!"<<endl;
+    exit(1);
+}
+```
+
+- **malloc()** 函数在 c 语言就出现了，在 C++中也存在，但建议不要使用`malloc()`函数;
+- **`new`** 与 **`malloc()`** 相比，优点是：**new 在分配内存的时候还创建了对象**;
+
+### 2.2 delete
+
+- 当你觉得某个已经分配了内存的变量不再需要使用的时候，你可以使用`delete`操作符释放它所占用的内存
+
+```cpp
+delete pvalue; // 释放pvalue所指向的内存
+```
+
+## 3: 动态内存分配示例
+
+- https://www.runoob.com/cplusplus/cpp-dynamic-memory.html
+
+### 3.1 double\*
+
+```cpp
+int main() {
+    double* pvalue = NULL;  // 初始化为 null 的指针
+    pvalue = new double;    // 为变量请求内存
+
+    *pvalue = 100.568;  // 在分配的地址存储值
+    cout << "value of pvalue : " << *pvalue << endl;
+    delete pvalue;
+
+    return 0;
+}
+
+```
+
+### 3.2 数组的动态内存分配
+
+```cpp
+int main() {
+    int** p;   // 二维数组的指针
+    int i, j;  // p[4][8]
+    //开始分配4行8列的二维数据
+    p = new int*[4];
+    for (i = 0; i < 4; i++) {
+        p[i] = new int[8];
+    }
+
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < 8; j++) {
+            p[i][j] = j * i;
+        }
+    }
+    //打印数据
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < 8; j++) {
+            if (j == 0)
+                cout << endl;
+            cout << p[i][j] << "\t";
+        }
+    }
+    //开始释放申请的堆
+    for (i = 0; i < 4; i++) {
+        delete[] p[i];
+    }
+    delete[] p;
+    return 0;
+}
+```
+
+### 3.3 对象的动态内存分配

000_1_13-命名空间namespace/main.cpp

@@ -0,0 +1,45 @@
+#include <iostream>
+
+using namespace std;
+
+/* namespace first_space {
+void func() {
+    cout << "inside first_space" << endl;
+}
+};  // namespace first_space
+
+namespace seconds_space {
+void func() {
+    cout << "inside seconds_space" << endl;
+}
+};  // namespace seconds_space
+
+int main() {
+    // 调用第一个namespace空间的函数
+    first_space::func();
+
+    // 调用第二个namespace空间的函数
+    seconds_space::func();
+    return 0;
+} */
+
+// 第一个命名空间
+namespace first_space {
+void func() {
+    cout << "Inside first_space" << endl;
+}
+// 第二个命名空间
+namespace second_space {
+void func() {
+    cout << "Inside second_space" << endl;
+}
+};  // namespace second_space
+};  // namespace first_space
+
+using namespace first_space::second_space;
+int main() {
+    // 调用第二个命名空间中的函数
+    func();
+
+    return 0;
+}