Educator:程序设计二（C++面向对象）_实训13_虚函数

于 2024-05-21 12:00:00 发布
阅读量680 收藏 7
点赞数 10
分类专栏： Educator头歌系列 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iceslime/article/details/139077605
版权

第1关：设计和使用虚函数

任务描述

建立一个继承体系。List 是基类，ArrayList 和 LinkedList 是派生类。

List 提供 5 个函数，分别是增删查改显。其中，前 4 个是纯虚函数，第 5 个是虚函数。

用户需在 ArrayList 和 LinkedList 中编写实现相应的实现。

注意一条：在 ArrayList 中无需再实现显示函数。

请务必注意，在本题中需要填写两份代码文件以完成题目要求，分别是"ArrayList.cpp"与"LinkedList.cpp"

#include "ArrayList.h"
 
/****************start from here**********************/
ArrayList::ArrayList()
{
	size = 0;
	data = new int[10];
	capacity = 10;
}
 
ArrayList::ArrayList(const ArrayList &rhs)
{
	data = new int[rhs.capacity];
	size = rhs.size;
	for (int i = 0; i < size; i++)
	{
		data[i] = rhs.data[i];
	}
}
 
ArrayList::ArrayList(int const a[], int n)
{
	data = new int[n];
	size = n;
	for (int i = 0; i < size; i++)
	{
		data[i] = a[i];
	}
}
 
ArrayList::ArrayList(int n, int value)
{
	data = new int[n];
	size = n;
	for (int i; i < size; i++)
	{
		data[i] = value;
	}
}
 
ArrayList::~ArrayList()
{
	delete[] data;
}
 
void ArrayList::insert(int pos, int value)
{
 
	if (size == capacity)
	{
		int *old = data;
		data = new int[2 * size];
		for (int i = 0; i < size; i++)
		{
			data[i] = old[i];
		}
		capacity = 2 * size;
	}
	for (int i = size - 1; i >= pos; i--)
		data[i + 1] = data[i];
	data[pos] = value;
	size++;
}
 
void ArrayList::remove(int pos)
{
	for (int i = pos; i < size - 1; i++)
		data[i] = data[i + 1];
	size--;
}
int ArrayList::at(int pos) const
{
	return data[pos];
}
void ArrayList::modify(int pos, int newValue)
{
	data[pos] = newValue;
}
 
#include "LinkedList.h"
#include<iostream>
using namespace std;
/****************start from here**********************/
LinkedList::LinkedList() : List(0)
{
	head = new Node();
}
 
LinkedList::LinkedList(const LinkedList &rhs) : List(rhs.size)
{
	head = new Node;
	Node *p = head;
	for (Node *q = rhs.head->next; q; q = q->next)
	{
		p->next = new Node(q->data, q->next);
		p = p->next;
	}
}
 
LinkedList::LinkedList(int const a[], int n) : List(n)
{
	head = new Node();
	Node *p = head;
	for (int i = 0; i < size; i++)
	{
		p->next = new Node(a[i], nullptr);
		p = p->next;
	}
}
 
LinkedList::LinkedList(int n, int value) : List(n)
{
	head = new Node();
	Node *p = head;
	for (int i = 0; i < size; i++)
	{
		p->next = new Node(value, nullptr);
		p = p->next;
	}
}
 
LinkedList::~LinkedList()
{
	Node *p = head;
	while (head->next != NULL)
	{
		p = head->next;
		delete head;
		head = p;
	}
	delete head;
}
 
void LinkedList::insert(int pos, int value)
{
	Node *p = head;
	for (int i = -1; i < pos - 1; i++)
	{
		p = p->next;
	}
	Node *q = new Node(value, p->next);
	p->next = q;
	size++;
}
void LinkedList::remove(int pos)
{
	Node *p = head;
	for (int i = -1; i < pos - 1; i++)
	{
		p = p->next;
	}
	Node *q = head;
	for (int j = -1; j < pos + 1; j++)
	{
		q = q->next;
	}
	p->next = q;
	size--;
}
 
int LinkedList::at(int pos) const
{
	Node *p = head;
	for (int i = -1; i < pos; i++)
	{
		p = p->next;
	}
	return p->data;
}
 
void LinkedList::modify(int pos, int newValue)
{
	Node *p = head;
	for (int i = -1; i < pos; i++)
	{
		p = p->next;
	}
	p->data = newValue;
}
void LinkedList::disp(ostream &os) const
{
	Node *p = head;
	while (p->next != NULL)
	{
		p = p->next;
		cout << p->data << " ";
	}
	cout << endl;
}

_____________________________________________________________________________

第2关：普通非成员函数的动态绑定

任务描述

建立一个继承体系，List 是基类，ArrayList 和 LinkedList 是其派生类。并且编写实现下述函数并达到如下效果。

  1. ostream& operator << (ostream&os, const List&rhs);

做一个流输出运算符重载，其第二个参数是List的常引用类型。我们知道子类的对象天生可以作为父类类型使用，因此

  1. ArrayList a;
  2. LinkedList b;
  3. operator << (cout,a);
  4. operator << (cout,b);

这上面的调用显然都是合法的。但是现在要求实现如下效果：第 3 行的函数执行的是适合 ArrayList 输出的代码，而第 4 行执行的是适合 LinkedList 输出的代码。即，虽然调用的函数一样，但需要根据当时的实参类型选择合适的实现。相当于对非成员函数做到动态绑定。

请务必注意，在本题中需要填写三份代码文件以完成题目要求，分别是"ArrayList.cpp"与"LinkedList.cpp"等

/****************start from here**********************/
#include"ArrayList.h"
#include<iostream>
using namespace std;
ArrayList::ArrayList()
{
	size = 0;
	data = new int[10];
	capacity = 10;
}
 
ArrayList::ArrayList(const ArrayList &rhs)
{
	data = new int[rhs.capacity];
	size = rhs.size;
	for (int i = 0; i < size; i++)
	{
		data[i] = rhs.data[i];
	}
}
 
ArrayList::ArrayList(int const a[], int n)
{
	data = new int[n];
	size = n;
	for (int i = 0; i < n; i++)
	{
		data[i] = a[i];
	}
}
 
ArrayList::ArrayList(int n, int value)
{
	data = new int[n];
	size = n;
	for (int i; i < n; i++)
	{
		data[i] = value;
	}
}
 
ArrayList::~ArrayList()
{
	delete[] data;
}
 
void ArrayList::insert(int pos, int value)
{
 
	if (size == capacity)
	{
		int *old = data;
		data = new int[2 * size];
		for (int i = 0; i < size; i++)
		{
			data[i] = old[i];
		}
		capacity = 2 * size;
	}
	for (int i = size - 1; i >pos; i--)
		data[i + 1] = data[i];
	data[pos] = value;
	size++;
}
 
void ArrayList::remove(int pos)
{
	for (int i = pos; i < size - 1; i++)
		data[i] = data[i + 1];
	size--;
}
int ArrayList::at(int pos) const
{
	return data[pos];
}
void ArrayList::modify(int pos, int newValue)
{
	data[pos] = newValue;
}
void ArrayList::setCapacity(int newCapa)
{
    if(newCapa<capacity)
        return ;
    else
    {
        capacity=newCapa;
        int *newdata=new int[capacity];
        for(int i=0;i<size;i++)
        {
            newdata[i]=data[i];
        }
        delete[]data;
        data=newdata;
    }
}
/****************start from here**********************/
#include"LinkedList.h"
#include<iostream>
using namespace std;
LinkedList::LinkedList() : List(0)
{
	head = new Node();
}
 
LinkedList::LinkedList(const LinkedList &rhs) : List(rhs.size)
{
	head = new Node;
	Node *p = head;
	for (Node *q = rhs.head->next; q; q = q->next)
	{
		p->next = new Node(q->data, nullptr);
		p = p->next;
	}
}
 
LinkedList::LinkedList(int const a[], int n) : List(n)
{
	head = new Node();
	Node *p = head;
	for (int i = 0; i < n; i++)
	{
		p->next = new Node(a[i], nullptr);
		p = p->next;
	}
}
 
LinkedList::LinkedList(int n, int value) : List(n)
{
	head = new Node();
	Node *p = head;
	for (int i = 0; i < n; i++)
	{
		p->next = new Node(value, nullptr);
		p = p->next;
	}
}
 
LinkedList::~LinkedList()
{
	Node *p = head;
	while (head->next != NULL)
	{
		p = head->next;
		delete head;
		head = p;
	}
	delete head;
}
LinkedList::Node* LinkedList::advance(int pos)const
{
    Node *p=head;
    for(int i=-1;i<pos;i++)
    {
        p=p->next;
    }
    return p;
}
 
void LinkedList::insert(int pos, int value)
{
	Node *p = head;
	for (int i = -1; i < pos - 1; i++)
	{
		p = p->next;
	}
	Node *q = new Node(value, p->next);
	p->next = q;
	size++;
}
void LinkedList::remove(int pos)
{
	Node *p = head;
	for (int i = -1; i < pos - 1; i++)
	{
		p = p->next;
	}
	Node *q = head;
	for (int j = -1; j < pos + 1; j++)
	{
		q = q->next;
	}
	p->next = q;
	size--;
}
 
int LinkedList::at(int pos) const
{
	Node *p = head;
	for (int i = -1; i < pos; i++)
	{
		p = p->next;
	}
	return p->data;
}
 
void LinkedList::modify(int pos, int newValue)
{
	Node *p = head;
	for (int i = -1; i < pos; i++)
	{
		p = p->next;
	}
	p->data = newValue;
}
 
void LinkedList::disp(ostream &os) const
{
	Node *p = head;
	while (p->next != NULL)
	{
		p = p->next;
		cout << p->data << " ";
	}
}
#ifndef _LIST_H_
#define _LIST_H_
#include <iostream>
using std::ostream;
using namespace std;
class List{
protected:
    int size;
public:
    List(int s=0):size(s){}
    List(const List&rhs):size(rhs.size){}
    virtual ~List(){}
    int getSize()const{return size;}
    virtual void insert(int pos,int value)=0;
    virtual void remove(int pos)=0;
    virtual int at(int pos)const=0;
    virtual void modify(int pos,int newValue)=0;
    virtual void disp(ostream&os)const
    {
        for(int i=0,n=getSize();i<n;i++)
        {
            os<<at(i)<<" ";
        }
    }
};
 
#endif // _LIST_H_

第3关：接口继承

任务描述

已有 List 类，以及其 2 个派生类 ArrayList 和 LinkedList。为其编写一个 IList 类。IList 类在逻辑上为这个继承体系提供一个接口。

相关知识

类是一个数据与操作的集合体。因此在做继承的时候，子类同时继承了父类的数据和函数。

但是对面向对象的基础而言（对 C++ 而言就是公有继承），重要的是公有函数的继承。只有在公有函数可以继承的情况下，才能采用公有继承。

因此有一个“丧心病狂”的想法，基类中只有公有函数，没有数据！很自然的，因为没有数据，因此函数也无法给出定义。因此，这种基类中实际上只有公有函数的声明。这就是接口继承，因为基类中只有接口。 接口继承是有用的。某个类继承了某个接口，相当于向用户保证：“我一定会实现某些函数”。

#ifndef _ILIST_H_
#define _ILIST_H_
/****************start from here**********************/
#include<iostream>
using namespace std;
class IList
{
    public:
    virtual void insert(int pos,int value)=0;  
    virtual void remove(int pos)=0;  
    virtual int at(int pos)const=0;  
    virtual void modify(int pos,int newValue)=0;
    virtual void disp(ostream&os)const{};
};
 
 
#endif

iceslime
关注
  • 10
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++面向对象 - 多态性的应用
Junds0的博客
04-06 2301
List 类提供 5 个虚函数，其中有 4 个是纯虚函数，需要用户在子类中实现。这上面的调用显然都是合法的。但是现在要求实现如下效果：第 3 行的函数执行的是适合 ArrayList 输出的代码，而第 4 行执行的是适合 LinkedList 输出的代码。即，虽然调用的函数一样，但需要根据当时的实参类型选择合适的实现。用户需要编写 IList 类，IList 类只提供 5 个纯虚函数，分别是增、删、查、改和显示函数。但是对面向对象的基础而言（对 C++ 而言就是公有继承），重要的是公有函数的继承。
程序设计二（面向对象）_实训13_虚函数实验答案补充
最新发布
qq_65628600的博客
09-24 2359
建立一个继承体系。 是基类， 和 是派生类。 提供 5 个函数，分别是增删查改显。其中，前 4 个是纯虚函数，第 5 个是虚函数。用户需在 和 中编写实现相应的实现。注意一条：在 中无需再实现显示函数。虚函数是 C++ 实现动态绑定的关键。所谓动态绑定，如下： 从语法上看， 只是一个指向 类型的指针。但是，在第 2、3 行代码中， 实际上指向了一个 对象。此时通过 调用了 成员函数。那么，此时调用的是 类的函数还是 类的 函数呢？这取决于是否为虚函数。如
18.1C++ 多态的应用
人类工程师的博客
11-23 510
#include<iostream> using namespace std; class Animal { private: public: virtual void eat(void){cout<<"eat"<<endl;} }; class Mankind:public Animal { private: public: void eat(void){cout<<"eat rice"<<endl;} }; class Do.
C++面向对象特性——多态
CLZHIT的博客
12-27 744
多态性（ polymorphism ）是面向对象设计语言的基本特征之一。仅仅是将数据和函数捆绑在一起，进行类的封装，使用一些简单的继承，还不能算是真正应用了面向对象的设计思想。多态性是面向对象的精髓。多态性可以简单地概括为“一个接口，多种方法”。通常是指对于同一个消息、同一种调用，在不同的场合，不同的情况下，执行不同的行为。虚函数就是在基类中被声明为virtual，并在一个或多个派生类中被重新定义的成员函数。// 类内部 class 类名 {virtual 返回类型 函数名(参数表) {
C++多态使用(一)
Android系统攻城狮
04-23 549
一、多态 派生类对象的地址可以赋值给基类指针。对于通过基类指针调用基类和派生类中都有的同名、同参数表的虚函数 的语句，编译时并不确定要执行的是基类还是派生类的虚函数； 当程序运行到该语句时，如果基类指针指向的是一个基类对象，则基类的虚函数被调用，如果基类指针指向的是 一个派生类对象，则派生类的虚函数被调用。这种机制就叫作“多态”。 所谓“虚函数”，就是在声明时前面加了 virtua...
C++多态的使用
qq_45279570的博客
01-13 113
多态使用规则 根据实际的对象类型来判断重写函数的调用 如果父类指针指向的是父类对象则调用父类中定义的函数 如果父类指针指向的是子类对象则调用子类中定义的重写函数 多态实例 #include <iostream> using namespace std ; class calArea{ public : virtual double areaCal(){ // this is polomorphic function // depends on child
Branningan, G. (ED.). (1996). The enlightened educator: Research adventures in the schools. New York: McGraw-Hill, 301 pp
06-29
The enlightened educator: Research adventures in the schools. New York: McGraw-Hill, 301 pp Psychology in rhe Schools Volume 33, January 1996 B O O K R E V I E W S GILBERT R. GREDLER ...
Java的面向对象编程教程
09-26
Java的面向对象编程是软件开发中的核心概念，它基于“对象”的思想，使得代码更加模块化，易于理解和维护。在本教程中，我们将深入探讨Java的面向对象特性，包括类、对象、封装、继承和多态性。 1. **类与对象**： ...
Software-Development-Educator-System:特殊教育Web应用（PhpHtmlCssJs）
03-18
"Software-Development-Educator-System" 是一个专为特殊教育设计的Web应用程序，它集成了多种技术，包括PHP、HTML、CSS和JavaScript，旨在提供一个互动且适应特殊教育需求的在线平台。以下是对这些技术及其在Web...
ai_hack_2021:该存储库包含为AI HACK 2021完成的工作
05-05
链接到博客文章： ://techcommunity.microsoft.com/t5/educator-developer-blog/mech-eng-defectors-a-hackathon-story-ai-hack-2021/ba-p/2178670 项目摘要 波士顿住房市场数据集无处不在，但并不完美：存在体积小...
夏普教育家：毕业设计
02-23
2. **面向对象编程（OOP）**：C#是一种面向对象的语言，理解类、对象、接口、抽象类、封装、继承和多态等概念至关重要。在夏普教育家项目中，可能会有专门的数据模型来表示学生、教师、课程等实体。 3. **.NET ...
C++ —面向对象之多态的实现与应用
阿亮的博客
04-05 1738
多态 今天我们的主角就是多态了，那么什么多态呢？多态有什么用？ 多态性可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程 领域的核心概念。当多态应用形参类型的时候，可以接受更多的类型。当多态用于返回值类型的时候，可 可以返回更多类型的数据。多态可以让你的代码拥
c++多态之动态多态及应用
weixin_54509036的博客
10-07 262
c++中的动态多态介绍及应用 1.多态的基本概念 **多态是c++面向对象的三大特性之一，那么什么是多态呢？**多态分为两类：静态多态和动态多态 1.1 静态多态 静态动态：函数重载和运算符重载，复用函数名 1.2 动态多态 动态多态：派生类和虚函数实现运行时多态 让我们用代码来演示： #include <iostream> using namespace std; //动态多态的满足关系： //1 有继承关系 //2 子类重写父类中的虚函数 virtual class Animal { pub
c++纯虚函数、多态的应用
weixin_43419612的博客
09-02 949
C++多态(父类指针指向子类对象) 1.多态定义： 基类指针指向基类对象时就使用基类的成员（包括成员函数和成员变量），指向派生类对象时就使用派生类的成员。换句话说，基类指针可以按照基类的方式来做事，也可以按照派生类的方式来做事，它有多种形态，或者说有多种表现方式，我们将这种现象称为多态（Polymorphism）。 2.构成多态的条件： 1.调用函数的对象必须是指针或者引用。 2.被调用的函数必须是虚函数，且完成了虚函数的重写。 3.小游戏 英雄、怪兽、武器的定义： //定义一个英雄类
C++面向对象 多态
zy1872071381的博客
08-25 667
C++面向对象 多态
C++中的虚函数（一）
青青的专栏--C/C++ OOA/D Design Pattern
04-28 559
C++中的虚函数（一） 作者：aber    虽然很难找到一本不讨论多态性的C++书籍或杂志，但是，大多数这类讨论使多态性和C++虚函数的使用看起来很难。我打算在这篇文章中通过从几个方面和结合一些例子使读者理解在C++中的虚函数实现技术。说明一点，写这篇文章只是想和大家交流学习经验因为本人学识浅薄，难免有一些错误和不足，希望大家批评和指正，在此深表感谢！
多态与虚函数编程题 #1（C++程序设计第6周）
NodYoung
12-22 2889
问题描述 下面程序的输出结果是：A::FunC::Do请填空：#include <iostream> using namespace std; class A { private: int nVal; public: void Fun() { cout << "A::Fun" << endl; } void Do()
程序设计二（面向对象）_实训13_虚函数
Junds0的博客
12-12 6968
已有List类，以及其2个派生类ArrayList和LinkedList。为其编写一个IList类。IList类在逻辑上为这个继承体系提供一个接口。建立一个继承体系，List是基类，ArrayList和LinkedList是其派生类。做一个流输出运算符重载，其第二个参数是List的常引用类型。List是基类，ArrayList和LinkedList是派生类。List提供5个函数，分别是增删查改显。其中，前4个是纯虚函数，第5个是虚函数。用户需在ArrayList和LinkedList中编写实现相应的实现。
从列表中找到所有不以a开头，并以or结尾的单词 zhiye_list=[ ' scholar' , 'translator' , 'actor ' , ' cooker' , ' banker ' , ' educator ' ] new=_____(4)_ for zhiye in zhiye_list: if zhiye[0]=='a': ____ if_____(6)____== 'or ': new.____(7)____(0,zhiye) print('符合条件的单词有:{}'.format(' , '.join(new) ))
06-11
zhiye_list = ['scholar', 'translator', 'actor', 'cooker', 'banker', 'educator'] new = [] for zhiye in zhiye_list: if zhiye[0] == 'a': continue if zhiye.endswith('or'): new.append(zhiye) print('...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值