详解类与对象——多态


(^ _ ^)超长文嘻嘻

一. 多态

1. 多态的基本概念

多态,通俗的说,就是完成一个行为的多种形态,具体点就是去完成某个行为,当不同的对象去完成时会 产生出不同的状态。

多态是C++面向对象三大特性之一

多态分为两类

  • 静态多态: 函数重载 和 运算符重载属于静态多态,复用函数名

  • 动态多态: 派生类和虚函数实现运行时多态

静态多态和动态多态区别:

  • 静态多态的函数地址早绑定 - 编译阶段确定函数地址

  • 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

class Animal

{

public:

    //Speak函数就是虚函数

    //函数前面加上virtual关键字,变成虚函数,那么编译器在编译的时候就不能确定函数调用了。

    virtual void speak()

    {

        cout << "动物在说话" << endl;

    }

};

  

class Cat :public Animal

{

public:

    void speak()

    {

        cout << "小猫在说话" << endl;

    }

};

  

class Dog :public Animal

{

public:

  

    void speak()

    {

        cout << "小狗在说话" << endl;

    }

  

};

//我们希望传入什么对象,那么就调用什么对象的函数

//如果函数地址在编译阶段就能确定,那么静态联编

//如果函数地址在运行阶段才能确定,就是动态联编

  

void DoSpeak(Animal & animal)

{

    animal.speak();

}

//

//多态满足条件:

//1、有继承关系

//2、子类重写父类中的虚函数

//多态使用:

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

  

void test01()

{

    Cat cat;

    DoSpeak(cat);

  
  

    Dog dog;

    DoSpeak(dog);

}

  
  

int main() {

  

    test01();

  

    system("pause");

  

    return 0;

}

总结:

多态满足条件

  • 有继承关系

  • 子类重写父类中的虚函数

多态使用条件

  • 父类指针或引用指向子类对象

重写:函数返回值类型 函数名 参数列表 完全一致称为重写

二.多态案例——计算机类

案例描述:

分别利用普通写法和多态技术,设计实现两个操作数进行运算的计算器类

多态的优点:

  • 代码组织结构清晰

  • 可读性强

  • 利于前期和后期的扩展以及维护

以下为代码实现:

#include 
using namespace std;
//普通实现
class Calculator
{
public:
	int getresult(string oper) {
		if (oper == "+")
		{
			return m_num1 + m_num2;
		}
		else if (oper == "-")
		{
			return m_num1 - m_num2;
		}
		else if (oper == "*")
		{
			return m_num1 * m_num2;
		}
		else if (oper == "/")
		{
			return m_num1 / m_num2;
		}
	}

	int m_num1;
	int m_num2;
};
void test01() {
	Calculator c;
	c.m_num1 = 10;
	c.m_num2 = 20;
	cout << c.m_num1 << "+" << c.m_num2 << "=" << c.getresult("+")<<endl;
	cout << c.m_num1 << "-" << c.m_num2 << "=" << c.getresult("-") << endl;
	cout << c.m_num1 << "*" << c.m_num2 << "=" << c.getresult("*") << endl;
}

//若想拓展新的功能,要求修改源码
//在真实开发中,提倡开闭原则
//对拓展进行开发,对修改进行关闭

//多态实现

//多态实现

//抽象计算器类

//多态优点:代码组织结构清晰,可读性强,利于前期和后期的扩展以及维护

class AbstractCalculator

{

public:



	virtual int getResult()//虚函数

	{

		return 0;

	}



	int m_Num1;

	int m_Num2;

};



//加法计算器

class AddCalculator :public AbstractCalculator

{

public:

	int getResult()

	{

		return m_Num1 + m_Num2;

	}

};



//减法计算器

class SubCalculator :public AbstractCalculator

{

public:

	int getResult()

	{

		return m_Num1 - m_Num2;

	}

};



//乘法计算器

class MulCalculator :public AbstractCalculator

{

public:

	int getResult()

	{

		return m_Num1 * m_Num2;

	}

};




void test02()

{
	//多态使用条件
	//父类指针或者引用指向子类对象

	//创建加法计算器

	AbstractCalculator* abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 20;
	cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult()<<endl;

	delete abc; //用完了记得销毁



	//创建减法计算器

	abc = new SubCalculator;

	abc->m_Num1 = 10;

	abc->m_Num2 = 10;

	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;

	delete abc;



	//创建乘法计算器

	abc = new MulCalculator;

	abc->m_Num1 = 10;

	abc->m_Num2 = 10;

	cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;

	delete abc;

}



int main() {



	//test01();



	test02();



	system("pause");



	return 0;

}

三. 纯虚函数和抽象类

在多态中,通常父类中虚函数的实现是毫无意义的,主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法:virtual 返回值类型 函数名 (参数列表)= 0 ;

当类中只要有了一个纯虚函数,这个类也称为抽象类

抽象类特点

  • 无法实例化对象

  • 子类必须重写抽象类中的纯虚函数,否则也属于抽象类

作用:
常常用于必须重写函数时候

示例:


class Base

{

public:

    //纯虚函数

    //类中只要有一个纯虚函数就称为抽象类

    //抽象类无法实例化对象

    //子类必须重写父类中的纯虚函数,否则也属于抽象类

    virtual void func() = 0;

};

  

class Son :public Base

{

public:

    virtual void func()

    {

        cout << "func调用" << endl;

    };

};

  

void test01()

{

    Base * base = NULL;

    //base = new Base; // 错误,抽象类无法实例化对象

    base = new Son;

    base->func();

    delete base;//记得销毁

}

  

int main() {

  

    test01();

  

    system("pause");

  

    return 0;

}

四.虚析构和纯虚析构

多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时无法调用到子类的析构代码

解决方式:将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性:

  • 可以解决父类指针释放子类对象

  • 都需要有具体的函数实现

虚析构和纯虚析构区别:

  • 如果是纯虚析构,该类属于抽象类,无法实例化对象(类似纯虚函数)

虚析构语法:

virtual ~类名(){}

纯虚析构语法:

virtual ~类名() = 0;

类名::~类名(){}

class Animal {

public:

  

    Animal()

    {

        cout << "Animal 构造函数调用!" << endl;

    }

    virtual void Speak() = 0;

  

    //析构函数加上virtual关键字,变成虚析构函数

    //virtual ~Animal()

    //{

    //  cout << "Animal虚析构函数调用!" << endl;

    //}

  
  

    virtual ~Animal() = 0;

};

  

Animal::~Animal()

{

    cout << "Animal 纯虚析构函数调用!" << endl;

}

  

//和包含普通纯虚函数的类一样,包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。

  

class Cat : public Animal {

public:

    Cat(string name)

    {

        cout << "Cat构造函数调用!" << endl;

        m_Name = new string(name);

    }

    virtual void Speak()

    {

        cout << *m_Name <<  "小猫在说话!" << endl;

    }

    ~Cat()

    {

        cout << "Cat析构函数调用!" << endl;

        if (this->m_Name != NULL) {

            delete m_Name;

            m_Name = NULL;

        }

    }

  

public:

    string *m_Name;

};

  

void test01()

{

    Animal *animal = new Cat("Tom");

    animal->Speak();

  

    //通过父类指针去释放,会导致子类对象可能清理不干净,造成内存泄漏

    //怎么解决?给基类增加一个虚析构函数

    //虚析构函数就是用来解决通过父类指针释放子类对象

    delete animal;

}

  

int main() {

  

    test01();

  

    system("pause");

  

    return 0;

} 

小结:

​ 1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象

​ 2. 如果子类中没有堆区数据,可以不写为虚析构或纯虚析构

​ 3. 拥有纯虚析构函数的类也属于抽象类

五.多态案例:组装电脑

案例描述:

电脑主要组成部件为 CPU(用于计算),显卡(用于显示),内存条(用于存储)

将每个零件封装出抽象基类,并且提供不同的厂商生产不同的零件,例如Intel厂商和Lenovo厂商

创建电脑类提供让电脑工作的函数,并且调用每个零件工作的接口

测试时组装三台不同的电脑进行工作

#include

using namespace std;

  

//抽象CPU类

class CPU

{

public:

    //抽象的计算函数

    virtual void calculate() = 0;

};

  

//抽象显卡类

class VideoCard

{

public:

    //抽象的显示函数

    virtual void display() = 0;

};

  

//抽象内存条类

class Memory

{

public:

    //抽象的存储函数

    virtual void storage() = 0;

};

  

//电脑类

class Computer

{

public:

    Computer(CPU * cpu, VideoCard * vc, Memory * mem)

    {

        m_cpu = cpu;

        m_vc = vc;

        m_mem = mem;

    }

  

    //提供工作的函数

    void work()

    {

        //让零件工作起来,调用接口

        m_cpu->calculate();

  

        m_vc->display();

  

        m_mem->storage();

    }

  

    //提供析构函数 释放3个电脑零件

    ~Computer()

    {

  

        //释放CPU零件

        if (m_cpu != NULL)

        {

            delete m_cpu;

            m_cpu = NULL;

        }

  

        //释放显卡零件

        if (m_vc != NULL)

        {

            delete m_vc;

            m_vc = NULL;

        }

  

        //释放内存条零件

        if (m_mem != NULL)

        {

            delete m_mem;

            m_mem = NULL;

        }

    }

  

private:

  

    CPU * m_cpu; //CPU的零件指针

    VideoCard * m_vc; //显卡零件指针

    Memory * m_mem; //内存条零件指针

};

  

//具体厂商

//Intel厂商

class IntelCPU :public CPU

{

public:

    virtual void calculate()

    {

        cout << "Intel的CPU开始计算了!" << endl;

    }

};

  

class IntelVideoCard :public VideoCard

{

public:

    virtual void display()

    {

        cout << "Intel的显卡开始显示了!" << endl;

    }

};

  

class IntelMemory :public Memory

{

public:

    virtual void storage()

    {

        cout << "Intel的内存条开始存储了!" << endl;

    }

};

  

//Lenovo厂商

class LenovoCPU :public CPU

{

public:

    virtual void calculate()

    {

        cout << "Lenovo的CPU开始计算了!" << endl;

    }

};

  

class LenovoVideoCard :public VideoCard

{

public:

    virtual void display()

    {

        cout << "Lenovo的显卡开始显示了!" << endl;

    }

};

  

class LenovoMemory :public Memory

{

public:

    virtual void storage()

    {

        cout << "Lenovo的内存条开始存储了!" << endl;

    }

};

  
  

void test01()

{

    //第一台电脑零件

    CPU * intelCpu = new IntelCPU;

    VideoCard * intelCard = new IntelVideoCard;

    Memory * intelMem = new IntelMemory;

  

    cout << "第一台电脑开始工作:" << endl;

    //创建第一台电脑

    Computer * computer1 = new Computer(intelCpu, intelCard, intelMem);

    computer1->work();

    delete computer1;

  

    cout << "-----------------------" << endl;

    cout << "第二台电脑开始工作:" << endl;

    //第二台电脑组装

    Computer * computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);;

    computer2->work();

    delete computer2;

  

    cout << "-----------------------" << endl;

    cout << "第三台电脑开始工作:" << endl;

    //第三台电脑组装

    Computer * computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);;

    computer3->work();

    delete computer3;

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

你可能感兴趣的:(c++,c++)