C++继承与多态

 

三类继承方式

• 子类会将父类的除构造函数析构函数赋值运算重载符外的成员继承过来，只不过编译器隐藏了父类的私有属性，子类不可以访问。

class Base {
public:
    int a_;
protected:
    int b_;
private:
    int c_;
};

class Son :public Base {
public:
    int d_;
};
void test01() {
    cout << sizeof(Son) << endl;
}

几点注意：

• 如果显示创建了一个子类对象，又显示创建了一个父类对象,则该子类对象并不是该父类对象的子类，该子类对象的父类在创建子类的时候被隐式创建了，因此显示创建的子类对象在操作它继承下来的成员的时候并不会影响显示创建的父类对象的成员。

class Base {
public:
    int a_;
protected:
    int b_;
private:
    int c_;
};

class Son :public Base {
public:
    int d_;
};
void test01() {
    Son son;
    Base base;
    son.a_ = 10;
    base.a_ = 20;
    cout <<"显示创建的子类对象的a_属性"<< son.a_ << endl;
    cout << "显示创建的父类类对象的a_属性" << base.a_ << endl;
}

 

• 创建子类对象的时候，即便不显示创建父类，编译器也会创建父类。而且先构造父类，后析构子类。

 

子类的类型可以转换为父类（但不建议），父类却不能转换为子类，子类之间同样不能相互转换。

 因此下面标黄处的语句是错误的：

 1 void dospeak1(Animal& animal) {
 2     animal.speak();
 3 }
 4 void dospeak2(Cat& cat) {
 5     cat.speak();
 6 }
 7 void test() {
 8     Animal animal;
 9     Cat cat;
10     Dog dog;
11 
12     dospeak1(animal);
13     dospeak1(cat);
14     dospeak2(animal);
15     dospeak2(cat);
16 }

• 同时子类可以拷贝给父类（但不建议），父类不能拷贝给子类，子类之间也不能相互拷贝

 

子类成员与父类同名问题

当子类成员没有和父类同名时，子类直接用"."符号调用该成员即可，如果子类成员和父类成员有同名的，需要在"."符号后面加上父类作用域

多继承

 

菱形继承问题

一个父类A有多个子类BCD时，这些子类有一个共同的子类E，多个子类会将父类的属性继承下来，同样多个子类的子类也会将这个属性继承下来，这样做的问题是：

• 多个子类的子类E访问这个属性时不知道访问BCD哪一个,造成二义性

• E继承了BCD的这个属性，可它们都是同一个属性这样会导致资源浪费，即E只需要继承一个就可以

class Animal {
public:
    int age_;
};
class Sheep :public Animal {

};
class Tuo :public Animal {

};
class Sheeptuo :public Sheep, public Tuo {

};
int main(){
    Sheeptuo st;
    //菱形继承，两个父类有相同的数据，加作用域后就能区分到底是哪个父类的属性
    st.Sheep::age_ = 18;
    st.Tuo::age_ = 28;
    cout << "st.Sheep::age_ =" << st.Sheep::age_ << endl;
    cout << "st.Tuo::age_ =" << st.Tuo::age_ << endl;
    system("pause");
    return 0;
}

运行结果：

解决上述问题需要虚继承，这就会导致我们age_这个数据只有一份

class Animal {
public:
    int age_;
};
class Sheep :virtual public Animal {

};
class Tuo :virtual public Animal {

};
class Sheeptuo :public Sheep, public Tuo {

};
int main(){
    Sheeptuo st;

    
    st.Sheep::age_ = 18;
    st.Tuo::age_ = 28;
    cout << "st.Sheep::age_ =" << st.Sheep::age_ << endl;
    cout << "st.Tuo::age_ =" << st.Tuo::age_ << endl;
    cout << "st.age_=" << st.age_ << endl;

    system("pause");
    return 0;
}

 

class Animal {
public:
    int age_;
};
class Sheep :virtual public Animal {

};
class Tuo :virtual public Animal {

};
class Sheeptuo :public Sheep, public Tuo {

};
int main(){
    Sheeptuo st;

    
    st.Sheep::age_ = 18;
    st.Tuo::age_ = 28;
    cout << "st.Sheep::age_ =" << st.Sheep::age_ << endl;
    cout << "st.Tuo::age_ =" << st.Tuo::age_ << endl;
    cout << "st.age_=" << st.age_ << endl;
    Sheep sh;
    sh.age_ = 10;
    Tuo tuo;
    tuo.age_ = 20;
    cout << "sh.age_ =" << sh.age_ << endl;
    cout << "tuo.age_ =" << tuo.age_ << endl;

    system("pause");
    return 0;
}

 

 

底层原理：

virtual关键字使得Sheeptuo这个子类继承的不是/它两个父类（Sheep和Tuo）从基类（Animal）那里继承的成员属性（也就是age_）,而是继承了两个父类的虚基类指针，这两个指针分别指向两个父类自己的虚基类表，这个虚基类表记录了一个偏移量，而虚基类指针加上这个偏移量就能找到唯一的成员属性，即基类的成员属性，因此现在只有一份。

st.Sheep::m_age;st.Tuo::m_age;的时候，会首先找到Sheep或Tuo的虚函数指针通过虚函数指针找到虚函数表，通过虚函数中的偏移量找到m_age

st.m_age的时候直接调用st继承下来的m_age

虚继承只有多继承的时候才起作用

此时B直接调用从A继承来的属性，虚继承不起作用

动态多态与静态多态

 静态多态：

class Animal {
public:
    void speak() {
        cout << "动物在说话" << endl;
    }
    int age_;
};
class Cat :public Animal {
public:
    void speak() {
        cout << "小猫在说话" << endl;
    }
};
//执行的speak函数属于地址早绑定，在编译阶段确定所调用函数（animal.speak()）的地址，
//注意此时还没有发生传参，因此编译器只能在"animal.speak()"这条语句中看到animal下的speak()

void dospeak(Animal& animal) {
    animal.speak();
}
void test() {
    Cat cat;
    dospeak(cat);//相当于用父类的引用接收了一个子类的对象
}

• 静态多态到底早绑定哪个函数的地址，也就是到底调用谁的函数，这个要看谁在调用speak（cat.speak()就是cat在调用，animal.speak()就是animal调用）

 1 class Animal {
 2 public:
 3     void speak() {
 4         cout << "动物在说话" << endl;
 5     }
 6     int age_;
 7 };
 8 class Cat :public Animal {
 9 public:
10     void speak() {
11         cout << "小猫在说话" << endl;
12     }
13 };
14 
15 
16 
17 void dospeak1(Animal& animal) {
18     animal.speak();
19 }
20 void dospeak2(Cat& cat) {
21     cat.speak();
22 }
23 void test() {
24     Animal animal;
25     Cat cat;
26     dospeak1(animal);
27     dospeak1(cat);
28     dospeak2(cat);
29 }

运行结果：

 动态多态：

动态多态的原理是：指通过虚函数和继承实现的多态，即同一函数可以在不同的子类对象上产生不同的行为。在动态多态中，父类指针或引用可以指向子类对象，通过父类的指针和引用调用虚函数实现对子类对象的多态访问。

c++规定，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数。因此，在子类从新声明该虚函数时，可以加，也可以不加，但习惯上每一层声明函数时都加virtual,使程序更加清晰。

这里面正是因为有子类的虚函数，所以子类中的speak虚函数的地址替换了继承下来的虚函数表中虚函数的地址。

class Animal {
public:
    virtual void speak() {
        cout << "动物在说话" << endl;
    }
    int age_;
};
class Cat :public Animal {
public:

    void speak() {
        cout << "小猫在说话" << endl;
    }
};

void dospeak1(Animal& animal) {
    animal.speak();
}void test() {
    Animal animal;
    Cat cat;
    dospeak1(animal);
    dospeak1(cat);//当对象(这个对象指的是cat,dospeak1的animal是cat的别名)调用虚函数时，会根据对象的虚函数指针找到该对象所属的虚函数表，并从表中查找对应的虚函数地址，然后调用该虚函数。
}

我们常说的多态是动态多态，下面举个例子来表明多态带来的好处。

不使用多态来实现加减：

class AbstractCalculator {
public:
    //该成员函数的缺点是：
    //如果想扩展新的功能，需要修改源码
    //我们在开发中尽量要去扩展代码，而不是修改代码
    //如果此时我想加入除法功能，我需要修改成员函数getResult

    //如果我们这个功能出现问题，我们还需要浏览整个getResult函数，不便于我们的维护
    int getResult(string oper) {
        if (oper == "+") {
            return Num1_ + Num2_;
        }
        else if (oper == "-") {
            return Num1_ - Num2_;
        }
    }
    int Num1_;
    int Num2_;
};
void test01() {
    AbstractCalculator c;
    c.Num1_ = 10;
    c.Num2_ = 10;
    cout << c.Num1_ << "+" << c.Num2_ << "=" << c.getResult("+") << endl;
}

使用多态来完成加减：

class AbstractCalculator {
public:
    virtual int getResult() {
        return 0;
    }
    int Num1_;
    int Num2_;
};
class AddCalculator:public AbstractCalculator {
    int getResult() {
        return Num1_ + Num2_;
    }
};
class SubCalculator :public AbstractCalculator {
    int getResult() {
        return Num1_ - Num2_;
    }
};
void test02() {
    AbstractCalculator* abc = new AddCalculator;
    abc->Num1_ = 10;
    abc->Num2_ = 10;
    cout << abc->Num1_ << "+" << abc->Num2_ << "=" << abc->getResult() << endl;
    delete abc;
    abc = new SubCalculator;
    abc->Num1_ = 10;
    abc->Num2_ = 10;
    cout << abc->Num1_ << "-" << abc->Num2_ << "=" << abc->getResult() << endl;
    delete abc;

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

多态好处:
1、组织结构清晰
2、可读性强
3.对于前期和后期扩展以及维护性高。假如我们想加入除法的时候，我们另外写一个除法的子类就可以了；如果我们加法有问题，那么我们找到加法的子类修改一下就可以

纯虚函数与抽象类

虚析构和纯虚析构

• 正是因为有多态的存在，才导致父类的指针可以指向子类堆区对象，但是delete父类指针时，无法调用子类的析构函数，这就导致如果子类中有成员属性在堆区开辟了一块内存，那么它理应在子类中的析构函数释放，但是此时子类的析构函数不会被调用，这样子类中堆区内存不会被释放造成内存泄漏
• 而由于虚析构的存在，在delete父类指针时会调用子类的析构函数，然后子类的析构函数会调用父类的析构函数，这样整个子类被完全释放

class AbstractDrinking {
public:
    AbstractDrinking() {
        cout << "AbstractDrinking的默认构造的调用" << endl;
    }
    ~AbstractDrinking() {
        cout << "AbstractDrinking的析构函数的调用" << endl;
    }
    virtual void Boil() = 0;
};
class Coffee :public AbstractDrinking {
public:
    Coffee() = default;
    Coffee(string name) {
        cout << "Coffee的有参构造的调用" << endl;
        Name_ = new string(name);
    }
    ~Coffee() {
        cout << "Coffee的析构函数调用" << endl;
        if (Name_) {
            delete Name_;
            Name_ = nullptr;
        }
    }
    virtual void Boil() {
        cout << *Name_<<"煮农夫山泉" << endl;
    }
    string* Name_;
};
void test01() {
    //这个堆区内存可以被释放，但是上面的new string(name)堆区内存无法被释放
    //此处的Coffee是堆区对象，那么父类指针释放这个堆区子对象时，不会调用子对象的析构函数
    AbstractDrinking* abs = new Coffee("雀巢");
    abs->Boil();
    delete abs;
}

 

class AbstractDrinking {
public:
    AbstractDrinking() {
        cout << "AbstractDrinking的默认构造的调用" << endl;
    }
    virtual ~AbstractDrinking() {
        cout << "AbstractDrinking的虚析构函数的调用" << endl;
    }
    virtual void Boil() = 0;
};
class Coffee :public AbstractDrinking {
public:
    Coffee() = default;
    Coffee(string name) {
        cout << "Coffee的有参构造的调用" << endl;
        Name_ = new string(name);
    }
    ~Coffee() {
        cout << "Coffee的析构函数调用" << endl;
        if (Name_) {
            delete Name_;
            Name_ = nullptr;
        }
    }
    virtual void Boil() {
        cout << *Name_<<"煮农夫山泉" << endl;
    }
    string* Name_;
};
void test01() {
    //这个堆区内存可以被释放，但是上面的new string(name)堆区内存无法被释放
    //此处的Coffee是堆区对象，那么父类指针释放这个堆区子对象时，不会调用子对象的析构函数
    AbstractDrinking* abs = new Coffee("雀巢");
    abs->Boil();
    delete abs;
}

 纯虚析构函数：

class AbstractDrinking {
public:
    AbstractDrinking() {
        cout << "AbstractDrinking的默认构造的调用" << endl;
    }

    virtual ~AbstractDrinking() = 0;
    virtual void Boil() = 0;
};
//纯虚析构函数必须类内声明，类外定义（有函数体实现）
//防止父类中也会开辟堆区内存，导致无法释放
AbstractDrinking::~AbstractDrinking() {
    cout << "AbstractDrinking的纯虚析构函数的调用" << endl;
}
class Coffee :public AbstractDrinking {
public:
    Coffee() = default;
    Coffee(string name) {
        cout << "Coffee的有参构造的调用" << endl;
        Name_ = new string(name);
    }
    ~Coffee() {
        cout << "Coffee的析构函数调用" << endl;
        if (Name_) {
            delete Name_;
            Name_ = nullptr;
        }
    }
    virtual void Boil() {
        cout << *Name_ << "煮农夫山泉" << endl;
    }
    string* Name_;
};
void test01() {
    //这个堆区内存可以被释放，但是上面的new string(name)堆区内存无法被释放
    //此处的Coffee是堆区对象，那么父类指针释放这个堆区子对象时，不会调用子对象的析构函数
    AbstractDrinking* abs = new Coffee("雀巢");
    abs->Boil();
    delete abs;
}