[陈宗权C++]C++第5天AM--运算符重载_继承

参考：

重点：

//                   父类公开成员        父保                  父类私有成员
//公开继承  子类内部   子类公成(公)     可访问(保)               不可访问
//            外界      可访问          不可访问                 不可访问
//私有继承  子类内部    可访问(私)      可访问(私)               不可访问
//            外界      不可访问        不可访问                 不可访问

//保护继承   子类内部   可访问(保)      可访问(保)               不可访问
//            外界         不               不                      不

• 子类可以改写来自父类的成员，隐藏来自父类的同名成员,只要同名，就能隐藏，参数表不同，也能隐藏!!!!!!

正文：

////达内C++教程\03_标准C++编程_陈宗权_7day\标准C++编程_day05AM_运算符重载_继承_TEST_1_了解即可
//
//#include <iostream>
//using namespace std;
//
//char mem[1000];
//int pos;
//
//class A {
//public:
//  A() { cout <<"A()" << endl; }
//  ~A() { cout << "~A()" << endl; }
//
//  //返回必须是void* ,即使不写，也是static 
//  static void* operator new(size_t bytes) {
//      cout << "new A" << endl;
//      int alloc = pos;
//      pos += bytes;
//      return mem + pos;
//
//  }
//
//  static void operator delete(void* p) {
//      cout << "delete A" << endl;
//      //先不管怎么收，
//  }
//
//};
//
//void* operator new(size_t bytes)
//{
//  cout << "new" << bytes << endl; return mem;
//}
//
//void operator delete(void* p)
//{
//  cout <<"delete" << endl;
//}
//
//int main()
//{
//  //new 类型，分多少空间的作用
//  A* x = new A;//1.分配空间，2.执行构造函数
//  delete x;//1.执行析构函数，2.释放空间
//
//  x = new A[3];
//  delete[] x;
//
//  int* p = new int;
//  delete p;
//
//}

//友元类

//子类对象一定是父类对象

//protect 公开和私有之间


//                   父类公开成员        父保                  父类私有成员
//公开继承  子类内部   子类公成(公)     可访问(保)               不可访问
//            外界      可访问          不可访问                 不可访问
//私有继承  子类内部    可访问(私)      可访问(私)               不可访问
//            外界      不可访问        不可访问                 不可访问

//保护继承   子类内部   可访问(保)      可访问(保)               不可访问
//            外界         不               不                      不


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

class Person {
protected:
    string name;
private:
    bool gender;
public:
    void eat(const char*  food) { cout << name << "在吃" << food << endl; }
    //声明的可以不定义，只要没有调用
    void sleep();
    void show() {
        cout << "大家好，我是" << name << (gender ? "帅哥" : "美女") << ",很荣幸认识你" << endl;
    }

    Person(const char* name, bool gender) :name(name), gender(gender) {}


};

class Teacher : public Person
{
    string course;
public:
    void teacher(const char* _class) {
        cout << name<<"老师在给"<<_class <<"班讲"<<course<<"课程"<< endl;
    }
    //在初始化列表中，把数据传给父类的构造函数，由父类自己进行初始化,初始化列表各项的顺序本决定执行顺序
    Teacher(const char* name, bool gender, const char* course):Person(name,gender),course(course){}
    string Name()const { return name; }

    // 子类可以改写来自父类的成员，隐藏来自父类的同名成员,只要同名，就能隐藏，参数表不同，也能隐藏!!!!!!
    void show() {
        cout <<"同学们好，我是"<<name<<"老师，"<<"希望能带大家把"<<course<<"课程学好"<< endl;
    }
    void show(const char* _class) {

        cout << _class<<"同学们好，我是" << name << "老师，" << "希望能带大家把" << course << "课程学好" << endl;
    }
};

int main()

{
    Person a("furong",false);
    Teacher b("quange",true,"UNIX C");
    a.eat("巧克力");
    b.eat("泡椒凤爪");
    a.show();//这个不行，但是我编译通过运行了？
    //b.Person::show();
    b.teacher("1班");
    b.show();
    b.show("2班");
    system("pause");
}