（面向对象）_实训13_虚函数

已于 2024-05-08 00:18:30 修改
阅读量488 收藏 7
点赞数 17
文章标签： 开发语言 c++
于 2023-05-27 17:54:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y_1215/article/details/130903983
版权

第一关

#include "ArrayList.h"
#include<string.h>


ArrayList::~ArrayList() {
    //delete data;
}
ArrayList::ArrayList() { size = 0; capacity = 0; data = new int; }
ArrayList::ArrayList(const ArrayList& rhs) { memcpy(data, rhs.data, 4 * sizeof(rhs.data)); size = rhs.size; capacity = rhs.capacity; }
ArrayList::ArrayList(int const a[], int n)
{
    int i = 0;
    while (i < n)
    {
        data[i] = a[i];
        i++;
    }
    size = n;
}
ArrayList::ArrayList(int n, int value)
{
    size = n;
    int i = 0;
    while (i < n)
    {
        *data++ = value;
    }
}
void ArrayList::insert(int pos, int value) {
   
    int i = pos;
    while (i < size)
    {
        data[i + 1] = data[i];
        i++;
    }
    data[pos] = value;
    size++;
}

void ArrayList::remove(int pos) {
    int i = pos;
    while (i < (size - 1))
    {
        data[i] = data[i + 1];
        i++;
    }
    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;
#include<string.h>

void LinkedList::disp(ostream& os)const {
    Node* pointer = head->next;
    int i = 0;
    while (i++ < size)
    {
        cout << pointer->data << " ";
        pointer = pointer->next;
    }
    cout<<endl;
}
LinkedList::LinkedList()
{
    size = 0;
    head = new Node;
    head->next = NULL;

}
//拷贝构造函数，构造一个逻辑上与参数内容相同的链表
LinkedList::LinkedList(const LinkedList& rhs)
{
    head = new Node;
    head->next = NULL;

    size = rhs.size;
    Node* pointer1 = head;           //让指针一号指到当前链表的头
    Node* pointer2 = rhs.head->next;//让指针二号指到  引用链表的头中的next指针所指到的下一个节点

    while (pointer2)
    {
        pointer1->next = new Node;//先给他开空间，开了空间再指向他，准备给他安东西
        pointer1 = pointer1->next;

        pointer1->data = pointer2->data;
        pointer1->next = NULL;//不要让结点里的next指针为空
        pointer2 = pointer2->next;//让指针二号移位到下一个结点去

    }
}
//    //原生数组构造函数，构造一个内容与给定数组相同的链表
LinkedList::LinkedList(int const a[], int n)
{
    head = new Node;
    head->next = NULL;

    size = n;
    Node* pointer = head;
    for (int i = 0; i < n; i++)
    {
        pointer->next = new Node;
        pointer = pointer->next;
        pointer->data = a[i];
        pointer->next = NULL;//不要让结点里的next指针为空
    }
}
//    //填充构造函数，构造一个内容为n个value的链表
LinkedList::LinkedList(int n, int value)
{
    size = n;
    head = new Node;
    head->next = NULL;

    Node* toolman = head;

    for (int i = 0; i < n; i++)
    {
        toolman->next = new Node;
        toolman = toolman->next;

        toolman->data = value;
        toolman->next = NULL;
    }

}
LinkedList::~LinkedList()
{
    Node* toolman1 = head;
    Node* toolman2 = head;

    while (toolman1->next)
    {
        toolman2 = toolman1->next;
        delete toolman1;
        toolman1 = toolman2;
    }
    head = NULL;
    delete toolman1;
    toolman1 = NULL;
    toolman2 = NULL;
}








void LinkedList::insert(int pos, int value) {
    Node* pointer1 = head;//首先要知道pos代表第几个节点

    int i = 0;
    while (i++ < pos) {
        pointer1 = pointer1->next;
    }//结束后pointer1指向的是pos位置的结点
    Node *newnode=new Node;
    newnode->data = value;
    newnode->next = new Node;
    newnode->next = pointer1->next;
    pointer1->next = newnode;
    size++;
}

void LinkedList::remove(int pos) {
    Node* pointer = head;
    int i = 0;
    while (i < pos )
    {
        pointer = pointer->next;
        i++;
    }
    pointer->next = pointer->next->next;
    size--;
}

int LinkedList::at(int pos)const {
    Node* pointer = head;
    int i = -1;
    while (i < pos)
    {
        pointer = pointer->next;
        i++;
    }
    return pointer->data;
}


void LinkedList::modify(int pos, int newValue) {
    Node* pointer = head;
    int i = -1;
    while (i < pos)
    {
        pointer = pointer->next;
        i++;
    }
    pointer->data = newValue
    ;
}

第二关

/****************start from here**********************/
/****************start from here**********************/
#include "ArrayList.h"
#include<string.h>
#include<iostream>
using namespace std;

/****************start from here**********************/
using std::ostream;
ostream& operator << (ostream&os, const ArrayList&rhs){
    rhs.disp(os);
    return os;
}

ArrayList::~ArrayList() {
    //delete data;
}
ArrayList::ArrayList() { size = 0; capacity = 0; data = new int; }
ArrayList::ArrayList(const ArrayList& rhs) { memcpy(data, rhs.data, 4 * sizeof(rhs.data)); size = rhs.size; capacity = rhs.capacity; }
ArrayList::ArrayList(int const a[], int n)
{
    int i = 0;
    while (i < n)
    {
        data[i] = a[i];
        i++;
    }
    size = n;
}
ArrayList::ArrayList(int n, int value)
{
    size = n;
    int i = 0;
    while (i < n)
    {
        *data++ = value;
    }
}
void ArrayList::insert(int pos, int value) {
   
    int i = pos;
    while (i < size)
    {
        data[i + 1] = data[i];
        i++;
    }
    data[pos] = value;
    size++;
}

void ArrayList::remove(int pos) {
    int i = pos;
    while (i < (size - 1))
    {
        data[i] = data[i + 1];
        i++;
    }
    size--;
}

int  ArrayList::at(int pos)const {
    return data[pos];
}

void ArrayList::modify(int pos, int newValue) {
    data[pos] = newValue;
}
/****************start from here**********************/
/****************start from here**********************/
#include "LinkedList.h"
#include<iostream>
using namespace std;
#include<string.h>
/****************start from here**********************/
using std::ostream;

using namespace std;

ostream& operator << (ostream&os, const LinkedList&rhs){
    rhs.disp(os);
    return os;
}




void LinkedList::disp(ostream& os)const {
    Node* pointer = head->next;
    int i = 0;
    while (i++ < size)
    {
        cout << pointer->data << " ";
        pointer = pointer->next;
    }
   
}
LinkedList::LinkedList()
{
    size = 0;
    head = new Node;
    head->next = NULL;

}
//拷贝构造函数，构造一个逻辑上与参数内容相同的链表
LinkedList::LinkedList(const LinkedList& rhs)
{
    head = new Node;
    head->next = NULL;

    size = rhs.size;
    Node* pointer1 = head;           //让指针一号指到当前链表的头
    Node* pointer2 = rhs.head->next;//让指针二号指到  引用链表的头中的next指针所指到的下一个节点

    while (pointer2)
    {
        pointer1->next = new Node;//先给他开空间，开了空间再指向他，准备给他安东西
        pointer1 = pointer1->next;

        pointer1->data = pointer2->data;
        pointer1->next = NULL;//不要让结点里的next指针为空
        pointer2 = pointer2->next;//让指针二号移位到下一个结点去

    }
}
//    //原生数组构造函数，构造一个内容与给定数组相同的链表
LinkedList::LinkedList(int const a[], int n)
{
    head = new Node;
    head->next = NULL;

    size = n;
    Node* pointer = head;
    for (int i = 0; i < n; i++)
    {
        pointer->next = new Node;
        pointer = pointer->next;
        pointer->data = a[i];
        pointer->next = NULL;//不要让结点里的next指针为空
    }
}
//    //填充构造函数，构造一个内容为n个value的链表
LinkedList::LinkedList(int n, int value)
{
    size = n;
    head = new Node;
    head->next = NULL;

    Node* toolman = head;

    for (int i = 0; i < n; i++)
    {
        toolman->next = new Node;
        toolman = toolman->next;

        toolman->data = value;
        toolman->next = NULL;
    }

}
LinkedList::~LinkedList()
{
    Node* toolman1 = head;
    Node* toolman2 = head;

    while (toolman1->next)
    {
        toolman2 = toolman1->next;
        delete toolman1;
        toolman1 = toolman2;
    }
    head = NULL;
    delete toolman1;
    toolman1 = NULL;
    toolman2 = NULL;
}


void LinkedList::insert(int pos, int value) {
    Node* pointer1 = head;//首先要知道pos代表第几个节点

    int i = 0;
    while (i++ < pos) {
        pointer1 = pointer1->next;
    }//结束后pointer1指向的是pos位置的结点
    Node *newnode=new Node;
    newnode->data = value;
    newnode->next = new Node;
    newnode->next = pointer1->next;
    pointer1->next = newnode;
    size++;
}

void LinkedList::remove(int pos) {
    Node* pointer = head;
    int i = 0;
    while (i < pos )
    {
        pointer = pointer->next;
        i++;
    }
    pointer->next = pointer->next->next;
    size--;
}

int LinkedList::at(int pos)const {
    Node* pointer = head;
    int i = -1;
    while (i < pos)
    {
        pointer = pointer->next;
        i++;
    }
    return pointer->data;
}


void LinkedList::modify(int pos, int newValue) {
    Node* pointer = head;
    int i = -1;
    while (i < pos)
    {
        pointer = pointer->next;
        i++;
    }
    pointer->data = newValue
    ;
}




#ifndef _LIST_H_
#define _LIST_H_

#include <iostream>
using namespace std;
using std::ostream;



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 = size; i < n; ++i) {
            os << at(i) << " ";//注意，这里at函数并没有实现
                           //但不妨碍这么写
        }
        
    }
    
    /*ÄãµÄ¹¤×÷ÔÚÕâÀ´Ë´¦Éè¼Ædispº¯Êý*/
};

#endif // _LIST_H_

第三关

#ifndef _ILIST_H_
#define _ILIST_H_
#include<iostream>
#include<string.h>
using namespace std;
using std::ostream;

/****************start from here**********************/

// IList类只提供5个纯虚函数，分别是增、删、查、改和显示函数。
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;
};

#endif

点个赞，直接带走，不客气！

哈哈哈哈，知道大家都为啥来到这，我牛志伟接各种东西  qq+3640456339

学弟学妹们没事可以来我博客主页看看，有啥问题都可私信我。

Y_3_7
关注
  • 17
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
程序设计二（面向对象）_实训13_虚函数
Junds0的博客
12-12 6576
已有List类，以及其2个派生类ArrayList和LinkedList。为其编写一个IList类。IList类在逻辑上为这个继承体系提供一个接口。建立一个继承体系，List是基类，ArrayList和LinkedList是其派生类。做一个流输出运算符重载，其第二个参数是List的常引用类型。List是基类，ArrayList和LinkedList是派生类。List提供5个函数，分别是增删查改显。其中，前4个是纯虚函数，第5个是虚函数。用户需在ArrayList和LinkedList中编写实现相应的实现。
面向对象C++（13）纯虚函数
qq_45772415的博客
04-24 1071
纯虚函数 定义格式： virtual <类型> （函数名）（参数表）=0； 后面多一个"=0",不是表明返回值为0，声明为纯虚函数后，不需要函数体。不具备函数功能，不能被调用。 纯虚函数的作用：为派生类保留一个函数名，便于后面的派生类根据自己的需要重新定义功能。 抽象类的概念 抽象类具体类的概念 如果一个类至少有一个纯虚函数，就称该类为抽象类。能够 建立实例化对象的类称为具体类，也即是...
头歌程序设计二（面向对象）_实训13_虚函数
热门推荐
qq_65628600的博客
07-06 1万+
头歌程序设计二（面向对象）_实训13_虚函数
Educator:程序设计二（C++面向对象）_实训13_虚函数
iceslime的博客
05-21 455
因此有一个“丧心病狂”的想法，基类中只有公有函数，没有数据！很自然的，因为没有数据，因此函数也无法给出定义。因此，这种基类中实际上只有公有函数的声明。这就是接口继承，因为基类中只有接口。但是对面向对象的基础而言（对 C++ 而言就是公有继承），重要的是公有函数的继承。只有在公有函数可以继承的情况下，才能采用公有继承。即，虽然调用的函数一样，但需要根据当时的实参类型选择合适的实现。其中，前 4 个是纯虚函数，第 5 个是虚函数。这上面的调用显然都是合法的。因此在做继承的时候，子类同时继承了父类的数据和函数。
程序设计二（面向对象）_实训13_虚函数实验答案补充2
qq_65628600的博客
09-24 1701
建立一个继承体系，List是基类，ArrayList和LinkedList是其派生类。并且编写实现下述函数并达到如下效果。做一个流输出运算符重载，其第二个参数是List的常引用类型。我们知道子类的对象天生可以作为父类类型使用，因此这上面的调用显然都是合法的。但是现在要求实现如下效果：第 3 行的函数执行的是适合ArrayList输出的代码，而第 4 行执行的是适合LinkedList输出的代码。即，虽然调用的函数一样，但需要根据当时的实参类型选择合适的实现。相当于对非成员函数做到动态绑定。
【C++学习笔记】面向对象程序设计——虚函数和多态
weixin_46062098的博客
05-05 269
虚函数 (virtual) OOP (Object Oriented Programming) 的核心思想是多态性 (Polymorphism)。 通常情况下，如果我们不使用某个函数，则无须为该函数提供定义，但是我们必须为每一个虚函数都提供定义，而不管它是否被用到了，这是因为连编译器也无法确认到底会使用哪个虚函数。 因为有时候看似是代码中只有基类的引用或者指针调用了一个虚函数，但是在运行中如果实参是派生类的引用或指针，那么其实调用的是派生类的虚函数，所以在派生类中不但要在声明中覆盖 (override)
程序设计二（面向对象）_实训13_虚函数实验答案补充
qq_65628600的博客
09-24 1873
建立一个继承体系。 是基类， 和 是派生类。 提供 5 个函数，分别是增删查改显。其中，前 4 个是纯虚函数，第 5 个是虚函数。用户需在 和 中编写实现相应的实现。注意一条：在 中无需再实现显示函数。虚函数是 C++ 实现动态绑定的关键。所谓动态绑定，如下： 从语法上看， 只是一个指向 类型的指针。但是，在第 2、3 行代码中， 实际上指向了一个 对象。此时通过 调用了 成员函数。那么，此时调用的是 类的函数还是 类的 函数呢？这取决于是否为虚函数。如
Lesson_面向对象继承，多态，接口_实训
07-10
Lesson_面向对象继承，多态，接口_实训
面向对象程序设计(C++)实训
06-09
适用于大一程序猿们的C++期末实训
面向对象编程基础_python面向对象_python教程_
09-29
python强大的面向对象能力，让你更好的理解python核心语法
mianxiangduixiang.zip_c 面向对象_visual c
09-24
面向对象练习题，巩固面向对象知识，适合初学者
oopc.rar_C语言_C语言面向对象_c语言 面向对象_oopc_面向对象
09-23
c语言是面向过程的程序语言，可是用它也能实现面向对象，该代码给出实现面向对象的c源码
开发语言Java+前端框架Vue+后端框架SpringBoot开发的ADR药物不良反应监测系统源码 系统有哪些优势？
最新发布
zmm201453的博客
05-30 920
ADR药物不良反应监测系统具有提高监测效率与准确性、实时预警与快速响应、数据整合与分析能力强、降低用药风险与保障患者安全、促进临床合理用药、支持药品监管决策、提升医疗质量和安全水平以及易于扩展与集成等优势。这些优势使得ADR监测系统在现代医疗领域中发挥着越来越重要的作用。
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 847
string类各函数接口。
C语言在头⽂件中#if、_STDC_等字⾏起什么作⽤？
PAP
05-26 421
C语言——在头⽂件中#if、_STDC_等字⾏起什么作⽤？
C语言之指针进阶（3），函数指针
x_p96484685433的博客
05-25 1373
本文主要讲述C语言指针中的函数指针，包括函数指针变量的概念、创建及使用。两段特殊代码的理解，typedef关键字的使用，以及函数指针数组的使用，最后还有一个代码案例--计算器的实现。希望对大家有所帮助。
C-数据结构-树状存储的基本实现
aqiangdeba的博客
05-27 975
main.c320。
【如何利用c++RAII技术实现自动加解锁】
逆风飞翔的博客
05-28 346
使用C++中的 RAII（资源获取即初始化）技术来实现自动加锁解锁
头歌实训作业答案c++数组实训
12-04
很抱歉，作为一个AI服务助手，我不能提供或者介绍任何形式的作业答案，因为这违反了学术诚信的原则。但是，我可以为您提供一些关于C++数组实训的基本知识和思路，帮助您更好地完成作业。 C++数组是一种存储相同类型数据的集合，可以通过下标访问数组中的元素。在头歌实训作业中，您需要使用数组来实现朋友圈点赞功能。具体实现思路如下： 1.首先，您需要定义一个数组来存储每个朋友圈的点赞数。数组的大小应该与朋友圈的数量相同。 2.然后，您需要使用循环结构来读取每个朋友圈的点赞数，并将其存储到数组中。 3.接下来，您需要使用循环结构来遍历数组，找到点赞数最多的朋友圈，并输出其编号和点赞数。 下面是一个简单的C++代码示例，用于实现上述思路： ```cpp #include <iostream> using namespace std; int main() { const int N = 5; // 朋友圈数量 int likes[N]; // 存储点赞数的数组 // 读取每个朋友圈的点赞数 for (int i = 0; i < N; i++) { cout << "请输入第" << i+1 << "个朋友圈的点赞数："; cin >> likes[i]; } // 找到点赞数最多的朋友圈 int maxIndex = 0; for (int i = 1; i < N; i++) { if (likes[i] > likes[maxIndex]) { maxIndex = i; } } // 输出点赞数最多的朋友圈的编号和点赞数 cout << "点赞数最多的朋友圈是第" << maxIndex+1 << "个朋友圈，点赞数为" << likes[maxIndex] << endl; return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值