一个关于多态之虚函数的例子

最新推荐文章于 2022-04-09 10:54:57 发布

算法工程师000001

最新推荐文章于 2022-04-09 10:54:57 发布

阅读量832

点赞数

分类专栏： c++ 文章标签：虚函数

c++ 专栏收录该内容

18 篇文章 1 订阅

订阅专栏

程序实践多态性工资发放管理系统

目录(?)[+]

引言

本博文通过包含了一个公司支付系统中各种雇员情况的一个继承层次来讨论基类和派生类之间的关系.佣金雇员(表示为一个基类对象)的薪水完全是销售提成,带底薪佣雇员(表示为一个派生类的对象)的薪水由底薪和销售提成组成.以及创建一个增强的雇员类层次结构,以解决下面的问题:

假设某家公司按周支付雇员工资,雇员一共有有4类:
- 定薪雇员:不管每周工作多长时间都领取固定的周薪
- 钟点雇员:按工作的小时数领取工资,并且可以领取超过40个小时之外的加班费
- 佣金雇员:工资完全是销售业绩提成
- 带薪佣雇员:工资是基本工资和销售提成组成
在这次工资发放阶级,公司决定奖励带佣金雇员,把他们的基本工资提高10%.公司想实现一个C++程序多态地执行工资的计算.

我们使用抽象类Employee表示通常概念的雇员.直接从Employee类派生的是类SalariedEmployee,CommissionEmployee 和HourlyEmployee.而BasePlusCommissionEmployee类又是从CommissionEmployee类直接派生的,代表最后一种雇员类型.如图1所中的UML图显示多态的雇员工资应用程序中类的继承层次结构.

图1:雇员类型层次结构的UML图

抽象类Employee声明了类层次结构的"接口",即程序可以对所有的Employee类对象调用的一组成员函数集合.每个雇员,不论他的工资计算方式如何,都有名,姓及社会安全号码,因此在抽象基类Employee中含有private数据成员firstName ,lastName和 socialSecurityNumber.接下来的内容将实现上述的Employee类层次结构.在最后构建一个测试程序,它创建所有这些类的对象并多态地处理对象.

创建抽象基类: Employee类

图2给出了图表类继承层次中的5个类,顶部显示的是earnings和print函数名.对于每个类,这张图表显示了每个函数期望的实现.注意在Employee类中earnings函数被指定"=0",表示它是一个纯virtual函数.每个派生类都重写earnings函数,提供合适的实现.

图2:Employee类层次结构的多态性接口

让我们考虑Employee类头文件(如下程序所示).public成员函数包括:一个构造函数,该构造函数以名,姓及社会安全号码为参数;设置函数名,姓及社会安全号码;获取函数,返回了名,姓及社会安全号码;以及纯virtual 函数earnings和virtual函数print;

Employee类头文件

[cpp]view plaincopyprint? 
    
 //  Employee.h: Employee abstract base class.  
 #ifndef EMPLOYEE_H  
 #define EMPLOYEE_H  
   
 #include <string> // C++ standard string class  
 using std::string;  
   
 class Employee   
 {  
 public:  
    Employee( const string &, const string &, const string & );  
   
    void setFirstName( const string & ); // set first name  
    string getFirstName() const; // return first name  
   
    void setLastName( const string & ); // set last name  
    string getLastName() const; // return last name  
   
    void setSocialSecurityNumber( const string & ); // set SSN  
    string getSocialSecurityNumber() const; // return SSN  
   
    // pure virtual function makes Employee abstract base class  
    virtual double earnings() const = 0; // pure virtual  
    virtual void print() const; // virtual  
 private:  
    string firstName;  
    string lastName;  
    string socialSecurityNumber;  
 }; // end class Employee  
   
 #endif // EMPLOYEE_H  

而 Employee类的实现文件中,没有为纯virtual 函数earnings提供任何实现.请注意: Employee类的构造函数并没有确认社会号码的有效性.通常应该提供这类有效性确认.

Employee类的实现文件

[cpp]view plaincopyprint? 
    
 //  Employee.cpp: Abstract-base-class Employee member-function definitions.  
 // Note: No definitions are given for pure virtual functions.  
 #include <iostream>  
 using std::cout;  
   
 #include "Employee.h" // Employee class definition  
   
 // constructor  
 Employee::Employee( const string &first, const string &last,  
    const string &ssn )  
    : firstName( first ), lastName( last ), socialSecurityNumber( ssn )  
 {  
    // empty body   
 } // end Employee constructor  
   
 // set first name  
 void Employee::setFirstName( const string &first )   
 {   
    firstName = first;    
 } // end function setFirstName  
   
 // return first name  
 string Employee::getFirstName() const   
 {   
    return firstName;    
 } // end function getFirstName  
   
 // set last name  
 void Employee::setLastName( const string &last )  
 {  
    lastName = last;     
 } // end function setLastName  
   
 // return last name  
 string Employee::getLastName() const  
 {  
    return lastName;     
 } // end function getLastName  
   
 // set social security number  
 void Employee::setSocialSecurityNumber( const string &ssn )  
 {  
    socialSecurityNumber = ssn; // should validate  
 } // end function setSocialSecurityNumber  
   
 // return social security number  
 string Employee::getSocialSecurityNumber() const  
 {  
    return socialSecurityNumber;     
 } // end function getSocialSecurityNumber  
   
 // print Employee's information  
 void Employee::print() const  
 {   
    cout << getFirstName() << ' ' << getLastName()   
       << "\nsocial security number: " << getSocialSecurityNumber();   
 } // end function print  

注意:virtual函数print提供的实现会在每个派生类中被重写.可是,这些print函数都将使用这个抽象类中print函数的版本,输出Employee声明了类层次结构中所有类共有的信息.

创建具体的派生类: SalariedEmployee类

SalariedEmployee类是从Employee类派生而来的,其public成员函数包括:一个以名, 姓,社会安全号码和周薪为参数的构造函数;给数据成员weeklySalary赋一个非负的设置函数;返回weeklySalary值的获取函数;计算一个SalariedEmployee雇员收入的virtual函数earnings;打印雇员信息的virtual函数print,它输出的内容依次是雇员类型(即:"salaried employee").以及由基类Employee的print函数和SalariedEmployee类的 getWeeklySalary函数产生的雇员的特定信息.

SalariedEmployee类头文件

[cpp]view plaincopyprint? 
    
 // SalariedEmployee.h: SalariedEmployee class derived from Employee.  
 #ifndef SALARIED_H  
 #define SALARIED_H  
   
 #include "Employee.h" // Employee class definition  
   
 class SalariedEmployee : public Employee   
 {  
 public:  
    SalariedEmployee( const string &, const string &,   
       const string &, double = 0.0 );  
   
    void setWeeklySalary( double ); // set weekly salary  
    double getWeeklySalary() const; // return weekly salary  
   
    // keyword virtual signals intent to override  
    virtual double earnings() const; // calculate earnings  
    virtual void print() const; // print SalariedEmployee object  
 private:  
    double weeklySalary; // salary per week  
 }; // end class SalariedEmployee  
   
 #endif // SALARIED_H  

SalariedEmployee类的成员函数的实现.类的构造函数把名,姓和社会安全号码传递给基类Employee的构造函数,从而对从基类继承但在派行类中不可访问的private数据成员进行了初始化.SalariedEmployee类的print函数重写了基类Employee的print函数.如果SalariedEmployee类不重写print函数,那么SalariedEmployee类将继承基类Employee的print函数.

SalariedEmployee类实现文件

[cpp]view plaincopyprint? 
    
 // SalariedEmployee.cpp :SalariedEmployee class member-function definitions.  
 #include <iostream>  
 using std::cout;  
   
 #include "SalariedEmployee.h" // SalariedEmployee class definition  
   
 // constructor   
 SalariedEmployee::SalariedEmployee( const string &first,   
    const string &last, const string &ssn, double salary )  
    : Employee( first, last, ssn )  
 {   
    setWeeklySalary( salary );   
 } // end SalariedEmployee constructor  
   
 // set salary  
 void SalariedEmployee::setWeeklySalary( double salary )  
 {   
    weeklySalary = ( salary < 0.0 ) ? 0.0 : salary;   
 } // end function setWeeklySalary  
   
 // return salary  
 double SalariedEmployee::getWeeklySalary() const  
 {  
    return weeklySalary;  
 } // end function getWeeklySalary  
   
 // calculate earnings;   
 // override pure virtual function earnings in Employee  
 double SalariedEmployee::earnings() const   
 {   
    return getWeeklySalary();   
 } // end function earnings  
   
 // print SalariedEmployee's information   
 void SalariedEmployee::print() const  
 {  
    cout << "salaried employee: ";  
    Employee::print(); // code reuse  
    cout << "\nweekly salary: " << getWeeklySalary();  
 } // end function print  

创建具体的派生类: HourlyEmployee类

HourlyEmployee类头文件

[cpp]view plaincopyprint? 
    
 //  HourlyEmployee.h  
 // HourlyEmployee class definition.  
 #ifndef HOURLY_H  
 #define HOURLY_H  
   
 #include "Employee.h" // Employee class definition  
   
 class HourlyEmployee : public Employee   
 {  
 public:  
    HourlyEmployee( const string &, const string &,   
       const string &, double = 0.0, double = 0.0 );  
      
    void setWage( double ); // set hourly wage  
    double getWage() const; // return hourly wage  
   
    void setHours( double ); // set hours worked  
    double getHours() const; // return hours worked  
   
    // keyword virtual signals intent to override  
    virtual double earnings() const; // calculate earnings  
    virtual void print() const; // print HourlyEmployee object  
 private:  
    double wage; // wage per hour  
    double hours; // hours worked for week  
 }; // end class HourlyEmployee  
   
 #endif // HOURLY_H  

HourlyEmployee类实现文件

// HourlyEmployee.cpp: HourlyEmployee class member-function definitions.
#include <iostream>
using std::cout;

#include "HourlyEmployee.h" // HourlyEmployee class definition

// constructor
HourlyEmployee::HourlyEmployee(const string &first, const string &last,
	const string &ssn, double hourlyWage, double hoursWorked)
	: Employee(first, last, ssn)
{
	setWage(hourlyWage); // validate hourly wage
	setHours(hoursWorked); // validate hours worked
} // end HourlyEmployee constructor

// set wage
void HourlyEmployee::setWage(double hourlyWage)
{
	wage = hourlyWage < 0.0 ? 0.0 : hourlyWage;
} // end function setWage

// return wage
double HourlyEmployee::getWage() const
{
	return wage;
} // end function getWage

// set hours worked
void HourlyEmployee::setHours(double hoursWorked)
{
	hours = hoursWorked < 0.0 ? 0.0 : hoursWorked;
}
double HourlyEmployee::getHours() const
{
	return hours;
}
double HourlyEmployee::earnings() const
{
	return getWage() * getHours();
}
void HourlyEmployee::print() const
{
	cout << "Hourly employee: ";
	Employee::print(); // code reuse
	cout << "\nwage: " << getWage()
		<< "; hours: " << getHours();
}

创建具体的派生类: CommissionEmployee类

CommissionEmployee类头文件

[cpp]view plaincopyprint? 
    
 // CommissionEmployee.h: CommissionEmployee class derived from Employee.  
 #ifndef COMMISSION_H  
 #define COMMISSION_H  
   
 #include "Employee.h" // Employee class definition  
   
 class CommissionEmployee : public Employee   
 {  
 public:  
    CommissionEmployee( const string &, const string &,  
       const string &, double = 0.0, double = 0.0 );  
   
    void setCommissionRate( double ); // set commission rate  
    double getCommissionRate() const; // return commission rate  
   
    void setGrossSales( double ); // set gross sales amount  
    double getGrossSales() const; // return gross sales amount  
   
    // keyword virtual signals intent to override  
    virtual double earnings() const; // calculate earnings  
    virtual void print() const; // print CommissionEmployee object  
 private:  
    double grossSales; // gross weekly sales  
    double commissionRate; // commission percentage  
 }; // end class CommissionEmployee  
   
 #endif // COMMISSION_H  

CommissionEmployee类实现文件

[cpp]view plaincopyprint? 
    
 // CommissionEmployee.cpp: CommissionEmployee class member-function definitions.  
 #include <iostream>  
 using std::cout;  
   
 #include "CommissionEmployee.h" // CommissionEmployee class definition  
   
 // constructor   
 CommissionEmployee::CommissionEmployee( const string &first,   
    const string &last, const string &ssn, double sales, double rate )  
    : Employee( first, last, ssn )    
 {  
    setGrossSales( sales );  
    setCommissionRate( rate );  
 } // end CommissionEmployee constructor  
   
 // set commission rate  
 void CommissionEmployee::setCommissionRate( double rate )  
 {   
     commissionRate = ( rate > 0.0 && rate < 1.0 ) ? rate : 0.0;  
 } // end function setCommissionRate  
   
 // return commission rate  
 double CommissionEmployee::getCommissionRate() const  
 {  
     return commissionRate;  
 } // end function getCommissionRate  
   
 // set gross sales amount  
 void CommissionEmployee::setGrossSales( double sales )   
 {   
    grossSales = ( sales < 0.0 ) ? 0.0 : sales;   
 } // end function setGrossSales  
   
 // return gross sales amount  
 double CommissionEmployee::getGrossSales() const  
 {  
     return grossSales;  
 } // end function getGrossSales  
   
 // calculate earnings;  
 // override pure virtual function earnings in Employee  
 double CommissionEmployee::earnings() const  
 {   
    return getCommissionRate() * getGrossSales();   
 } // end function earnings  
   
 // print CommissionEmployee's information   
 void CommissionEmployee::print() const  
 {  
    cout << "commission employee: ";  
    Employee::print(); // code reuse  
    cout << "\ngross sales: " << getGrossSales()   
       << "; commission rate: " << getCommissionRate();  
 } // end function print  

创建具体的派生类: BasePlusCommissionEmployee类

BasePlusCommissionEmployee类头文件

[cpp]view plaincopyprint? 
    
 // BasePlusCommissionEmployee.h  
 // BasePlusCommissionEmployee class derived from Employee.  
 #ifndef BASEPLUS_H  
 #define BASEPLUS_H  
   
 #include "CommissionEmployee.h" // CommissionEmployee class definition  
   
 class BasePlusCommissionEmployee : public CommissionEmployee   
 {  
 public:  
    BasePlusCommissionEmployee( const string &, const string &,  
       const string &, double = 0.0, double = 0.0, double = 0.0 );  
   
    void setBaseSalary( double ); // set base salary  
    double getBaseSalary() const; // return base salary  
   
    // keyword virtual signals intent to override  
    virtual double earnings() const; // calculate earnings  
    virtual void print() const; // print BasePlusCommissionEmployee object  
 private:  
    double baseSalary; // base salary per week  
 }; // end class BasePlusCommissionEmployee  
   
 #endif // BASEPLUS_H  

BasePlusCommissionEmployee类实现文件

[cpp]view plaincopyprint? 
    
 // BasePlusCommissionEmployee.cpp: BasePlusCommissionEmployee member-function definitions.  
 #include <iostream>  
 using std::cout;  
   
 // BasePlusCommissionEmployee class definition  
 #include "BasePlusCommissionEmployee.h"  
   
 // constructor   
 BasePlusCommissionEmployee::BasePlusCommissionEmployee(   
    const string &first, const string &last, const string &ssn,   
    double sales, double rate, double salary )  
    : CommissionEmployee( first, last, ssn, sales, rate )    
 {  
    setBaseSalary( salary ); // validate and store base salary  
 } // end BasePlusCommissionEmployee constructor  
   
 // set base salary  
 void BasePlusCommissionEmployee::setBaseSalary( double salary )  
 {   
    baseSalary = ( salary < 0.0 ) ? 0.0 : salary;   
 } // end function setBaseSalary  
   
 // return base salary  
 double BasePlusCommissionEmployee::getBaseSalary() const  
 {   
     return baseSalary;   
 } // end function getBaseSalary  
   
 // calculate earnings;  
 // override pure virtual function earnings in Employee  
 double BasePlusCommissionEmployee::earnings() const  
 {   
     return getBaseSalary() + CommissionEmployee::earnings();   
 } // end function earnings  
   
 // print BasePlusCommissionEmployee's information   
 void BasePlusCommissionEmployee::print() const  
 {  
    cout << "base-salaried ";  
    CommissionEmployee::print(); // code reuse  
    cout << "; base salary: " << getBaseSalary();  
 } // end function print  

演示多态性的执行过程

为了测试Employee类层次结构,如下所示程序中的程序为4个具体类 SalariedEmployee, HourlyEmployee, CommissionEmployee和BasePlusCommissionEmployee的每一个都创建了一个对象.程序首先使用静态绑定方式对这些对象进行了操作,然后使用Employee指针的vector多态地对这些对象进行操作.

Employee类层次结构的驱动程序

[cpp]view plaincopyprint? 
    
 // Demonstrating downcasting and run-time type information.  
 // NOTE: For this example to run in Visual C++ .NET,   
 // you need to enable RTTI (Run-Time Type Info) for the project.  
 #include <iostream>  
 using std::cout;  
 using std::endl;  
 using std::fixed;  
   
 #include <iomanip>  
 using std::setprecision;  
     
 #include <vector>  
 using std::vector;  
   
 #include <typeinfo>  
   
 // include definitions of classes in Employee hierarchy  
 #include "Employee.h"  
 #include "SalariedEmployee.h"   
 #include "HourlyEmployee.h"  
 #include "CommissionEmployee.h"    
 #include "BasePlusCommissionEmployee.h"   
   
 int main()  
 {  
    // set floating-point output formatting  
    cout << fixed << setprecision( 2 );     
      
    // create vector of four base-class pointers  
    vector < Employee * > employees( 4 );  
   
    // initialize vector with various kinds of Employees  
    employees[ 0 ] = new SalariedEmployee(   
       "John", "Smith", "111-11-1111", 800 );  
    employees[ 1 ] = new HourlyEmployee(   
       "Karen", "Price", "222-22-2222", 16.75, 40 );  
    employees[ 2 ] = new CommissionEmployee(   
       "Sue", "Jones", "333-33-3333", 10000, .06 );  
    employees[ 3 ] = new BasePlusCommissionEmployee(   
       "Bob", "Lewis", "444-44-4444", 5000, .04, 300 );  
   
    // polymorphically process each element in vector employees  
    for ( size_t i = 0; i < employees.size(); i++ )   
    {  
       employees[ i ]->print(); // output employee information  
       cout << endl;  
   
       // downcast pointer  
       BasePlusCommissionEmployee *derivedPtr =  
          dynamic_cast < BasePlusCommissionEmployee * >   
             ( employees[ i ] );  
   
       // determine whether element points to base-salaried   
       // commission employee  
       if ( derivedPtr != 0 ) // 0 if not a BasePlusCommissionEmployee  
       {  
          double oldBaseSalary = derivedPtr->getBaseSalary();  
          cout << "old base salary: $" << oldBaseSalary << endl;  
          derivedPtr->setBaseSalary( 1.10 * oldBaseSalary );  
          cout << "new base salary with 10% increase is: $"   
             << derivedPtr->getBaseSalary() << endl;  
       } // end if  
         
       cout << "earned $" << employees[ i ]->earnings() << "\n\n";  
    } // end for     
    
    // release objects pointed to by vector抯 elements  
    for ( size_t j = 0; j < employees.size(); j++ )   
    {  
       // output class name  
       cout << "deleting object of "   
          << typeid( *employees[ j ] ).name() << endl;  
   
       delete employees[ j ];  
    } // end for  
   
    return 0;  
 } // end main  

输出结果:

算法工程师000001

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
一个关于多态之虚函数的例子

程序实践多态性工资发放管理系统目录(?)[+]引言本博文通过包含了一个公司支付系统中各种雇员情况的一个继承层次来讨论基类和派生类之间的关系.佣金雇员(表示为一个基类对象)的薪水完全是销售提成,带底薪佣雇员(表示为一个派生类的对象)的薪水由底薪和销售提成组成.以及创建一个增强的雇员类层次结构,以解决下面的问题:假设某家公司按周支付雇员工资,雇员一共
复制链接

扫一扫