6.2单一继承

第7章 继承

7.1 类之间的关系

7.2 基类和派生类

7.3 基类的初始化

7.4 继承的应用实例

第8章 虚函数与多态性

8.2 类指针的关系

 

7.1 类之间的关系

has-A，uses-A和is-A

has-A 包含关系，用以描述一个类由多个“部件类”构成。实现has-A关系用类成员表示，即一个类中的数据成员是另一种已经定义的类。

uses-A 一个类部分地使用另一个类。通过类之间成员函数的相互联系，定义友元或对象参数传递实现。

is-A 机制称为“继承”。关系具有传递性，不具有对称性。

继承是类之间定义的一种重要关系。

一个B类继承A类，或称从类A派生类B。

类A称为基类（父类），类B称为派生类（子类）

7.2 基类和派生类

类继承关系的语法形式

class 派生类名:基类名表

{

数据成员和成员函数声明

};

基类名表 构成

访问控制 基类名1,访问控制 基类名2,...,访问控制 基类名n

7.2.1访问控制

派生类对基类成员的使用，与继承访问控制和基类中成员性质有关。

公有继承

基类的公有成员->派生类的公有成员

基类的保护成员->派生类的保护成员

私有继承

基类的公有成员和保护成员->派生类的私有成员

保护继承

基类的公有成员和保护成员->派生类的保护成员

不论哪种方式继承，派生类都不能直接使用基类的私有成员

派生类支配基类的同名函数

对象一定先调用自己的同名成员函数，如果自己没有同名函数，则调用直接基类的同名函数，依此类推。当然，使用作用域分辨运算符可以指定要调用的函数。

二义性

可以使用作用域分辨运算符“::”和成员名限定解决二义性。

//子类函数与父类函数同名，覆盖父类函数

//每一个子类都会生成一个默认的父类对象，调用同名父类函数的方法

#include "coder.h"
#include "cppcoder.h"

void main()
{
    cppcoder *ptansheng = new cppcoder;

    ptansheng->girlfriend();
    ptansheng->ui();
    ptansheng->coding();//子类函数与父类函数同名，覆盖父类函数
    ptansheng->coder::coding();//每一个子类都会生成一个默认的父类对象，调用同名父类函数的方法

    delete ptansheng;
    
    system("pause");
}

赋值兼容规则是指在公有派生情况下，一个派生类的对象可以作为基类的对象来使用的情况。

（1）派生的对象可以赋给基类的对象。

（2）派生类的对象可以初始化基类的引用。

（3）派生类的对象的地址可以赋给指向基类的指针。

但是，在后两种情况下，这样的引用或者指针只能访问派生类对象所继承的基类成员。

//用父类的指针可以接受子类的地址

reinterpret_cast专业转换指针

void main()
{
    coder *pcoder = new cppcoder;//用父类的指针可以接受子类的地址
    pcoder->coding();

    cppcoder *pcppcoder = reinterpret_cast<cppcoder *>(pcoder);//专业转换指针
    pcppcoder->coding();

    std::cout << typeid(pcoder).name() << std::endl;
    std::cout << typeid(pcppcoder).name() << std::endl;

    system("pause");
}

7.2.2重名成员

派生类定义了与基类同名的成员，在派生类中访问同名成员时屏蔽了基类的同名成员。

在派生类中使用基类的同名成员，显式地使用类名限定符：

类名::成员

//访问基类的同名函数

//reinterpret_cast专业转换指针

#include <iostream>

class father
{
public:
    father()
    {
        num = 99;
    }
    int num;
    void print()
    {
        std::cout << num << std::endl;
    }
};

class son :public father
{
public:
    son()
    {
        num = 89;
    }
    int num;
    void print()
    {
        std::cout << num << std::endl;
    }
};

void main()
{
    son *pson = new son;

    pson->print();//89
    pson->father::print();//访问基类的同名函数，98

    father *p = reinterpret_cast<father *>(pson);//reinterpret_cast专业转换指针
    p->print();//98

    system("pause");
}

7.2.3派生类中的静态成员

基类定义的静态成员，将被所有派生类共享。

根据派生成员自身的访问特性和派生类的继承方式，在类层次体系中具有不同的访问特性。

派生类中访问静态成员，用以下形式显式说明：

类名::成员

或通过对象访问：

对象名.成员

注意：静态成员可以被继承，这时基类对象和派生类的对象共享该静态成员。

静态数据成员，统计某个类以及派生类的所有对象的个数

静态成员函数，可以脱离对象调用的函数

#include <iostream>

class myclass//基类
{
public:
    int data;
    static int num;//声明静态变量
    myclass()
    {
        num++;//静态数据成员，统计某个类以及派生类的所有对象的个数
    }
    static void print()
    {
        //this->data;//静态成员函数没有this指针
        std::cout << num << std::endl;
    }
};

int myclass::num = 0;//定义静态变量

class ziclass :public myclass//子类
{
};

class sunclass :public ziclass//孙类
{
};

void main()
{
    ziclass *p = new ziclass;
    ziclass z1;
    sunclass *ps = new sunclass;

    p->print();//3
    p->myclass::print();//3

    ps->print();//3
    ps->ziclass::myclass::print();//3
    
    system("pause");
}

7.3 基类的初始化

建立一个类层次后，通常创建某个派生类的对象，包括使用基类的数据和函数。

C++提供一种机制，在创建派生类对象时用指定参数调用基类的构造函数来初始化派生类继承基类的数据。

定义派生类的构造函数的一般形式如下：

派生类名::派生类名(参数表0):基类名(参数表)

{

...//函数体

}

#include <iostream>

class myclass
{
private:
    int x;
public:
    myclass() :x(0)//构造函数
    {
        std::cout << "myclass init without num" << std::endl;
    }
    myclass(int num) :x(num)//构造函数
    {
        std::cout << "myclass init with num" << std::endl;
    }
};

class myziclass :public myclass
{
private:
    int x;
    int y;
public:
    myziclass()//构造函数
    {
        std::cout << "myziclass init without num" << std::endl;
    }
    myziclass(int num) :myclass(num), x(num + 1), y(num + 2)//派生类名::派生类名(参数表0):基类名(参数表)
    {
        std::cout << "myziclass init with num" << std::endl;
    }
};

void main()
{
    myziclass *p = new myziclass(1);

    system("pause");
}

7.4 继承的应用实例

点，线，圆，球

#include <iostream>

class dian
{
private:
    int x;
    int y;
    int z;
public:
    friend class xian;
    dian(int a, int b, int c) :x(a), y(b), z(c)
    {

    }
    void print()
    {
        std::cout << "x=" << x << " y=" << y << " z=" << z << std::endl;
    }
};

class xian//包含设计
{
private:
    dian dian1;
    dian dian2;
public:
    xian(dian dianx, dian diany) :dian1(dianx), dian2(diany)
    {

    }
    double getlength()//线的长度
    {
        double length = 0;
        length = sqrt((dian1.x - dian2.x)*(dian1.x - dian2.x) + (dian1.y - dian2.y)*(dian1.y - dian2.y) + (dian1.z - dian2.z)*(dian1.z - dian2.z));
        return length;
    }
};

class yuan :public xian//继承设计
{
public:
    yuan(dian dianx, dian diany) :xian(dianx, diany)
    {
        
    }
    double getmianji()//圆的面积
    {
        return 3.1415926*(this->getlength())*(this->getlength());
    }
    double getzhouchang()//圆的周长
    {
        return 3.1415926 * 2 * (this->getlength());
    }
};

class qiu :public yuan//继承设计
{
public:
    qiu(dian dian1, dian dian2) :yuan(dian1, dian2)
    {

    }
    double getmianji()//球的面积
    {
        return 3.1415926 * (this->getlength()) * (this->getlength()) * 4;
    }
    double getzhouchang()//球的周长
    {
        return 4 / 3.0*.31415626*(this->getlength()) *(this->getlength()) *(this->getlength());
    }

};

void main()
{
    dian dian1(0, 0, 1);//创建一个点
    dian dian2(0, 0, 6);//创建一个点

    dian1.print();//打印点的坐标
    dian2.print();//打印点的坐标

    xian xian1(dian1, dian2);//创建一个线

    std::cout << xian1.getlength() << std::endl;//打印线的长度

    yuan yuan1(dian1, dian2);//创建一个圆

    std::cout << yuan1.getmianji() << std::endl;//打印圆的面积

    std::cout << yuan1.getzhouchang() << std::endl;//打印圆的周长

    qiu qiu1(dian1, dian2);

    std::cout << qiu1.getmianji() << std::endl;//打印球的面积

    std::cout << qiu1.getzhouchang() << std::endl;//打印球的周长
    
    system("pause");
}

第8章 虚函数与多态性

多态性是指一个名字，多种语义；或界面相同，多种实现。

重载函数是多态性的一种简单形式。

虚函数允许函数调用与函数体的联系在运行时才进行，称为动态联编。

8.2 类指针的关系

基类指针和派生类指针与基类对象和派生类对象4种可能匹配：

1 直接用基类指针引用基类对象；

2 直接用派生类指针引用派生类对象；

3 用基类指针引用一个派生类对象；

4 用派生类指针引用一个基类对象；

//类而言，数据是私有的，代码是公有的

//指针为空，指向一个类，可以直接调用方法，但是涉及内部成员会崩溃，不涉及内部成员可以执行

//父类指针引用父类对象，完全正常引用

//子类指针引用子类对象，覆盖父类的同名函数

//父类指针引用子类对象，只能引用父类中的函数

//子类指针引用父类对象

//不涉及内部数据的函数会调用成功//涉及到内部数据的会调用成功，但是执行失败

//子类指针需要使用作用域运算符pnewnewzi->fu::print();才能引用父类函数

//static_cast用于一般的数据类型转换

zi *pnewnewzi = static_cast<zi *>(new fu);

#include <iostream>
#include "fu.h"
#include "zi.h"

//类而言，数据是私有的，代码是公有的
//指针为空，指向一个类，可以直接调用方法，但是涉及内部成员会崩溃，不涉及内部成员可以执行

//父类指针引用父类对象，完全正常引用
//子类指针引用子类对象，覆盖父类的同名函数
//父类指针引用子类对象，只能引用父类中的函数
//子类指针引用父类对象
//不涉及内部数据的函数会调用成功
//涉及到内部数据的会调用成功，但是执行失败
//子类指针需要使用作用域运算符pnewnewzi->fu::print();才能引用父类函数

void main()
{
    //4用派生类指针引用一个基类对象
    //zi *pnewzi = new fu;//error C2440: “初始化”: 无法从“fu *”转换为“zi *”

    //static_cast用于一般的数据类型转换
    fu *pnewnewfu = new fu;
    zi *pnewnewzi = static_cast<zi *>(pnewnewfu);

    pnewnewzi->fufu();//我是你爹
    pnewnewzi->zizi();//我是你儿子
    pnewnewzi->fu::print();//父亲
    //pnewnewzi->zi::print();//报错
    //std::cout << pnewnewzi->strzi << std::endl;//报错
    
    //3用基类指针引用一个派生类对象
    //fu *pnewfu = new zi;
    //pnewfu->print();//父亲
    //pnewfu->fufu();//我是你爹

    //2直接用派生类指针引用派生类对象
    //zi *pzi = new zi;
    //pzi->print();//儿子,子类函数覆盖父类函数
    //pzi->zizi();//我是你儿子
    //pzi->fufu();//我是你爹
    
    //1直接用基类指针引用基类对象
    //fu *pfu = new fu;
    //pfu->print();//父亲
    //pfu->fufu();//我是你爹
    
    //类的对象形式
    //fu fu1;
    //fu1.print();//父亲
    //fu1.fufu();//我是你爹

    system("pause");
}

//1直接用基类指针引用基类对象，正常

//2直接用派生类指针引用派生类对象，正常

//3用基类指针引用一个派生类对象，子类没有被删除，会内存泄漏

解决办法：使用虚析构函数。

//4用派生类指针引用一个基类对象，内存越界，超过界限释放内存，有时候会出错

#include <iostream>
#include "fu.h"
#include "zi.h"

void main()
{
    {//1直接用基类指针引用基类对象，正常
        //fu *pfu = new fu;
        //delete pfu;
    }

    {//2直接用派生类指针引用派生类对象，正常
        //zi *pzi = new zi;
        //delete pzi;
    }

    {//3用基类指针引用一个派生类对象，子类没有被删除，会内存泄漏
        //fu *pnewfu = new zi;
        //delete pnewfu;
    }

    {//4用派生类指针引用一个基类对象，内存越界，超过界限释放内存，有时候会出错
        zi *pnewzi = static_cast<zi *>(new fu);
        delete pnewzi;
    }

    system("pause");
}

//成员变量的覆盖

//类A是基类，类B是类A的派生类，如果类B重新说明了新的数据成员，而这些新的数据成员与继承过来的数据成员同名，那么这些新的数据成员和继承过来的数据成员是相互独立的，不论是否静态数据成员

#include <iostream>

//成员变量的覆盖
//类A是基类，类B是类A的派生类，如果类B重新定义了新的重名数据成员，这些新的数据成员和继承的数据成员是相互独立的

class A
{
public:
    int num;
    static int data;//声明静态数据成员
};

class B :public A
{
public:
    int num;
    static int data;//声明静态数据成员
};

int A::data = 1;//定义静态数据成员
int B::data = 2;//定义静态数据成员

void main()
{
    B b1;
    b1.num = 10;
    b1.A::num = 20;

    std::cout << b1.num << " " << &b1.num << std::endl;//10
    std::cout << b1.A::num << " " << &b1.A::num << std::endl;//20

    std::cout << b1.data << " " << &b1.data << std::endl;//2
    std::cout << b1.A::data << " " << &b1.A::data << std::endl;//1

    system("pause");
}