#include <iostream>

using namespace std;

class Point{
private:
    int x,y;

public:
    Point() : x(0),y(0){}
    Point(int x,int y) : x(x),y(y){}

    //重载 << 运算符(输出)
    friend ostream& operator << (ostream& os,Point point){
        os << "(" << point.x << "," << point.y << ")";
        return os;
    }

    //重载 >> 运算符(输入)
    friend istream& operator >> (istream& is,Point& point){
        is >> point.x >> point.y;
        return  is;
    }

};


int main()
{
    Point p1(1,2);
    //输出
    cout << "Point p1:" << p1 << endl;

    //输入
    Point p2;
    cout << "Input your Point:";
    cin >> p2;
    cout << "Point p2:" << p2 << endl;


    return 0;
}

#include <iostream>

using namespace std;
class ClassA{
private:
    int value;
public:
    ClassA(int v) : value(v){}

    // 声明 ClassB 为友元类
    friend class ClassB;
};


class ClassB{
public:
    void showValue(ClassA& a){
        // 可以访问 ClassA 的私有成员
        cout << "Value of ClassA: " << a.value << endl;
    }
};

int main()
{
    ClassA a(100);
    ClassB b;
    b.showValue(a);
    return 0;
}

#include <iostream>

using namespace std;

template <typename T>
// 定义一个通用的函数模板
T add(T a,T b){//可以处理不同类型的加法
    return a + b;
}

int main()
{
    // 使用函数模板调用通用函数
    double resultDouble = add(3.4,2.5);
    int resultInt = add(1,2);

    // 输出函数模板调用结果
    std::cout << "Result 1: " << resultDouble << std::endl;
    std::cout << "Result 2: " << resultInt << std::endl;

    return 0;
}

3.3 模板特化

#include <iostream>
#include <string.h>
using namespace std;

// 定义一个通用的模板函数
template <typename T>
T maximum(T a,T b){
    return (a > b) ? a : b;
}

// 对模板函数进行完全特化，针对 char* 类型
template <>
const char * maximum<const char *>(const char * a,const char * b){
    return strcmp(a,b) > 0 ? a : b;
}



int main()
{
    int intMax = maximum(3, 5); //调用模板函数，通用模板：适合所有类型
    std::cout << "Maximum of integers: " << intMax << std::endl;

    const char* charMax = maximum("apple", "orange"); //调用特化的函数，完全特化
    std::cout << "Maximum of strings: " << charMax << std::endl;
    return 0;
}

#include <iostream>

using namespace std;

// 定义一个通用的模板类
template <typename T , typename U>
class MyTemplate{
public:
    void display() {
        cout << "Generic Display" << endl;
    }
};

//对模板类进行部分特化，针对特定的类型组合
template <typename T>
class MyTemplate<T,int>{

public:
    void display() {
        cout <<  "Specialized Display for T and int" << endl;
    }
};


int main()
{
    MyTemplate<float,double> obj1;
    obj1.display();

    MyTemplate<float,int> obj2;
    obj2.display();
    //obj1 是普通情况，obj2 触发了"当第二个类型是int"的特殊处理规则
    return 0;
}

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    //创建一个vector容器
    vector<int> myVector;
    //向vector容器尾部加入数据
    myVector.push_back(3);
    myVector.push_back(7);
    myVector.push_back(12);

    // 使用迭代器遍历 vector 容器并输出其中的元素
    // 在 C++ 中，auto 是一个关键字，用于声明变量时的类型推断。
    // 它允许编译器根据变量的初始化表达式推断出变量的类型，从而简化代码书写过程。
    cout << "Vector element: ";
    for(auto it = myVector.begin();it != myVector.end();it++){
        cout << *it << endl;
    }

    // 获取 vector 容器的大小和访问特定位置的元素
    cout << "Vector size: " << myVector.size() << endl;
    cout << "Element at index 1: " << myVector[1] << endl;

    cout << "Element at index 2: " << myVector[2] << endl;
    // 修改特定位置的元素
    myVector[2] = 20;
    cout << "Element at index 2: " << myVector[2] << endl;

    //循环遍历 vector 并输出元素
    for(int num : myVector){
         std::cout << num << endl;
    }
    // 清空 vector 容器
    myVector.clear();
    // 检查 vector 是否为空
    if(myVector.empty()){
        cout << "Vector is empty." << endl;
    }else {
        cout << "Vector is not empty." << endl;
    }
    return 0;
}

4.2 list

#include <iostream>
#include <list>

using namespace std;

int main()
{
    //创建一个vector容器
    list<int> mylist;
    //向list容器尾部加入数据
    mylist.push_back(10);
    mylist.push_back(20);
    mylist.push_back(30);

    //向list容器头部加入数据
    mylist.push_front(5);
    mylist.push_front(15);

    // 使用迭代器遍历 list 容器并输出其中的元素
    // 在 C++ 中，auto 是一个关键字，用于声明变量时的类型推断。
    // 它允许编译器根据变量的初始化表达式推断出变量的类型，从而简化代码书写过程。
    cout << "List element: ";
    for(auto it = mylist.begin();it != mylist.end();it++){
        cout << *it << endl;
    }

    // 删除 list 中特定的元素值
    mylist.remove(20);

    //循环遍历 list 并输出元素
    for(int num : mylist){
         std::cout << num << endl;
    }
    // 清空 list 容器
    //mylist.clear();
    // 检查 list 是否为空
    if(mylist.empty()){
        cout << "list is empty." << endl;
    }else {
        cout << "list is not empty." << endl;
    }
    return 0;
}

#include <iostream>
#include <set>

using namespace std;

int main()
{
    // 创建一个存储 int 类型值的 set 容器
    set<int> myset;
    //向set容器加入数据
    myset.insert(10);
    myset.insert(20);
    myset.insert(30);
    // 尝试插入重复元素
    myset.insert(20);// 不会插入重复的元素

    // 使用迭代器遍历 set 容器并输出其中的元素
    // 在 C++ 中，auto 是一个关键字，用于声明变量时的类型推断。
    // 它允许编译器根据变量的初始化表达式推断出变量的类型，从而简化代码书写过程。
    cout << "set element: ";
    for(auto it = myset.begin();it != myset.end();it++){
        cout << *it << endl;
    }

    // 查找特定值在 set 中的位置
    int searchValue = 200;
    auto found = myset.find(searchValue);
    if(found != myset.end()){
        cout <<  "Found " << searchValue << " in the set." << endl;
    }else {
        cout << searchValue << " not found in the set." << endl;
    }

    // 删除特定值的元素
    myset.erase(10);
    cout << "set element: ";
    for(auto it = myset.begin();it != myset.end();it++){
        cout << *it << endl;
    }


    // 清空 set 容器
    //myset.clear();
    // 检查 set 是否为空
    if(myset.empty()){
        cout << "set is empty." << endl;
    }else {
        cout << "set is not empty." << endl;
    }
    return 0;
}

#include <iostream>

using namespace std;

void divide(int number1,int number2){
    try {
        if(number2 == 0){
            //除数不能为0
            throw "Division by zero is not allowed!";
        }
        int ret = number1 / number2;
        cout << "The result is " << ret << endl;
    } catch (const char* errorMessage) {
         cout << "Exception caught is " << errorMessage << endl;
    }

}

int main()
{
    int a = 10;
    int b = 0;
    divide(a, b);
    return 0;
}

5.2 自定义异常

#include <iostream>
#include <exception>

using namespace std;

//自定义异常类，继承自std::exception
class MyException : public exception {
private:
    const char * message;//异常消息

public:
    MyException(const char* msg) : message(msg){}   // 构造函数，接受异常消息作为参数
    // 重写基类的what()方法，返回异常消息
    const char *what() const throw() {
        return message;
    }
};

// 一个函数，演示如何抛出自定义异常
void myFunction(){
    // 在这个示例中，函数总是抛出自定义异常
    throw  MyException("This is a custom exception!");
}

int main()
{
    try {
        myFunction();
    } catch (MyException e) {
        cout << "Caught MyException: " << e.what() << endl;
    }

    return 0;
}