Class 类练习6. <未完成> 条件型三方关系/ 甲乙方参数修改 / 通过第三方统计数据 / 条三后续操作 / 继承细节 / list

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);
            /*后续行为里不包括银行相关参数的修改，因为原文没有提贷款放下来以后银行要做什么*/
        }
    }
};