继承与多态C++:继承中的赋值兼容规则,子类的成员函数,虚函数(重写),多态

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了继承与多态C++:继承中的赋值兼容规则,子类的成员函数,虚函数(重写),多态相关的知识,希望对你有一定的参考价值。

    实现基类(父类)以及派生类(子类),验证继承与转换--赋值兼容规则:


  1. 子类对象可以赋值给父类对象(切割/切片)

  2. 父类对象不能赋值给子类对象

  3. 父类的指针/引用可以指向子类对象

  4. 子类的指针/引用不能指向父类对象(可以通过强制类型转换完成)


#include<iostream>
using namespace std;

class People    //父类或者基类
{
public:
    void Display()
    {
        cout << "_name" << endl;
    }
protected:
    string _name;
};


class Student:public People        //子类或者派生类
{
protected:
    int _num;
};


void Test()
{
    People p;
    Student s;
    p = s;    //切片
    //s = p;    //无法通过,说明父类对象不可以赋值给子类对象
    People* p1 = &s;    //父类的指针和引用可以指向子类
    People& p2 = s;

    //Student* s1 = &p;    //子类的指针和引用不可以指向父类
    //Student& s2 = p;
    Student* s1 = (Student*)&p;    //可以通过强转实现
    Student& s2 = (Student&)p;

    //p2->_num = 10;    //_num是子类对象,要越界父类对象才能访问到子类对象
    //s2._num = 20;
}


int main()
{
    Test();
    system("pause");
    return 0;
}


    如何书写基类与派生类的默认成员函数呢?如:构造函数、拷贝构造函数、赋值运算符重载、析构函数。

#include<iostream>
using namespace std;

class People
{
public:
    People(const char* name)
        :_name(name)
    {
        cout << "People()" << endl;
    }

    People(const People& p)
        :_name(p._name)
    {
        cout << "People(const People& p)" << endl;
    }

    People& operator=(const People& s)
    {
        if (&s != this)
        {
            cout << "People& operator= (const People& s)"<<endl;
            _name = s._name;
        }
        return *this;
    }

    ~People()
    {
        cout << "~People()" << endl;
    }

protected:
    string _name;
};

class Student:public People
{
public:
    Student(const char* name, int num)
        :People(name)
        , _num(num)
    {
        cout << "Student()" << endl;
    }

    Student(const Student& s)
        :People(s)
        , _num(s._num)
    {
        cout << "Student(const Student& s)" << endl;
    }
    
    Student& operator= (const Student& s)
    {
        if (this != &s)
        {
            cout << "Student& opeartor= (const Student& s)" << endl;
            People::operator=(s);
            _num = s._num;
        }
        return *this;
    }

    ~Student()
    {
        cout << "~Student()" << endl;
    }
protected:
    int _num;
};

void Test()
{
    Student s1("张三",15);
    Student s2(s1);
    Student s3("李四",12);
    s3 = s1;
}


int main()
{
    Test();
    system("pause");
    return 0;
}


虚函数&多态

虚函数:

在类的成员函数前面加上virtual,成为虚函数。

虚函数的重写:

当在子类中定义了一个与父类相同的虚函数时,就称为子类的函数重写了父类的虚函数。

多态:

使用父类的函数或者指针调用函数时,若指向父类的虚函数就调用父类的虚函数,若调用子类的虚函数就调用子类的虚函数。

    如:

#include<iostream>
using namespace std;

class People
{
public:
    virtual void BuyTickets()
    {
        cout << "买票" << endl;
    }
};

class Student :public People
{
public:
    virtual void BuyTickets()
    {
        cout << "买票-半价" << endl;
    }
};

void Fun(People& p)
{
    p.BuyTickets();
}

void Test()
{
    People p;
    Student s;
    Fun(p);//People为父类,则调用父类的虚函数。
    Fun(s);//调用子类的虚函数。
}

int main()
{
    Test();
    system("pause");
    return 0;
}


本文出自 “C语言100-200素数” 博客,请务必保留此出处http://10740184.blog.51cto.com/10730184/1749895

以上是关于继承与多态C++:继承中的赋值兼容规则,子类的成员函数,虚函数(重写),多态的主要内容,如果未能解决你的问题,请参考以下文章

C++继承 上篇

C++继承 上篇

C++继承 上篇

[C++]——继承赋值兼容规则与组合 (这一篇就够了!)

[C++]——继承赋值兼容规则与组合 (这一篇就够了!)

[C++]——继承赋值兼容规则与组合 (这一篇就够了!)