面向对象程序设计——虚函数和多态性

最新推荐文章于 2023-05-27 17:54:39 发布
最新推荐文章于 2023-05-27 17:54:39 发布
阅读量1.1k 收藏 10
点赞数 4
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TTTSEP9TH2244/article/details/122513901
版权

一、实验目的：

  1. 掌握动态联编的概念；
  2. 掌握虚函数和纯虚函数的使用方法；
  3. 掌握抽象类的使用。

二、实验内容：

在前面实验基础上，完成以下内容：

（1）在基类Account中添加deposit、withdraw、settle这3个函数的声明，且将它们都声明为纯虚函数，通过基类的指针可以调用派生类的相应函数。

（2）将show函数声明为虚函数，通过基类的指针来调用派生类的show函数。

（3）将计算两个日期相差天数的distance函数改为“—”运算符重载函数，使得计算两个日期相差天数更直观，增加程序的可读性。

提示：

储蓄账户一年算一次利息，而信用账户一月算一次利息。而使用基类指针来调用settle函数时，事先并不知道该指针所指向对象的具体类型，无法决定采用何种方式调用settle函数，因此只能将二者允许接收的参数统一为每月1日。同时对储蓄账户的settle函数进行修改，使它在结算利息之前先判断是否为1月，只有参数所给的日期是1月时才进行结算。

Main.cpp:

#include<iostream>
#include "account.h"
using namespace std;
Account::Account(int Id,double Balance)
{
    id=Id;
    balance=Balance;
}
void Account::show()
{
    cout<<"\t账号:"<<getId()<<"\t\t余额:"<<getBalance()<<"元"<<endl;
}
void Account::getTotal()
{
    cout<<"\t所有账户总金额:"<<total<<"元"<<endl;
}
SavingsAccount::SavingsAccount(int year,int month,int day,int id,double balance,double Rate):Account(id,balance),lastDate(year,month,day)
{
    rate=Rate;
    cout<<year<<"年"<<month<<"月"<<day<<"日";
    cout<<"\tID为"<<id<<"的账户已创建成功!"<<endl;
}
const double SavingsAccount::accumulate(Date date)
{
    return (lastDate-date)*balance;
}
void SavingsAccount::deposit(Date date,double amount)
{
    accumulation+=accumulate(date);
    balance+=amount;
    lastDate = date;
    total+=amount;
    cout<<date.getYear()<<"年"<<date.getMonth()<<"月"<<date.getDay()<<"日";
    cout<<"\t账户"<<id<<"存入:"<<amount<<"元"<<"\t\t账户"<<id<<"余额:"<<balance<<"元"<<endl;
}
void SavingsAccount::withdraw(Date date,double amount)
{
    accumulation+=accumulate(date);
    balance-=amount;
    lastDate = date;
    total-=amount;
    cout<<date.getYear()<<"年"<<date.getMonth()<<"月"<<date.getDay()<<"日";
    cout<<"\t账户"<<id<<"取出:"<<amount<<"元"<<"\t\t账户"<<id<<"余额:"<<balance<<"元"<<endl;
}
void SavingsAccount::settle(Date date)
{
    double settle = 0;
    if(date.getYear()>lastDate.getYear())
    {
        for(int i=1;i<=date.getYear()-lastDate.getYear();i++)
        {
            accumulation+=accumulate(date);
            settle = accumulation/356*rate;
        }
    }
    cout<<date.getYear()<<"年"<<date.getMonth()<<"月"<<date.getDay()<<"日";
    cout<<"\t账户"<<id<<"结算利息:"<<settle<<"元"<<endl;
    deposit(date,settle);
}
void SavingsAccount::show()
{
    Account::show();
}
CreditAccount::CreditAccount(int year,int month,int day,int id,double balance,double Credit,double Rate,double Fee): Account(id,balance),lastDate(year,month,day)
{
    credit=Credit;
    fee=Fee;
    rate=Rate;
    cout<<year<<"年"<<month<<"月"<<day<<"日";
    cout<<"\tID为"<<id<<"的账户已创建成功!"<<endl;
}
double CreditAccount::getDebt(Date date)
{
    settle(date);
    return balance;
}
void CreditAccount::deposit(Date date,double amount)
{
    settle(date);
    if(credit<=0 || amount>credit)
    {
        date.show();
        cout<<"\t账户"<<id<<"\t信用卡可用额度不足!"<<endl;
    }
    else
    {
        balance-=amount;
        credit-=amount;
        date.show();
        cout<<"\t账户"<<id<<"\t信用卡已用额度:"<<amount<<"元"<<"\t信用卡剩余额度:"<<credit<<"元"<<endl;
        total-=amount;
    }
}
void CreditAccount::withdraw(Date date,double amount)
{
    settle(date);
    balance+=amount;
    if((credit+amount)<=10000)
    {
        credit=credit+amount;
    }
    else
    {
        credit=10000;
    }
    total+=amount;
    date.show();
    cout<<"\t账户"<<id<<"\t信用卡还款:"<<amount<<"元  "<<"\t信用卡剩余额度:"<<credit<<"元"<<endl;
}
void CreditAccount::settle(Date date)
{
    double settle=0;
    if((date.getMonth()<lastDate.getMonth())||(date.getYear()>lastDate.getYear()))
    {
        for(int i=1;i<=date.getYear()-lastDate.getYear();i++)
        {
            settle+=fee;
        }
    }
    if(date.getDay()==1||date.getMonth()>lastDate.getMonth()||date.getYear()>lastDate.getYear())
    {
        if(date.getYear()==lastDate.getYear())
        {
            for(int j=1;j<=(date.getMonth()-lastDate.getMonth());j++)
            {
                for(int m=1;m<=lastDate-date;m++)
                {
                    settle-=balance*rate;
                }
            }
        }
        else
        {
            for(int j=1;j<=(date.getMonth()-lastDate.getMonth())+12;j++)
            {
                for(int m=1;m<=lastDate-date;m++)
                {
                    settle-=balance*rate;
                }
            }
        }
    }
    else
    {
        settle-=0;
    }
    balance-=settle;
    lastDate=date;
    total-=settle;
}
void CreditAccount::show()
{
    Account::show();
}

Account.h:

#ifndef ACCOUNT_H_
#define ACCOUNT_H_
#include"date.h"
class Account                      
{
protected:
    int id;
    double balance;
    static double total;
public:
    Account(int id, double balance);
    const int getId() {return id;}
    const double getBalance() {return balance;}
    static void getTotal();
    virtual void deposit(Date date,double amount)=0;
    virtual void withdraw(Date date,double amount)=0;
    virtual void settle(Date date)=0;
    virtual void show();
};
class SavingsAccount:public Account    
{
protected:
    double rate;    
    Date lastDate;
    double accumulation=0;
    const double accumulate(Date date);
public:
    SavingsAccount(int year,int month,int day,int id,double balance,double rate);
    void deposit(Date date,double amount);
    void withdraw(Date date,double amount);
    void settle(Date date);
    const double getRate() {return rate;}
    void show();
};
class CreditAccount:public Account
{
protected:
    double credit;
    double rate;
    double fee;
    Date lastDate;
public:
    CreditAccount(int year,int month,int day,int id,double balance,double credit,double rate,double fee);
    double getAvailableCredit() {return credit;}
    void deposit(Date date,double amount);
    void withdraw(Date date,double amount);
    double getDebt(Date date);
    void settle(Date date);
    void show();
};
#endif // ACCOUNT_H_INCLUDED

Account.cpp:

#include<iostream>
#include "account.h"
using namespace std;
Account::Account(int Id,double Balance)
{
    id=Id;
    balance=Balance;
}
void Account::show()
{
    cout<<"\t账号:"<<getId()<<"\t\t余额:"<<getBalance()<<"元"<<endl;
}
void Account::getTotal()
{
    cout<<"\t所有账户总金额:"<<total<<"元"<<endl;
}
SavingsAccount::SavingsAccount(int year,int month,int day,int id,double balance,double Rate):Account(id,balance),lastDate(year,month,day)
{
    rate=Rate;
    cout<<year<<"年"<<month<<"月"<<day<<"日";
    cout<<"\tID为"<<id<<"的账户已创建成功!"<<endl;
}
const double SavingsAccount::accumulate(Date date)
{
    return (lastDate-date)*balance;
}
void SavingsAccount::deposit(Date date,double amount)
{
    accumulation+=accumulate(date);
    balance+=amount;
    lastDate = date;
    total+=amount;
    cout<<date.getYear()<<"年"<<date.getMonth()<<"月"<<date.getDay()<<"日";
    cout<<"\t账户"<<id<<"存入:"<<amount<<"元"<<"\t\t账户"<<id<<"余额:"<<balance<<"元"<<endl;
}
void SavingsAccount::withdraw(Date date,double amount)
{
    accumulation+=accumulate(date);
    balance-=amount;
    lastDate = date;
    total-=amount;
    cout<<date.getYear()<<"年"<<date.getMonth()<<"月"<<date.getDay()<<"日";
    cout<<"\t账户"<<id<<"取出:"<<amount<<"元"<<"\t\t账户"<<id<<"余额:"<<balance<<"元"<<endl;
}
void SavingsAccount::settle(Date date)
{
    double settle = 0;
    if(date.getYear()>lastDate.getYear())
    {
        for(int i=1;i<=date.getYear()-lastDate.getYear();i++)
        {
            accumulation+=accumulate(date);
            settle = accumulation/356*rate;
        }
    }
    cout<<date.getYear()<<"年"<<date.getMonth()<<"月"<<date.getDay()<<"日";
    cout<<"\t账户"<<id<<"结算利息:"<<settle<<"元"<<endl;
    deposit(date,settle);
}
void SavingsAccount::show()
{
    Account::show();
}
CreditAccount::CreditAccount(int year,int month,int day,int id,double balance,double Credit,double Rate,double Fee): Account(id,balance),lastDate(year,month,day)
{
    credit=Credit;
    fee=Fee;
    rate=Rate;
    cout<<year<<"年"<<month<<"月"<<day<<"日";
    cout<<"\tID为"<<id<<"的账户已创建成功!"<<endl;
}
double CreditAccount::getDebt(Date date)
{
    settle(date);
    return balance;
}
void CreditAccount::deposit(Date date,double amount)
{
    settle(date);
    if(credit<=0 || amount>credit)
    {
        date.show();
        cout<<"\t账户"<<id<<"\t信用卡可用额度不足!"<<endl;
    }
    else
    {
        balance-=amount;
        credit-=amount;
        date.show();
        cout<<"\t账户"<<id<<"\t信用卡已用额度:"<<amount<<"元"<<"\t信用卡剩余额度:"<<credit<<"元"<<endl;
        total-=amount;
    }
}
void CreditAccount::withdraw(Date date,double amount)
{
    settle(date);
    balance+=amount;
    if((credit+amount)<=10000)
    {
        credit=credit+amount;
    }
    else
    {
        credit=10000;
    }
    total+=amount;
    date.show();
    cout<<"\t账户"<<id<<"\t信用卡还款:"<<amount<<"元  "<<"\t信用卡剩余额度:"<<credit<<"元"<<endl;
}
void CreditAccount::settle(Date date)
{
    double settle=0;
    if((date.getMonth()<lastDate.getMonth())||(date.getYear()>lastDate.getYear()))
    {
        for(int i=1;i<=date.getYear()-lastDate.getYear();i++)
        {
            settle+=fee;
        }
    }
    if(date.getDay()==1||date.getMonth()>lastDate.getMonth()||date.getYear()>lastDate.getYear())
    {
        if(date.getYear()==lastDate.getYear())
        {
            for(int j=1;j<=(date.getMonth()-lastDate.getMonth());j++)
            {
                for(int m=1;m<=lastDate-date;m++)
                {
                    settle-=balance*rate;
                }
            }
        }
        else
        {
            for(int j=1;j<=(date.getMonth()-lastDate.getMonth())+12;j++)
            {
                for(int m=1;m<=lastDate-date;m++)
                {
                    settle-=balance*rate;
                }
            }
        }
    }
    else
    {
        settle-=0;
    }
    balance-=settle;
    lastDate=date;
    total-=settle;
}
void CreditAccount::show()
{
    Account::show();
}

Date.h:

#ifndef DATE_H_INCLUDED
#define DATE_H_INCLUDED
class  Date
{
    int  year, month, day;
    int  totalDays;
public:
    Date(int year, int month, int day);
    int  getYear() const { return year; }
    int  getMonth() const { return month; }
    int  getDay() const { return day; }
    void  show() const;
    bool  isLeapYear(int year) const;
    int operator-(const Date &date) const {return date.totalDays-totalDays;}
};
#endif // DATE_H_INCLUDED

Date.cpp:

#include<iostream>
#include "date.h"
using namespace std;
Date::Date(int Year, int Month, int Day)
{
    year=Year;
    month=Month;
    day=Day;
    int Days=0;
    for(int i=0;i<year;i++)
    {
        if(isLeapYear(i)==true)
            Days=Days+366;
        else
            Days=Days+365;
    }
    switch(month){
    case 1:Days+=0;break;
    case 2:Days+=31;break;
    case 3:Days+=59;break;
    case 4:Days+=90;break;
    case 5:Days+=120;break;
    case 6:Days+=151;break;
    case 7:Days+=181;break;
    case 8:Days+=212;break;
    case 9:Days+=243;break;
    case 10:Days+=273;break;
    case 11:Days+=304;break;
    case 12:Days+=334;break;
    default:cout<<"month error!"<<endl;
    }
    totalDays=Days+day;
}
void  Date::show() const
{
    cout<<getYear()<<"年"<<getMonth()<<"月"<<getDay()<<"日";
}
bool  Date::isLeapYear(int year) const
{
    if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
        return true;
    else
        return false;
}

运行截图：
在这里插入图片描述
学习掌握

动态联编，即是系统在运行时动态实现某个动作。而动态联编就是通过虚函数来实现的，因此学习了虚函数的定义以及使用方法及注意点，比如就要确保虚函数再定义时，参数表要与原先的保持完全一致。

具有虚函数的类就是抽象类，如果在抽象类的派生类中没有重新说明纯虚函数，则该函数在派生类中仍然为纯虚函数，而这个派生类仍然还是一个抽象类。

爱吃苹果的派大星
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
程序设计二（面向对象）_实训13_虚函数
Junds0的博客
12-12 6968
已有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 1103
纯虚函数 定义格式： virtual <类型> （函数名）（参数表）=0； 后面多一个"=0",不是表明返回值为0，声明为纯虚函数后，不需要函数体。不具备函数功能，不能被调用。 纯虚函数的作用：为派生类保留一个函数名，便于后面的派生类根据自己的需要重新定义功能。 抽象类的概念 抽象类具体类的概念 如果一个类至少有一个纯虚函数，就称该类为抽象类。能够 建立实例化对象的类称为具体类，也即是...
C++实验六 多态性和虚函数的应用 课程 实验报告
06-11
C++实验六 多态性和虚函数的应用 课程 实验报告 作业参考的良品！
个人银行账户管理程序c++代码改写
qq_42350656的博客
01-09 302
面向对象 Java是完全面向对象的语言，所有的代码都要写在类中，即使是主函数public static void main(String[] args）{}也要放在主类中。 除了基本数据类型，其他数据在Java中都是类，同时Java提供了基本数据类型对应的包装类。 Java中对象的创建和初始化是分离的，通过new创建对象，内存分配在堆上，声明对象引用，内存分配在栈上，最后初始化对象引用。 ...
虚函数
weixin_34357436的博客
03-22 102
虚函数是重载的另一种表现形式。这是一种动态的重载方式，它提供了一种更为灵活的、运行时的多态性机制。虚函数允许函数调用与函数体之间的联系在运行时才建立，也就是在运行时才决定如何动作，即所谓的动态连编。 虚函数首先是基类中的成员函数，但这个成员函数前面加了关键字virtual，并在派生类中被重载。 它的一般形式： virtual 返回类型 函数名（形参表...
C++实验8报告多态性与虚函数
Laic Zhang的博客
05-31 7231
所使用的开发工具及环境： PC机一套 实验目的： (1)了解多态性的概念。 (2)了解虚函数的作用及使用方法。 (3)了解静态关联和动态关联的概念和川法。 (4)了解纯虚函数和抽象类的概念和用法。 实验内容： 1、分析程序运行结果，掌握虚函数的使用。 程序一： #include <iostream> using namespace std; class ONE { public: ...
头歌程序设计二（面向对象）_实训13_虚函数
热门推荐
qq_65628600的博客
07-06 1万+
头歌程序设计二（面向对象）_实训13_虚函数
（面向对象）_实训13_虚函数
最新发布
Y_1215的博客
05-27 835
第一关 第二关 第三关 点个赞，直接带走，不客气！
第15章 面向对象程序设计 02＜虚函数＞
qq_43186100的博客
06-23 405
111
面向对象程序设计03多态性和虚函数.ppt
05-13
面向对象程序设计中的多态性和虚函数 多态性是面向对象程序设计方法的一个重要特征，它主要表现在函数调用时实现“一种接口、多种方法”。在面向对象程序设计中，多态性可以分为两种：编译时多态性和运行时多态性。...
2023年面向对象程序设计课程标准.doc
10-26
7. 多态性，包括函数重载、拷贝构造函数、运算符重载、虚函数和动态绑定。 8. 类属机制，包括类属类和类属函数的概念。 9. 输入/输出流，学习C++的I/O机制、格式化输入/输出及流运算符重载。 10. 面向对象软件构造，...
C++面向对象程序设计教程——课件PPT
10-19
首先，第1章“面向对象程序设计概述”引入了面向对象的基本理念，包括封装、继承和多态性三大核心概念。面向对象编程允许我们将复杂的问题分解为独立的对象，这些对象可以相互协作完成任务，提高代码的可读性和复用...
《面向对象程序设计实训》课程教学大纲.docx
12-17
多态性将通过虚函数和抽象类来实现。 4. **类与对象**：深入探讨类的设计原则，如接口设计、数据隐藏和信息封装。同时，讲解构造函数、析构函数和拷贝构造函数的作用，以及友元机制。 5. **模板与泛型编程**：介绍...
面向对象程序设计——基于Visual C++：第2章 C++语言基础.pptx
09-19
"面向对象程序设计——基于Visual C++：第2章 C++语言基础"，这表明我们将讨论C++编程语言的核心特性，以及如何使用Visual C++作为开发环境来编写和运行C++程序。本章主要涵盖了C++的基本概念，包括它与C语言的关系...
多态性与虚函数——面向对象程序设计
weixin_51320687的博客
01-20 282
1.多态性的概念 多态性：向不同的对象发送同一个消息，不同的对象在接收时会产生不同 的行为。 静态多态性：由函数中在和运算符重载形成。 动态多态性：通过虚函数实现。 2.示例 先建立一个Point类，包含数据成员x，y（坐标点）。以它为基类，派生出一个Circle（圆）类，增加数据成员r（半径），再以Circle类为直接基类，派生出一个Cylinder（圆柱体）类，再增加数据成员h（高）。要求编写程序，重载运算符“<<",">>",使之用于输出一上类对象。 声明类Point #inc
面向对象编程系列二：虚函数基本概念
weixin_30555515的博客
06-28 125
如果基类希望派生类对它的某些成员函数进行重定义，那么该基类需要将成员函数声明为virtual函数，即虚函数，而不希望被重定义的函数则为普通的非虚函数。 调用虚函数时编译器需要动态绑定以确定究竟要调用的是哪一个类的函数，而触发动态绑定的不仅要求调用的函数是虚函数，还要求必须通过基类类型的引用或指针进行函数调用。 （1）派生类对象可以当做基类对象使用 因为每个派生类对象都包含基类部分，所以可以将...
【c++】面向对象程序设计之虚函数详解
weixin_30867015的博客
07-03 192
一、动态绑定什么时候发生 当且仅当通过指针或引用调用虚函数时，才会在运行时解析该调用 二、派生类中的虚函数 当我们在派生类中覆盖了某个虚函数时，可以再一次使用virtual指出该函数的性质，但是这么做并非必须，因为一旦某个函数被声明成虚函数，则在所有派生类中它都是虚函数。 一个派生类的函数如果覆盖了某个继承而来的虚函数，则它的形参类型及返回类型必须与被它覆盖的基类函数完全一致，除非当类的虚...
【面向对象程序设计常见面试题】虚函数是怎么实现的？(已阅)
IanChenV
03-28 903
简单说来使用了虚函数表. 虚函数的作用是实现动态联编，(联编工作要在程序运行时进行，这种在程序运行时进行联编工作被称为动态联 编。）也就是在程序的运行阶段动态地选择合适的成员函数，在定义了虚函数后，可以在基类的派生类中对虚函数 重新定义，在派生类中重新定义的函数应与虚函数具有相同的形参个数和形参类型。以实现统一的接口。 注意以下程序的输出结果： 1、无虚函数，即静态编
面向对象程序设计（一） 继承与虚函数
kurino的博客
04-17 395
面向对象程序设计（一） 继承与虚函数 文章目录面向对象程序设计（一） 继承与虚函数基础概念虚函数**派生类中的虚函数**：抽象基类抽象基类的作用是定义对事物操作的通用概念，而并非具体策略继承中的类作用域 基础概念 继承：继承是一种类之间的层级关系。通常在层级关系的根部有一个基类，其它类则直接地或间接地从基类继承而来，继承得来的类叫做派生类。 虚函数：基类希望派生类相对于基类自定义自己的合适的版本的函数。在基类中用virtual关键字来定义，同时在派生类中也隐式的是虚函数。任何非静态函数都可以是虚函数。 类派

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值