fig12_17.cpp

最新推荐文章于 2024-03-26 09:36:56 发布

rocvfx

最新推荐文章于 2024-03-26 09:36:56 发布

阅读量513

点赞数

CC 4.0 BY-SA版权

分类专栏：牛逼c++

本文链接：https://blog.youkuaiyun.com/rocvfx/article/details/73565175

牛逼c++ 专栏收录该内容

114 篇文章

订阅专栏

本文介绍了一个包含多种类型员工（如月薪员工、佣金员工等）的类层次结构实现。通过继承和多态，实现了不同类型的员工及其薪酬计算方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Employee.h

#pragma once
#include<string>

class Employee
{
public:
	Employee(const std::string &, const std::string &,
		const std::string &);
	virtual ~Employee() {}

	void setFirstName(const std::string &);
	std::string getFirstName() const;

	void setLastName(const std::string &);
	std::string getLastName() const;

	void setSociaSecurityNumber(const std::string &);
	std::string getSocialSecurityNumber() const;

	virtual double earnings() const = 0;
	virtual void print() const;

private:
	std::string firstName;
	std::string lastName;
	std::string socialSecurityNumber;


};

Employee.cpp

#include<iostream>
#include"Employee.h"
using namespace std;

Employee::Employee(const string &first, const string &last,
	const string &ssn)
	:firstName(first), lastName(last), socialSecurityNumber(ssn)
{

}

void Employee::setFirstName(const string &first)
{
	firstName = first;
}

string Employee::getFirstName() const
{
	return firstName;
}

void Employee::setLastName(const string &last)
{
	lastName = last;
}

string Employee::getLastName() const
{
	return lastName;
}

void Employee::setSociaSecurityNumber(const string &ssn)
{
	socialSecurityNumber = ssn;
}

string Employee::getSocialSecurityNumber() const
{
	return socialSecurityNumber;
}

void Employee::print() const
{
	cout << getFirstName() << ' ' << getLastName()
		<< "\nsocial security number: " << getSocialSecurityNumber();

}

CommissionEmployee.h

#pragma once
#include<string>
#include"Employee.h"

class CommissionEmployee :public Employee
{
public:
		CommissionEmployee(const std::string &, const std::string &,
			const std::string &, double = 0.0, double = 0.0);
		virtual ~CommissionEmployee() {}

		void setCommissionRate(double);
		double getCommissionRate() const;

		void setGrossSales(double);
		double getGrossSales() const;

		virtual double earnings() const override;
		virtual void print() const override;
private:
	double grossSales;
	double commissionRate;
};

CommissionEmployee.cpp

#include<iostream>
#include<stdexcept>
#include"CommissionEmployee.h"

using namespace std;

CommissionEmployee::CommissionEmployee(const string &first,
	const string &last, const string &ssn, double sales, double rate)
	:Employee(first, last, ssn)
{
	setGrossSales(sales);
	setCommissionRate(rate);
}

void CommissionEmployee::setGrossSales(double sales)
{
	if (sales >= 0.0)
		grossSales = sales;
	else
		throw invalid_argument("Gross sales must be >= 0.0");

}

double CommissionEmployee::getGrossSales() const
{
	return grossSales;
}

void CommissionEmployee::setCommissionRate(double rate)
{
	if (rate > 0.0 && rate < 1.0)
		commissionRate = rate;
	else
		throw invalid_argument("Commission rate must be > 0.0 and < 1.0");

}

double CommissionEmployee::getCommissionRate() const
{
	return commissionRate;
}

double CommissionEmployee::earnings() const
{
	return getCommissionRate() *getGrossSales();
}

void CommissionEmployee::print() const
{
	cout << "commission employee: ";
	Employee::print();
	cout << "\ngross sales: " << getGrossSales()
		<< "; commission rate: " << getCommissionRate();
}

SalariedEmployee.h

#pragma once
#include<string>
#include"Employee.h"

class SalariedEmployee :public Employee
{
public:
	SalariedEmployee(const std::string &, const std::string &,
		const std::string &, double = 0.0);
	virtual ~SalariedEmployee() {}

	void setWeeklySalary(double);
	double getWeeklySalary() const;

	virtual double earnings() const override;
	virtual void print() const override;

private:
	double weeklySalary;

};

SalariedEmployee.cpp

#include<iostream>
#include<stdexcept>
#include"SalariedEmployee.h"

 using namespace std;

SalariedEmployee::SalariedEmployee(const string &first,
	const string &last, const string &ssn, double salary)
	:Employee(first, last, ssn)
{
	setWeeklySalary(salary);
}

void SalariedEmployee::setWeeklySalary(double salary)
{
	if (salary >= 0.0)
		weeklySalary = salary;
	else
		throw invalid_argument("Weekly salary must be >= 0.0");

}

double SalariedEmployee::getWeeklySalary() const
{
	return weeklySalary;
}

double SalariedEmployee::earnings() const
{
	return getWeeklySalary();
}

void SalariedEmployee::print() const
{
	cout << "salaried employee: ";
	Employee::print();
	cout << "\nweekly salary: " << getWeeklySalary();
}

BasePlusCommissionEmployee.h

#pragma once
#include<string>
#include"CommissionEmployee.h"

class BasePlusCommissionEmployee : public CommissionEmployee
{
public:
	BasePlusCommissionEmployee(const std::string &, const std::string &,
		const std::string &, double = 0.0, double = 0.0, double = 0.0);
	virtual ~BasePlusCommissionEmployee() { }   //原文为virtual ~CommissionEmployee（）{}，编译错误

	void setBaseSalary(double);
	double getBaseSalary() const;

	virtual double earnings() const override;
	virtual void print() const override;

private:
	double baseSalary;

};

BasePlusCommissionEmployee.cpp

#include<iostream>
#include<stdexcept>
#include"BasePlusCommissionEmployee.h"
using namespace std;

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);
}

void BasePlusCommissionEmployee::setBaseSalary(double salary)
{
	if (salary >= 0.0)
		baseSalary = salary;
	else
		throw invalid_argument("Dalary must be >= 0.0");
}

double BasePlusCommissionEmployee::getBaseSalary() const
{
	return baseSalary;
}

double BasePlusCommissionEmployee::earnings() const
{
	return getBaseSalary() + CommissionEmployee::earnings();
}

void BasePlusCommissionEmployee::print() const
{
	cout << "base-salaried ";
	CommissionEmployee::print();
	cout << "; base salary: " << getBaseSalary();
	cout << ";base-salary: " << getBaseSalary();

}

fig12_17.cpp

#include<iostream>
#include<iomanip>
#include<vector>
#include"Employee.h"
#include"SalariedEmployee.h"
#include"CommissionEmployee.h"
#include"BasePlusCommissionEmployee.h"
using namespace std;

void virtualViaPointer(const Employee * const);
void virtualViaReference(const Employee &);

int main()
{
	cout << fixed << setprecision(2);

	SalariedEmployee salariedEmployee(
		"jone", "Smith", "111-11-1111", 800);
	CommissionEmployee commissionEmployee(
		"Sue", "Jones", "333-33-3333", 10000, .06);
	BasePlusCommissionEmployee BasePlusCommissionEmployee(
		"Bob", "Lewis", "444-44-4444", 5000, .04, 300);

	cout << "Employees processed individually using static binding:\n\n";

	salariedEmployee.print();
	cout << "\nnearned $" << salariedEmployee.earnings() << "\n\n";
	commissionEmployee.print();
	cout << "\nearnings $" << commissionEmployee.earnings() << "\n\n";
	BasePlusCommissionEmployee.print();
	cout << "\nearned $" << BasePlusCommissionEmployee.earnings()
		<< "\n\n";

	vector<Employee *>employees(3);

	employees[0] = &salariedEmployee;
	employees[1] = &commissionEmployee;
	employees[2] = &BasePlusCommissionEmployee;
	cout << "Employee processed polymorphically via dynamic binding:\n\n";
	cout << "Virtual function calls made off base-class pointers:\n\n";

	for (const Employee *employeePtr : employees)
		virtualViaPointer(employeePtr);

	cout << "Virtual function calls made off base-class references:\n\n";

	for (const Employee *employeePtr : employees)
		virtualViaReference(*employeePtr);

}

void virtualViaPointer(const Employee * const baseClassPtr)
{
	baseClassPtr->print();
	cout << "\nearned $" << baseClassPtr->earnings() << "\n\n";

}

void virtualViaReference(const Employee &baseClassRef)
{
	baseClassRef.print();
	cout << "\nearned $" << baseClassRef.earnings() << "\n\n";
}