类中说明的重载

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 在类中说明的重载
  6.  * */
  7. class Cube {
  8.     public:
  9.         Cube() {
  10.             height = 1;
  11.             width = 2;
  12.             length = 3;
  13.         }
  14.         Cube(int h, int w, int l) {
  15.             height = h;
  16.             width = w;
  17.             length = l;
  18.         }
  19.     private:
  20.         int height;
  21.         int width;
  22.         int length;
  23. };
  24. int main() {
  25.     Cube c1;
  26.     Cube c1(4, 5, 6);
  28.     return 0;
  29. }

基类成员在派生类的重载

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 基类成员在派生类的重载
  6.  * */
  7. class Point {
  8.     public:
  9.         Point(int x, int y) {
  10.             Point::x = x;
  11.             Point::y = y;
  12.         }
  13.         float area() {
  14.             return 0.0;
  15.         }
  16.     private:
  17.         int x;
  18.         int y;
  19. };
  20. class Circle: public Point {
  21.     public:
  22.         Circle(int x, int y, int r): Point(x, y) {
  23.             Circle::radius = r;
  24.         }
  25.         float area() {
  26.             return 3.1415926535*radius*radius;
  27.         }
  28.     private:
  29.         int radius;  
  30. };
  31. int main() {
  32.     Point p(10, 10);
  33.     Circle c(5, 5, 20);
  34.     cout<<"point1:"<<p.area()<<endl;
  35.     cout<<"circle1:"<<c.area()<<endl;
  36.     cout<<"point1:"<<c.Point::area()<<endl; // 可以通过作用域符号找到基类的同名函数
  38.     return 0;
  39. }

虚函数

  2. #include<bits/stdc++.h>
  3. using namespace std;
  5. /**
  6.  * 虚函数的作用
  7.  * */
  8. class Undergra {
  9.     public:
  10.         virtual void cal_fee() {
  11.             fee1 = 4200;
  12.             fee2 = 800;
  13.             fee3 = 400;
  14.             fee = fee1 + fee2 + fee3;
  15.         }
  16.         virtual void dis() {
  17.             cout<<"undergraduate fee:"<<endl;
  18.             cout<<"study fee:"<<fee1<<endl;
  19.             cout<<"sleep fee:"<<fee2<<endl;
  20.             cout<<"other fee:"<<fee3<<endl;
  21.             cout<<"total fee:"<<fee<<endl;
  22.         }
  24.     protected:
  25.         int fee1;
  26.         int fee2;
  27.         int fee3;
  28.         int fee;
  29. };
  31. class PostGra: public Undergra {
  32.     public:
  33.         void cal_fee() {
  34.             fee1 = 1800;
  35.             fee2 = 400;
  36.             fee = fee1 + fee2;
  37.         }
  38.         void dis() {
  39.             cout<<"postgraduate fee:"<<endl;
  40.             cout<<"sleep fee:"<<fee1<<endl;
  41.             cout<<"other fee:"<<fee2<<endl;
  42.             cout<<"total fee:"<<fee<<endl;
  43.         }
  44. };
  45. int main() {
  47.     Undergra u1;
  48.     PostGra p1;
  49.     Undergra *ptr = &u1;
  51.     ptr->cal_fee();
  52.     ptr->dis();
  54.     ptr = &p1;
  55.     ptr->cal_fee();
  56.     ptr->dis();
  57.     return 0;
  58. }

虚函数是其他类的派生类,不会影响基类的同名函数

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 虚函数
  6.  * 如果基类成员函数是虚函数，那么所有派生类都是虚函数
  7.  * 如果虚函数是其他类的派生类，那么基类的同名函数保持原有性质
  8.  * */
  9. class A {
  10.     public:
  11.         void f(int i) {
  12.             cout<<"A"<<endl;
  13.         }
  14. };
  15. class B: public A {
  16.     public:
  17.         virtual void f(int i) {
  18.             cout<<"B"<<endl;
  19.         }
  20. };
  22. class C: public B {
  23.     public:
  24.         void f(int i) {
  25.             cout<<"C"<<endl;
  26.         }
  27. };
  29. class D: public C {
  30.     public:
  31.         void f(int ) {
  32.             cout<<"D"<<endl;
  33.         }
  34. };
  36. int main() {
  37.     A *pa, a;
  38.     B *pb, b;
  39.     C c;
  40.     D d;
  41.     pa = &a; pa->f(1);
  42.     pa = &b; pa->f(1);
  43.     pa = &c; pa->f(1);
  44.     pa = &d; pa->f(1);
  45.     // 由于 A 的 f 不是虚函数，那么其子类都会调用 A 的f函数
  47.     // B 的f是虚函数，那么其子类的f 都具有虚函数的性质
  48.     pb = &b; pb->f(1);
  49.     pb = &c; pb->f(1);
  50.     pb = &d; pb->f(1);
  51.     return 0;
  52. }

只有通过基类指针和引用才能实现虚函数特性

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 只有通过基类指针和引用才能实现虚函数特性
  6.  * */
  7. class B {
  8.     public:
  9.         virtual void f() {
  10.             cout<<"B  f"<<endl;
  11.         }
  12. };  
  13. class D: public B {
  14.     public:
  15.         void f() {
  16.             cout<<"D  f"<<endl;
  17.         }
  18. };
  19. int main() {
  20.     D d;
  21.     B *pb = &d, &rb = d, b;
  22.     b = d; // 截断赋值，因此实质还是调用B的函数
  23.     b.f();
  24.     pb->f(); // 虚函数特性
  25.     rb.f(); // 虚函数特性
  26.     return 0;
  27. }

派生类从基类继承的成员函数访问虚函数时，会访问派生类的版本

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 派生类从基类继承的成员函数访问虚函数时，会访问派生类的版本
  6.  * */
  7. class B {
  8.     public:
  9.         void f() {
  10.             g();
  11.         }
  12.         virtual void g() {
  13.             cout<<"B  g"<<endl;
  14.         }
  15. };
  16. class D: public B {
  17.     public :
  18.         void g() {
  19.             cout<<"D g"<<endl;
  20.         }
  21. };
  22. int main() {
  23.     D d;
  24.     d.f(); // 这里访问的是派生类中的g，如果 virtual 关键字去掉，那么访问基类中的g
  25.     return 0;
  26. }

虚函数调用过程

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 虚函数调用过程
  6.  * */
  7. class B {
  8.     public:
  9.         void f() {
  10.             cout<<"B   f"<<endl;
  11.         }  
  12.         virtual void vf() {
  13.             cout<<"B  vf"<<endl;
  14.         }
  15.         void ff() {
  16.             vf();
  17.             f();
  18.         }
  19.         virtual void vff() {
  20.             vf();
  21.             f();
  22.         }
  23. };
  25. class D: public B {
  26.     public:
  27.         void f() {
  28.             cout<<"D  f"<<endl;
  29.         }
  30.         void ff() {
  31.             f();
  32.             vf();
  33.         }
  34.         void vf() {
  35.             cout<<"D  vf"<<endl;
  36.         }
  37. };
  38. int main() {
  39.     D d;
  40.     B *pb = &d;
  41.     pb->f(); // 非虚函数，调用 B 的f
  42.     pb->ff(); // 非虚函数，调用 B 的ff，从而调用 D的vf 以及B 的f
  43.     pb->vf(); // 虚函数，调用 D 的vf
  44.     pb->vff(); // 虚函数，调用 D 的vf 以及 B 的f
  45.     return 0;
  46. }

虚析构函数

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 虚析构函数
  6.  * */
  7. class A {
  8.     public :
  9.         virtual ~A() {
  10.             cout<<"destruct A"<<endl;
  11.         }
  12. };
  14. class B: public A {
  15.     public:
  16.         ~B() {
  17.             cout<<"destruct B"<<endl;
  18.         }
  19. };
  20. int main() {
  21.     A *p = new B();
  22.     delete p;
  23.     return 0;
  24. }

输出

  1. destruct B
  2. destruct A

如果没有 virtual ，那么只会调用 A 的析构函数

纯虚函数

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 纯虚函数
  6.  * */
  7. class Point {
  8.     public:
  9.         Point(int i = 0, int j = 0) {
  10.             x0 = i;
  11.             y0 = j;
  12.         }
  13.         virtual void Draw() = 0;
  14.     private:
  15.         int x0, y0;
  16. };
  18. class Line: public Point {
  19.     public:
  20.         Line(int i = 0, int j = 0, int m = 0, int n = 0): Point(i, j) {
  21.             x1 = m;
  22.             y1 = n;
  23.         }
  24.         void Draw() {
  25.             cout<<"draw line"<<endl;
  26.         }
  27.     private:
  28.         int x1, y1;
  29. };
  31. class Ellipse: public Point {
  32.     public:
  33.         Ellipse(int i = 0, int j = 0, int p = 0, int q = 0): Point(i, j) {
  34.             x2 = p;
  35.             y2 = q;
  36.         }
  37.         void Draw() {
  38.             cout<<"draw ellipse"<<endl;
  39.         }
  40.     private:
  41.         int x2, y2;
  42. };
  43. int main() {
  44.     Line *line = new Line;
  45.     Ellipse *ellipse = new Ellipse;
  46.     line->Draw();
  47.     ellipse->Draw();
  49.     delete line, ellipse;
  50.     return 0;
  51. }

抽象类

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 抽象类
  6.  * */
  8. class Figure {
  9.     public:
  10.         virtual float area()=0;
  11. };
  13. class Circle: public Figure {
  14.     public:
  15.         Circle(float r) {
  16.             radius = r;
  17.         }
  18.         float area() {
  19.             return radius * radius * 3.1415926535;
  20.         }
  22.     private:
  23.         float radius;
  24. };
  25. class Triangle: public Figure {
  26. public:    
  28.     Triangle(float h, float w) {
  29.         high = h;
  30.         width = w;
  31.     }
  32.     float area() {
  33.         return high * width * 0.5;
  34.     }
  35. protected:
  36.     float high, width;
  38. };
  40. class Rectangle: public Triangle {
  41.     public:
  42.         Rectangle(float h, float w):Triangle(h, w) {
  44.         }
  45.         float area() {
  46.             return high * width;
  47.         }
  49. };
  50. int main() {
  51.     Figure *p[6];
  52.     p[0] = new Triangle(3.0, 2.0);
  53.     p[1] = new Rectangle(2.5, 3.0);
  54.     p[2] = new Rectangle(5.0, 1.0);
  55.     p[3] = new Rectangle(3.0, 6.0);
  56.     p[4] = new Circle(5.2);
  57.     p[5] = new Circle(8.0);
  59.     for(int i = 0; i < 6; i++) {
  60.         printf("area[%d] = %f\n", i, p[i]->area());
  61.     }
  62.     return 0;
  63. }

抽象类不能建立对象

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 抽象类不能建立对象
  6.  * 函数原型不一样，仍然是抽象类
  7.  * */
  8. class Figure {
  9.     protected:
  10.         double x, y;
  11.     public:
  12.         void set(double i, double j) {
  13.             x = i;
  14.             y = j;
  15.         }
  16.         virtual void area() = 0;
  17. };
  18. class Triangle : public Figure {
  19.     public:
  20.         void area() {
  21.             printf("triangle area : %f\n", x*y*0.5);
  22.         }
  23. };
  24. class Rectangle : public Figure {
  25.     public:
  26.         void area(int i) { // 只有函数原型一模一样才是虚函数，否则是重载，因此 Rectangle 仍然是抽象类
  27.             printf("rectangle area : %f\n", x*y);
  28.         }
  29. };
  30. int main() {
  31.     Figure *pf;
  32.     // Figure f; // 错误，抽象类不能建立对象
  34.     // Rectangle r; // 错误，area 是重载而不是虚函数，因此仍然是抽象类
  36.     Triangle t;
  37.     t.set(10, 20);
  38.     pf = &t;
  39.     pf->area();
  41.     Figure &rf = t;
  42.     rf.set(20, 20);
  43.     rf.area();
  44.     return 0;
  45. }