函数重载顺序

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 函数重载顺序
  6.  * */
  7. void f(int i) {
  8.     cout<<i<<endl;
  9. }
  10. void f(const char *s) {
  11.     cout<<s<<endl;
  12. }
  13. int main() {
  14.     char c = 'A';
  15.     int i = 1;
  16.     short s = 2;
  17.     double ff = 3.4;
  18.     char a[10] = "123456789";
  20.     f(c); // char->int 提升匹配
  21.     f(i); // 精确匹配
  22.     f(s); // short->int 提升匹配
  23.     f(ff); // double->int 标准转换匹配
  25.     f('a'); // char->int 提升匹配
  26.     f(3); // 精确匹配
  27.     f("string"); // 精确匹配
  28.     f(a);  // 精确匹配
  29.     return 0;
  30. }

重载基类的成员函数，会影响基类成员函数在派生类中的可见性

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 重载基类的成员函数，会影响基类成员函数在派生类中的可见性
  6.  * */
  7. class Base {
  8.     int x;
  9.     public:
  10.         void setx(int i) {
  11.             x = i;
  12.         }
  13.         void set(int n) {
  14.             x = n;
  15.         }
  16.         void print() {
  17.             printf("Base class x=%d\n", x);
  18.         }
  19. };
  21. class D: public Base {
  22.     int m, n;
  23.     public:
  24.         void set(int p, int k) {
  25.             m = p;
  26.             n = k;
  27.         }
  28.         void set(int i, int j, int k) {
  29.             Base::set(i);
  30.             m = j;
  31.             n = k;
  32.         }
  33.         void print() {
  34.             Base::print();
  35.             printf("D class m=%d n=%d\n", m, n);
  36.         }
  37. };
  38. int main() {
  39.     D d;
  40.     d.set(1, 3);
  41.     d.print(); // 由于基类的 x 未初始化，因此是一个不确定的值
  43.     d.set(5, 6, 7);
  44.     d.print();
  46.     // d.set(10); // 错误，set 被重载了，影响了基类成员函数在派生类中的可见性
  48.     d.Base::print(); // 正确，由于 print 被派生类重写了，如果要调用基类的函数，需要加上“类名::”
  50.     d.setx(8); // 正确，setx 没有被重载或者覆写，因此在派生类中是可见的
  51.     d.Base::print();
  52.     return 0;
  53. }

运算符重载

类 重载二元运算符

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 类 重载二元运算符
  6.  * 成员函数重载加减，友元函数重载乘除
  7.  * */
  8. class Complex {
  9.     double r, i;
  10. public:
  11.     Complex (double R=0, double I=0):r(R), i(I) {};
  13.     Complex operator+(Complex b); // 非静态函数重载加减
  14.     Complex operator-(Complex b);
  16.     friend Complex operator*(Complex a, Complex b); // 友元函数重载乘除
  17.     friend Complex operator/(Complex a, Complex b); 
  18.     void display();
  19. };
  21. Complex Complex::operator+(Complex b) {
  22.     return Complex(r+b.r, i+b.i);
  23. }
  24. Complex Complex::operator-(Complex b) {
  25.     return Complex(r-b.r, i-b.i);
  26. }
  28. Complex operator*(Complex a, Complex b) {
  29.     Complex t;
  30.     t.r = a.r*b.r - a.i*b.i;
  31.     t.i = a.r*b.i + b.r*a.i;
  32.     return t;
  33. }
  35. Complex operator/(Complex a, Complex b) {
  36.     Complex t;
  37.     double x;
  38.     x = 1/(b.r*b.r + b.i*b.i);
  39.     t.r = x * (a.r * b.r + a.i * b.i);
  40.     t.i = x * (a.i * b.r - a.r * b.i);
  41.     return t;
  42. }
  43. void Complex::display() {
  44.     cout<<r;
  45.     if(i > 0) cout<<"+";
  47.     if(i != 0) cout<<i<<"i"<<endl;
  48. }
  49. int main() {
  50.     Complex c1(1, 2), c2(3, 4), c3, c4, c5, c6;
  51.     c1.display();
  52.     c2.display();
  54.     c3 = c1+c2;
  55.     c3.display();
  57.     c4 = c1-c2;
  58.     c4.display();
  60.     c5 = c1 * c2;
  61.     c5.display();
  63.     c6 = c1/c2;
  64.     c6.display();
  66.     c1.operator+(c2); // 成员函数显示调用
  67.     operator*(c1, c2); // 友元函数显示调用 
  68.     return 0;
  69. }

友元函数重载二元运算符

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 友元函数重载二元运算符
  6.  * 因为友元函数第一个参数默认是 this 指针，不会进行隐式类型转换
  7.  * */
  9. class Complex {
  10.     double r, i;
  11. public:
  12.     Complex(double R=0, double I=0): r(R), i(I) {};
  13.     // friend Complex operator+(Complex a, double b) {
  14.     //     return Complex(a.r+b, a.i);
  15.     // }
  17.     // friend Complex operator+(double a, Complex b) {
  18.     //     return Complex(a+b.r, b.i);
  19.     // }
  20.     friend Complex operator+(Complex a, Complex b) { // 包含了隐式类型转换
  21.         return Complex(a.r+b.r, a.i+b.i);
  22.     }
  23.     void display() {
  24.         cout<<r;
  25.         if(i > 0) cout<<"+";
  26.         if(i != 0) cout<<i<<"i"<<endl;
  27.     }
  28. };
  29. int main() {
  30.     Complex c1(1, 2), c2;
  31.     c2 = c1 + 5;
  32.     c2.display();
  34.     c2 = 5 + c1;
  35.     c2.display();
  36.     return 0;
  37. }

成员函数重载一元运算符

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 一元运算符重载
  6.  * 成员函数
  7.  * */
  8. class Time {
  9.     int h, m, s;
  10. public:
  11.     Time(int hour, int minute, int second);
  13.     Time operator++();
  14.     void display();
  15. };
  17. Time::Time(int hour, int minute, int second) {
  18.     h = hour;
  19.     m = minute;
  20.     s = second;
  21.     if(hour >= 24) h = 0;
  22.     if(minute >= 60) m = 0;
  23.     if(second >= 60) s = 0;
  24. }
  26. Time Time::operator++() {
  27.     ++s;
  28.     if(s >= 60) {
  29.         s = 0;
  30.         ++m;
  31.         if(m >= 60) {
  32.             m = 0;
  33.             if(h >= 24) {
  34.                 h = 0;
  35.             }
  36.         }
  37.     }
  38. }
  40. void Time::display() {
  41.     printf("hour:%d minute:%d second:%d\n", h, m, s);
  42. }
  43. int main() {
  44.     Time t1(23, 59, 59);
  45.     t1.display();
  47.     ++t1; // 隐式调用
  48.     t1.display();
  50.     t1.operator++(); // 显式调用
  51.     t1.display();
  52.     return 0;
  53. }

友元函数重载一元运算符

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 一元运算符重载
  6.  * 友元函数
  7.  * */
  9. class Time {
  10.     int h, m, s;
  11. public:
  12.     Time(int hour, int minute, int second);
  14.     friend Time operator++(Time &t);
  15.     void display();
  16. };
  18. Time::Time(int hour, int minute, int second) {
  19.     h = hour;
  20.     m = minute;
  21.     s = second;
  22.     if(hour >= 24) h = 0;
  23.     if(minute >= 60) m = 0;
  24.     if(second >= 60) s = 0;
  25. }
  27. Time operator++(Time &t) {
  28.     ++t.s;
  29.     if(t.s >= 60) {
  30.         t.s = 0;
  31.         ++t.m;
  32.         if(t.m >= 60) {
  33.             t.m = 0;
  34.             if(t.h >= 24) {
  35.                 t.h = 0;
  36.             }
  37.         }
  38.     }
  39.     return t;
  40. }
  42. void Time::display() {
  43.     printf("hour:%d minute:%d second:%d\n", h, m, s);
  44. }
  45. int main() {
  46.     Time t1(23, 59, 59);
  47.     t1.display();
  49.     ++t1; // 隐式调用
  50.     t1.display();
  52.     operator++(t1); // 显式调用
  53.     t1.display();
  54.     return 0;
  55. }

自增增减运算符重载

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 自增自减运算符重载
  6.  * */
  7. class Counter {
  8.     int n;
  9. public:
  10.     Counter(int i = 0) {
  11.         n = i;
  12.     }
  13.     Counter operator++(); // 成员函数，前缀
  14.     Counter operator++(int); // 成员函数，后缀
  16.     friend Counter operator--(Counter &c); // 友元函数，前缀
  17.     friend Counter operator--(Counter &c, int); // 友元函数，后缀
  18.     void display();
  19. };
  21. Counter Counter::operator++() {
  22.     ++n;
  23.     return *this;
  24. }
  25. Counter Counter::operator++(int) {
  26.     n++;
  27.     return *this;
  28. }
  29. Counter operator--(Counter &c) {
  30.     --c.n;
  31.     return c;
  32. }
  33. Counter operator--(Counter &c, int) {
  34.     c.n--;
  35.     return c;
  36. }
  38. void Counter::display() {
  39.     printf("Counter number=%d\n", n);
  40. }
  42. int main() {
  43.     Counter a;
  44.     ++a;
  45.     a.display();
  47.     a++;
  48.     a.display();
  50.     --a;
  51.     a.display();
  53.     a--;
  54.     a.display();
  55.     return 0;
  56. }

赋值运算符重载

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 赋值运算符重载
  6.  * 类的赋值运算函数只能为成员函数，不能为友元
  7.  * 类的赋值运算函数不能被继承
  8.  * */
  9. class String {
  10.     char *ptr;
  11.     int n;
  12. public:
  13.     String(char *s, int a) {
  14.         ptr = new char[strlen(s)+1];
  15.         strcpy(ptr, s);
  16.         n = a;
  17.     }
  18.     ~String() {
  19.         delete ptr;
  20.     }
  22.     void print() {
  23.         cout<<ptr<<endl;
  24.     }
  26.     String & operator=(const String &s) ;
  27. };
  29. String & String::operator=(const String &s) {
  30.     if(this == &s) return *this;
  31.     delete ptr;
  32.     ptr = new char[strlen(s.ptr)+1];
  33.     strcpy(ptr, s.ptr);
  34.     return *this;
  35. }
  36. int main() {
  37.     String p1 ("hello world", 12);
  38.     {
  39.         String p2("chong qing", 10);
  40.         p2 = p1;
  41.         cout<<"p2:";
  42.         p2.print();
  43.     }
  44.     cout<<"p1:";
  45.     p1.print(); // 错误，指针悬挂
  46.     // 没有显示赋值，调用默认进行对象赋值，因此 p2 结束调用析构释放了空间，导致 p1 的指针悬挂
  49.     return 0;
  50. }

构造函数将标准类型转为类对象

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 构造函数将标准类型转为类对象
  6.  * */
  7. class Date {
  8.     int year, month, day;
  9. public:
  10.     Date(int yy=1900, int mm=1, int dd=1) {
  11.         year = yy;
  12.         month = mm;
  13.         day = dd;
  14.     }
  16.     void show() {
  17.         printf("year=%d month=%d day=%d\n", year, month, day);
  18.     }
  19. };
  20. int main() {
  21.     Date d(2000, 10, 11);
  22.     d.show();
  23.     d = 2006; // 调用Date 的构造函数
  24.     d.show();
  25.     return 0;
  26. }

类转为其他类型

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 类型转换
  6.  * 类转为其他类型
  7.  * */
  8. class Circle {
  9.     double x, y, r;
  10. public:
  11.     Circle(double x1, double y1, double r1) {
  12.         x = x1;
  13.         y = y1;
  14.         r = r1;
  15.     }
  16.     operator int() {
  17.         return int(r);
  18.     }
  19.     operator double() {
  20.         return 2*3.14*r;
  21.     }
  22.     operator float() {
  23.         return (float)3.14*r*r;
  24.     }
  25. };
  26. int main() {
  27.     Circle c(2.3, 3.4, 2.5);
  28.     int r = c;
  29.     double length = c;
  30.     float area = c;
  31.     double len = (double)c;
  33.     cout<<r<<endl;
  34.     cout<<length<<endl;
  35.     cout<<len<<endl;
  36.     cout<<area<<endl;
  37.     return 0;
  38. }

重载输入输出

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 重载输入输出
  6.  * */
  8. class Sales {
  9.     char name[10];
  10.     char id[18];
  11.     int age;
  12. public:
  13.     Sales(char *Name, char *Id, int Age);
  14.     friend ostream &operator<<(ostream &os, const Sales &s);
  15.     friend istream &operator>>(istream &is, Sales &s);  
  16. };
  17. Sales::Sales(char *Name, char *Id, int Age) {
  18.     strcpy(name, Name);
  19.     strcpy(id, Id);
  20.     age = Age;
  21. }
  22. ostream &operator<<(ostream &os, const Sales &s) {
  23.     cout<<s.name<<"\t";
  24.     cout<<s.id<<"\t";
  25.     cout<<s.age<<endl;
  26. }
  27. istream &operator>>(istream &is, Sales &s) {
  28.     cout<<"please input employee name, id and age"<<endl;
  29.     is>>s.name>>s.id>>s.age;
  30. }
  31. int main() {
  32.     Sales s("console", "45564646456", 19);
  33.     cout<<s<<endl;
  35.     cin>>s;
  36.     cout<<s;
  37.     return 0;
  38. }