# Cplus learning

**Repository Path**: ding-xueshuang/cplus-learning

## Basic Information

- **Project Name**: Cplus learning
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-10-31
- **Last Updated**: 2024-11-22

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# C++入门
## 写在前面
这个仓库主要用于本人学习C++编程，内容一部分属于自己独创，一部分会借鉴比如：菜鸟教程、github、博客园或者是一些大佬的笔记。无任何商业盈利目的。
## 一、基本概念与语法
### （1）预处理
如`define`宏
```C++
# include<iostream>
using namespace std;

# define PI 3.1415926 // 1 宏定义

# define Max(a,b)(a>b?a:b) // 2 参数宏

int main(){
    int r = 2;
    cout<<"circle's area is:"<<PI*r*r<<endl;
    int a=10;
    int b=20;
    cout<<"max data="<<Max(a,b)<<endl;

    return 0;
}
```
### （2）动态内存
堆：程序运行时，可动态分配的内存空间
栈：函数内部所有变量占用的内存空间
动态分配内存空间：在程序运行时，给指定类型的变量分配内存空间，使用new。

## 二、函数
### 1、函数声明
```
函数返回值 函数名（参数类型 参数名，..）
{
    局部变量类型 局部变量名
    函数内容
    return 返回值
}
如果没有返回值的话，声明函数返回值为void，不写return
```
下面是个简单的比较函数的代码，其接受两个整型参数，`data1`与`data2`，当`data1>=data2`时，返回`data1`，反之，返回`data2`：
```C++
int compare(int data1,int data2){
    int r;
    if(data1>=data2)
        r = data1;
    else
        r = data2;
    return r;
}
```
### 2、函数调用
`main()`函数调用刚刚定义的函数，并且声明一个整型参数`int r`来接受函数返回值。
```C++
int main(){
    int r = compare(3,2);
    cout<<"r is:"<<r;
    return 0;
}
```
### 3、函数的传参
#### （1）值传递
参数的实际值赋值给函数的形参。在这种情况下，因为传递时形参拷贝了实参的值，并不是实参本身参与函数内的改变，故修改函数内的形参对实参没有影响。比如：下面交换函数，实参的值没有改变
```C++
void swap(int a,int b)
{
    int tmp = a;
    a = b;
    b = tmp;
}
int main(){
    int a=3;
    int b=2;
    // 值传递
    swap(a,b);
    cout<<"a="<<a<<","<<"b="<<b; // a=3,b=2
    return 0;
}
```
#### （2）指针传递
指针传递是将实参的地址传递给形参。此时修改形参，对应实参的值会改变。
```C++
void swap(int *a,int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}
int main(){
    int a=3;
    int b=2;
    //指针传递
    swap(&a,&b);
    cout<<"a="<<a<<','<<"b="<<b; // a=2,b=3
    return 0;
}
```
#### （3）引用传递
引用也传递的是实参的地址，其本质是为实参起了一个别名，使得我们可以通过不同的名字来访问同一个对象。故修改引用传递的形参，实参也会改变。
```C++
void swap(int &a,int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}
int main(){
    int a=3;
    int b=2;
    // 引用传递
    swap(a,b);
    cout<<"a="<<a<<','<<"b="<<b; // a=2,b=3
    return 0;
}
```
## 三、面对对象
### 1、封装
封装是将数据的方法和操作封装组合在一个类（`class`），这个类具有`private`，`protected`，`public`三个权限，从而达到隐藏类内细节，仅提供必要的接口供外界访问的过程。
C++的类可以将数据高度抽象，只留类方法接口供人调用，而使用者无需了解类内部的数据实现，只需关注接口实现的方法即可。
```C++
// 例子如下
class Student
{
    private:
        char name; // 私有属性，类外不可访问
    public:
        viod set_name(char n[]) // 外界调用的接口，对对象的name进行赋值
        {
            name = n;
        }
        void get_name() // 外界调用的接口，对对象的属性进行访问
        {
            cout<<"student name:"<<endl;
        }
};

int main()
{
    Student s; // 实例化类为对象
    s.set_name("Li Hua"); // 调用对象方法 对name属性赋值
    s.get_name() // 访问对象s的属性
}
```
#### （1）类的定义
如下代码所示：该类定义了一个学生类别，包括属性`age`与`height`，类中还可以定义类的成员函数`get_student_inf`与`set_student`
```C++
# include<iostream>
# include<string>
using namespace std;
class Student
{
    public:
        int age;
        float height;
    
    //成员函数
    void get_student_inf(void);
    void set_student(int a,float h);
};
void Student::get_student_inf(void)
{
    cout<<"student age:"<<age<<","<<"height:"<<height;
}

void Student::set_student(int a,float h)
{
    age = a;
    height = h;
}

int main()
{
    Student s1; // 从类中初始化对象
    s1.set_student(20,161.2);
    s1.get_student_inf();
    return 0;
}
```
#### （2）类的访问权限
由`public`、`private`、`protected` 组成。
```C++
class Student
{
    private:
        int age;
        float height;
    
    //成员函数
    public:
        void get_student_inf(void);
        void set_student(int a,float h);
        // Student(); //默认类的构造函数 无参数
        Student(int a,int h); // 带参数的构造函数
        Student(const Student &obj); //拷贝构造函数
        ~Student(); // 析构函数
};
```
#### （3）类的构造函数与析构函数
##### 不带参数的构造函数
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。
```C++
# include<iostream>
# include<string>
using namespace std;
class Student
{
    private:
        int age;
        float height;
    
    //成员函数
    public:
        void get_student_inf(void);
        void set_student(int a,float h);
        Student(); //构造函数
};
Student::Student()
{
    cout<<"调用Student类的构造函数"<<endl;
}

void Student::get_student_inf(void)
{
    cout<<"student age:"<<age<<","<<"height:"<<height;
}

void Student::set_student(int a,float h)
{
    age = a;
    height = h;
}

int main()
{
    Student s1;
    s1.set_student(20,161.2);
    s1.get_student_inf();
    return 0;
}
```
以上程序执行结果为：
```
调用Student类的构造函数
student age:20,height:161.2
```
##### 带参数的构造函数
默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值。
```C++
# include<iostream>
# include<string>
using namespace std;
class Student
{
    private:
        int age;
        float height;
    
    //成员函数
    public:
        void get_student_inf(void);
        void set_student(int a,float h);
        // Student(); //默认类的构造函数 无参数
        Student(int a,int h);
};
Student::Student(int a, int h)
{
    cout<<"调用Student类带参数的构造函数"<<endl;
    age = a;
    height = h;
}

void Student::get_student_inf(void)
{
    cout<<"student age:"<<age<<","<<"height:"<<height;
}

void Student::set_student(int a,float h)
{
    age = a;
    height = h;
}

int main()
{
    Student s1(20,169);
    // s1.set_student(20,161.2);
    s1.get_student_inf(); //调用Student类带参数的构造函数
                          //student age:20,height:169
    return 0;
}
```
##### 类的拷贝构造函数
拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
```C++
# include<iostream>
# include<string>
using namespace std;
class Student
{
    private:
        int age;
        float height;
    
    //成员函数
    public:
        void get_student_inf(void);
        void set_student(int a,float h);
        // Student(); //默认类的构造函数 无参数
        Student(int a,int h); // 带参数的构造函数
        Student(const Student &obj); //拷贝构造函数
        ~Student(); // 析构函数
};
Student::Student(int a, int h)  // 带参数的构造函数
{
    cout<<"调用Student类带参数的构造函数"<<endl;
    age = a;
    height = h;
}

Student::Student(const Student &obj) // 拷贝构造函数 &obj引用对象s1来初始化s2
{
    cout<<"调用Student类的拷贝构造函数"<<endl;
    age = obj.age;
    height = obj.height;
}

Student::~Student() // 析构函数
{
    cout<<"调用Student类的析构函数"<<endl;
}

void Student::get_student_inf(void)
{
    cout<<"student age:"<<age<<","<<"height:"<<height<<endl;
}

int main()
{
    Student s1(20,169);
    Student s2 = s1; // 拷贝s1来初始化s2
    s2.get_student_inf();
    return 0;
}
```
##### 类的析构函数
类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
析构函数的作用是在（比如关闭文件、释放内存等）前释放资源。
```C++
# include<iostream>
# include<string>
using namespace std;
class Student
{
    private:
        int age;
        float height;
    
    //成员函数
    public:
        void get_student_inf(void);
        void set_student(int a,float h);
        // Student(); //默认类的构造函数 无参数
        Student(int a,int h); // 带参数的构造函数
        ~Student();
};
Student::Student(int a, int h)
{
    cout<<"调用Student类带参数的构造函数"<<endl;
    age = a;
    height = h;
}

Student::~Student()
{
    cout<<"调用Student类的析构函数"<<endl;
}

void Student::get_student_inf(void)
{
    cout<<"student age:"<<age<<","<<"height:"<<height;
}

void Student::set_student(int a,float h)
{
    age = a;
    height = h;
}

int main()
{
    Student s1(20,169);
    return 0;
    /*输出：
    调用Student类带参数的构造函数
    调用Student类的析构函数 */
}
```
类在创建对象时，会自动调用构造函数初始化对象，而在执行结束时会自动调用析构函数释放内存。
#### （4）类的友元
友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。
```友元函数使用关键字friend标识，格式如下：
friend 函数返回类型 友元函数名(输入参数){}
```

```C++
# include<iostream>
# include<string>
using namespace std;
class Student
{
    private:
        int age;
        float height;
    
    //成员函数
    public:
        friend void get_inf(Student s); // friend 关键字声明get_inf()为友元函数，不属于Student
        void set_student(int a,float h);
        // Student(); //默认类的构造函数 无参数
        Student(int a,int h); // 带参数的构造函数
        Student(const Student &obj); //拷贝构造函数
        ~Student(); // 析构函数
};
Student::Student(int a, int h)  // 带参数的构造函数
{
    cout<<"调用Student类带参数的构造函数"<<endl;
    age = a;
    height = h;
}

Student::Student(const Student &obj)
{
    cout<<"调用Student类的拷贝构造函数"<<endl;
    age = obj.age;
    height = obj.height;
}

Student::~Student() // 析构函数
{
    cout<<"调用Student类的析构函数"<<endl;
}

void get_inf(Student s) // get_student_inf()为Student类的友元 不属于Student
{
    cout<<"调用Student类的友元函数"<<endl;
    cout<<"student age:"<<s.age<<","<<"height:"<<s.height<<endl;
}

void Student::set_student(int a,float h)
{
    age = a;
    height = h;
}

int main()
{
    Student s1(20,169);
    Student s2 = s1;
    get_inf(s2); // 调用友元函数
    return 0;
}
```
#### （5）this指针
this 指针是一个特殊的指针，它指向当前对象的实例。可以使用this指针来调用类的成员函数。但是this指针不能调用友元函数，因为友元函数不属于类，而是作为可访问类的函数存在。
```C++
# include<iostream>
# include<string>
using namespace std;
class Student
{
    private:
        int age;
        float height;
    
    //成员函数
    public:
        friend void get_inf(Student s); // friend 关键字声明get_inf()为友元函数，不属于Student
        void set_student(int a,float h);
        void get_student_inf(void);
        // Student(); //默认类的构造函数 无参数
        Student(int a,int h); // 带参数的构造函数
        Student(const Student &obj); //拷贝构造函数
        ~Student(); // 析构函数
};
Student::Student(int a, int h)  // 带参数的构造函数
{
    cout<<"调用Student类带参数的构造函数"<<endl;
    age = a;
    height = h;
}

Student::Student(const Student &obj)
{
    cout<<"调用Student类的拷贝构造函数"<<endl;
    age = obj.age;
    height = obj.height;
}

Student::~Student() // 析构函数
{
    cout<<"调用Student类的析构函数"<<endl;
}

void Student::get_student_inf()
{
    cout<<"Student age:"<<this->age<<","<<"height:"<<this->height<<endl;
}

void get_inf(Student s) // get_student_inf()为Student类的友元 不属于Student
{
    cout<<"调用Student类的友元函数"<<endl;
    cout<<"student age:"<<s.age<<","<<"height:"<<s.height<<endl;
}

void Student::set_student(int a,float h)
{
    age = a;
    height = h;
}

int main()
{
    Student s1(20,169);
    Student s2 = s1;
    s1.get_student_inf();
    // get_inf(s2);
    return 0;
}
```
#### （6）指向类的指针
```C++
int main()
{   //方法1
    Student s3(25,183);
    Student *p = &s3; //指针p指向对象s3的地址
    p->get_student_inf();
    return 0;

    //方法2
    Student *p = new Student(23,165); ////指针p指向 new Student(23,165)的地址
    p->get_student_inf();
    delete p;
    
}
```
函数可接受一个类的指针来访问类中的方法。比如：
```C++
// 综上class Student 类已经定义
void print_Student(Student *p)
{
    p->get_student_inf();
}

int main()
{
    Student s4(19,166);
    print_Student(&s4);
    return 0;
}
```
#### （7）类中的静态成员
##### 静态成员变量
静态成员变量的关键字是static 表明无论创建多少个类的对象，静态成员都只有一个副本。这意味着，静态成员变量是被类的多个对象共享的。
```C++
# include<iostream>
# include<string>
using namespace std;
class Student
{
    private:
        int age;
        float height;
    
    //成员函数
    public:
        static int Group; // 静态成员变量
        friend void get_inf(Student s); // friend 关键字声明get_inf()为友元函数，不属于Student
        void set_student(int a,float h);
        void get_student_inf(void);
        // Student(); //默认类的构造函数 无参数
        Student(int a,int h); // 带参数的构造函数
        Student(const Student &obj); //拷贝构造函数
        ~Student(); // 析构函数
};
Student::Student(int a, int h)  // 带参数的构造函数
{
    cout<<"调用Student类带参数的构造函数"<<endl;
    age = a;
    height = h;
}

Student::Student(const Student &obj)
{
    cout<<"调用Student类的拷贝构造函数"<<endl;
    age = obj.age;
    height = obj.height;
}

Student::~Student() // 析构函数
{
    cout<<"调用Student类的析构函数"<<endl;
}

void Student::get_student_inf()
{
    cout<<"Student age:"<<this->age<<","<<"height:"<<this->height
    <<","<<"Group:"<<Group<<endl;
}

void Student::set_student(int a,float h)
{
    age = a;
    height = h;
}

void get_inf(Student s) // get_student_inf()为Student类的友元 不属于Student
{
    cout<<"调用Student类的友元函数"<<endl;
    cout<<"student age:"<<s.age<<","<<"height:"<<s.height<<endl;
}

void print_Student(Student *p)
{
    p->get_student_inf();
}

int Student::Group = 2024; //初始化静态成员变量

int main()
{
    Student s4(19,166);
    Student s5(25,186);
    print_Student(&s4);
    print_Student(&s5);
    return 0;
}
```
##### 静态成员函数
静态成员函数可以在类不初始化对象的前提下调用，且它只能访问静态成员变量、静态成员函数、类外的函数。因此，笔者理解静态变量与函数是类内不属于该类的数据与结构。
```
但注意调用静态成员变量时使用格式如下：类名::静态成员函数（）
```
```C++
void Student::get_Group()
{
    cout<<"Group is:"<<Group<<endl;
}
int main()
{
    Student s6(21,178);
    Student::get_Group(); //静态成员函数调用
    return 0;
}
```
#### （8）函数重载与运算符重载
##### 函数重载
在同一个作用域（类）内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。
```C++
# include<iostream>
using namespace std;

class printData{
    public:
        void print(int data)
        {
            cout<<"int data:"<<data<<endl;
        }
        // 重载print函数
        void print(double data1){
            cout<<"float data:"<<data1<<endl;
        }
        void print(char data2[]){
            cout<<"char data:"<<data2<<endl;
        }
};

int main()
{
    printData p;
    p.print(4);
    p.print(12.334);
    p.print("hello world!");
    return 0;
}
```
##### 运算符重载
###### a.类内运算符重载
关键字 operator"重载运算符"(参数引用){}
```C++
class Point{
    public:
        Point(int a, int b)
        {
            x = a;
            y = b;            
        }
        Point operator +(const Point &p)
        {
            Point p1(x,y);
            p1.x = this->x+p.x;
            p1.y = this->y+p.y;
            return p1;
        }
        void print()
        {
            cout<<"(x,y)="<<"("<<x<<","<<y<<")"<<endl;
        }
    private:
        int x;
        int y;
};

int main()
{ 
    Point p(1,3);
    Point p1(2,4);
    Point p3 = p1+p;
    p3.print();
    return 0;
}
```
###### b.类外重载
友元函数实现重载
```C++
class Point{
    public:
        Point(){};
        Point(int a, int b):x(a),y(b) {};
        // 使用友元函数 进行类外重载
        friend Point operator +(const Point &p1, const Point &p2);
        void print()
        {
            cout<<"(x,y)="<<"("<<x<<","<<y<<")"<<endl;
        }
    private:
        int x;
        int y;
};

Point operator +(const Point &p1, const Point &p2)
{
    Point p;
    p.x = p1.x+p2.x;
    p.y = p1.y+p2.y;
    return p;
}
int main()
{
    Point p(1,0);
    Point p1(2,1);
    Point p3 = p1+p;
    p3.print();
    return 0;
}
```
### 2、继承
继承是一个子类通过父类派生，来获得父类属性与方法的过程。
继承允许创建具有共享代码的类层次结构，减少重复代码，提高代码复用性和可维护性。
父类通过`private`，`protected`，`public`三个权限对子类进行限制访问。
以下三个内容派生类不会继承自基类：
（1）基类的构造函数、析构函数、拷贝构造函数
（2）基类的重载运算符
（3）基类的友元函数
#### （1）公有继承

当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。

```C++
# include<iostream>
using namespace std;

class Animal
{
    public:
        void eat();
        void sleep();
    protected:
        void fur();
    private:
        void no_fur();

};
//cat 公有继承 自Animal
class Cat: public Animal{
    public:
        void Miao();

};

void Animal::eat() //基类方法
{
    cout<<"it can eat!"<<endl;
}
void Animal::sleep()
{
    cout<<"it can sleep!"<<endl;
}
void Animal::fur()
{
    cout<<"it looks furry!"<<endl;
}
void Animal::no_fur()
{
    cout<<"it looks no fur!"<<endl;
}

void Cat::Miao() // 派生类方法
{
    cout<<"it can miao!"<<endl;
}

int main()
{
    Cat c;
    c.eat();
    c.sleep();
    c.Miao();
    // c.fur();
    // c.no_fur();
    return 0;
}
```
#### （2）保护继承
当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
```C++
class Dog: protected Animal{
    public:
        void bark();
};
```
#### （3）私有继承
当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。
#### （4）多继承
一个子类可以同时拥有多个父类，其多继承语法如下：
```
class 子类名：继承权限 父类1名，继承权限 父类2名
{
    子类
}
```
```C++
#include <iostream>
 
using namespace std;
 
// 基类1 Shape
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 基类2 PaintCost
class PaintCost 
{
   public:
      int getCost(int area)
      {
         return area * 70;
      }
};
 
// 派生类
class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
   int area;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   area = Rect.getArea();
   
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   // 输出总花费
   cout << "Total paint cost: $" << Rect.getCost(area) << endl;
   return 0;
}
```
### 3、多态
多态是允许不同类的对象使用相同的接口名字，但具有不同实现的特性。
多态主要通过虚函数（Virtual Function）和抽象基类（Abstract Base Class）来实现。
虚函数允许在派生类中重写基类的方法，而抽象基类包含至少一个纯虚函数（Pure Virtual Function），不能被实例化，只能作为其他派生类的基类。
通过多态，我们可以编写更加通用、可扩展的代码，提高代码的灵活性。
#### （1）虚函数的使用
```C++
#include <iostream> 
using namespace std;

class Shape
{
    protected:
        int width, height;
    public:
        Shape(int a=0, int b=0): width(a), height(b){}
        // 声明虚函数 这样可以允许每个子类都有一个函数 area() 的独立实现
        virtual int area()
        {
            cout<<" Shape area is:"<<endl;
            return 0;
        }
};
class Rectangle: public Shape
{
    public:
        Rectangle(int a=0,int b=0):Shape(a,b) {}
        // 多态
        int area()
        {
            cout<<"Rectangle area is:"<<(width*height)<<endl;
            return (width*height);
        }
};
class Triangle: public Shape
{
    public:
        Triangle(int a=0,int b=0):Shape(a,b) {}
        int area()
        {
            cout<<" Triangle area is:"<<(width*height/2)<<endl;
            return (width*height/2);
        }
};

int main()
{
    Shape *s;
    Rectangle r(3,4);
    Triangle t(3,4);

    s = &r;
    s->area();

    s = &t;
    s->area();
    return 0;
}
```
如果不声明`virtual`关键字，函数就会静态链接到基类方法，不能实现多态。
#### （1）设计抽象基类
抽象类不能被用于实例化对象，它只能作为接口使用。如果试图实例化一个抽象类的对象，会导致编译错误。
如果类中至少有一个函数被声明为纯虚函数（“=0”），则这个类就是抽象类。比如`virtual int get_area()=0;`
```C++
# include<iostream>
using namespace std;

class Shape // 设计抽象类 不可以被实例化对象
{
    protected:
        int width;
        int height;
    public:
        // 纯虚函数声明
        virtual int get_area()=0;
        void set_width(int w)
        {
            width = w;
        }
        void set_height(int h)
        {
            height = h;
        }
};

class Rectangle:public Shape // 只有其派生类可以被实例化对象
{
    public:
        int get_area() // 前提是派生类已经将父类的纯虚函数实现
        {
            cout<<"Rectangle area is:"<<(width*height)<<endl;
            return (width*height);
        }
};
class Traingle:public Shape
{
    public:
        int get_area()
        {
            cout<<"Triangle area is:"<<(width*height/2)<<endl;
            return (width*height/2);
        }
};

int main()
{
    Rectangle r;
    r.set_height(3);
    r.set_width(4);
    cout<<r.get_area()<<endl;
    
    Traingle t;
    t.set_height(3);
    t.set_width(4);
    cout<<t.get_area()<<endl;
    
    return 0;
}
```
## 四、文件流
主要用到文件流有`fstream`包含写入`ofstream`与读出`ifstream`
```c++
# include<iostream>
# include<fstream> // 文件读写流 包含ofstream与ifstream
using namespace std;

int main()
{
    char data[100];

    ofstream outfile; // 创建写模式对象
    outfile.open("default_file.dat"); // 以写模式打开文件

    cout<<"please writing to the file:"<<endl;
    cin.getline(data,100); // 逐行获取写入字符
    outfile<<data<<endl;   // 向文件写入
    outfile.close();       // 关闭

    ifstream infile;  // 创建读模式对象
    infile.open("default_file.dat"); // 以读模式打开文件

    infile >> data;  // 从文件读取数据
    cout<<data<<endl;// 在屏幕上显示出来
    infile.close();  // 关闭

    return 0;
}
```
## 五、异常处理
throw 抛出一个异常
catch 捕获异常关键字
try 它后面通常跟着一个或多个 catch 块。
```C++
# include<iostream>
using namespace std;

double division(int a, int b)
{
   if( b == 0 )
   {
        throw "Division by zero condition!";
   }
   return (a/b);
}

int main()
{
    int x = 10;
    int y = 0;
    int z = 0;

    try
    {
        z = division(x,y);
        cout<< z <<endl;
    } 
    catch(const char* m)
    {
        cerr << m <<endl;
    }

    return 0;
}

```
## 六、模版
可使用函数模版与类模版，自定义数据类型。
```c++
# include<iostream>
# include<string>
# include<vector>
using namespace std;

// template <typename T> // 1 函数模版，自定义的函数类型
// T const& Max(T const&a,T const &b)
// {
//     return a>b?a:b;
// }

template<typename T> // 2 类自定义模版
class Stack
{
    private:
        vector<T> elem; // 实现可存储任何类型的vector 容器
    public:
        void push(T const &);
        void pop();
        T top() const;
        bool empty() const
        {
            return elem.empty();
        }
};

template<typename T>
void Stack<T>::push(T const& e)
{
    elem.push_back(e);
}

template<typename T>
void Stack<T>::pop()
{
    if(elem.empty())
        throw out_of_range("Stack<>::pop():empty stack!");
    elem.pop_back();
}

template<typename T>
T Stack<T>::top() const
{
    if(elem.empty())
        throw out_of_range("Stack<>::top():empty stack!");
    return elem.back();
}

int main()
{
    // int i =20;
    // int j =30;
    // cout<<"Max:"<<Max(i,j)<<endl;
    try
    {
        Stack<int> s1;
        s1.push(7);
        s1.push(4);
        s1.pop();
        int t = s1.top();
        cout<<"s1.top="<<t<<endl;

        Stack<string> s2;
        s2.push("hello");
        s2.push("world");
        s2.pop();
        s2.pop();
        string st = s2.top();
        cout<<"s2.top="<<st<<endl;
    }
    catch(exception const&m)
    {
        cerr<<m.what()<<endl;
        return -1;
    }
}
```
## 七、STL
### （1）vector
`<vector>`是一个序列容器，用于存储动态大小的数组，允许开发者在容器的末尾快速地添加或删除元素。
```
1、导入<vector>: #include<vector>
2、声明：std::vector<int> v;
3、添加元素：v.push_back(1);
4、访问：int data = v[0];
5、获取元素数量：size_t s = v.size();
6、清空：v.clear();
```
```c++
// 遍历容器
vector<int> print_vector(vector<int> &v)
{
    cout<<"vector data:";
    for(int i=0;i<v.size();i++)
        cout<<v[i]<<" ";
    cout<<endl;
    return v;
}

int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);

    print_vector(v); // 输出vector的所有元素
    cout<<v[0]<<endl; // 输出制定位置元素
    cout<<"vector frist data is:"<<v.front()<<endl;
    cout<<"vector last data is:"<<v.back()<<endl;
    v.pop_back();// 从尾部弹出元素
    return 0;
}
```
## 八、多线程
### 1、概念
C++的多线程设计在一个程序中创建和管理多个并发执行的线程。
```
1、线程：线程是程序执行的单一控制流，多个线程可以在同一个进程中独立运行。
同一个进程里的线程共享该进程的内存空间、资源等。但每个线程都有自己的栈、寄存器和程序计数器。
2、并发：多个任务在时间片段内交替执行。
3、并行：多个任务在多个处理器上同时执行。
```
### 2、创建线程
```c++
void print_prog(int count)
{
    for(int i=0; i<count;i++)
    {
        cout<<"hello from thread (function print)!\n";
    }
}
int main()
{
    thread t2(print_prog,2);
    t2.join();
    return 0;
}
```
结果：
```
hello from thread (function print)!
hello from thread (function print)!
```
### 3、线程管理
使用`join()`等待线程完成执行，使用`datach()`将线程与主线程分离，现成在后台独立运行，主线程不再等待。
### 4、线程传参
（1）值传递
比如上面的函数创建`thread t2(print_prog,2);`将实参的值2传递给`print_prog(int count)`函数进行拷贝。
（2）引用传递
使用ref(参数)对参数进行引用，比如：`thread t2(print_prog,ref(count));`
```c++
void print_prog(int &count)
{
    for(int i=0; i<count;i++)
    {
        cout<<"hello from thread (function print)!\n";
    }
}

int main()
{
    int count = 2;
    thread t2(print_prog,ref(count));
    t2.join();
    return 0;
}
```
### 5、线程的同步与互斥
#### （1）互斥量与条件变量
互斥量`mutex`用于防止多个线程同时访问共享资源。当一个线程需要访问共享资源时，它首先需要锁定（lock）互斥量。如果互斥量已经被其他线程锁定，那么请求锁定的线程将被阻塞，直到互斥量被解锁（unlock）。条件变量`condition_variable`用于线程间的协调，允许一个或多个线程等待某个条件的发生，通常与互斥量结合，实现线程之间的同步。
```c++
# include<mutex>
void print_prog(int &count)
{
    mtx.lock(); // 锁定
    cout<<"mutex locked"<<endl;
    for(int i=0; i<count;i++)
    {
        cout<<"hello from thread (function print)!\n";
    }
    mtx.unlock(); // 解锁
    cout<<"mutex unlocked"<<endl;
}

int main()
{
    int c1 = 2;
    int c2 = 4;
    thread t1(print_prog, ref(c1));
    t1.join();
    thread t2(print_prog,ref(c2));
    t2.join();
    return 0;
}
```
运行结果如下：
```
mutex locked
hello from thread (function print)!
hello from thread (function print)!
mutex unlocked
mutex locked
hello from thread (function print)!
hello from thread (function print)!
hello from thread (function print)!
hello from thread (function print)!
mutex unlocked
```
#### （2）锁与原子操作
锁：主要使用`unique_lock<mutex>`进行转移所有权与手动解锁。
原子操作：确保对共享数据的访问是不可分割的，即在多线程环境下，原子操作要么完全执行，要么完全不执行，不会出现中间状态。
```c++

```
#### （3）线程局部存储
线程局部存储允许每个线程拥有自己的数据副本。关键字thread_local。
```c++
thread_local int thread_n = 1;
void print_test()
{
    thread_n = 10;
    cout<<"thread data:"<<thread_n<<endl;
}

int main()
{
    thread t1(print_test);
    t1.join();
    thread t2(print_test);
    t2.join();
    return 0;
}
```
运行结果为：
```
thread data:10
thread data:10
```
#### 生产者-消费者模型（多线程）
```
功能：
1、生产者线程生成数据并将其放入共享队列。
2、消费者线程从共享队列中取出数据并处理。
3、使用互斥锁（mutex）和条件变量（condition_variable）来同步线程。
技术点：
1、使用 thread 创建线程。
2、使用 queue 作为共享队列，当queue空时生产者生产，不空时消费者消费。
3、使用 mutex 和 condition_variable 进行线程同步。
4、使用 atomic 原子性来确保数据的一致性。
```
##### （1）共享资源
```c++
std::queue<int> data_queue;
std::mutex mtx; 
std::condition_variable cond_var; // 互斥锁与条件变量 实现线程同步
std::atomic<bool> done(false); // 原子布尔变量，用于标记生产者是否已经完成。
```
##### （2）生产者消费者构建
```
步骤1：
    生产者开始生成数据，并将数据放入 data_queue。
    消费者线程进入循环，检查 !done || !data_queue.empty()。
步骤2：
    生产者生成数据并放入 data_queue，然后调用 cond_var.notify_one() 通知消费者有新数据。
    消费者线程在 cond_var.wait(lock, [] { return !data_queue.empty() || done; }) 中等待，直到队列中有数据或生产者完成。
步骤3：
    消费者线程从队列中取出数据并处理。
    处理完数据后，消费者线程再次检查 !done || !data_queue.empty()，决定是否继续运行。
步骤4：
    生产者完成生成数据，设置 done = true。
    消费者线程在 cond_var.wait(lock, [] { return !data_queue.empty() || done; }) 中被唤醒，检查队列中是否有剩余数据。
    如果队列为空且 done == true，消费者线程退出循环，结束运行。
```
```c++
// 生产者函数
void producer() {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        data_queue.push(i);
        lock.unlock();
        cond_var.notify_one(); // 通知消费者有新数据
        // std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟生成数据的时间
    }
    done = true; // 标记生产者完成
}

// 消费者函数
void consumer() {
    while (!done || !data_queue.empty()) {
    // 生产者没有生产完成 或者 共享队列不为空
        std::unique_lock<std::mutex> lock(mtx);
        // 消费者线程开始
        cond_var.wait(lock, [] { return !data_queue.empty() || done; }); 
        // 消费者线程等待 新数据或生产者完成

        while (!data_queue.empty()) {
        // 当共享队列不为空
            int data = data_queue.front();
            data_queue.pop();
            std::cout << "Consumed: " << data << std::endl;
            // 消费者消费共享队列
        }
        lock.unlock();
        // std::this_thread::sleep_for(std::chrono::milliseconds(50)); // 模拟处理数据的时间
    }
}

int main() {
    std::thread producer_thread(producer);
    std::thread consumer_thread(consumer);

    producer_thread.join();
    consumer_thread.join();

    return 0;
}
```
运行结果如下：
```
Consumed: 0
Consumed: 1
Consumed: 2
Consumed: 3
Consumed: 4
Consumed: 5
Consumed: 6
Consumed: 7
Consumed: 8
Consumed: 9
```
## 九、C++标准库
### 1、内存管理库`<memory>`
使用智能指针，来自动管理动态分类的内存。
```
1 std::unique_ptr：独占所有权的智能指针，同一时间只能有一个 unique_ptr 指向特定内存。
2 std::shared_ptr：共享所有权的智能指针，多个 shared_ptr 可以指向同一内存，内存在最后一个 shared_ptr 被销毁时释放。
3 std::weak_ptr：弱引用智能指针，用于与 shared_ptr 配合使用，避免循环引用导致的内存泄漏。
```
#### （1）unique_ptr
```c++
# include<iostream>
# include<memory>
using namespace std;

class Student
{
    public:
        void Print()
        {
            cout<<"class Student"<<endl;
        }
};

int main()
{
    //独占所有权的智能指针
    unique_ptr<Student> p(new Student());
    // 调用类的成员函数
    p->Print();
    return 0;
    // 当 main 函数结束时，myPtr 被销毁，自动释放 MyClass 对象的内存
}
```
#### （2）shared_ptr
```c++
# include<iostream>
# include<memory>
using namespace std;

class Student
{
    public:
        void Print()
        {
            cout<<"class Student"<<endl;
        }
};

int main()
{
    //独占所有权的智能指针
    unique_ptr<Student> p(new Student());
    // 多个 shared_ptr 可以指向同一内存
    shared_ptr<Student> p1(new Student());
    shared_ptr<Student> p2 = p1;
    // 调用类的成员函数
    p->Print();
    p1->Print();
    p2->Print();

    return 0;
}
```
## 十、网络编程
网络编程主要使用socket抽象端口实现，其主要分为服务器端与客户端，调用socket库里的函数实现。
对于服务器端，实现：
```
1、调用socket函数创建监听socket
2、调用bind函数将socket绑定到某个IP和端口号组成的二元组上
3、调用listen函数开启监听
4、当有客户端连接请求时，调用accept函数接受连接，产生一个新的socket（与客户端通信的socket）
5、基于新产生的socket调用send或recv函数开始与客户端进行数据交流
6、通信结束后，调用close函数关闭socket
```
客户端实现：
```
1、调用socket函数创建客户端socket
2、调用connect函数尝试连接服务器
3、连接成功后调用send或recv函数与服务器进行数据交流
4、通信结束后，调用close函数关闭监听socket
```