using namespace std;
class Car;
class Lender;
class Person;
class Company; //超前使用说明
class Bank;
/*----------------------------雇用关系合同信息-----------------------------*/
//提纲:
/*条件型三方关系成立*/
/* +并修改甲乙两方参数信息*/
/*三方关系成立以后的后续操作*/
class EmploymentInfo{
private:
Person* person;
Company* company;
int salary;
public:
EmploymentInfo(Person* ptr1,Company* ptr2,int sala){
if(ptr1->get_count()<3) {
person = ptr1; // 条件型关系:1. 建立关系之前的判断
company = ptr2; // 2. 判断通过以后正式开始初始化合同对象
salary = sala;
ptr1->count_add_by_one(this); // 3. 修改合同双方参数,将合同信息添加进去,供双方使用
ptr2->hire(this); //
}
else { //4. 判断错误,不真正初始化内容,因此双方参数并没有修改
cout <<"you are already employed by more than 3 company"<<endl;
}
}
int get_salary(){
return salary;
}
};
/*----------------------------汽车类-----------------------------*/
/*提纲*/
/*如果这个对象的某个信息,不仅为它所有,而且还要拿出来被别的函数使用*/
/*那么为了完成调用,单独设置一个提取数据的函数*/
class Car{
private:
string plate;
int horse_power;
double mileage;
int existing_loans;
int price;
public:
Car (int par1,int par2,double par3,int par4){
plate =par1;
horse_power =par2;
mileage=par3;
price = 0;
existing_loans =0;
}
void adjust_loans(int debt){
existing_loans = debt;
}
int get_loans(){
return existing_loans;
} // 函数不只有数据,如果还要拿出来给别的类使用,那就单独写函数
int get_price(){
price = horse_power*10000/mileage;
return price;
/*这样一来不只是price被初始化了,而且也可以作为函数的返回值被其他对象拿来使用*/
}
};
/*----------------------------父类:贷方-----------------------------*/
/*提纲*/
/*父类最好加上一个初始化函数,因为看到现在都加上了*/
/*父类数据设置成保护型方便子类继承并调用*/
/*list添加内容*/
/*为什么我一定要写純虚函数的存在?*/
//因为在借贷关系类里指向的指针是指向贷方类的,而我需要给出贷方计算可使用收入,Lender没有一个可计算收入函数
//我就没办法,借贷关系类里写出计算可支配收入的函数
class Lender{
protected:
/*这里不设置成protected导致这里所用信息,子类均不能使用*/
string name;
string address;
int disposal_income;
list<Car *> cars_owned;
/*为什么这里又要用list,因为list是不设上限的,而且易于添加*/
public:
virtual int get_disposable_income()=0;
Lender(string s1,string s2){
name = s1;
address = s2;
disposal_income = 0;
}
void add_a_car(Car* ptr1){
cars_owned.push_back(ptr1);
}
void send_receipt(Bank* bankptr){
cout << "A receipt about your loan has been sent to Bank: " << bankptr->get_bankname() <<endl;
}
/*list执行添加的实例*/
/*但是等一下我们要执行对list内的内容执行统计,执行一下遍历操作,对每一个list内的元素执行统计*/
void following_procedures(Car* ptr1,Bank* bankptr){
add_a_car(ptr1);
send_receipt(bankptr);
}
};
// 1. 由于产生了辅助/藉由关系,因此将第三方挑出来单独成立一个类
2. 关系建立,双方一定会受到影响,设置双方函数,在关系建立时调用函数来修改双方参数
// 3. 通过第三方执行统计操作的本质是:
(1) 第三方建立的时候,修改甲方参数,使得本合同贴附到甲方“合同列表”中
(2) 想要统计甲方数据的时候,遍历甲方的“合同列表”,取出每一张合同中的数据,供甲方统计
(3) 这个列表可以是 “指针列表” 也可以是 List.
/*----------------------------子类:人-----------------------------*/
/*提纲*/
/*子类初始化:父类的初始化列表完成*/
/*list的遍历方式,通过list调用指针对象的函数(非常规)*/
//---------------为什么将贷方设置成基类而不是汽车购买方
//设置基类的讲究:有针对贷方的操作,因此会有指针指向贷方
//但是没有针对汽车购买方的操作,没有设置汽车购买方指针的必要
class Person : public Lender{
private:
int age;
EmploymentInfo* employmentInfo[3];
/*由于一个人最多给三家公司供职,因此这个这个列表最多包含了三个对象*/
/*为什么不用list?因为list是不设上线的*/
int company_count;
public:
/*看到现在几个例子,都是父类就有初始化函数的,即使包含了纯虚函数在里面,因此最好还是给父类一个初始化函数*/
/*然后子类借由初始化列表完成子类的初始化*/
/*初始化列表的使用实例*/
Person(int num,string address,string name):Lender(name,address){
age =num;
}
int calc_disposable_income ();
int get_count(){
return company_count;
}
void count_add_by_one(EmploymentInfo* ptr3){
for(int i=0;i<3;i++){
if (employmentInfo[i]==NULL){
employmentInfo[i]=ptr3;
}
}
company_count++;
}
/*非常重要:指针列表的使用,填充信息,使用这种方式*/
/*因为不一定是最后一个是空,很有可能是中间的某一个为空*/
};
int Person::calc_disposable_income() {
int existing_loans = 0, all_car_prices = 0, all_salary = 0;
/*-------STEP-1收集所有贷款信息+车辆估价------*/
for (auto iterator = cars_owned.begin(); iterator != cars_owned.end(); iterator++) {
existing_loans += (*iterator)->get_loans();
all_car_prices += (*iterator)->get_price(); /*这里不需要指针不为空,因为list本来就不为空*/
// 这里值得注意一下,list里面一般全是对象指针,提取指针对应对象的方法,不同于常规,要加上(*ptr)
// list 遍历
// list指针操作
/*-------------STEP-2收集所有收入信息------------*/
for (int i = 0; i < 3; i++) {
if (employmentInfo[i] != NULL) {
all_salary += employmentInfo[i]->get_salary();
}
} // 现在需要统计公司下所有成员薪水,找到“合同列表”
// 取出每一张合同中的薪水信息
/*--------------STEP-3计算可支配收入------------*/
disposal_income = all_salary / age - 0.1 * all_car_prices - 0.2 * existing_loans;
}
}
/*----------------------------公司类-----------------------------*/
/*提纲*/
/*条件型三方关系的乙方,依据甲方的类似方法,也对乙方的信息做出修改与调整*/
class Company : public Lender{
private:
int turnover;
int disposable_income;
/*不关心员工到底多少个,关心我们签了多少合同,因为合同里有注明薪水*/
list<EmploymentInfo *> employeeinfo;
list<Car *> cars_owned;
public:
Company(int para1,string name1,string address1):Lender(name1,address1){
turnover=para1; //营业额
disposal_income=0;
}
int get_disposable_income();
void hire(EmploymentInfo* ptr){
employeeinfo.push_back(ptr);
}
};
int Company::get_disposable_income() {
/*可支配收入*/
disposal_income=turnover;
/*先减去员工工资,员工=签了用工合同的人,所有这样的人,
* 在合同对象建立之前全部经由乙方对象调整记录在本类中的数据里*/
for(auto iterator=employeeinfo.begin();iterator!=employeeinfo.end();iterator++){
disposal_income-= (*iterator)->get_salary();
}
/*再减去车辆贷款,所有这样的车,在购买行为成立之时
* 经由乙方对象参数调整记录在本类中的数据里*/
for(auto iterator=cars_owned.begin();iterator!=cars_owned.end();iterator++){
disposal_income-=0.2 * (*iterator)->get_loans();
}
return disposable_income;
}
/*----------------------------银行类-----------------------------*/
class Bank{
private:
double interest_rate;
string name;
string address;
public:
Bank(double para1,string para2,string para3){
interest_rate = para1;
name = para2;
address = para3;
}
string get_bankname(){
return name;
}
double get_interestrate(){
return interest_rate;
}
};
/*----------------------------借贷类-----------------------------*/
/*指向父类的指针会自动指向子类吗? - 好像是可以*/
/*提纲*/
/*条件型三方关系的成立 */
/*三方关系成立的后续行为*/
class LoanInfo {
private:
Bank* borrower;
Lender* lender;
Car* car;
public:
LoanInfo(Bank* bankptr,Lender* lenderptr,Car* carpara){
if(lenderptr->get_disposable_income() < carpara->get_price() * bankptr->get_interestrate()){
borrower = bankptr;
lender = lenderptr;
/*后续行为*/
lenderptr->following_procedures(carpara,bankptr);
/*后续行为里不包括银行相关参数的修改,因为原文没有提贷款放下来以后银行要做什么*/
}
}
};