精华内容
下载资源
问答
  • 使用多态实现一个线性表(队列,串,堆栈) 要求: 具有线性表的基本操作:插入,删除,测长等。 思路: 队列,堆栈都以实现push,pop,测长等操作。 现在要求用多态实现,就要建立一个线性表的共性模板,来...
    /*
     使用多态实现一个线性表(队列,串,堆栈)
     要求:
     具有线性表的基本操作:插入,删除,测长等。
    
      思路:
          队列,堆栈都以实现push,pop,测长等操作。
    	  现在要求用多态实现,就要建立一个线性表的共性模板,来实现以上功能。
    */
    #include<iostream>
    using namespace std;
    template<typename T>
    class Tcontainer
    {
    public:
    	virtual void push(const T& ) = 0;
    	virtual void pop() = 0;
    	virtual const T& begin() = 0;
    	virtual const T& end() = 0;
    	virtual size_t size()  = 0;
    };
    
    
    template<typename T>
    class Tvector:public Tcontainer<T>
    {
    public:
    	static const size_t _step  = 100 ;
    	Tvector()
    	{
    		_size = 0;
    		_cap = _step;
    		buf = 0;
    		re_capacity(_cap);
    	}
    
    	~Tvector()
    	{
    		free(buf);
    	}
    
    	void re_capacity(size_t s)
    	{
    		if(!buf)
    		{
    			buf = (T*)malloc(sizeof(T)*s);
    		}
    		else
    			buf = (T*)realloc(buf,sizeof(T)*s);
    	}
    
    	virtual void push(const T& v)
    	{
    		if(_size >= _cap)
    		{
    			re_capacity(_cap += _step);
    		}
    
    		buf[_size++]  = v;
    	}
    
    	virtual void pop()
    	{
    		if(_size)
    		{
    			_size--;
    		}
    	}
    
    	virtual const T& begin()
    	{
    		return buf[0];
    	}
    
    	virtual const T& end()
    	{
    		if(_size)
    			return buf[_size -1];
    	}
    
    	virtual size_t size()
    	{
    		return _size;
    	}
    
    	const T& operator[] (size_t i)
    	{
    		if( i >= 0 && i < _size)
    		{
    			return buf[i];
    		}
    	}
    private:
    	size_t _size;
    	size_t _cap;
    	T* buf;
    };
    
    
    int main()
    {
    	Tvector<int> v;
    	for(int i = 0; i < 100; ++i )
    	{
    		v.push(i);
    	}
    
    	for(int i = 0; i<100;++i)
    	{
    		cout<<v[i]<<endl;
    	}
    	return 0;
    }
    	  
    

    展开全文
  • 多态

    2021-03-01 09:41:35
    使用多态实现思路:(1)编写具有继承关系的父类和子类.(2)子类重写父类方法(3)使用父类的引用指向子类的对象(向上转型,自动进行类型转换). 实现多态的两种形式:(1)使用父类作为方法形参实现多态(2)使用父类作为方法返

    一、为什么使用多态
    在这里插入图片描述
    未使用多态实现给宠物喂食时,要给狗狗类增加狗狗吃食的方法,企鹅也要增加,然后在主人类编写给狗狗和企鹅喂食的方法,编写测试方法,调用主人类给狗狗和企鹅喂的方法.
    在这里插入图片描述
    频繁的修改代码,代码可扩展性和可维护性差,这时就要使用多态优化设计.
    二.什么是多态
    在这里插入图片描述
    2.如何使用多态
    使用多态实现思路:(1)编写具有继承关系的父类和子类.(2)子类重写父类方法(3)使用父类的引用指向子类的对象(向上转型,自动进行类型转换).
    实现多态的两种形式:(1)使用父类作为方法形参实现多态(2)使用父类作为方法返回值实现多态
    在这里插入图片描述
    可以将父类作为方法形参
    在这里插入图片描述
    也可以将父类作为返回值类型.
    在这里插入图片描述
    但是父类引用不能调用子类特有方法,这时就要用到向下转型.
    在这里插入图片描述
    进行强制类型转换,并且父类指向真实的子类类型.
    三、总结
    在这里插入图片描述

    展开全文
  • 多态实现

    2013-01-17 15:58:32
    多态Ploymorphism:理解多态原理,用抽象类和抽象方法,以及虚函数实现多态。 封装Encapsulation:保证对象自身数据的完整性、安全性。 v 在基类Person中声明抽象方法Login(),让它约束子类,必须实现不同的...

    继承inheritance:实现代码的复用,建立类的层次关系。

    多态Ploymorphism:理解多态原理,用抽象类和抽象方法,以及虚函数实现多态。

    封装Encapsulation:保证对象自身数据的完整性、安全性。

    在基类Person中声明抽象方法Login(),让它约束子类,必须实现不同的Login(),从而实现多态。

    (1)抽象方法是一个没有方法体的方法,用关键字abstract修饰。语法如下:

    Ø <访问修饰符> abstract返回类型方法名(<参数>);

    Ø  方法被标记为抽象的,要求子类必须实现该方法;方法没有方法体(方法名括号后直接跟一个分号结束),提醒编译器注意,如果子类没有重写该抽象方法,就会报错。

    Ø  注意:抽象方法没有闭合的大括号,下面的声明方式是错误的:

    § <访问修饰符> abstract 返回类型 方法名(<参数>){}

    (2)含有抽象方法的类被称为抽象类,用关键字abstract修饰。语法如下:

    Ø  <访问修饰符> abstract class类名

    Ø  抽象类中并不一定都是抽象方法,抽象类中也可以容纳具体实现的方法。但是,有抽象方法的类必然是抽象类。

    v  (3)在子类中,通过关键字override重写抽象方法,语法如下:

    Ø <访问修饰符> override返回类型方法名(<参数>){}

    考虑背景:

    Ø  通常情况下,许多角色的用户登录系统的逻辑是一样的,只是管理员(Admin)的有所差别。

    Ø  那么这个通用的登录方法应该放在哪里呢?按照上面的思想,应该放在父类里面。

    思路:

    Ø  “父类(Person)中的Login()方法实现通用的登录逻辑,一般用户(User)默认采用父类的登录方法即可,管理员(Admin)可以把父类的登录方法重写,实现管理员特有的登录逻辑”。

    实现方式:

    Ø  C#中用virtual方法修饰的方法称为虚方法,虚方法可以有具体的实现,也可以被重写。在父类中定义虚方法,然后在子类中可以重写虚方法,也实现了面向对象的多态。

    Ø 虚方法的语法如下:

    § <访问修饰符> virtual 返回类型方法名(<参数>)

    § {

    §     //方法体

    § }

     

     

    展开全文
  • 现在基本上知道了什么是多态,接着我们来一个例子使用多态和不使用多态实现一个小功能的对比。感受下使用多态带来的便利。 1.非多态方式实现计算器 这里计算器我们就简单描述成两个数的相加,相减和相乘。 #...

    现在基本上知道了什么是多态,接着我们来一个例子使用多态和不使用多态来实现一个小功能的对比。感受下使用多态带来的便利。

     

    1.非多态方式实现计算器

    这里计算器我们就简单描述成两个数的相加,相减和相乘。

    #include <iostream>
    #include <string>
    using namespace std;
    
    class Calculator
    {
    
    public:
        int m_Num1;
        int m_Num2;
    
        int getResult(string ope)
        {
    	if (ope == "+")
    	{
    	    return m_Num1 + m_Num2;
    	}
    	else if (ope == "-")
    	{
    	    return m_Num1 - m_Num2;
    	}
    	else if (ope == "*")
    	{
    	    return m_Num1 * m_Num2;
    	}
    
        }
    };
    
    void test02()
    {
        //创建一个计算器对象
        Calculator cal;
        cal.m_Num1 = 20;
        cal.m_Num2 = 10;
    
        cout << cal.m_Num1 << "+" << cal.m_Num2 << "=" << cal.getResult("+") << endl;
        cout << cal.m_Num1 << "-" << cal.m_Num2 << "=" << cal.getResult("-") << endl;
        cout << cal.m_Num1 << "*" << cal.m_Num2 << "=" << cal.getResult("*") << endl;
    
    }
    
    int main()
    {
    	test02();
    	system("pause");
    }

    运行结果

    基本上实现一个计算器功能,但是这个有很大的缺点,那就是如果想增加两个数相除,两个数求平均数,我们都需要增加一个if else判断,这个是很痛苦的事情。

     

    2.使用多态方式实现计算器

           这里看看使用多态怎么实现计算器,而且代码可读性更强。思路是这样,我们先定义的一个抽象的计算器类,里面有两个int成员变量和一个getResult的方法。然后我们对于加法,我们新建一个加法的类,继承这个抽象计算器类,在加法子类中实现相加的返回,同理,新创建加法类和乘法类来实现相应的计算功能。

    #include <iostream>
    #include <string>
    using namespace std;
    
    class AbstractCalculator
    {
    
    public:
        int m_Num1;
        int m_Num2;
    
        virtual int getResult()
        {
    	return 0;
        }
    };
    
    //加法类
    class AddCalculator : public AbstractCalculator
    {
        virtual int getResult()
        {
    	return m_Num1 + m_Num2;
        }
    };
    
    //加法类
    class SubCalculator : public AbstractCalculator
    {
        virtual int getResult()
        {
    	return m_Num1 - m_Num2;
        }
    };
    
    //乘法类
    class MulCalculator : public AbstractCalculator
    {
        virtual int getResult()
        {
    	return m_Num1 * m_Num2;
        }
    };
    
    void test02()
    {
        //动态多态使用
        AbstractCalculator * abc = new AddCalculator;  //父类指针指向子类对象
    
        //加法
        abc->m_Num1 = 20;
        abc->m_Num2 = 10;
        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()
    {
        test02();
        system("pause");
    }

    上面用到了动态多态第二种使用情况,就是使用父类的指针指向子类对象。第二点需要注意,前后创建了一个父类对象指针abc,每次用完记得删除。不然不同计算都需要创建一次父类对象,太耗费内存。

    运行结果

     

    多态带来的好处

    1)组织结构清晰
    2)代码可读性强
    3)对于前期拓展和后期维护性高

    展开全文
  • 但从实际的角度出发,只要一门语言拥有类,对象的概念,以及提供了对应的语法,就可以用来实现面向对象编程了,所以从这个角度来看,Go语言是可以被认为是一门面向对象编程语言的。 那么抛出第二个问题,Go语言有...
  • Golang继承多态实现

    2017-02-21 16:17:59
    思路: 1.结构体方法可以继承(也不是继承,父结构体的方法可以顺延下来)。 2.利用接口。 3.利用父结构体self变量,替换为真实使用的对象,调用的时候使用struct.self.Method调用接口中的方法。 [code="...
  • 本文实例讲述了C#使用虚拟方法实现多态。分享给大家供大家参考。具体分析如下: 我们看一个例子,假若有一个动物类,类中用方法cry()描述动物的叫声,不同的动物的叫声是不一样的。根据继承的特征,把类中公共部分的...
  •  1)使用void * 可传递任意参数 struct device { void *data; void (*set_device)(struct device * dev); };  2)函数指针,根据函数指针注册与否,来执行相应操作 struct device *dev if (!dev...
  • 第五章 多态

    2021-02-18 09:12:23
    使用多态实现思路 实现多态的三个要素 编写具有继承关系的父类和子类 子类重写父类方法 使用父类的引用指向子类对象 向上转型 Pet pet = new Dog();>>>自动类型转换 实现多态的两种形式 使用父类作为...
  • 多态实现原理

    万次阅读 2017-10-20 18:09:05
    多态使用大家应该都比较了解,但是多态实现原理就有点抽象了,查了很多很多资料,连续几天断断续续的看,有时候看着看着就走神了。毕竟太抽象,哈哈~ 不过依然硬着头皮看下来了(也不知道看了多少遍),并且将...
  • 第三章 多态 一、编写父子类 1.多态是具有表现多种型生态的能力的特征,同一个实现接口,使用不同的实例而...3. 实现思路编写子类,子类重写父类方法 运行时,使用父类的类型,子类的对象。 二、实现多态的两个...
  • 通过函数参数的不同(参数个数或者类型)实现多态已经有了一个思路,本文介绍另类的多态(参数相同),通过隐藏函数名的方式,采用指针函数和函数指针数组。
  • java类的多态

    2019-01-20 22:07:10
    多态的必要条件 1.要有继承 2.要有重写 静态属性、静态方法、非静态的属性不涉及重写,所以这些内容没有多态 ...使用多态实现思路 编写父类 编写子类,子类重写父类方法 运行时,使用父类的类型...
  • 什么是多态多态实现方法是什么? 点击查看
  • 第三章 多态

    2017-04-08 20:22:42
    3.使用多态实现思路  编写父类  编写子类,子类重写父类方法  运行时,使用父类的类型,子类的对象 4.实现多态的两种形式:  使用父类作为方法形参实现多态  使用父类作为方法的返回
  • 因为在MFC和QT中,它的每个基类都有着大量的虚函数,而在实际应用当中,继承类可能只是改写其中的很少的几项,如果采用多态实现,那么会浪费大量的内存空间。 借用文献【2】的一段话,“也正 是因为这个原因,从...
  • } 多态实现方法: 通过 基类 创建的 指针 指向 派生类 的 对象,值得注意的是该指针只能调用基类的函数,如果将基类的函数定义成虚函数,那么可以调用派生类的函数,但是也只能调用派生类重写的函数,当然依旧...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,780
精华内容 11,112
关键字:

使用多态实现的思路