C++学习笔记_03类的继承 2021-04-15

//C++学习笔记_03类的继承   友元类 
#include<cstring>
#include<iostream>
#define C_MAX 10
using namespace std;
//如果 课程这个类，只有学生才有，不能说单独定义一个课程对象
class CCourse
{
    friend class CStudent;
private:
    char cname[C_MAX][16]; //课程名称（多个课程，最多 C_MAX 门课程）
                //二维数组，可以表示一组字符串
                //cname[0] = "语文"， cname[1] = "数学"
                //char *pname[C_MAX];
    unsigned int cnt;              //当前修几门课程
    unsigned int score[C_MAX];     //各门课程的得分
    CCourse() :cnt(0){}  //相当于构造的时候执行 cnt = 0
public:
    ~CCourse();
    bool addCourse(char szName[]);//新增一门课程
    bool setScore(char szName[], int score); //给某个课程打分
    void Print(); //打印分数
};
CCourse::~CCourse(){}
bool CCourse::addCourse(char szName[]){
    if (cnt == C_MAX) return false;
    for (int i = 0; i < cnt; i++)
        if (strcmp(szName, cname[i]) == 0) // if(!x) 等价于 if(x==0)
            return false;
    strcpy(cname[cnt],szName);
    score[cnt] = 0;
    cnt++;
    return true;
}
bool CCourse::setScore(char szName[], int score){
    for (int i = 0; i < cnt; i++)
        if (strcmp(szName, cname[i]) == 0) {// if(!x) 等价于 if(x==0)
            this->score[i] = score;
            return true;
        }
    return false;//没有找到相关课程
}
void CCourse::Print(){
    for (int i = 0; i < cnt; i++)
        cout << cname[i] << " :" << score[i] << endl;        
    cout << endl;
}
class CStudent
{
private:
    char name[16];
    unsigned int age;    
public:
    CCourse cour; //课程属性
    CStudent();
    CStudent(char szName[], unsigned int uiAge);
    ~CStudent();
};
CStudent::CStudent(){}
CStudent::CStudent(char szName[], unsigned int uiAge){
    strcpy(name,szName);
    age = uiAge;
}
CStudent::~CStudent(){}
void TestStudent()
{
    CStudent S1("Lily", 21);
    CStudent S2("Jame", 22);
    //CCourse cour; //直接这样定义，没有意义（这是谁的课程？）
                    //我们能不能不允许 直接定义 CCourse 对象？
                    //我们可以把 CCourse 的构造函数设为 private
    //这个时候，我实现了 CCourse 的隐藏，
    //但是，同时出现一个新的问题：CStudent 不能定义 CCourse 对象
    //怎么办？ --》 在CCourse中，设置 CStudent 为 友元类
    S1.cour.addCourse("语文");
    S1.cour.addCourse("数学");
    S1.cour.addCourse("英语");
    S2.cour.addCourse("语文");
    S2.cour.addCourse("数学");
    S2.cour.addCourse("日语");
    S1.cour.setScore("语文", 98);
    S1.cour.setScore("英语", 88);
    S1.cour.setScore("数学", 68);
    S2.cour.setScore("语文", 98);
    S2.cour.setScore("英语", 88);
    S2.cour.setScore("数学", 68);
    S1.cour.Print();
    S2.cour.Print();
}
int main()
{
    TestStudent();
    //system("pause"); 
  return 0;
}

//C++学习笔记_03类的继承
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
class CPerson
{
private:
    char name[16];
protected:        //对象不能直接访问，但是允许子类中的成员函数进行访问
    unsigned int age;
public:
    CPerson();
    CPerson(char szName[], unsigned int uiAge);
    ~CPerson();
    void Print();
};
CPerson::CPerson(){}
CPerson::CPerson(char szName[], unsigned int uiAge){
    cout << "构造 CPerson(char szName[], unsigned int uiAge)" << endl;
    strcpy(name,szName);
    age = uiAge;
}
CPerson::~CPerson(){}
void CPerson::Print(){
    cout << "姓名  :" << name << endl;
    cout << "年龄  :" << age << endl;
}
//CWorker 继承 CPerson： 也就是说，不需要重写 某些函数或者变量
//无论什么继承方式，父类的 private 成员，子类不允许访问
//对于父类的 public 成员，和 protected成员：
//public 表示公有继承方式：父类的成员，访问权限不变              (不降权)
//private 表示私有继承：   父类的成员，相当于子类的 私有成员     (降权)
//protected 表示保护继承:  父类的成员，相当于子类的 protected成员(降权)
class CWorker:public CPerson
{
private:
    char company[20]; //公司
public:
    CWorker(char szName[], unsigned int uiAge, char szCompany[]);
    ~CWorker();
    void Print();
    unsigned int GetAge(){//不允许调用 父类 的私有成员
        return age; //如果我们想调用的话，可以把 age 声明成 protected 成员  
    }
};
CWorker::CWorker(char szName[], unsigned int uiAge, char szCompany[]):CPerson(szName, uiAge){
    //CPerson::CPerson(szName, uiAge); //不能这样写，因为这样写相当于定义一个新 CPerson 对象
    //在外部调用父类构造函数构造对象，
    //如果在函数里面调用，则会生成一个新的CPerson对象(匿名对象)
    strcpy(company,szCompany);
}
CWorker::~CWorker(){}
void CWorker::Print(){
    CPerson::Print();  //指定调用父类的Print函数，
        //不加CPerson:: 则会有限调用自己定义的 Print() --> 无限递归
    cout << "公司  :" << company << endl;
}
void TestInherit()
{
    CWorker W1("小王", 30, "腾信");
    W1.Print(); //事实上就调用了父类的 Print()
    //并不是说父类CPerson 的所有函数，CWorker 都能调用
    //CWorker 不能调用 CPerson 的 private 中的变量和函数
    //W1.age = 40;// 不允许调用父类的私有成员
    //protected：受保护的成员，子类中的函数，可以直接调用。
    //如果子类也定义了 Print() 函数(同名，而且入参一样)，那么，会隐藏掉父类的函数。
}
int main()
{
    TestInherit();
    //system("pause"); 
  return 0;
}

//C++学习笔记_03类的继承  多重继承 
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
#define C_MAX 10
class CPerson
{
private:
    char name[16];
protected:        //对象不能直接访问，但是允许子类中的成员函数进行访问
    unsigned int age;
public:
    CPerson();
    CPerson(char szName[], unsigned int uiAge);
    ~CPerson();
    void Print();
};
CPerson::CPerson(){}
CPerson::CPerson(char szName[], unsigned int uiAge){
    cout << "构造 CPerson(char szName[], unsigned int uiAge)" << endl;
    strcpy(name,szName);
    age = uiAge;
}
CPerson::~CPerson(){}
void CPerson::Print(){
    cout << "姓名  :" << name << endl;
    cout << "年龄  :" << age << endl;
}
//CWorker 继承 CPerson： 也就是说，不需要重写 某些函数或者变量
//无论什么继承方式，父类的 private 成员，子类不允许访问
//对于父类的 public 成员，和 protected成员：
//public 表示公有继承方式：父类的成员，访问权限不变              (不降权)
//private 表示私有继承：   父类的成员，相当于子类的 私有成员     (降权)
//protected 表示保护继承:  父类的成员，相当于子类的 protected成员(降权)
class CWorker:public CPerson
{
private:
    char company[20]; //公司
public:
    CWorker(char szName[], unsigned int uiAge, char szCompany[]);
    ~CWorker();
    void Print();
    unsigned int GetAge(){//不允许调用 父类 的私有成员
        return age; //如果我们想调用的话，可以把 age 声明成 protected 成员  
    }
};
CWorker::CWorker(char szName[], unsigned int uiAge, char szCompany[]):CPerson(szName, uiAge){
    //CPerson::CPerson(szName, uiAge); //不能这样写，因为这样写相当于定义一个新 CPerson 对象
    //在外部调用父类构造函数构造对象，
    //如果在函数里面调用，则会生成一个新的CPerson对象(匿名对象)
    strcpy(company,szCompany);
}
CWorker::~CWorker(){}
void CWorker::Print(){
    CPerson::Print();  //指定调用父类的Print函数，
        //不加CPerson:: 则会有限调用自己定义的 Print() --> 无限递归
    cout << "公司  :" << company << endl;
}
class CFarmer:public CPerson
{
private:
    char address[20]; //农民的土地位置
public:
    CFarmer(char szName[], unsigned int uiAge, char szAddr[]);
    ~CFarmer(){}
    void Print();    
};
CFarmer::CFarmer(char szName[], unsigned int uiAge, char szAddr[]) :CPerson(szName, uiAge){
    strcpy(address,szAddr);
}
void CFarmer:: Print(){
    CPerson::Print();
    cout << "土地  :" << address << endl;
}
void TestFarmer()
{
    CFarmer Fa("小张",36,"中国大连");
    Fa.Print(); 
}
class CBase
{
public:
    CBase();
    ~CBase();
    void Print();
};
CBase::CBase() {cout << "构造 CBase..." << endl;}
CBase::~CBase() {cout << "析构 CBase..." << endl;}
void CBase::Print() {cout << "I am CBase..." << endl;}
class CSuper
{
public:
    CSuper();
    ~CSuper();
    void Print();
};
CSuper::CSuper() {cout << "构造 CSuper..." << endl;}
CSuper::~CSuper() {cout << "析构 CSuper..." << endl;}
void CSuper::Print() {cout << "I am CSuper..." << endl;}
//比如说，我们定义学生类 CStudent，和 中国人类 CChinese
//再定义中国的学生类  CChStudent 可以同时继承 CStudent 和 CChinese
//这就是多重继承
//多重继承：一个类，继承两个父类
class Derived :public CBase, public CSuper
{
public:
    Derived();
    ~Derived();
};
Derived::Derived() {cout << "构造 Derived..." << endl;}
Derived::~Derived() {cout << "析构 Derived..." << endl;}
void TestBase()//测试多重继承的运行顺序
{
    Derived  D1;
}
int main()
{
    TestFarmer();
    TestBase();
    //system("pause"); 
  return 0;
}