学习笔记 - C++

  double x = (double) 1;  //C语言的强制类型转换
  double y = double(1);   //C++的强制类型转换
  int a = static_cast<int>(7.9 + 6.7);    //C++的强制类型转换

    //static_cast操作符，用于强制类型转换
    int a = static_cast<int>(7.9 + 6.7);    

    //const_cast 操作符，显式改变变量的const或volatile属性
    const int constant = 1;
    int& var = const_cast<int&>(constant);
    var = 2;
    cout << "constant's value: " << constant << endl;
    cout << "var's value: " << var << endl;
    //Output:
    //constant's value: 1
    //var's value: 2
    //常量值依然不变，但两者地址相同，神奇！

    cout << "constant's address: " << &constant << endl;
    cout << "var's address: " << &var << endl;
    //Output:
    //constant's address: 0x7ffdba948dac
    //var's address: 0x7ffdba948dac

    //reinterpret_cast 操作符， 无视类型强型转换，过于强大一般不建议使用
    reinterpret_cast<type> (object);

    //dynamic_cast 操作符，主要应用在执行多态对象的类型转换  
    dynamic_cast<type> (object);

    //typeid操作符，可用于在程序运行期间获取未知对象的类型，比如类名
    char* objectType = typeid(object).name();

  bool is_valid = true;  //相当于 = 1
  bool is_valid = false; //相当于 = 0

  int main(){
      setlocale(LC_ALL, "");
      const wchar_t* str = L"哈哈哈哈哈哈哈嗝emmm";
      wprintf(str);
      cout << endl;
      //Output: 哈哈哈哈哈哈哈嗝emmm
  }

  //auto的栗子
  vector<int> vec;
  auto it = vec.begin();  //auto自动推断为 vector<int>::iterator 类型
  vector<int>::iterator it2 = vec.begin();    //等价于上一句

  // auto与decltype的比较
  // 对const
  double a_var = 3.14;
  const double a_con = 3.14;
  decltype(a_var) b_dec_var = 3.14;   // b_dec_var = 3.14
  decltype(a_con) b_dec_con = 3.14;   // b_dec_con = 3.14
  auto b_auto_var = a_var;            // b_auto_var = 3.14
  auto b_auto_con = a_con;            // b_auto_con = 3.14
  b_dec_var = 3.14;                   // ok
  //b_dec_con = 3.14;                 // error，decltype保留const
  b_auto_var = 3.14;                  // ok
  b_auto_con = 3.14;                  // ok，auto不保留const

  // 对解引用操作
  double c = 3.14;
  double* ptr = &c;
  auto d_auto = *ptr;             // d_auto是double型的，auto还原为原来的
  decltype(* ptr) d_dec = c;      // d_dec是double&型的，decltype还原为引用的

  int a = 5, b = 0;
  assert(b);
  cout << a/b << endl;
  //输出：test3: ../test3/main.cpp:6: int main(): Assertion `b' failed.

  int a = 5, b = -3;
  assert(b > 0);
  cout << __gcd(a, b) << endl;
  //输出：test3: ../test3/main.cpp:6: int main(): Assertion `b > 0' failed.

  while(!cin.eof()){    //写成 while(cin)也是可以的
    //Do Something
  }

  inline double cube(double a){   //关键字inline
    return (a*a*a);
  }

//可用函数larger判断两个int, char, double, string型变量的最大值，使用时无需使用四个函数，只需larger这一个函数
  int larger(int x, int y)  {return (x > y)?x:y;}
  char larger(char x, char y) {return (x > y)?x:y;}
  double larger(double x, double y) {return (x > y)?x:y;}
  string larger(string x, string y) {return (x > y)?x:y;}

  int main(){
    //Do Something
  }

  typedef unsigned long long ull;
  typedef long long ll;

  int main(){
    ull a = 0;
    ll b = 0;
  }

  namespace temp{
    const int a = 10;
    const int b = 20;
  }
  using namespace temp;   //简化使用所有该namespace成员的语法

  int main(){
    cout << a << endl;  //简化使用
    cout << b << endl;  //简化使用
  }

  namespace temp{
    const int a = 10;
    const int b = 20;
  }
  using temp::a;   //简化使用某个该namespace成员的语法

  int main(){
    cout << a << endl;  //简化使用
    cout << temp::b << endl;
  }

  int len, pos;
  string str_sub;
  string str1 = "Hello";
  string str2 = "World";

  string str3 = str1 + ' ' + str2;  //str3 == "Hello World"
  str3[6] = 'w';  //可用下标访问与修改, str3 == "Hello world"
  len = str3.length();  //获取长度，也可用str3.size();
  pos = str3.find("or");  //查找子串，失败返回npos
  str_sub = str3.substr(6, 5);  //返回子串，6为开始位置，5为长度，str_sub == "world"
  str1.swap(str2);  //交换子串， str1 == "World", str2 == "Hello"  

  str1 < str2;    //可以直接用 > >= == <= < 比较两个字符串  

  getline(cin, str1, ',');    //读取整行字符串直到遇到','，第三个参数可省略

  const int row = 20;
  const int col = 10;
  typedef int tableType[row][col];
  tableType matrix;

  #include <iostream>   //系统提供的头文件用 < >
  #include "myHeaderFile.h"   //用户定义的用 " "

  //写头文件时使用以下格式可避免多重包含变量导致编译错误
  //Header file
  #ifndef H_test    //if not define，第二次包含时已经define就会跳过下面的代码
  #define H_test
    //Do Something
  #endif

  typedef void(* FunPtr)(int, int);   //typedef简化代码
  void Add(int i, int j) { cout << i << " + " << j << " = " << i + j << endl; }
  void Sub(int i, int j) { cout << i << " - " << j << " = " << i - j << endl; }
  int main(){
      FunPtr ptr;   //声明
      ptr = &Add;   //绑定Add函数
      ptr(3, 5);
      //Output: 3 + 5 = 8

      ptr = &Sub;
      ptr(5, 3);    //绑定Sub函数
      //Output: 5 - 3 = 2
  }

int& max(int& a, int& b)  { return (a > b) ? a : b; }   //引用传参且返回引用
int main(){
    int a = 2, b = 1;
    max(a, b) = -1;  //将-1赋给a,b中的最大值, a = -1
}

  istream cin;
  ostream cout;

  //读取一个字符存到ch中，空格、回车均可存     
  cin.get(ch);  

  //输出字符
  cout.put(ch);    

  char str[20];
  cin.getline(str, 20);  //读取到 \n 或 20-1个字符
  cout << str << endl;
  //Input:  123456 78910
  //Output: 123456 78910

  //Input:  123456 789101112131415
  //Output: 123456 789101112131

  const char* str = "Apple";
  for(int i = 1; i <= 5; i++){
      cout.write(str, i);
      cout << endl;
  }
  //Output:
  //A
  //Ap
  //App
  //Appl
  //Apple

  //忽略掉下面100个字符 或者 忽略掉下个'\n'之前的所有字符   
  cin.ignore(100, '\n');   

  //把ch变量退回输入流中    
  cin.putback(ch);

  //检测下一个字符为何值
  ch = cin.peek();

  //使cin流恢复正常状态
  cin.clear();

  ostream& unit(ostream& output){     //语法
      output << " GB";
      return output;
  }

  int main(){
      cout << 1 + 2 << unit << endl;
      //output: 3 GB
  }

  // 声明流变量
  ifstream inData;
  ofstream outData;

  // 打开文件
  inData.open("FilePath1");    //打开文件路径为FilePath1的文件
  outData.open("FilePath2");

  {
     // Do Something
     //把inData当作cin， outData当作cout使用，同文本重定向操作
  }

  // 关闭文件
  inData.close();
  outData.close();

    ifstream in;
    ofstream out;
    in.open("FilePath", ios::in);
    out.open("FilePath", ios::app);

    int pin = in.tellg();     //取得输入指针
    int pout = out.tellp();   //取得输出指针

    in.seekg(0);   //移动到指定位置，0代表文件头
    out.seekp(0);

    ofstream out;
    ifstream in;
    out.open("/home/a/1.out");
    double arr[4] = {3.14, 6.28, 2.7100, 9.99990};
    double arr2[4] = {0};

    out.write((char*) &arr, sizeof(arr));   //语法
    out.close();

    in.open("/home/a/1.out");
    in.read((char*) &arr2, sizeof(arr2));     //同样是语法
    copy(arr2, arr2 + 4, ostream_iterator<double>(cout, " "));
    cout << endl;
    //Output: 3.14 6.28 2.71 9.9999

  dataTypeName
    clockType
  domain
    each clockType value is a time of day in the form of hours, minutes, and seconds.
  operations
    Set the time.
    Return the time.
    ......

  class clockType{
  private:      //私有成员不能被类外部访问，类内部默认为private，故若private出现在public和protected前面时可以省略
      //ADT的domain
      int hr;
      int min;
      int sec;

  public:
      // ADT的Operations
      void setTime(int, int, int);
      void getTime(int&, int&, int&);
      void printTime()    const;
      void incrementSeconds();
      void incrementMinutes();
      void incrementHours();
      bool equalTime(const clockType& otherClock) const;    //传引用可提高性能（因为无需拷贝）
  };

  class clockType{
    //......
  };

  void clockType::setTime(int hours, int minutes, int seconds){
      hr = (0 <= hours && hours < 24)?hours:0;
      min = (0 <= minutes && minutes < 60)?minutes:0;
      seconds = (0 <= seconds && seconds < 60)?seconds:0;
  }

    class test{
    public:
        int get()  { return a; }
        void fun() { a++; }
    private:
        static int a;
    };

    int test::a;  //静态成员函数的定义

    int main(){
        test obj1;
        test obj2;
        cout << obj1.get() << endl;
        //Output: 0

        obj1.fun();
        cout << obj1.get() << " " << obj2.get() << endl;
        //Output: 1 1
    }

    class test{
    public:
        static int showA() { return a; }
        void fun() { a++; }
    private:
        static int a;
    };

    int test::a;  //静态成员函数的定义

    int main(){
        test obj1;
        cout << test::showA() << endl;
        //Output: 0

        obj1.fun();
        cout << test::showA() << endl;
        //Output: 1
    }

  void get_balance()  const;

  int A::* ip = &A::m;   //A::* 为“指向类A的成员的指针”， &A::m 为 “类A的成员的地址”  

  class test{
  public:
      test(int a): data(a), data2(0) {}
      void modify()    const;
  private:
      int data;
      mutable int data2;
  };

  void test::modify() const{
      data = 0;   //error: assignment of member ‘test::data’ in read-only object
      data2 = 0;  //ok
  }

  class clockType{
  public:
      //省略成员函数
      clockType(int hours, int minutes, int seconds);  //带参数的构造函数
      clockType();  //默认构造函数
  private:
      int hr, min, sec;
  };

  //相关实现
  //实际上无需写拷贝构造，因为不含指针数据成员
  clockType::clockType(int hours, int minutes, int seconds): hr(hours), min(minutes), seconds(sec){}

  clockType::clockType(): hr(0), min(0), sec(0) {}    // 构造函数初始化值列表
  //一般不写作 clockType::clockType()  { hr = 0; min = 0; sec = 0; }  ，因为赋值会先初始化后赋值

  class clockType{
  public:
      //省略成员函数
      clockType(int = 0, int = 0, int = 0);  //默认构造函数
  private:
      int hr, min, sec;
  };

  //相关实现
  clockType::clockType(int hours, int minutes, int seconds): hr(hours), min(minutes), seconds(sec){}

  int main(){
    clockType myclock1;
    clockType myclock2(5, 12, 40);
  }

  class clockType{
  public:
      //省略成员函数
      clockType(int hours, int minutes, int seconds);
      clockType();
  private:
      int hr, min, sec;
  };

  //相关实现
  //省略clockType(int hours, int minutes, int seconds)的实现

  clockType::clockType(): clockType(0, 0, 0) {}   
  //委托给clockType(int hours, int minutes, int seconds)进行构造

  class myVector{
  public:
      myVector();
      myVector(const myVector& anotherVector);    //拷贝构造函数
      ~myVector();
      void print()    const;
  private:
      unsigned t_size;
      int* p;
  };

  myVector::myVector(){
      t_size = 10;
      p = new int[t_size]();
      for(int i = 0; i < t_size; i++){  p[i] = i;  }
  }

  myVector::myVector(const myVector &anotherVector){
      t_size = anotherVector.t_size;      //t_size在向量中会改变，故要拷贝
      p = new int[t_size];
      for(int i = 0; i < t_size; i++){    //深拷贝
          p[i] = (anotherVector.p)[i];    //注意需要打括号，优先级问题
      }
  }

  myVector::~myVector() { delete [] p; }

  void myVector::print() const{
      for(int i = 0; i < t_size; i++){
          cout << p[i] << " ";
      }
      cout << endl;
  }

  //主函数----------------------------------------------------------
  int main(){
      myVector vec;
      myVector vec2(vec);
      vec2.print();
      //Output:
      //0 1 2 3 4 5 6 7 8 9
  }

  //如在类中new了数组后，在实例退出作用域时需要将其删除，可编写析构函数delete掉
  class myVector{
  public:
    myVector();
    ~myVector();
  private:
    int* p;
  };

  myVector::myVector(){
    p = new int[10];
  }

  myVector::~myVector(){
    delete [] p;
    cout << "clear done!" << endl;
  }

  //主函数----------------------------------------------------------
  int main(){
    int n_case = 2;
    for(int i = 1; i <= n_case; i++){
        myVector vec;
    }
  }
  //Output
  //clear done!
  //clear done!

    //例如：cirle类和rectangle类从shape类派生
    class circle: public shape{   //shape类的public成员变成cirle类的public成员
      //Do Something
    };

    class circle: private rectangle{    //shape类的public成员变成cirle类的private成员(private可省略)
      //Do Something
    };

  class baseClass{
  public:
      void print()    const;
      baseClass():base_var("base_var"){}
  private:
      string base_var;
  };

  class derivedClass: public baseClass{
  public:
      void print()    const;
      derivedClass():derived_var("derived_var"){}
  private:
      string derived_var;
   };

  void baseClass::print() const{
      cout << base_var << endl;
  }

  void derivedClass::print() const{
      baseClass::print();
      cout << derived_var << endl;
  }

  int main(){
      baseClass base_object;
      derivedClass derived_object;
      base_object.print();
      // Output:
      // derived_var

      derived_object.print();
      //Output:
      // base_var
      // derived_var
      return 0;
  }

  class baseClass{
  public:
      void print()    const;
      baseClass(string var);
  private:
      string base_var;
  };

  class derivedClass: public baseClass{
  public:
      void print()    const;
      derivedClass(string var, string var2);  //var是给derviedClass的，var2是给baseClass的
  private:
      string derived_var;
  };

  // ---------------------------------------
  baseClass::baseClass(string var = "base_bar by default"): base_var(var){}    //基类构造函数

  derivedClass::derivedClass(string var = "derived_var",
   string var2 = "base_var provoked by derivedClass"):baseClass(var2), derived_var(var) {}   //触发基类构造函数

  void baseClass::print() const{
      cout << base_var << endl;
  }
  void derivedClass::print() const{
      baseClass::print();
      cout << derived_var << endl;
  }
  // ---------------------------------------
  int main(){
      baseClass base_object;
      derivedClass derived_object;
      base_object.print();
      // Output:
      // base_var by default

      derived_object.print();
      // Output:
      // base_var provoked by derivedClass
      // derived_var

      derivedClass derived_object2("derived_bar by user", "base_bar by user");
      derived_object2.print();
      // Output:
      // base_bar by user
      // derived_bar by user

      return 0;
  }

  #include <cstdlib>
  #include <iostream>
  #include <string>
  #include <algorithm>
  using namespace std;
  class MyString:public string
  {

      // 在此处补充你的代码 ------------------------------------------------------------------------
  public:
      MyString(): string() {}   //触发基类string类构造函数
      MyString(const string s): string(s) {}  //触发基类string类构造函数
      MyString(const char* s): string(s) {}   //触发基类string类构造函数
      //触发基类string类构造函数，这里把派生类对象s交给string类构造函数处理是没问题的，反之则不行
      MyString(const MyString& s): string(s) {}   
      MyString operator () (int loc, int len){    //因此这是唯一的拓展
          return this->substr(loc, len);          //但其实也是调用一下string类的方法substr然后完事
      }
      // -----------------------------------------------------------------------------------------

  };


  int main()
  {
      MyString s1("abcd-"),s2,s3("efgh-"),s4(s1);
      MyString SArray[4] = {"big","me","about","take"};
      cout << "1. " << s1 << s2 << s3<< s4<< endl;
      s4 = s3;
      s3 = s1 + s3;
      cout << "2. " << s1 << endl;
      cout << "3. " << s2 << endl;
      cout << "4. " << s3 << endl;
      cout << "5. " << s4 << endl;
      cout << "6. " << s1[2] << endl;
      s2 = s1;
      s1 = "ijkl-";
      s1[2] = 'A' ;
      cout << "7. " << s2 << endl;
      cout << "8. " << s1 << endl;
      s1 += "mnop";
      cout << "9. " << s1 << endl;
      s4 = "qrst-" + s2;
      cout << "10. " << s4 << endl;
      s1 = s2 + s4 + " uvw " + "xyz";
      cout << "11. " << s1 << endl;
          sort(SArray,SArray+4);
      for( int i = 0;i < 4;i ++ )
      cout << SArray[i] << endl;
      //s1的从下标0开始长度为4的子串
      cout << s1(0,4) << endl;
      //s1的从下标5开始长度为10的子串
      cout << s1(5,10) << endl;
      return 0;
  }

  class A{
  public:
      int a;
  };

  class B{
  public:
      int b;
  };

  class C: public A, public B{  //多继承语法
  public:
      int c;
  };

  int main(){
      C obj;
      obj.a;  //继承A，可访问
      obj.b;  //继承B，可访问
      obj.c;  //自身的，可访问
  }

  class A{
    //...
  };

  class B1 : virtual public A{
    //...
  };

  class B2 : virtual public A{
    //...
  };

  class C : public B1, public B2{   //因为B1，B2继承A时使用虚基类，所以C最终只会继承一份A，不会引起成员重复  
    //...
  };

  class A{
  public:
      string var_A;
      A() {}
      A(string var): var_A(var)   {}
  };

  class B1 : virtual public A{
  public:
      string var_B1;
      B1(string var): A(var + "B1 to A"), var_B1(var) {}
  };

  class B2 : virtual public A{
  public:
      string var_B2;
      B2(string var): A(var + "B2 to A"), var_B2(var) {}
  };

  class C : public B1, public B2{
  public:
      string var_C;
      C(string var): A(var + "C to A"), B1(var + "C to B1"), B2(var + "C to B2"), var_C(var)  {}
  };

  int main(){
      A obj_A("A's var ");
      B1 obj_B1("B1's var ");
      B2 obj_B2("B2's var ");
      C obj_C("C's var ");


      cout << obj_A.var_A << endl;
      // Output:
      // A's var


      cout << obj_B1.var_A << endl;
      cout << obj_B1.var_B1 << endl;
      // Output:
      // B1's var B1 to A
      // B1's var


      cout << obj_C.var_A << endl;    //B1,B2中A的构造函数被忽略，但必须写
      cout << obj_C.var_B1 << endl;
      cout << obj_C.var_B2 << endl;
      cout << obj_C.var_C << endl;
      // Output:
      // C's var C to A
      // C's var C to B1
      // C's var C to B2
      // C's var
  }

  class linearList{
  public:
      //析构函数需要为虚函数，作用是能调用引用对象中数据类型的析构函数，如果不写只会调用基类的析构函数，派生类的不会被调用
      virtual ~linearList() {}
      virtual bool empty()  const = 0;
      virtual int size()  const = 0;
      virtual void erase(int theIndex) = 0;
  };

  //datatype类-------------------------------------------------------
  class dateType{
  public:
      dateType(int year, int month, int day);
      void print();
  private:
      int dYear, dMonth, dDay;
  };

  dateType::dateType(int year = 2018, int month = 2, int day = 30):
      dYear(year), dMonth(month), dDay(day){}   //dataType的默认构造函数

  void dateType::print(){
      cout << "Date: " << dYear << "-" << dMonth << "-" << dDay << endl;
  }

  // personalType类----------------------------------------------
  class personalType{
  public:
      personalType(string name);
      void print();
  private:
      string dName;
  };

  personalType::personalType(string name = "null"): dName(name){}

  void personalType::print(){
      cout << "Name: " << dName << endl;
  }

  //persoanlInfo类--------------------------------------------------
  class personalInfo{
  public:
      personalInfo();
      personalInfo(int year, int month, int day, string name);
      void print();
  private:
      personalType personalName;
      dateType bDay;
  };

  personalInfo::personalInfo(){}    //使用对象成员构造函数的默认值
  personalInfo::personalInfo(int year, int month, int day,
     string name):personalName(name), bDay(year, month, day){}  //向成员对象的构造函数传递参数

  void personalInfo::print(){
      personalName.print();
      bDay.print();
  }

  //主函数----------------------------------------------------------
  int main(){
    personalInfo student;
    student.print();
    //Output
    //Name: null
    //Date: 2018-2-30

    personalInfo student2(1999, 9, 9, "your nick name");
    student2.print();
    //Output
    //Name: your nick name
    //Date: 1999-9-9
  }

  class A{
  public:
      void print()   const;
      A get()   const;
      int x, y;
  };

  void A::print()  const  { cout << x << " " << y << " " << endl;}

  A A::get() const  { return  * this; }

  int main(){
      A instanceA;
      A instanceB;
      instanceA.x = 1, instanceA.y = 2;
      instanceB = instanceA.get();
      instanceB.print();
  }

  //一个神奇的栗子
  class person{
  public:
      person& setFirstName(string var);   //此处返回的是引用
      person& setLastName(string var);
      void print();
  private:
      string first_name;
      string last_name;
  };

  person& person::setFirstName(string var){ first_name = var; return * this; }
  person& person::setLastName(string var){ last_name = var; return * this; }
  void person::print(){ cout << first_name << " " << last_name << endl; }

  int main(){
      person null;
      null.setFirstName("Name").setLastName("Error");  //因为返回引用且为自身*this，故可连续用两次.
      null.print();
      //Output
      //Name Error
  }

  class A{
  public:
      int public_data_a;
  private:
      int private_data_a;
  };

  class B: public A{
  public:
      int public_data_b;
  private:
      int private_data_b;
  };

  int main(){
      B objB;

      A* ptr = &objB;         //基类指针绑定派生类实例
      ptr->public_data_a;     //能访问基类的成员，不能访问派生类的成员

      B* ptr2 = &objB;        //派生类指针绑定派生类实例
      ptr2->public_data_a;    //都能访问！
      ptr2->public_data_b;
  }

  class A{
  public:
      virtual void print();   //只需要在基类加上virtual，派生类不需要
  };

  class B: public A{
  public:
      void print();
  };

  void A::print(){
      cout << "It's in A" << endl;
  }

  void B::print(){
      cout << "It's in B" << endl;
  }

  void callPrint(A& p){   //注意使用引用或者指针传参
      p.print();
  }

  // -----------------------------------
  int main(){
      A instanceA;
      B instanceB;
      callPrint(instanceA);
      callPrint(instanceB);
      //Output：
      //It's in A
      //It's in B

      //若不加virtual，Output：
      //It's in A
      //It's in A
  }

  class B;    //前向引用声明，因为下面的函数cSwap需要用到
  class A{
  public:
      A() { x = 1; }
      //下面一句是友元函数，函数原型前需加上friend
      friend void cSwap(A& cA, B& cB);  //这是一个交换两个类数据的函数，需要用到友元函数，注意传的是引用
      int get() { return x; }
  private:
      int x;
  };

  class B{
  public:
      B(): x(2) {}
      friend void cSwap(A& cA, B& cB);
      int get(){ return x; }
  private:
      int x;
  };

  void cSwap(A& cA, B& cB){    //友元函数定义，前面不需要加上friend
      int temp = cA.x;
      cA.x = cB.x;
      cB.x = temp;
  }

  // ---------------------------
  int main(){
      A instanceA;
      B instanceB;
      cout << instanceA.get() << " " << instanceB.get() << endl;
      //Output: 1 2

      cSwap(instanceA, instanceB);
      cout << instanceA.get() << " " << instanceB.get() << endl;
      //Output: 2 1
  }

    class ComplexNum{
    public:
        ComplexNum(): real(0), vir(0)  {}
        ComplexNum(int a, int b): real(a), vir(b)  {}

        // 下面是运算符+重载的函数原型，ComplexNum是返回类型，operator+其实是函数名，(const ComplexNum&) 则是右值  
        // 仔细想想，其实和普通的类内函数声明没有区别  
        // 另外注意返回不能是引用，原因看下面
        ComplexNum operator + (const ComplexNum&)   const;
        void display();
    private:
        int real;
        int vir;
    };

    //重载运算符语法如下面这一句
    // 重载+需要定义一个先的类对象返回，如果返回引用，res退出函数已被销毁，引用会失效
    ComplexNum ComplexNum::operator + (const ComplexNum& other_complex_num)  const{
        return ComplexNum(real + other_complex_num.real, vir + other_complex_num.vir);
    }

    void ComplexNum::display(){ cout << real << "+" << vir << "i" << endl; }

    // -------------------------
    int main(){
        ComplexNum num1(1, 2);
        ComplexNum num2(2, 4);
        ComplexNum num3 = num1 + num2;  //等价于 num1.operator+(num2)
        num3.display();
        //Output: 3+6i
    }

    class ComplexNum{
    public:
        ComplexNum(int a, int b): real(a), vir(b)  {}
        bool operator == (const ComplexNum&)   const;
    private:
        int real, vir;
    };

    bool ComplexNum::operator == (const ComplexNum& other_complex_num)  const{
        return (real == other_complex_num.real && vir == other_complex_num.vir);
    }

    // -------------------------
    int main(){
        ComplexNum num1(1, 2);
        ComplexNum num2(1, 3);
        cout << ((num1 == num2)?"TURE":"FALSE") << endl;
        //Output: FALSE
    }

    class ComplexNum{
    public:
        ComplexNum(): real(0), vir(0)  {}
        ComplexNum(int a, int b): real(a), vir(b)  {}
        friend ComplexNum operator + (const ComplexNum& first, const ComplexNum& second)   ;  //函数原型1
        friend ComplexNum operator + (const ComplexNum& first, const int& second)   ;  //函数原型2
        friend ComplexNum operator + (const int& second, const ComplexNum& first)   ;  //函数原型3
        void display();
    private:
        int real;
        int vir;
    };

    //分别重载complex + complex, complex + int, int + complex三种情况
    ComplexNum operator + (const ComplexNum& first, const ComplexNum &second){
        return ComplexNum(first.real + second.real, first.vir + second.vir);
    }

    ComplexNum operator + (const ComplexNum& first, const int& second){
        return ComplexNum(first.real + second, first.vir);
    }

    ComplexNum operator + (const int& second, const ComplexNum& first){
        return ComplexNum(first.real + second, first.vir);
    }

    void ComplexNum::display(){ cout << real << "+" << vir << "i" << endl; }

    // ---------------------------------------------
    int main(){
        ComplexNum num1(1, 2);
        ComplexNum num2(2, 4);
        ComplexNum num3 = 4 + num1 + num2 + 3;
        num3.display();
        //Output: 10+6i
    }

  class ComplexNum{
  public:
      ComplexNum(int a, int b): real(a), vir(b)  {}
      //<< >> 重载的函数原型如下
      //注意ostream和istream是不可以改变的，其为输入输出流
      friend ostream& operator << (ostream& ostreamObject, const ComplexNum& num);
      friend istream& operator >> (istream& istreamObject, ComplexNum& num);  //注意没有const，const就不能输入了！
  private:
      int real, vir;
  };

  ostream& operator << (ostream& ostreamObject, const ComplexNum& num){
      ostreamObject << "(" << num.real << "," << num.vir << "i)";
      return ostreamObject;   //注意return，后续可能接着用到
  }

  istream& operator >> (istream& istreamObject, ComplexNum& num){
      istreamObject >> num.real >> num.vir;
      return istreamObject;
  }

  // -------------------------
  int main(){
      ComplexNum num1(1, 2);
      ComplexNum num2(2, 4);
      ComplexNum num3(0, 0);
      cin >> num3;
      //Input: 3 6

      cout << num1 << " + " << num2 << " = " << num3 << endl;
      //Output: (1,2i) + (2,4i) = (3,6i)
  }

  class myVector{
  public:
      myVector(int start);
      ~myVector();
      void print()    const;
      const myVector& operator = (const myVector& other);
  private:
      unsigned t_size;
      int* p;
  };

  myVector::myVector(int start){
      t_size = 5;
      p = new int[t_size]();
      for(int i = 0; i < t_size; i++){  p[i] = start + i;  }
  }

  myVector::~myVector() { delete []p; }

  void myVector::print() const{
      for(int i = 0; i < t_size; i++){
          cout << p[i] << " ";
      }
      cout << endl;
  }

  myVector& myVector::operator = (const myVector& other){
      if(this != &other){     //避免自身复制，浪费时间空间
          t_size = other.t_size;
          for(int i = 0; i < t_size; i++){    //深拷贝
              p[i] = (other.p)[i];
          }
      }
      return * this;
  }

  //主函数----------------------------------------------------------
  int main(){
      myVector vec(0);
      myVector vec2(10);
      vec.print();
      vec2.print();
      //Output:
      //0 1 2 3 4
      //10 11 12 13 14

      vec = vec2;
      vec.print();
      vec2.print();
      //Output:
      //10 11 12 13 14
      //10 11 12 13 14
  }

  //重载下标[]，以向量为栗
  class myVector{
  public:
      myVector(int start);
      ~myVector();
      void print()    const;
      int& operator[] (const int& i);     //重载下标[]
  private:
      unsigned t_size;
      int* p;
  };

  myVector::myVector(int start){
      t_size = 5;
      p = new int[t_size]();
      for(int i = 0; i < t_size; i++){  p[i] = start + i;  }
  }

  myVector::~myVector() { delete [] p; }

  void myVector::print() const{
      for(int i = 0; i < t_size; i++){
          cout << p[i] << " ";
      }
      cout << endl;
  }

  int& myVector:: operator[] (const int& i){
      return p[i];
  }

  //主函数----------------------------------------------------------
  int main(){
      myVector vec(0);
      myVector vec2(10);
      cin >> vec[0];
      vec.print();
  }

  //重载自增运算符
  class ComplexNum{
  public:
      ComplexNum(int a, int b)   {real = a, vir = b;}

      // 重载前置自增，自减同理，注意为与内置版本一致，需返回引用
      ComplexNum& operator ++();

      // 重载后置自增，自减同理，其中int i无实际意义，仅起标识为后置的作用，注意为与内置版本一致，需返回值   
      ComplexNum operator ++(int);  
      void display();
  private:
      int real, vir;
  };

  ComplexNum& ComplexNum::operator ++(){
      real++;
      return * this;
  }

  ComplexNum ComplexNum::operator ++(int){
      ComplexNum temp = * this;
      real++;
      return temp;
  }

  void ComplexNum::display(){ cout << real << "+" << vir << "i" << endl; }

  // -------------------------
  int main(){
      ComplexNum num1(1, 2);
      ComplexNum num2(2, 4);
      num1.display();
      num2.display();
      //Output:
      //1+2i
      //2+4i

      num1++;   // 相当于 num1.operator++(0);
      ++num2;   // 相当于 num2.operator++;
      num1.display();
      num2.display();
      //Output:
      //2+2i
      //3+4i
  }

  struct myAbs{
      int operator () (int val){
          return (val < 0) ? -val : val;
      }
  };

  int main(){
      cout << myAbs()(-42) << endl;
      //Output: 42
  }

  // 函数对象经常作为泛型算法的实参
  struct printTwice{
    char op;
    printTwice(char ch = ' '): op(ch) {}
    void operator () (const string& obj) const{
        cout << obj << op << obj << endl;
    }
  };

  int main(){
    printTwice(',')("123");
    //Output: 123,123

    string arr[3] = {"abc", "def", "hhh"};
    for_each(arr, arr + 3, printTwice());
    //Output:
    //abc abc
    //def def
    //hhh hhh
  }

  class myString{
  public:
      myString(char* str);
      myString() {}
  private:
      char* p;
  };

  myString::myString(char* str){
      int length = strlen(str);
      p = new char[length + 1];
      strcpy(p, str);
  }

  int main(){
      myString s1 = myString((char*)("Apple"));  //从char*类型到myString类型，通过隐式调用构造函数
  }

  //以立方转原来的数为栗子
  class cube{
  public:
      cube(double num = 0): res(num*num*num) {}
      operator double() { return pow(res, 1.0/3) ; }    //重载类型转换符
  private:
      double res;
  };

  int main(){
      cube num(double(4.0));
      cout << double(num) << endl;
      //Output: 4
  }

  //以立方转开方为栗子
  class square{
  public:
      square(double num = 0): res(sqrt(num)) {}
      double get() { return res; }
  private:
      double res;
  };


  class cube{
  public:
      cube(double num = 0): res(num*num*num) {}
      operator square();    //重载操作符
  private:
      double res;
  };


  cube::operator square(){
      return square(pow(res, 1.0/3));
  }

  // ---------------
  int main(){
      cube num(double(4.0));
      square num2(num);
      cout << num2.get() << endl;
      //Output: 2
  }

  class test{
  public:
      explicit test(int a): data(a) {}
  private:
      int data;
  };

  int main(){
      test obj1(100);     //合法
      test obj2 = 200;    //error: conversion from ‘int’ to non-scalar type ‘test’ requested
  }

  class MyCin{
  public:
      MyCin() { flag = 1; }
      MyCin& operator >> (int& obj){    // 重载运算符 >>，作为输入流因此为类成员
          cin >> obj;
          if(obj == -1)   flag = 0;
          return (* this);
      }

      operator bool(){    // 重点！ 重载操作符bool，适用于 while(),  if() 等或者显示的 bool()调用转换
          return flag;
      }

  private:
      int flag;   //标记是否遇到-1
  };

  int main()
  {
      MyCin m;
      int n1,n2;
      while(m >> n1 >> n2)
          cout  << n1 << " " << n2 << endl;
      return 0;
  }

  template <class T>  //模板语法，T是类型，由传参决定
  T larger(T x, T y) { return (x > y)?x:y; }

  // -------------------------
  int main(){
      cout << larger(5, 7) << endl;
      //Output: 7

      cout << larger('A', 'Z') << endl;
      //Output: Z

      cout << larger(9.9999, 9.9898) << endl;
      //Output: 9.9999
  }

  #include <iostream>
  #include <string>
  using namespace std;
  template <class T>
  T SumArray(

  // 在此处补充你的代码 ---------------------------
   T * begin, T * end){
      T res = * begin;
      T * it = begin + 1;
      while(it != end){
          res = res + * it;   //注意string类重载了+，所以这样子是可以的
          it++;
      }
      return res;
  // -------------------------------------------
  }
  int main() {
      string array[4] = { "Tom","Jack","Mary","John"};
      cout << SumArray(array,array+4) << endl;
      int a[4] = { 1, 2, 3, 4};  //提示：1+2+3+4 = 10
      cout << SumArray(a,a+4) << endl;
      return 0;
  }

template <class T>    //语法需要
  class point{
  public:
      point();
      void setPoint(const T ix, const T iy);
      void display()  const;
  private:
      T x;
      T y;
  };

  template <class T>
  point<T>::point(): x(0), y(0) {}   //注意是point<T>，并且每一处有使用T的地方，前面都要加 template <class T>

  template <class T>
  void point<T>::setPoint(const T ix, const T iy){ x = ix; y = iy; }

  template <class T>
  void point<T>::display() const{ cout << "x is " << x << ", y is " << y << endl;}

  // -------------------------
  int main(){
      point<int> p1;
      point<double> p2;
      p1.setPoint(5, 6);
      p2.setPoint(3.1415, 2.71);

      p1.display();
      //Output: x is 5, y is 6

      p2.display();
      //Output: x is 3.1415, y is 2.71
  }

  //类模板
  template <class T1, class T2>   //两个参数
  class test{
  public:
      test(T1 x, T2 y): a(x), b(y) {}
      void print() { cout << a << " and " << b << endl;}
  private:
      T1 a;
      T2 b;
  };

  int main(){
      test<string, double> obj1("HAhhhhhh", 1.234567);
      obj1.print();
      //Output: HAhhhhhh and 1.23457
  }

  //函数模板
  template <class T1, class T2>   //两个参数
  void print(T1 x, T2 y){ cout << x << " or " << y << endl; }

  int main(){
      print("emmm", 12580);
      //Output: emmm or 12580
  }

  template <class T, int size>    //size作为参数传进去
  class array{
  public:
      array() { arr = new T[size]; }
  private:
      T* arr;
  };

  int main(){
      array<string, 10> obj1;
  }

  int a, b;
  cin >> a >> b;
  try{
      if(b != 0){ cout << "a/b = " << a/b << endl;}
      else{ throw(b); }
      cout << "Try END" << endl;  //发生异常时没有被执行，因为流程从try块中退出，转到catch块中
  }
  catch(int i){
      cout << "Exception caught: b = " << b << endl;
  }
  cout << "END" << endl;  //仍然执行

  //Input: 7 1
  //Output:
  //a/b = 7
  //Try END
  //END

  //Input: 5 0
  //Output:
  //Exception caught: b = 0
  //END

    char ch;
    cin.get(ch);
    try{
        if(isalpha(ch))     throw 'a';
        else if(isdigit(ch))    throw 1;
        else if(isspace(ch))    throw 1.0;
    }
    catch(char){
        cout << "Catch a Alpha!" << endl;
    }
    catch(int){
        cout << "Catch a Number!" << endl;
    }
    catch(double){
        cout << "Catch a Space!" << endl;
    }
    //Input: z
    //Output: Catch a Alpha!

    //Input: 5
    //Output: Catch a Number!

    //Input: (空格，打出来你也看不见)
    //Output: Catch a Space!

  void divide(int x, int y){
      try{
          if(y != 0){ cout << "x/y = " << x/y << endl; }
          else{ throw y; }
      }
      catch(int){
          cout << "Divide ERROR!" << endl;
          throw;  //重新抛出
      }
  }
  int main(){
      int x, y;
      cin >> x >> y;
      try{
          divide(x, y);
      }
      catch(int){     //捕捉重新抛出的错误
          cout << "Function ERROR!" << endl;
      }
      //Input:8 0
      //Output:
      //Divide ERROR!
      //Function ERROR!
  }

  //比如在sort中
  sort(arr, arr + N, greater<int>());    //降序排序

    #include <iostream>
    #include <cctype>
    #include <cstdlib>
    #include <vector>
    #include <sstream>

    using namespace std;

    class myString{
    public:
        myString(const vector<string>& pvec): vec(pvec) {
            vec.insert(vec.begin(), string("none"));
        }
        bool op();            //对外调用接口，每一行指令调用一次op()，指令为over时返回false
    private:
        vector<string> vec;

        void insert();
        void reset();
        void print();
        void printall();
        int find();
        int rfind();
        string copy();
        string add();

        int getNXL();         //获取n，x，l
        string getS();        //获取s
    };

    int myString::getNXL(){
        string str;
        cin >> str;
        if(str == "find"){
            return find();
        }else if(str == "rfind"){
            return rfind();
        }else{
            return atoi(str.c_str());   //str.c_str():返回char*型字符串
        }
    }

    string myString::getS(){
        string str;
        cin >> str;
        if(str == "copy"){
            return copy();
        }else if(str == "add"){
            return add();
        }else{
            return str;
        }
    }

    void myString::insert(){
        string s = getS();
        int n = getNXL();
        int x = getNXL();
        vec[n].insert(x, s);    //vec[n].insert(x, s)：在第x的位置插入元素s
    }

    void myString::reset(){
        string s = getS();
        int n = getNXL();
        vec[n] = s;
    }

    void myString::print(){
        int n = getNXL();
        cout << vec[n] << endl;
    }

    void myString::printall(){
        vector<string>::iterator it = vec.begin();  //迭代器，可看作指针
        it++;                                       //第一个是“none”故需++
        for(; it != vec.end(); it++){
            cout << * it << endl;
        }
    }

    int myString::find(){
        string s = getS();
        int n = getNXL();
        string str = vec[n];
        int pos = str.find(s.c_str());  //str.find(s): 正向查找子串s第一次出现的位置，失败返回npos
        if(pos != string::npos){        //string::npos: find(), rfind() 失败返回npos
            return pos;
        }else{
            return s.size();            //s.size(): 返回s的长度,也可写作s.length()
        }
    }

    int myString::rfind(){
        string s = getS();
        int n = getNXL();
        string str = vec[n];
        int pos = str.rfind(s.c_str()); //str.rfind(s):逆向查找子串s第一次出现的位置，失败返回npos
        if(pos != string::npos){
            return pos;
        }else{
            return s.size();
        }
    }

    string myString::copy(){
        int n = getNXL(), x = getNXL(), l = getNXL();
        return vec[n].substr(x, l);     //str.substr(x, l):返回str的子串，该子串为str的第x个字符开始长度为l的字符串
    }

    string myString::add(){
        stringstream ss;      //使用stringstream实现类型转换
        string s1 = getS(), s2 = getS();
        int a = atoi(s1.c_str()), b = atoi(s2.c_str());

        int flag = 1;
        for(int i = 0; i < s1.size(); i++){
            if(s1[i] < '0' || s1[i] > '9'){
                flag = 0;
                break;
            }
        }
        for(int i = 0; i < s2.size(); i++){
            if(s2[i] < '0' || s2[i] > '9'){
                flag = 0;
                break;
            }
        }

        if(0 <= a && a <= 99999 && 0 <= b && b <= 99999 && flag){
            ss << a + b;
            string str;
            ss >> str;
            return str;
        }else{
            return (s1 + s2);
        }
    }

    bool myString::op(){
        string str;
        cin >> str;
        if(str == "over")           return false;
        else if(str == "copy")      copy();
        else if(str == "add")       add();
        else if(str == "find")      find();
        else if(str == "rfind")     rfind();
        else if(str == "insert")    insert();
        else if(str == "reset")     reset();
        else if(str == "print")     print();
        else if(str == "printall")  printall();
        return true;
    }

    // ------------------------------

    int main(){
        vector<string> vec;
        int t;
        cin >> t;
        while(t--){
            string str;
            cin >> str;
            vec.push_back(str);
        }
        myString obj(vec);
        while(obj.op());
        return 0;
    }