class Course {
  // ...
};

class CoreCourse: virtual public Course {
  //...
};

class RequiredCourse: virtual public Course {
  // ...
};

class ProgrammingBasics: public CoreCourse, public RequiredCourse {
  // ...
};

class Course {
  string introduction;
  string goal;
  string context;
  string requirement;
};

class Requirement {
  string form;
  string method;
  string examing;
  string scoring;
};

class Course {
  string introduction;
  string goal;
  string context;
  string requirement;
  Requirement* requirement;
};

class TeachingForm {
  // ...
};

class TeachingMethod {
  // ...
}

class ExamingMethod {
  // ...
}

class ScoringMethod {
  // ...
}

class LectureTeaching: public TeachingForm {
  // ...
}

class LectureQuiz: public TeachingForm {
  // ...
}
// 以下省略剩余两种教学形式，和上面两种是一样的，可以命名为 ExtraGuide Experiment
class Teaching: public TeachingMethod {
  // ...
}

class Talking: public TeachingMethod {
  // ...
}
// 以下省略3种教学方法 Practice WorkDriving SelfLearning
class RegularExaming: public ExamingMethod {
  // ...
}
// 以下省略两种考核方式 ExperimentExaming FinalExaming
class RegularScoring: public Scoring {
  // ...
}
// 以下省略两种成绩评定 ExperimentScoring FinalScoring
class Requirement {
  TeachingForm* form;
  TeachingMethod* method;
  vector<ExamingMethod*> examing;
  vector<ScoringMethod*> scoring;
};

class Course {
  string introduction;
  string goal;
  string context;
  string requirement;
  Requirement* requirement;
};

class TrainingProgramming {
  vector<Course*> courses;
}

class A{
public:
	virtual void f(){
		printf("a");
	}
};

class B{
public:
	virtual void f(){
		printf("b");
	}
};

class C:virtual public A, virtual public B{
};

int main(void) {
	C* c = new C;
	c->f();
	return 0;
}
// In function 'int main()':
// request for member 'f' is ambiguous
// candidates are: 'virtual void B::f()'
//                  'virtual void A::f()'

#include <iostream>
using namespace std;
class M
{
	public:
		M()
		{
			cout << "creating M" << endl;
		}
};
class A
{
		int* a;
		static M m;
	public:
		A(int x)
		{
			a = new int[x];
			cout << "creating A" << endl;
		}
		virtual void func1()
		{
			cout << "in A::func1" << endl;
			func2();
		}
		virtual void func2()
		{
			cout << "in A::func2" << endl;
			func3();
		}
		virtual void func3()
		{
			cout << "in A::func3" << endl;
			func4(1);
		}
		virtual void func4(double dx)
		{
			cout << "in A::func4" << endl;
		}
		virtual ~A()
		{
			cout << "erasing A" << endl;
			delete[] a;
		}
};

M A::m;

class B: public A
{
	public:
		B(int x, int y): A(x)
		{
			b = new int[y];
			cout << "creating B" << endl;
		}
		void func1()
		{
			cout << "in B::func1" << endl;
			func2();
		}
		void func3()
		{
			cout << "in B::func3" << endl;
			func4(1.5);
		}
		void func4(int ix)
		{
			cout << "in B::func4" << endl;
		}
		virtual ~B()
		{
			delete[] b;
			cout << "erasing B" << endl;
		}
	private:
		int* b;
		M m2;
};
void foo(A& ra)
{
	ra.func1();
}
int main()
{
	int i = 2;
	A** att = new A*[i];
	att[0] = new A(1);
	att[1] = new B(2, 2);
	foo(*att[1]);
	for (int j = 0; j <= i - 1; j++)
		delete att[j];
	delete[] att;
}

#include <iostream>
using namespace std;
class Car
{
		char* pName;/*发动机名字*/
		int iId;/*车架号，自动产生具有唯一性*/
		int iI;/*行车里程数，初始化为0*/
	public:
		/*需要补充的代码*/
};
void main()
{
	Car c1("捷达发动机");
	Car c2("奥迪发动机");
	Car c3(c1);
	c3 = c1;
	c2 = c2 + 3;/*又跑了3公里*/
	++c2;/*又跑了1公里*/
	cout << c2 << endl; /*输出小汽车c2的信息*/
}

#include <iostream>
using namespace std;
class Car
{
		char* pName;/*发动机名字*/
		int iId;/*车架号，自动产生具有唯一性*/
		int iI;/*行车里程数，初始化为0*/
	public:
		Car(char* name){
      this->pName = name;
      iI = 0;
      iId = random(); // 用随机数模拟生成
    }
};
void main()
{
	Car c1("捷达发动机");
	Car c2("奥迪发动机");
	Car c3(c1);
	c3 = c1;
	c2 = c2 + 3;/*又跑了3公里*/
	++c2;/*又跑了1公里*/
	cout << c2 << endl; /*输出小汽车c2的信息*/
}

// ...
		Car(char* name){
      this->pName = name;
      iI = 0;
      iId = random(); // 用随机数模拟生成
    }

    Car(const Car& c){
      strcpy(this->pName, c.pName);
      this->iI = c.iI;
      this->iId = this->iId;
    }
// ...

// ...
    void operator=(const Car& c) {
			if (this->pName != c.pName) {
				strcpy(this->pName, c.pName);
			}
			this->iI = c.iI;
			this->iId = this->iId;
		}
    Car operator+(const Car& c) {
			Car newCar(c.pName);
			strcpy(newCar.pName, this->pName);
			// 由于题干中没有定义应该怎么处理车架号、发动机，所以可以自由发挥一下
			newCar.iI = this->iI + c.iI;
			newCar.iId = this->iId;
			return newCar;
		}
    Car operator+(const int& x) {
      Car newCar(this->pName);
      newCar.iI = this->iI + x;
      newCar.iId = this->iId;
      return newCar;
    }
    Car operator++(){
      Car newCar(this->pName);
      this->iI++;
      newCar.iId = this->iId;
      return newCar;
    }
// ...

// ...
    ostream& operator<<(ostream& os){
      os << "车架号："<< this->iId << "，发动机型号：" << this->pName << "，里程数：" << this->iI;
      return os;
    }
// ...

#include <iostream>
#include <string.h>
using namespace std;
class Car {
		char* pName;/*发动机名字*/
		int iId;/*车架号，自动产生具有唯一性*/
		int iI;/*行车里程数，初始化为0*/
	public:
		Car(char* name) {
			this->pName = name;
			iI = 0;
			iId = rand(); // 用随机数模拟生成
		}

		Car(const Car& c) {
			this->pName = new char[strlen(c.pName) + 1];
			strcpy(this->pName, c.pName);
			this->iI = c.iI;
			this->iId = this->iId;
		}

		void operator=(const Car& c) {
			if (this->pName != c.pName) {
				strcpy(this->pName, c.pName);
			}
			this->iI = c.iI;
			this->iId = this->iId;
		}

		Car operator+(const Car& c) {
			Car newCar(c.pName);
			strcpy(newCar.pName, this->pName);
			// 由于题干中没有定义应该怎么处理车架号、发动机，所以可以自由发挥一下
			newCar.iI = this->iI + c.iI;
			newCar.iId = this->iId;
			return newCar;
		}

		Car operator+(const int& x) {
			Car newCar(this->pName);
			newCar.iI = this->iI + x;
			newCar.iId = this->iId;
			return newCar;
		}

		Car operator++() {
			Car newCar(this->pName);
			this->iI++;
			newCar.iId = this->iId;;
			return newCar;
		}

		char* getpName() {
			return pName;
		}

		int getiI() {
			return iI;
		}

		int getiId() {
			return iId;
		}
};

ostream& operator<<(ostream& os, Car& c) {
	os << "车架号：" << c.getiId() << "，发动机型号：" << c.getpName() << "，里程数：" << c.getiI();
	return os;
}
int main() {
	Car c1("捷达发动机");
	Car c2("奥迪发动机");
	Car c3(c1);
	c3 = c1;
	c2 = c2 + 3;/*又跑了3公里*/
	++c2;/*又跑了1公里*/
	cout << c2 << endl; /*输出小汽车c2的信息*/
}

class AbstractBusiness {
private:
  float singleCharge;
public:
  virtual float charge(int used)=0;
  // ...
}

class CallingBusiness {
  public:
  CallingBusiness(float singleCharge = 0.19) {
    // 设置套餐外通话单价
    this->singleCharge = singleCharge;
  }

  float charge(int used) {
    // 假设按秒计算通话时长，但是按照分钟收费
    return ceil(used / 60) * singleCharge;
  }
}

class InternetBusiness {
  public:
  InternetBusiness(float singleCharge = 0.29) {
    // 设置套餐外费用单价
    this->singleCharge = singleCharge;
  }

  virtual float charge(int used) {
    // 假设按KB计算流量，但是按照MB收费
    return ceil(used / 1024) * singleCharge;
  }
}

class MobileOperator {
private:
  map<string, Business*> bs;
public:
  void addBusiness(string name, Business* b) {
    // 运营商公司添加一种业务
    bs[name] = b;
  }

  virtual float charge(string name, float used) {
    // 计算套餐外业务产生的费用
    return bs[name]->charge(used);
  }
}

class ChinaMobile: MobileOperator{
  // 中国移动派生类，可对套餐外收费细化定制
}

class Plan {
private:
  map<string, int> bus; // 套餐名称与限额
  MobileOperator* mo; // 运营商，处理套餐外费用
  float planCharge; // 套餐固定费
public:
  Plan(MobileOperator* mo) {
    // 设置运营商
    this->mo = mo;
  }

  void addBussiness(string name, int maxuse){
    // 为套餐添加业务和额度
    bus[name] = maxuse;
  }

  void setPlanCharge(float planCharge) {
    // 设置套餐基本费用
    this->planCharge = planCharge;
  }

  virtual float singleCharge(vector<string> names, vector<float> used) {
    // 单个套餐周期的收费
    float total = planCharge; // 先收套餐费
    for (int i = 0;i < names.size(); i++) {
      // 逐个业务收取费用
      if (bus[names[i]] <= used[i]) {
        // 如果没用完套餐，则无需收取套餐外费用
        continue;
      }
      else {
        // 收取套餐外费用，需要减掉套餐内额度
        total += mo->charge(names[i], used[i] - bus[names[i]]);
      }
    }

    return total;
  }

  virtual float charge(vector<string> names, vector<vector<float> used>) {
    // 用二维数组实现多个套餐周期的收费
    float total;
    for (int i = 0; i < names.size(); i++) {
      total += singleCharge(names[i], used[i]);
    }
  }
}

class MonthlyPlan: public Plan {
  // 包月套餐，与上述规则大致相同
}

class AnnuallyPlan: public Plan {
  // 统计全年每项业务的消费，按年计费
  float charge(vector<string> names, vector<vector<float> used>) {
    float total = planCharge;
    // 各项业务先设为0消耗
    vector<float> annually_used(names.size(), 0);
    for(int i = 0; i < names.size(); i++) {
      // 逐业务统计这段时间内使用了多少业务量
      for(int j = 0;j < used.size(); i++) {
        // 加单月的单个业务使用量
        annually_used[i] += used[j][i];
      }
    }
    for (int i = 0;i < names.size(); i++) {
      if (bus[names[i]] <= annually_used[i]) {
        // 未超出套餐额度则不额外扣费
        continue;
      }
      else {
        // 对套餐外部分收费
        total += mo->charge(names[i], annually_used[i] - bus[names[i]]);
      }
    }
    return total;
  }
}

int main(void) {
  Mobile* cm = new ChinaMobile();
  cm->addBusiness("通话", new CallingBussiness);
  cm->addBusiness("流量", new InternetBussiness);
  cm->addBusiness("短信", new MessageBusiness);
  Plan* p = new MonthlyPlan(cm);
  p->addBusiness("通话", 60*50);
  p->addBusiness("流量", 20*1024);
  p->addBusiness("短信", 50);
  p->setPlanCharge(8);
  vector<string> names = {"通话", "流量", "短信"};
  vector<vector<float>> used = {{888, 9999, 114}, {1234, 5678, 5}, {1145, 1419, 8}, {1611, 1645, 16}, {888, 999, 77}};// 考试的时候随便编几个数据
  p->charge(names, used);
}