master

分支 (1)

管理

管理

master

c-learning-code
/
test.cpp

// #include <iostream>
// #include <vector>
// using namespace std;
// int main(){
//     int d;
//     cout<<222<<endl;
//     cin>>d;
//     system("pause");
//     return 0;
// }

/**
 * @brief
 * leetcode球该落到何处题解模拟法
 */
// #include <iostream>
// #include <vector>
// using namespace std;
// int main(){
//         vector<vector<int>> grid;
//         grid = {{1,1,1,1,1,-1,-1,-1}};
//         vector<int> Res;
//         int m = grid.size();
//         int n = grid[0].size();
//         int res = 0;
//          for(int i=0;i<n;i++)
//          {
//              res = i;
//             for(int j=0;j<m;j++)
//             {
//                 if(grid[j][res] == 1 && res == n-1){
//                     res=-1;
//                     break;
//                     }
//                 else if(grid[j][res] == -1 && res == 0){
//                     res=-1;
//                     break;
//                     }
//                 else if(grid[j][res+1] == -1 && grid[j][res] == 1){
//                     res=-1;
//                     break;
//                     }
//                 else if(grid[j][res+1] == 1 && grid[j][res] == 1){
//                     res = res+1;
//                     }
//                 else if(grid[j][res-1] == -1 && grid[j][res] == -1){
//                     res--;
//                     }
//                 else
//                    {res=-1;
//                     break;}
//             }
//             Res.push_back(res);
//          }
//          for (int k = 0; k < Res.size(); k++)
//          {
//              /* code */
//              cout<<Res[k]<<endl;
//          }
//         system("pause");
//         return 0;
//     }

/**
 * @brief at 用法
 */
// #include <iostream>
// #include <vector>
// using namespace std;
// int main()
// {
//     vector<string> grid;
//     grid.push_back("dasdas");
//     grid.push_back("maca");
//     cout<<grid[0].at(1)<<endl;
//     cout<<grid[0][1]<<endl;   //s.at(i) 和s[i]用法一样；
//     cout<<typeid(grid[0].at(1)).name()<<endl;
//     system("pause");
// }

/**
 * @brief
 * typeid().name() 和at的用法
 */
// #include <iostream>
// #include <vector>
// #include <string>
// #include<cstdlib>
// using namespace std;
// int main(){
//     // string A = "2QEWQ";
//     // int i = A[0];
//     // cout<< to_string(i) <<endl;
//     // char m = 'M';
//     // cout<< (char)((int)m + 1)<<endl;
//     // cout<<typeid((char)((int)m + 1)).name()<<endl;
//     char l1 = 'A';
//     char l2 = 'Z';
//     while(l1 <= l2){
//         cout<<1<<endl;
//         l1 = (char)((int)l1 + 1);
//     }
//     system("pause");
// }

// #include <iostream>
// #include <vector>
// #include <string>
// #include <cstdlib>
// using namespace std;
//     int main() {
//         string s = "K1:Z2";
//         vector<string> res;
//         char i = s[0];
//         char j = s[1];
//         while(i <= s[3]){
//             while(s[4] >= j){
//             string m = {i, j, '\0'};
//             res.push_back(m);
//             j++;
//             }
//             i++;
//             j = s[1];
//         }
//     //  for (char i = s[0]; i <= s[3]; ++i)
//     //         for (char j = s[1]; j <= s[4]; ++j) {
//     //             string str = {i, j, '\0'};
//     //             res.push_back(str);
//     //         }
//       for (int i = res.size() - 1; i >= 0; i--)
//       {
//           /* code */
//           cout<<res[i]<<endl;
//       }
/**
 * @brief
 * by mao
 * char转换string的两种区别
 */
//     char hhh = 'd';
//     string ss = {hhh};
//     cout<< to_string(hhh) <<" "<<ss<<endl;
//       system("pause");
//       return 0;
//     }

/**
 * @file test.cpp
 * @author mao (you@domain.com)
 * @brief
 * 测试 string to char 的三种方式
 * data() c_str() copy()
 *
 */
// #include <iostream>
// #include <vector>
// #include <string>
// using namespace std;
// int main(){
//     // char mm = '1'-'0';
//     // cout<<(int)mm<<endl;
//     string s = "dasd";
//     const char *P = s.data();
//      cout<<typeid(*P).name()<<endl;
//      cout<<P[2]<<endl;
//       s = "qqwsa";
//       cout<<P[2]<<endl;
//       char *p = new char[s.length() + 1];
//       s.copy(p, string::npos);
//       cout<<p<<endl;
//     system("pause");
// }

/**
 * @brief
 * 进制转换
 * @author mao (you@domain.com)
 */
// class Solution
// {
// public:
//     string convertToBase7(int num)
//     {
//         string res = "";
//         if (num > 0)
//         {
//             while (num != 0)
//             {
//                 res = res + to_string(num % 7);
//                 num = num / 7;
//             }
//         }
//         else if (num < 0)
//         {
//             num = -num;
//             while (num != 0)
//             {
//                 res = res + to_string(num % 7);
//                 num = num / 7;
//             }
//             res = res + "-";
//         }
//         else
//             res = "0";
//         reverse(res.begin(), res.end());
//         return res;
//     }
// };

/**
 *
 * @author 毛 (you@domain.com)
 * @brief template <class T>模板的使用
 *
 */
// #include <iostream>
// using namespace std;
// template <class T>
// void swap(T &a, T &b)
// {
//     T temp;
//     temp = a;
//     a = b;
//     b = temp;
// }
// int main()
// {
//     string a = "das";
//     string b = "fds";
//     swap(a, b);
//     cout << "a=" << a << endl;
//     cout << "b=" << b << endl;
//     system("pause");
//     return 0;
// }

/**
 * @author mao(you@domain.com)
 * @brief
 * 友元函数的使用
 *
 * @copyright Copyright (c) 2022
 *
 */
// #include <iostream>
// #include <cmath>
// using namespace std;
// class point
// {
// public:
//     point(int yy, int xx)
//     {
//         x = xx;
//         y = yy;
//     };
//     void getlocation()
//     {
//         cout << "(" << x << "," << y << ")" << endl;
//     };
//     friend double Distance(point &a, point &b); //此处使用友元函数,可以直接调用函数。不属于对象函数，但是可以直接调用private；
// private:
//     int x;
//     int y;
// };
// double Distance(point &a, point &b)
// {
//     int dx = a.x - b.x;
//     int dy = a.y - b.y;
//     return sqrt(dx * dx + dy * dy);
// }
// int main()
// {
//     point P(2, 3);
//     point P2(8, 0);
//     P.getlocation();
//     cout << Distance(P, P2) << endl;
//     system("pause");
//     return 0;
// }

/**
 * @brief 异常处理
 * cerr 与cout的区别
 * 1.cout对应于标准输出流，cerr对应于标准错误流
 * 2.cout 要分配还船缓存
 * 3.cout 可以重定向
 */
// #include <exception> //可以重写结构体来继承异常
// #include <stdexcept>
// #include <iostream>
// using namespace std;
// // 捕获特定的异常(系统自带) string数组越界,vector越界
// int main()
// {
//     string m = "das";
//     try
//     {
//         m.at(12) = 'h';
//     }
//     catch ( exception &e)
//     {
//         cerr << e.what() << endl;
//     }
//     // cout<<mm<<endl;
//     system("pause");
//     return 0;
// }

/**
 * @brief、
 *  抛出异常
 */
// double division(int a, int b)
// {
//    if( b == 0 )
//    {
//       throw "Division by zero condition!";
//    }
//    return (a/b);
// }

// int main(){
//***自己定义的异常**/
//     int x = 50;
//    int y = 0;
//    double z = 0;
//    try {
//      z = division(x, y);
//      cout << z << endl;
//    }catch (const char* msg) {
//      cerr << msg << endl;
//    }
//**系统存在的异常**/
//    int A[11] = {1,3,4,5,6,7};
//    try
//    {
//        cout<<A[100]<<endl;
//    }
//    catch(const std::exception& e)
//    {
//        std::cerr << e.what() << '\n';
//    }
//    system("pause");
//    return 0;
// }

/**
 * @brief
 * 1.string 类的substr实现用法
 *  2.连续初始化赋值变量，会出现问题
 *
 */
// #include<iostream>
// #include<string>
// using namespace std;
// int main(){
//     // string m = "sadaewqewq";
//     // string ss = m.substr(1,9);
//     // cout<<ss<<endl;
//     // cout<<ss.length()<<endl;
//     int m, n ,p =3;
//     cout<<"m="<<m<<endl;
//     cout<<"n="<<n<<endl;
//     cout<<"p="<<p<<endl;
//     system("pause");
//     return 0;
// }

/**
 * @brief 运算符重载
 * 占个坑
 */

/**
 * @brief
 * c++实现多线程
 * 另开章节
 */
// #include<iostream>
// #include<vector>
// #include<string>
// using namespace std;
// int main(){
//     system("pause");
//     return 0;
// }

/**
 * @brief
 * 1.获取当前系统时间
 * 2.获取程序运行时间两种  GetTickCount();  clock();
 *
 */
// #include <iostream>
// #include <windows.h>
// #include <time.h>
// using namespace std;
// int main()
// {
// SYSTEMTIME sys;
// GetLocalTime(&sys);
// cout<<sys.wYear<<"year";
// cout<<sys.wMonth<<"month";
// cout<<sys.wDay<<"day";
// cout<<sys.wHour<<"hour";
// cout<<sys.wMinute<<"minute";
// cout<<sys.wSecond<<"second";
//
// return 0;
// ******************************************
// clock_t start, finish;
// double totaltime;
// start = clock();//把你的程序代码插入到这里面
// finish = clock();
// totaltime = (double)(finish - start) / CLOCKS_PER_SEC;  //CLOCKS_PER_SEC注意一下
// cout<<"this consle running time is "<<totaltime<<" second."<<endl;
// /*****************
// LONGLONG start, finish;
// LONGLONG totalTime;
// start = GetTickCount();
// //需要测试运行时间的代码段放在这
// finish = GetTickCount();
// totalTime = finish - start;
// cout<<"this consle running time is "<<totalTime<<" misecond"<<endl;
// system("pause");
// return 0;
// }

/**
 * @brief
 * c++几种实现for循环的方式
 */
// #include<iostream>
// #include<vector>
// using namespace std;
// int main(){
//     vector<int> a;
//     a = {1,2,3,4,5,6,67,8,4};
// /***第一种**/
//     // for(int i = 0; i < a.size(); i++){
//     //     cout<<a[i]<<"";
//     // }
// /***第二种**/
//     // for(auto i : a){
//     //     cout<<i<<"";
//     // }
//     // cout<<typeid(a).name()<<endl;
//     system("pause");
//     return 0;
// }

/**
 * @brief
 * 1.vector中最大元素以及其位置求法
 * *max_element 和 max_element - m.begin();
 * 2.是否包含一个元素以及下标，find;
 * 3.去重1.set 或者 unordered_set 2.unique 3.remove 去除特定元素 (其中set,unique会自动排序);
 * 4. 检查是否包含某一个元素 1.cout计数  2.有序 binary_search 3.find(v.begin(), v.end(), key) != v.end()
 */
// #include <iostream>
// #include <vector>
// #include <algorithm>
// #include <unordered_set>
// using namespace std;
// int main()
// {
//     int mm;
//     vector<int> m{4, 3, 7, 4, 8, 1, 5, 0, 8, 32, 13, 56, 4, 33, 54, 43};
/**************最大数以及下标**/
// mm = *max_element(m.begin(), m.end());
// cout<< mm <<max_element(m.begin(), m.end())-m.begin()<<endl;
/*1.*********set去重办法 */
// unordered_set<int> s(m.begin(),m.end());
// m.assign(s.begin(), s.end());
/*2.**********unique去重办法 */ /*(其中unique将重复元素移到最后，注：针对由于队列)*/
// sort(m.begin(), m.end());
// // //cout << unique(m.begin(), m.end() )- m.begin() <<endl;
// m.erase(unique(m.begin(), m.end()), m.end());
/*3.******remove去重方法****/
// auto ret = remove(m.begin(), m.end(), 4);
// m.erase(ret, m.end());
// for(int x : m)
//     cout << x << ",";
/***********find方法************查找第一次出现的位置,没有返回数组长度 = 下标最大加一*/
// auto it = find(m.begin(),m.end(),43);
//  cout << it - m.begin() <<endl;
/******cout方法*****/
// cout << count(m.begin(), m.end(), 5) << endl;
/**find**查找是否存在**/
// if (find(m.begin(), m.end(), 4) != m.end())
// 	cout << "Element found";
// else
// 	cout << "Element not found";
// system("pause");
// return 0;
// }

/**
 * @brief
 * 几种排序手撸（未完成）
 */
// #include <iostream>
// #include <vector>
// #include <algorithm>
// using namespace std;
// int main()
// {
//     int mm;
//     vector<int> arr{4, 3, 7, 4, 8, 1, 5, 0, 8, 32, 13, 56, 4, 33, 54, 43};
//     int len = arr.size();
///***冒泡排序**/
// for (int i = 0; i < len - 1; i++)
// {
//     for (int j = 0; j < len - 1 - i; j++)
//     {
//         if (arr[j] > arr[j + 1])
//         {                          // 相邻元素两两对比
//             int temp = arr[j + 1]; // 元素交换
//             arr[j + 1] = arr[j];
//             arr[j] = temp;
//         }
//     }
// }
///***选择排序**/
// for (int i = 0; i < len; i++)
// {
//     int  minIndx = i;
//     for (int j = i ; j < len ; j++)
//     {
//         if(arr[minIndx] > arr[j]){
//             minIndx = j;
//         }
//     }
//     int temp = arr[minIndx]; // 元素交换
//     arr[minIndx] = arr[i];
//     arr[i] = temp;
// }
///**插入排序**/
// for (int i = 1; i < len; i++) {
//     int preIndex = i - 1;
//     int current = arr[i];
//     while (preIndex >= 0 && arr[preIndex] > current) {
//         arr[preIndex + 1] = arr[preIndex];
//         preIndex--;
//     }
//     arr[preIndex + 1] = current;
// }
///***堆排序**/ (有时间完成)
///***快排序**/
///***归并排序**/
///***希尔排序**/
//     for (auto &&i : arr)
//     {
//         cout<< i <<endl;
//     }
//     system("pause");
//     return 0;
// }

// class Solution {
// public:
//     int maxSubArray(vector<int>& nums) {
//         int cout = 0;
//         int res = INT32_MIN;
//         for (int i = 0 ; i < nums.size() -1 ; i++){
//             cout = 0;
//             for (int j = i + 1; j < nums.size(); j++)
//             {
//                 cout += nums[j];
//                 res = max(cout,res);
//             }
//         }
//         return res;
//     }
// };

/**
 * @brief c++多态实现
 *  Shape shape 和 Shape* shap 的区别 ->的使用 和.的使用
 *  虚函数使用；
 */
//#include<vector>
//#include <iostream>
//#include<algorithm>
// using namespace std;
// class Shape {
// protected:
//    int width, height;
// public:
//    Shape(int a = 0, int b = 0)
//    {
//        width = a;
//        height = b;
//    }
//    virtual int area()
//    {
//        cout << "Parent class area :" << endl;
//        return 0;
//    }
//};
// class Rectangle : public Shape {
// public:
//    Rectangle(int a = 0, int b = 0) :Shape(a, b) { }
//    int area()
//    {
//        cout << "Rectangle class area :" << endl;
//        return (width * height);
//    }
//};
// class Triangle : public Shape {
// public:
//    Triangle(int a = 0, int b = 0) :Shape(a, b) { }
//    int area()
//    {
//        cout << "Triangle class area :" << endl;
//        return (width * height / 2);
//    }
//};
// 程序的主函数
// int main()
//{
//    Shape shape;
//    Shape* shap;
//    Triangle* Tri;
//    Rectangle* Rec;
//    Rectangle rec(10, 7);
//    Triangle  tri(10, 5);
//     存储矩形的地址
//    shape = rec;
//     调用矩形的求面积函数 area
//    shape.area();
//
//
//    shap = &rec;
//    shap->area();
//     存储三角形的地址
//    shape = tri;
//     调用三角形的求面积函数 area
//    shape.area();
//
//    return 0;
//}

/**
 * @brief 字符串匹配
 *
 */
// #include<iostream>
// #include<vector>
// using  namespace std;
// int main(){
//     string mm = "a.*.bbgg";
//     vector<string> str{"a.d.aasa", "a.d.dsds", "a.b.bbgg"};
//     system("pause");
//     return 0;
// }

/**
 * @brief
 * 智能指针的自动释放释放  shared_ptr  unique_ptr  weak_ptr 依赖前两个智能指针
 * 新的初始化方法reset();
 */
// #include <iostream>
// #include <string>
// #include <memory>
// using namespace std;
// class person
// {
// private:
//     string _name;
//     int _age;
// public:
//     person(int age, string name);
//     void getname();
//     ~person();
// };
// person::person(int age, string name) : _name(name), _age(age) {}
// person::~person()
// {
//     cout << "the poin " << _name << " is delete " << endl;
// }
// void person::getname()
// {
//     cout << "your name  " << _name << endl;
// }
// int main()
// {
//     person *p1 = new person(1, "mao");
//     p1->getname();
//     delete p1; //普通指针释放；
//     shared_ptr<person> p2(new person(3, "jjking"));
//     p2->getname();
//     p2.reset(); //智能指针提前释放；
//     // delete p2;
//     unique_ptr<person> p3(new person(5, "lucas"));
//     p3->getname();
//     // p3.getname();  在这里注意指针的调用区别；
//     //  delete p3;
//     weak_ptr<person> p4(p2);
//     // p3.use_count();
//     system("pause");
//     // return 0;
// }

/**
 * @brief
 * @date 2022-03-17
 */

// #include <iostream>
// #include <string>
// #include <memory>
// using namespace std;
// int main()
// {

//     // string ss = "示";
//     // cout << (int)ss[0]  << endl;
//     // cout << (int)ss[1] << endl;
//     // cout << ss[0] << endl;
//     // system("pause");

//     int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//     int *P = a;
//     cout << a[10] << " ";
//     cout << *P << " ";
//    // cout << a[p - a];
//     cout << *a <<" ";

//     *(P + 3) = 111;
//     cout << a[3];

//     system("pause");
//     return 0;
// }

// #include <iostream>
// using namespace std;
// class Base
// {
// public:
// 	inline virtual void who()
// 	{
// 		cout << "I am Base\n";
// 	}
// 	virtual ~Base() {}
// };
// class Derived : public Base
// {
// public:
// 	inline void who()  // 不写inline时隐式内联
// 	{
// 		cout << "I am Derived\n";
// 	}
// };

// int main()
// {
// 	// 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。
// 	// Base b;
// 	// b.who();

// 	// 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。
// 	Base *ptr = new Derived();
// 	ptr->who();

// 	// 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。
// 	delete ptr;
// 	ptr = nullptr;

// 	system("pause");
// 	return 0;
// }


// #include<bits/stdc++.h>
// using namespace std;

// class Base {
// public:
//    Base()
//    {

//    }
// };

// class Derived : public Base {
// public:
//     virtual inline void func() {  // 将虚函数声明为内联函数
//         cout << "Derived::func" << endl;
//     }
// };

// int main() {
//     Base *p = new Base();
//     Base *q = p;
//     std::cout << "Pointer pointing to address" << p << " " << q << endl;
//     std::cout << "Pointer itself address" << &p << " " << &q << endl;

//     Base p1 = Base();
//     Base *q1 = &p1;   //引用是浅拷贝
//     //std::cout << "Pointer pointing to address" << p1 << " " << q1 << endl;
//     std::cout << "Pointer itself address" << &p1 << " " << &q1 << endl;
//     system("pause");
// }

// #include<bits/stdc++.h>
// class mao
// {

// public:
// mao(int&& a){
//     name = a;
//   };
//   int name;
//   int getStack(){
//     return name;
//     };
// };


// int main() {
//   mao *p = new mao(3);
//   std::cout << p->getStack() << std::endl;
// //   mao *q = std::move(p);
// //   std::cout << p->getStack() << std::endl;
// //   std::cout << q->getStack() << std::endl;

//   system("pasue");
//   return 0;

// }

// #include<bits/stdc++.h>
//  class Sales_data {
//      public:
//      Sales_data(int&& _num,int&& _cost):num(_num),cost(_cost)
//      {

//      }
//     //  Sales_data(){

//     //  }
//     //  public:
//     //     Sales_data add(const Sales_data&, const Sales_data&);
//     int getcost()
//     {
//         return this->num;
//     }
//      public:
//         const int num;
//          int cost;
//  };

// Sales_data Sales_data::add(const Sales_data& n1, const Sales_data& n2){
//          Sales_data newData = Sales_data();
//          newData.num = n1.num + n2.num;
//          newData.cost = n1.cost + n2.cost;
//          return newData;
// }
// int main()
//  {
//          Sales_data p1 = Sales_data(1, 2);
//          std::cout << p1.getcost() << std::endl;
//          //  Sales_data p2 = Sales_data(2, 3);
//          //  Sales_data p3 = p1.add(p1, p2);
//          //  std::cout << p3.cost << std::endl;
//          system("pause");
//          return 0;
//  }


/**
 * @file test.cpp
 * @author your name (you@domain.com)
 * @brief 类中继承和重载的区别，虚函数的作用，指向对象构造函数的虚函数
 * @version 0.1
 * @date 2023-06-19
 *
 * @copyright Copyright (c) 2023
 *
 */
// #include<bits/stdc++.h>
// using namespace std;
// class Person
// {
//     public:
//         Person(int a):num(a){}
//         virtual int getnum(){
//             return num;
//         }
//         void printClass()
//         {
//             std::cout << "PERSON" << std::endl;
//         }
//     public:
//         int num;
// };

// class Man:public Person
// {
//     public:
//         Man(int&& _num):Person(_num){}  //利用父类构造函数，构造子类
//         virtual int getnum(){
//             return num+100;
//         }
//         void printClass()
//         {
//             std::cout << "man" << std::endl;
//         }
// };


// int main()
// {
//     Person *p = new Man(1);    //虚函数多态，是按照创建的
//     std::cout << p->getnum() << std::endl;   //MAN()->GENAME()
//     p->printClass() ;                          // Person ->printClass()
//     Man *p2 = new Man(1);    //虚函数多态，是按照创建的
//     std::cout << p2->getnum() << std::endl ;  //MAN()->GENAME()
//      p2->printClass();                          //Man ->printClass()
//     system("pause");
//     return 0;
// }

/**
 * @brief define 和 typedef的区别
 *
 */
// #define INT_PTR int*
// typedef int *intptr;
// int main()
// {
//     // INT_PTR a, b;
//     // intptr c, d;
//     // std::cout << typeid(c).name() << endl;
//     int i = 0;
//     for (int x = 0, y = 0; (y = 123) && (x < 4); x++)
//         i++;
//     std::cout << i << endl;
//         system("pause");
//     return 0;
// }

// #include<bits/stdc++.h>
// // extern "C"
// void f(const char **p) { *p += 2; }
// int main()
// {
//     const char *a[] = {"123", "abc", "456"}, **p;
//     p = a;
//     //f(p);
//     std::cout << *p;
//     system("pause");
//     return 0;

// }

/**
 * @brief sizeof 和 strlen的区别
 *
 */
// #include<bits/stdc++.h>
// // #include<string>
// int main()
// {
//     int a = 4;
//     int &b = a;
//    // int &c = new int(3);
//     // sizeof()
//     std::cout << sizeof(a) << std::endl;  //int 类型是4个字节
//     std::cout << sizeof(b) << std::endl;
//     std::cout << sizeof(&b) << std::endl; //指针是 8个字节
//     std::string s("aaa");
//     //const char *p = s.c_str();
//     std::cout << sizeof(s) << std::endl;    //32 4个char的字节
//    std::cout << strlen(s.c_str()) << std::endl; //有多少个字符不包含'/0'
//     system("pause");
//     return 0;
// }


// #include<bits/stdc++.h>
// int main()
// {
//     int a[] = {1, 2, 3, 4, 5};
//     int *p = a;
//     std::cout << *p << std::endl;
//     system("pasue");
//     return 0;
// }

/**
 * @brief 类的大小
 * 静态 ，对齐，虚函数
 */
// #include<bits/stdc++.h>
// class A
// {
//     public:
//         static int a;
// };
// class B
// {
//      public:
//          int a;
//          double b;
//         // char c[7];
// };
// class C
// {
//     virtual void Fun() {}
//      //虚函数有个指向虚表的指针
//     void aa(){}  //函数不占大小
// };

// class D
// {
//     virtual void Fun0() {}
// };

// class E:public C, public D   //继承两个类中都有虚函数，两个虚表指针
// {
//     virtual void Fun() {}
//     virtual void Fun0() {}
// };
// int main()
// {
//          B b;
//          A a;
//          C c;
//          std::cout << sizeof(a) << std::endl;
//          std::cout << sizeof(b) << std::endl;
//          std::cout << sizeof(c) << std::endl;
//          E e;
//          std::cout << sizeof(e) << std::endl;
//          system("pause");
//          return 0;
// }


/**
 * @file test.cpp
 * @author your name (you@domain.com)
 * @brief 华勤测评
 * @version 0.1
 * @date 2023-06-19
 *
 * @copyright Copyright (c) 2023
 *
 */
// #include<bits/stdc++.h>
// class test
// {
// public:
//     test()
//     {
//         std::cout << "号" << std::endl;
//     }
//     ~test();
// };
// int main()
// {
    // int *p = new int[5];   //未初始化
    // int *p = new int[5](); // 初始化为0;
    // std::cout << *p << std::endl;
/**/
    // test *P[5];   //一次构造函数也不会调用
/**/
    // std::vector<int> a{1, 2, 3, 4, 5};
    // for (auto n:a)              //不能改变便利的值。 值传递
    // {
    //     std::cout << n << std::endl;
    // }
    // for (auto &n:a)             //可以改变便利的值。 引用类型
    // {
    //     std::cout << n << std::endl;
    // }
    // for (auto it = a.begin(); it != a.end(); it++) //std::vector<int>::iterator it = a.begin() 迭代器类型
    // {
    //     std::cout << *it << std::endl;
    // }
    /**/
//     system("pause");
//     return 0;
// }
// #include<bits/stdc++.h>
// class MyClass {
// public:
//     MyClass(){}
//     MyClass(MyClass obj) {  // 非引用类型参数
//         // do something...
//     }
// };

// int main()
// {
//     MyClass obj1;
//     MyClass obj2 = obj1;  // 拷贝构造函数被无限递归调用
// }


/**
 * @brief
 * stl中常见排序写法
 * 问题自定义符合类型作为哈希表元素时，需要自己解决哈希冲突，要不然不能插入元素。
 */
// #include<bits/stdc++.h>
// #define PID pair<int, double>  //注意写法，取代的名称在前 和typedof区别
// using namespace std;
// int main()
// {
//     /***** vector排序******/
//     vector<int> vector_sort{1, 3, 6, 2, 1, 3, 43};
//     sort(vector_sort.begin(), vector_sort.end(), [](int a, int b) -> bool
//          { return a > b; });
//     for (auto v:vector_sort)
//     {
//         cout << v << endl;
//     }
//     /******unordered_set排序****/
//     //unordered_set<int> set_sort{1, 2, 3, 4, 5, 6, 7};
//    // unordered_set<PID> set_sort{{1, 4.333}, {2, 3.222}, {3, 1.2222}}; //初始化失败
//     //  for (auto it = set_sort.begin(); it != set_sort.end();it++)
//     //  {
//     //      cout << it->first << " " << it->second <<endl;
//     //  }


//     /*********multi_set排序**************/
//     cout << "*********multi_set sort**************" << endl;
//     multiset<PID> multiset_sort{{1,2.33},{2,3.55},{3,6.443},{0,2.44},{0,2.44}};   //会进行自动排序,默认第一个升序
//     for (auto it = multiset_sort.begin(); it != multiset_sort.end(); it++)
//     {
//         cout << it->first << " " << it->second << endl;
//     }

//     /**********multi_map排序**************/
//      cout << "*********multi_map sort**************" << endl;
//     multimap<int, double> multimap_sort{{0,1.2},{1,0.8},{3,0.6},{1,0.8}};    //默认按第一个索引排序
//     for (auto it = multimap_sort.begin(); it != multimap_sort.end(); it++)
//     {
//         cout << it->first << " " << it->second << endl;
//     }

//     /**********unordered_map排序**************/
//     std::unordered_map<std::string, int> myMap { {"apple", 5}, {"banana", 10}, {"orange", 3} };
//     for (auto it = myMap.begin(); it != myMap.end(); it++)
//     {
//         cout << it->first << " " << it->second << endl;
//     }

//     system("pause");
//     return 0;
// }


/**
 * @brief 自定义类型的unordered_set 的哈希函数，以及其初始化方法。
 * 哈希表中桶的数量就是索引的大小。
 * 当数据产生冲突时，即很多数据在一个桶里，会用新的数据结构来管理每个桶内数据；
 * 数据少的时候使用链表，数据多的时候使用红黑树。
 * 关于桶的初始化数量，和桶的调整这里不做研究。
 */
// #include<bits/stdc++.h>
// #define PID pair<int,double>
// using namespace std;
// struct MyHashFunctionS {
//     std::size_t operator()(const std::pair<double, int>& key) const {    //插入删除时时是用的(),所以重载
//         // 将 double 类型的哈希值和 int 类型的哈希值进行组合
//         std::size_t doubleHash = std::hash<double>{}(key.first);
//         std::size_t intHash = std::hash<int>{}(key.second);
//         // 使用位运算或其他方式将两个哈希值组合为一个哈希值
//         std::size_t combinedHash = doubleHash ^ (intHash << 1);
//         return combinedHash;
//     }
// };
// struct MyEquality {
//     bool operator()(const std::pair<double, int>& lhs, const std::pair<double, int>& rhs) const {
//         return lhs.first == rhs.first && lhs.second == rhs.second;
//        // return true;
//     }
// };
// //这里返回的哈希值作为哈希表的索引，当前元素计算出的值就为当前元素的索引
// std::size_t myHashFunction2(const std::pair<double, int>& key) {
//     std::size_t doubleHash = std::hash<double>{}(key.first);
//     std::size_t intHash = std::hash<int>{}(key.second);
//     // 使用位运算或其他方式将两个哈希值组合为一个哈希值
//     std::size_t combinedHash = doubleHash ^ (intHash << 1);
//     return combinedHash;
// }
// struct compare  //map是针对value改写的
// {
//    bool operator()(const std::string& a, const std::string b) const{
//         return a.length() > b.length();
//    }
// };
// int main()
// {
//     unordered_set<PID, MyHashFunctionS, MyEquality> myset{{1, 2.11}, {2, 4.3}, {5, 8.33}, {1, 2.11}};
//     // std::unordered_set<std::pair<double, int>, decltype(&myHashFunction2)> mySet2(10, &myHashFunction2);
//     // mySet2.insert({1,2});
//     // mySet2.insert({2,3});
//     // mySet2.insert({3,4});
//     // mySet2.insert({4,5});
//     // mySet2.insert({5,6});
//     // mySet2.insert({6,7});
//     // mySet2.insert({7,8});
//     // mySet2.insert({8,9});
//     // mySet2.insert({9,10});
//     // mySet2.insert({10,11});
//     // mySet2.insert({13,11});
//     // mySet2.insert({11,11});
//     // int time = 0;
//     // for (auto it = mySet2.begin(); it != mySet2.end(); it++)
//     // {
//     //     cout << it->first << " " << it->second << endl;
//     //     time++;
//     // }
//     // cout << time;
//     PID target(make_pair(1, 2.11));
//     auto iter = myset.find(target);
//     if (iter != myset.end()) {
//         std::cout << "Element found: "  << std::endl;
//     } else {
//         std::cout << "Element not found" << std::endl;
//     }
//     for (size_t i = 0; i < myset.bucket_count(); ++i) {
//         if (myset.bucket_size(i) > 0) {
//             std::cout << "Bucket " << i << " is not empty. It contains: ";
//             for (auto it = myset.begin(i); it != myset.end(i); ++it) {
//                 std::cout << it->first << " ";
//             }
//             std::cout << std::endl;
//         }
//     }
//     cout << "the size of myset of bucket is " << myset.bucket_count() << endl;
//     // for (auto it = myset.begin(); it != myset.end(); it++)
//     // {
//     //     cout << it->first << " " << it->second << " ";
//     // }
//     std::map<std::string, int, compare> myMap = {{"apple", 1}, {"banana", 2}, {"orange", 3}, {"a", 8},{"b",7}};
//     // std::map<std::string, int> myMap = {{"apple", 1}, {"banana", 2}, {"orange", 3}, {"a", 8},{"b",7}};
//     for (auto it = myMap.begin(); it != myMap.end(); it++)
//     {
//         cout << it->first << " " << it->second << endl;
//     }
//     //交换键值对
//     // std::transform(originalMap.begin(), originalMap.end(), std::inserter(swappedMap, swappedMap.begin()),
//     //                [](const std::pair<int, std::string>& pair) {
//     //                    return std::make_pair(pair.second, pair.first);
//     //                });
//     system("pause");
//     return 0;
// }
/**
 * @file test.cpp
 * @author your name (you@domain.com)
 * @brief 快排求第K的最大元素
 * @version 0.1
 * @date 2023-06-30
 *
 * @copyright Copyright (c) 2023
 *
 */
// #include <bits/stdc++.h>
// using namespace std;
// class Solution {
// public:
// int partition(vector<int>& numbers, int low, int high) {
//     int pivot = numbers[low];
//     int i = low;
//     for (int j = low; j < high; ++j) {
//         if (numbers[j] < pivot) {
//             std::swap(numbers[i], numbers[j]);
//             i++;
//             cout << i << endl;
//         }
//     }
//     std::swap(numbers[i], numbers[high]);
//     return i;
// }
// // int partition1(vector<int>& numbers, int low, int high)
// // {
// //         int pivot = numbers[low];
// //     int i = low;
// //     int j = high;

// //     while (i < j) {
// //         while (i < j && numbers[j] >= pivot)
// //             j--;

// //         if (i < j)
// //             numbers[i++] = numbers[j];

// //         while (i < j && numbers[i] <= pivot)
// //             i++;

// //         if (i < j)
// //             numbers[j--] = numbers[i];

// //     }

// //     numbers[i] = pivot;
// //     return i;
// // }


// int quickSort(vector<int>& numbers, int low, int high, int k) {
//     stack<pair<int, int>> stk;
//     stk.push(make_pair(low, high));

//     while (!stk.empty()) {
//         pair<int, int> top = stk.top();
//         stk.pop();

//         int left = top.first;
//         int right = top.second;

//         if (left >= right)
//             continue;

//         int pivotIndex = partition(numbers, left, right);


//         if (pivotIndex == k - 1) {
//             return numbers[pivotIndex];  // 找到第K个元素，结束排序
//         } else if (pivotIndex > k - 1) {
//             // 第K个元素在左侧子数组中
//             stk.push(make_pair(left, pivotIndex - 1));
//         } else {
//             // 第K个元素在右侧子数组中
//             stk.push(make_pair(pivotIndex + 1, right));
//         }
//     }
//     return -1;
// }

// int findKthLargest(vector<int>& nums, int k) {
//         return quickSort(nums, 0, nums.size()-1, k);
//     }
// };

// int main()
// {
//     Solution a;
//     vector<int> my{3,2,1,5,1,2,86,99,12,6,42};
//     vector<int> my2{3,2,1,5,1,2,86,99,12,6,42};
//      cout << a.findKthLargest(my, 5) << endl;
//  //   cout << "1::"<<a.partition(my,1,my.size()-1) << endl;
//  //   cout << "2::"<<a.partition1(my2,1,my.size()-1) << endl;
//     system("pause");
//     return 0;
// }


/**
 * @file test.cpp
 * @author your name (you@domain.com)
 * @brief 求大数的和
 * @version 0.1
 * @date 2023-07-27
 *
 * @copyright Copyright (c) 2023
 *
 */
// #include <bits/stdc++.h>
// #include <algorithm>
// using namespace std;
// class Solution {
//   public:
//     /**
//      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
//      *
//      * 计算两个数之和
//      * @param s string字符串 表示第一个整数
//      * @param t string字符串 表示第二个整数
//      * @return string字符串
//      */
//     string solve(string s, string t) {
//         // write code here
//         int slen = s.length();
//         int tlen = t.length();
//         if (slen == 0) return t;
//         if (tlen == 0) return s;
//         string res = "";
//         //由于数字比较大，所以这里不能直接转换成int类型做相加
//         //应该采用进位的方法
//         int lenbig = s.length() < t.length() ? t.length() : s.length();
//         int lensmall = s.length() > t.length() ? t.length() : s.length();
//         //给低位补零，这样方便做加法
//         if (slen < tlen) {
//             for (int n = tlen - slen; n > 0; n--)
//                 s = '0' + s;
//         } else if (slen > tlen) {
//             for (int n = slen - tlen; n > 0; n--)
//                 t = '0' + t;
//         }
//         int theaddmore = 0;   //设置进位项
//         for (int i = lenbig-1; i > 0; i--) {
//             int c1 = s.at(i) - '0';
//             int c2 = t.at(i) - '0';
//             int resInt = 0;
//             if ( c1 + c2 + theaddmore > 9) {
//                 resInt = c1 + c2 + theaddmore - 10;
//                 theaddmore = 1;
//             } else {
//                 resInt = c1 + c2 + theaddmore;
//                 theaddmore = 0;
//             }
//             res += (resInt + '0');
//         }
//         if (theaddmore)
//             res = res + '1';
//         reverse(res.begin(), res.end());
//         return res;
//     }
// };


// int main()
// {
//     Solution a;
//     string s = "99";
//     string t = "1";
//     cout << a.solve(s, t) << endl;

//     system("pause");
//     return 0;
// }

//这里就是说 int *p = &a; 是 p = &a p的类型是指针
// #include <iostream>
// #define sum(a,b) (a+b)
// using namespace std;
// int main(){
//     int a = 9;
//     int *p = &a;
//     int *q = new int(5);
//     cout << q << endl;
//     cout << *q << endl;
//     cout << p << endl;
//     cout << *p << endl;
//     cout << &a << endl;
//     system("pause");
// }

// #include <bits/stdc++.h>
// using namespace std;
// int main() {

//     char a[] = "123";
//     char *b = a;
//     a[1] = '1';
//     cout << b[1] << endl;
//     cout << "the result of sizeof 'aa' :"<<  sizeof("aa b") << endl;
//     system("pause");
//     return 0;
// }

// #include <bits/stdc++.h>
// using namespace std;
// int main(){
//     int a = 1;
//     int &&b = move(a);
//     b = 2;
//     int &&c = 5;
//     cout << c << endl;
//     cout << &c << endl;
//     int *r ;
//     r = &c;
//     cout << &b << endl;
//     cout << a << endl;
//     system("pause");
//     return 0;
// }