C++ 继承与派生

public_extends.cpp

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

/********************************************
一、派生类的定义格式
class 派生类名:访问权限 基类名1，
                访问限定符 基类名2，……，
                访问限定符  基类名n
{
private:
    成员表1； //派生类增加或替代的私有成员
public:
    成员表2； //派生类增加或替代的公有成员
protected:
    成员表3； //派生类增加或替代的保护成员
}；
********************************************/

/*--------------------------------------------
共有继承(public)：

  继承特点：
    1、基类公有成员相当于派生类中的共有成员
    2、基类保护成员相当于派生类中的保护成员
    3、基类私有成员在派生类中无法直接访问

调用基类的成员：
    1、调用基类的成员变量:
        基类名::变量名;
    2、调用基类的成员函数：
        基类名::函数名();
---------------------------------------------*/

class Person
{
protected:
    char name[20];
    int age;
    char sex;
public:
    void Register(char* name, int age, char sex){
        strcpy(this->name, name);
        this->age = age;
        this->sex=(sex='m'?'m':'f');
    }
    void ShowMe(){
        cout<<this->name<<'\t'<<this->age<<'\t'<<this->sex<<endl;
    }
};

//基类公有成员相当于派生类中的共有成员
//基类保护成员相当于派生类中的保护成员
class Student:public Person
{
public:
    int number;
    char className[20];
public:
    void RegisterStu(char *className, int number, char* name, int age, char sex){
        strcpy(this->className, className);
        this->number = number;
        Person::Register(name, age, sex); //派生类成员函数直接使用基类的共有成员
    }
    void ShowStu(){
        cout<<this->number<<'\t'<<this->className<<endl;
        Person::ShowMe(); //直接使用基类的共有成员函数
        //cout<<Person::age<<endl; //调用基类的成员变量
    }
};

int test_public(){
    /*
    Person person;
    person.Register("覃唐弢", 21, 'm');
    person.ShowMe();
    */
    Student stu;
    stu.RegisterStu("软件技术",129781, "覃唐弢", 21, 'm');
    stu.ShowStu();
    stu.ShowMe(); //对象直接使用基类的共有成员

    return 0;
}

protected_extends.cpp

#include <iostream>
using namespace std;

/**********************************************************************
保护继承方式创建的派生类对基类各种成员访问权限如下：
    1、基类的公有成员和保护成员都相当于派生类的保护成员
    2、派生类可以通过自身的成员函数或其子类的成员函数访问它们
    3、对于基类的私有成员，无论派生类内部成员或派生类使用者都无法直接访问
**********************************************************************/
class Person
{
protected:
    char name[20];
    int age;
    char sex;
public:
    void Register(char* name, int age, char sex){
        strcpy(this->name, name);
        this->age = age;
        this->sex=(sex='m'?'m':'f');
    }
    void ShowMe(){
        cout<<this->name<<'\t'<<this->age<<'\t'<<this->sex<<endl;
    }
};

class Student:protected Person //基类的公有成员和保护成员都相当于派生类的保护成员
{
public:
    int number;
    char className[20];
public:
    void RegisterStu(char *className, int number, char* name, int age, char sex){
        strcpy(this->className, className);
        this->number = number;
        Person::Register(name, age, sex); //派生类成员函数直接使用基类的共有成员
    }
    void ShowStu(){
        cout<<this->number<<'\t'<<this->className<<endl;
        Person::ShowMe(); //直接使用基类的共有成员函数
        //cout<<Person::age<<endl; //调用基类的成员变量
    }
};

int test_protected(){
    Student stu;
    stu.RegisterStu("软件技术",129781, "覃唐弢", 21, 'm');
    stu.ShowStu();
    //stu.ShowMe(); //error  基类的public函数 通过 protected 继承 在子类中 就成为了 protected 函数
    return 0;
}

private_extends.cpp

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

/*************************************************************
二、私有继承(private)

 继承特点：
    1、基类的共有成员和保护成员都相当于派生类的私有成员
    2、对于基类的私有成员，无论派生类内部成员
    或派生类使用者都无法直接访问
**************************************************************/

class Person
{
protected:
    char name[20];
    int age;
    char sex;
public:
    void Register(char* name, int age, char sex){
        strcpy(this->name, name);
        this->age = age;
        this->sex=(sex='m'?'m':'f');
    }
    void ShowMe(){
        cout<<this->name<<'\t'<<this->age<<'\t'<<this->sex<<endl;
    }
};

class Student:private Person //基类的共有成员和保护成员都相当于派生类的私有成员
{
public:
    int number;
    char className[20];
public:
    void RegisterStu(char *className, int number, char* name, int age, char sex){
        strcpy(this->className, className);
        this->number = number;
        Person::Register(name, age, sex); //派生类成员函数直接使用基类的共有成员
    }
    void ShowStu(){
        cout<<this->number<<'\t'<<this->className<<endl;
        Person::ShowMe(); //直接使用基类的共有成员函数
        //cout<<Person::age<<endl; //调用基类的成员变量
    }
};

int test_private(){
    Student stu;
    stu.RegisterStu("软件技术",129781, "覃唐弢", 21, 'm');
    stu.ShowStu();
    //stu.ShowMe(); //error  private继承方式 基类public的函数 在派生类 就成为了 private函数 所以在外部不能调用
    return 0;
}

///////////////////////////////

继承 Example

////////////////////////////////

Point.h

#ifndef POINT_H
#define POINT_H
class Point{
private:
    int x, y; //点x和y的坐标
public:
    Point(int=0, int=0); //构造函数
public:
    void setPoint(int, int); //设置坐标
    int getX(){
        return this->x;
    }
    int getY(){
        return this->y;
    }
    void printPoint();
};
#endif

 

Point.cpp

#include <iostream>
using namespace std;
#include "point.h"

Point::Point(int a, int b){
    this->setPoint(a, b);
}

void Point::setPoint(int a, int b){
    this->x = a;
    this->y = b;
}

void Point::printPoint(){
    cout<<"["<<this->x<<", "<<this->y<<"]";
}

Example.cpp

#include <iostream>
using namespace std;
#include "point.h"
#include "circle.h"

int test_point_circle(){
    Point p(30, 50);
    Circle c(120, 80, 10.0);
    cout<<"Point p:";
    p.printPoint();

    cout<<"\nCircle c:";
    c.printCircle();

    cout<<"The center of circle c:";
    c.Point::printPoint(); //调用 基类的 函数 ==> 变量名.基类名::函数名();

    cout<<"\nThe area of circle c:"
        <<c.area()<<endl;
    return 0;
}

 

/////////////////////////////

派生类的构造函数与析构函数

////////////////////////

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

/***********************************************************************
派生类的构造函数和析构函数:

一、派生类构造函数的一般形式：
    派生类名::派生类名(参数总表):基类名1(参数表1),…,基类名n(参数表n),
    内嵌对象名1(对象参数表1),…，内嵌对象名m(对象参数表m)
    {
        派生类新增加成员的初始化；
    }

二、派生类构造函数各部分的执行次序
    1、调用基类构造函数，按他们在派生类定义的先后顺序调用
    2、调用内嵌对象构造函数，调用次序按各个对象在派生类内声明的顺序
    3、派生类的构造函数中的操作

三、派生类析构函数
    派生类析构函数执行过程与构造函数执行过程相反。
    （1）执行派生类析构函数
    （2）执行内嵌对象的析构函数
    （3）执行基类析构函数
***********************************************************************/

class Person{
public:
    char name[20];
    int age;
public:
    Person(char* name, int age){
        strcpy(this->name, name);
        this->age=age;
        cout<<"constructor of person...."<<endl;
    }
    ~Person(){
        cout<<"deconstructor of person...."<<endl;
    }
public:
    void ShowMe(){
        cout<<this->name<<'\t'<<this->age<<endl;
    }
};

class Student:public Person{
public:
    char className[20];
    Person Monitor; //内嵌对象
public:
     Student(char* name, int age, char* className, char* name1, int age1)
        :Person(name, age),Monitor(name1, age1)
    {
        strcpy(this->className, className);    
        cout<<"constructor of Student...."<<endl;
    }
    ~Student(){
        cout<<"deconstrucor of Student...."<<endl;
    }
public:
    void ShowStudent(){
        cout<<"基类对象"<<'\t';
            Person::ShowMe();
        cout<<"内嵌对象"<<'\t';
            Monitor.ShowMe();
        cout<<"派生类对象"<<'\t'<<this->className<<endl;
    }
};

int test_constructor_deconstrucor(){
    Student stu("覃唐弢", 21, "软件技术", "刘德华", 66);
    stu.ShowStudent();
    /*
        constructor of person.... //基类 构造函数
        constructor of person.... //内嵌对象 构造函数
        constructor of Student.... //派生类 构造函数
        基类对象        覃唐弢  21
        内嵌对象        刘德华  66
        派生类对象      软件技术
        deconstrucor of Student.... //派生类 析构函数
        deconstructor of person.... //内嵌对象 析构函数
        deconstructor of person.... //基类 析构函数
    */
    return 0;
}

 

////////////////////////////////////

多重继承

////////////////////////////////////

Base1.h

#ifndef BASE1_H
#define BASE1_H
class Base1{
private:
    int value;
public:
    Base1(int x){
        this->value = x;
    }
public:
    int getData() const{
        return this->value;
    }
};
#endif

Base2.h

#ifndef BASE2_H
#define BASE2_H
class Base2{
private:
    char letter;
public:
    Base2(char c){
        this->letter=c;
    }
public:
    /*
    表示成员函数隐含传入的this指针为const指针，决定了在该成员函数中，
    任意修改它所在的类的成员的操作都是不允许的
    因为隐含了对this指针的const引用
    */
    char getData() const{
        return this->letter;
    }
};
#endif

Derivde.h
#ifndef CIRCLE_H
#define CIRCLE_H

#include <iostream>
using namespace std;
#include "point.h"

class Circle:public Point //继承
{
private:
    double radius;
public:
    Circle(int x=0, int y=0, double r=0.0);
public:
    void setRadius(double); //设置半径
    double getRadius(); //取半径
    double area(); //计算面积
    void printCircle(); //输出圆心坐标和半径
};
#endif

Derived.cpp

#include <iostream>
using namespace std;
#include "derived.h"

Derived::Derived(int i, char c, double f):Base1(i),Base2(c)
{
    this->real = f;
}

double Derived::getReal() const{
    return this->real;
}

void Derived::outPut(){
    cout<<"Integer:"<<Base1::getData()
        <<"\nCharacter:"<<Base2::getData()
        <<"\nReal number:"<<this->real
        <<endl;
}

 

多重继承.cpp

#include <iostream>
using namespace std;
#include "derived.h"
int main(){
    Base1 b1(10), *base1Ptr=0;
    Base2 b2('Z'), *base2Ptr=0;
    Derived d(7, 'A', 3.5);
  
    cout<<"对象输出各自的数据成员"<<endl;
    cout<<"Object b1 contains integer:"<<b1.getData()
        <<"\nObject b2 contains character:"<<b2.getData()
        <<"\nObject d contains:\n";
    d.outPut();
    cout<<"派生类对象对基类成员函数的访问"<<endl;
    cout<<"Data members of Derived can be"<<"accessed individually:"
        <<"\nInteger:"<<d.Base1::getData() //访问父类的函数
        <<"\nCharacter:"<<d.Base2::getData()
        <<"\nReal number:"<<d.getReal()
        <<endl;
    cout<<"Derived can be treated as an"
        <<"object of either base class:\n";
    cout<<"派生类对象作为Base1对象"<<endl;
    base1Ptr = &d;
    cout<<"base1Ptr->getData() yields:"
        <<base1Ptr->getData()
        <<'\n';
    cout<<"派生类对象作为Base2对象"<<endl;
    base2Ptr = &d;
    cout<<"base2Ptr->getData() yields:"
        <<base2Ptr->getData()
        <<'\n';
    
    return 0;
}