C++编程题继承与多态

于 2024-10-07 01:00:00 发布
阅读量1.5k 收藏 41
点赞数 36
分类专栏： 学编程 文章标签： c++ 开发语言 课程设计 windows c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/workflower/article/details/142722593
版权

采用纯虚函数实现多态性来建立通用的双向链表派生类。

解：

#include<iostream>

using namespace std;

//首先看结点组织，采用结点类加数据类

class Object{//数据类为抽象类

public:

        Object(){}

        virtual bool operator>(Object &)=0;//纯虚函数,参数必须为引用或指针

        virtual bool operator!=(Object &)=0;//纯虚函数,参数必须为引用或指针

        virtual void Print()=0;//纯虚函数

        virtual ~Object(){} //析构函数可为虚函数，构造函数不行

};

class DblNode{

        Object* info;     //数据域用指针指向数据类对象

        DblNode *llink,*rlink;    //前驱（左链）、后继（右链）指针

public:

        DblNode(); //生成头结点的构造函数

    ~DblNode();

        void Linkinfo(Object* obj);

        friend class DblList;

        //以DblList为友元类，DblList可直接访问DblNode的私有函数，与结构一样方便，但更安全

};

DblNode::DblNode(){info=NULL;llink=rlink=NULL;}

DblNode::~DblNode(){

        cout<<"删除结点类"<<'\t';

        delete info;     //释放数据域

}

void DblNode::Linkinfo(Object * obj){info=obj;}

//再定义双链表类，选择常用操作

class DblList{

        DblNode *head,*current;

public:

        DblList();//构造函数，生成头结点(空链表)

        ~DblList();//析构函数

        void MakeEmpty();//清空链表，只余表头结点

        void InsertFront(DblNode* p);      //可用来向前生成链表，在表头插入一个结点

        void InsertRear(DblNode* p);       //可用来向后生成链表，在表尾添加一个结点

        void InsertOrder(DblNode* p);  //按升序生成链表

        DblNode* CreatNode();//创建一个结点(孤立结点)

        DblNode* DeleteNode(DblNode* p);        //删除指定结点

        void PrintList();//打印链表的数据域

        int Length();//计算链表长度

        DblNode *Find(Object & obj);//搜索数据域与定值相同的结点，返回该结点的地址

        //其它操作

};

DblList::DblList(){//建立表头结点

        head=new DblNode();

        head->rlink=head->llink=head;

        current=NULL;

}

DblList::~DblList(){

        MakeEmpty();//清空链表

        cout<<"删除头结点:";

        delete head;

}

void DblList::MakeEmpty(){

        DblNode *tempP;

        while(head->rlink!=head){

                tempP=head->rlink;

                head->rlink=tempP->rlink;//把头结点后的第一个节点从链中脱离

                tempP->rlink->llink=head;//处理左指针

                delete tempP;           //删除(释放)脱离下来的结点

        }

        current=NULL;  //current指针恢复

}

void DblList::InsertFront(DblNode *p){

        p->llink=head;//注意次序

        p->rlink=head->rlink;

        head->rlink->llink=p;

        head->rlink=p;//最后做

}

void DblList::InsertRear(DblNode *p){

        p->rlink=head;//注意次序

        p->llink=head->llink;

        head->llink->rlink=p;

        head->llink=p;//最后做

}

void DblList::InsertOrder(DblNode* p){

        if(head==head->llink) {

                p->llink=head;//注意次序

                p->rlink=head->rlink;

                head->rlink->llink=p;

                head->rlink=p;//最后做

        }

        else{

                current=head->rlink;

                while(current!=head){

                        if(*current->info>*p->info) break; //找第一个比插入结点大的结点

                        current=current->rlink;

                }

                p->rlink=current;//注意次序

                p->llink=current->llink;

                current->llink->rlink=p;

                current->llink=p;//最后做

        }

}

DblNode* DblList::CreatNode(){//建立新节点

        current=new DblNode();

        return current;

}

DblNode* DblList::DeleteNode(DblNode* p){

        current=head->rlink;

        while(current!=head&&current!=p) current=current->rlink;

        if(current==head) current=NULL;

        else{//结点摘下

                p->llink->rlink=p->rlink;

                p->rlink->llink=p->llink;

                p->rlink=p->llink=NULL;

        }

        return current;

}

DblNode* DblList::Find(Object & obj){//对抽象类只能用“引用”

        current=head->rlink;

        while(current!=head&&*current->info!=obj) current=current->rlink;

        if(current==head) current=NULL;

        return current;//搜索成功返回该结点地址，不成功返回NULL

}

void DblList::PrintList(){

        current=head->rlink;

        while(current!=head){

                current->info->Print();

                current=current->rlink;

        }

        cout<<endl;

}

DblList::Length(){

        int count=0;

        current=head->rlink;

        while(current!=head){

                count++;

                current=current->rlink;

        }

        return count;

}

//ep8_9.cpp

#include "ep8_9.h"

#include<string>

using namespace std;

class StringObject:public Object{

        string sptr;

public:

        StringObject();

        StringObject(string);

        ~StringObject();

        bool StringObject::operator>(Object & obj);//虚函数

        bool StringObject::operator!=(Object & obj);//虚函数

        void Print();

};

StringObject::StringObject(){sptr="";}

StringObject::StringObject(string s){sptr=s;}

StringObject::~StringObject(){cout<<"删除字符串类"<<endl;}

bool StringObject::operator>(Object & obj){//虚函数

        StringObject & temp=(StringObject &)obj;//必须转换

        return sptr>temp.sptr;

}

bool StringObject::operator!=(Object & obj){//虚函数

        StringObject & temp=(StringObject &)obj;//必须转换

        return sptr!=temp.sptr;

}

void StringObject::Print(){cout<<sptr<<'\t';}//虚函数

int main(){

        DblNode * P1;

        StringObject* p;

        DblList list1,list2,list3;

        char *a[5]={"dog","cat","bear","sheep","ox"},*sp="cat";

        int i;

        for(i=0;i<5;i++){

                p=new StringObject(a[i]);//建立数据对象

                P1=list1.CreatNode();//建立结点

                P1->Linkinfo(p);//数据对象连接到结点

                list1.InsertFront(P1);//向前生成list1

                p=new StringObject(a[i]);

                P1=list2.CreatNode();

                P1->Linkinfo(p);

                list2.InsertRear(P1);//向后生成list2

        }

        list1.PrintList();

        cout<<"list1长度："<<list1.Length()<<endl;

        list2.PrintList();

        cout<<"要求删除的字符串\"cat\""<<endl;

        p=new StringObject(sp);//为了程序的通用性只能多一次转换

        P1=list1.Find(*p);

        delete p;

        if(P1!=NULL){

                cout<<"删除cat:"<<endl;

                P1=list1.DeleteNode(P1);

                delete P1;

                list1.PrintList();

                cout<<"list1长度："<<list1.Length()<<endl;

        }

        else cout<<"未找到"<<endl;

        cout<<"清空list1:"<<endl;

        list1.MakeEmpty();//清空list1

        list1.PrintList();

        for(i=0;i<5;i++){

                p=new StringObject(a[i]);

                P1=list3.CreatNode();

                P1->Linkinfo(p);

                list3.InsertOrder(P1);//升序创建list3

        }

        list3.PrintList();

        cout<<"程序结束："<<endl;

        return 0;

}

矩形法（rectangle）积分近似计算公式为：

被积函数用派生类引入，被积函数定义为纯虚函数。

基类（integer）成员数据包括：积分上下限b和a；分区数n；步长step=(b-a)/n，积分值result。定义积分函数integerate()为虚函数，它只显示提示信息。

派生的矩形法类（rectangle）重定义integerate()，采用矩形法作积分运算。

派生的梯形法类（ladder）和辛普生法（simpson）类似。

请编程，用三种方法对下列被积函数

    1. sin(x)，下限为0.0和上限为π/2；
    2. exp(x)，下限为0.0和上限为1.0；
    3. 4.0/（1+x*x），下限为0.0和上限为1.0。

进行定积分计算，并比较积分精度。

解：使用类参数传递被积函数，因类有数据域，也可以同时传递积分上下限，可由读者进行修改。

#include<iostream>

#include<cmath>

using namespace std;

class Base{

protected:

    double result,a,b,step;//Intevalue积分值，a积分下限，b积分上限

    int n;

public:

        virtual double fun(double x)=0;//被积函数声明为纯虚函数

        virtual void Integerate(){

                cout<<"这里是积分函数"<<endl;

        }

        Base(double ra=0,double rb=0,int nn=2000){

                a=ra;

                b=rb;

                n=nn;

                result=0;

        }

        void Print(){

                cout.precision(15);

                cout<<"积分值="<<result<<endl;

        }

};

class Rectangle:public Base{

public:

        void Integerate(){

                int i;

                step=(b-a)/n;

                for(i=0;i<=n;i++) result+=fun(a+step*i);

                result*=step;

        }

        Rectangle(double ra,double rb,int nn):Base(ra,rb,nn){}

};

class Ladder:public Base{

public:

        void Integerate(){

                int i;

                step=(b-a)/n;

                result=fun(a)+fun(b);

                for(i=1;i<n;i++) result+=2*fun(a+step*i);

                result*=step/2;

        }

        Ladder(double ra,double rb,int nn):Base(ra,rb,nn){}

};

class Simpson:public Base{

public:

        void Integerate(){

                int i;

                step=(b-a)/n;

                result=fun(a)+fun(b);

                for(i=1;i<n;i+=2) result+=4*fun(a+step*i);

                for(i=2;i<n;i+=2) result+=2*fun(a+step*i);

                result*=step/3;

        }

        Simpson(double ra,double rb,int nn):Base(ra,rb,nn){}

};

class sinR:public Rectangle{//矩形法和梯形法采用并列结构

public:

        sinR(double ra,double rb,int nn):Rectangle(ra,rb,nn){}

        double fun(double x){return sin(x);}

};

class sinL:public Ladder{

public:

        sinL(double ra,double rb,int nn):Ladder(ra,rb,nn){}

        double fun(double x){return sin(x);}

};

class expR:public Rectangle{

public:

        expR(double ra,double rb,int nn):Rectangle(ra,rb,nn){}

        double fun(double x){return exp(x);}

};

class expL:public Ladder{

public:

        expL(double ra,double rb,int nn):Ladder(ra,rb,nn){}

        double fun(double x){return exp(x);}

};

class otherR:public Rectangle{

public:

        otherR(double ra,double rb,int nn):Rectangle(ra,rb,nn){}

        double fun(double x){return (4.0/(1+x*x));}

};

class otherL:public Ladder{

public:

        otherL(double ra,double rb,int nn):Ladder(ra,rb,nn){}

        double fun(double x){return (4.0/(1+x*x));}

};

class sinS:public Simpson{//辛普生法采用层次结构

public:

        sinS(double ra,double rb,int nn):Simpson(ra,rb,nn){}

        double fun(double x){return sin(x);}

};

class expS:public sinS{

public:

        expS(double ra,double rb,int nn):sinS(ra,rb,nn){}

        double fun(double x){return exp(x);}

};

class otherS:public expS{

public:

        otherS(double ra,double rb,int nn):expS(ra,rb,nn){}

        double fun(double x){return (4.0/(1+x*x));}

};

int main(){

        Base *bp;

        sinR sr(0.0,3.1415926535/2.0,100);

        bp=&sr;

        bp->Integerate();//动态,可以访问派生类定义的被积函数

        bp->Print();

        sinL sl(0.0,3.1415926535/2.0,100);

        bp=&sl;

        bp->Integerate();//动态,可以访问派生类定义的被积函数

        bp->Print();

        sinS ss(0.0,3.1415926535/2.0,100);

        bp=&ss;

        bp->Integerate();//动态,在层次中选

        bp->Print();

        expR er(0.0,1.0,100);

        bp=&er;

        bp->Integerate();//动态,可以访问派生类定义的被积函数

        bp->Print();

        expL el(0.0,1.0,100);

        bp=&el;

        bp->Integerate();//动态,可以访问派生类定义的被积函数

        bp->Print();

        expS es(0.0,1.0,100);

        bp=&es;

        bp->Integerate();//动态,在层次中选

        bp->Print();

        otherR or(0.0,1.0,100);

        bp=&or;

        bp->Integerate();//动态,可以访问派生类定义的被积函数

        bp->Print();

        otherL ol(0.0,1.0,100);//增加到100000也达不到辛普生法的精度

        bp=&ol;

        bp->Integerate();//动态,可以访问派生类定义的被积函数

        bp->Print();

        otherS os(0.0,1.0,100);

        bp=&os;

        bp->Integerate();//动态,在层次中选

        bp->Print();

        return 0;

}

workflower
关注
专栏目录
CPP.rar_多态 .cpp_继承与多态_继承与多态C++
09-23
标题中的"CPP.rar_多态 .cpp_继承与多态_继承与多态C++"表明这个压缩包文件包含了关于C++编程语言中多态性（Polymorphism）和继承（Inheritance）的概念示例。多态性和继承是面向对象编程（Object-Oriented ...
C++ 面试题常考，封装，继承，多态.zip
01-20
- **STL（Standard Template Library）**：C++的标准模板库包含容器（如vector、list、set等）、算法（如排序、查找等）和迭代器，是C++编程的重要组成部分。 - **异常处理**：C++的异常处理机制用于捕获和处理程序...
C++重点复习题(多态和继承).doc
04-10
本文将对C++重点复习题（多态和继承）进行详细解释，涵盖了编程语言C++的多项重要知识点。 一、编程语言C++的编写步骤 编写C++程序需要经过编辑、编译、连接和运行四个步骤。编辑是将C++源程序输入计算机的过程，...
C++随堂测试（继承、多态、重载）.docx
11-27
本资源摘要信息涵盖了C++编程语言中的重要概念，包括继承、多态和重载。通过本资源，可以了解C++中的继承关系、保护继承、运算符重载、虚函数、多态性等概念，并且可以了解如何在实际编程中应用这些概念。 一、继承...
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 159
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
【C语言】数据类型和变量
2302_76713442的博客
10-06 1007
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 947
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
【C++力扣】917.仅仅反转字母|387.字符串中第一个唯一字符|415.字符串相加
白乐天_ξ( ✿＞◡❛)的博客
10-06 422
本文写的是力扣三道题的解答：917、387、415题，都是与string字符串有关的！
C - Separated Lunch
m0_74304371的博客
10-05 231
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
【C++】类与对象基础概念解析
A Charmer 的博客
10-03 1357
在 C++ 编程中，类与对象是核心概念之一，它们为程序设计提供了一种强大而灵活的方式来组织代码和管理数据。理解类与对象的基础概念对于掌握 C++ 编程至关重要。
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
m0_59237910的博客
10-01 410
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
【C++】STL--vector
2301_78724721的博客
10-03 810
/类模板只能实例化//初始化10个1//遍历i++)//范围for。
【C++打怪之路Lv5】-- 类和对象（下）
Sweeney_001的博客
09-29 1055
类和对象(下)：初始化列表，explicit关键字、static成员、友元、内部类、匿名对象
06.C/C++内存管理
2402_82670467的博客
09-29 1088
在这里C++的内存管理相较于C作出了许多升级，下面我们就来了解一下。我们先来看一下下面的问题，温习一下C的内存分布 在 C/C++中，内存主要分为以下几个部分： 一、栈（Stack） 1. 存储内容： - 局部变量：函数内部声明的非静态变量。 - 函数参数：传递给函数的参数。 - 函数调用信息：如返回地址等。 2. 特点： - 先进后出（LIFO）的数据结构。 - 内存由编译器自动管理，当函数被调用时分配空间，函数返回时自动释放。 - 空间相对较小，通常几兆字节。 二、堆（Heap）
C++的STL标准模版库容器--list类
最新发布
2401_82376751的博客
10-06 748
较为详细得讲述容器list类的各项功能与实现
C++：STL（四）之vector的基本介绍与使用方式|容器接口
白乐天_ξ( ✿＞◡❛)的博客
09-28 1220
本文主要是介绍vector容器以及接口的使用方式，和string类的那一节相似！
第九章---for循环及在STL的应用(vector\map\set\list\for_each)、嵌套while、while 统一输出、do-while
T-ang.的博客
09-29 1441
在C++中，循环语句用于重复执行一段代码，直到指定的条件不再满足。C++ 提供了几种循环机制，下面将详细讲解每种循环语句的用法和特点。
[C++][程序退出]详细讲解
SnowK博客
09-30 3570
[C++][程序退出]详细讲解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值