实验6

class F{
	private:
		int m,n;
	public:
        F(int,int);
        int add();
}; 
class A:public F{
	private:
		int m,n;
	public:
		A(int,int);
		int sub();
};
class B:public F{
	private:
	    int m,n;
	public:
		B(int,int);
		int mul();	
};
class C:public F{
	private:
		int m,n;
	public:
		C(int,int);
		int div();
};

　　

#include"F.h"
F::F(int m0,int n0):m(m0),n(n0){}
int F::add(){
	return m+n;
}
A::A(int m0,int n0):m(m0),n(n0),F(m0,n0){}
int A::sub(){
	return m-n;
}
B::B(int m0,int n0):m(m0),n(n0),F(m0,n0){}
B::mul(){
	return m*n;
}
C::C(int m0,int n0):m(m0),n(n0),F(m0,n0){}
C::div(){
	return m/n;
}

　　

#include<iostream>
#include"F.h"
using namespace std;
int main(){
	A a(9,3);
	B b(9,3);
	C c(9,3);
	cout<<a.sub()<<" "<<a.add()<<endl;
	cout<<b.mul()<<" "<<b.add()<<endl;
	cout<<c.div()<<" "<<c.add()<<endl;
	return 0;
}

　　

#pragma once
#include<iostream>
using namespace std;
class Fraction {
private:
	int top;
	int bottom;
public:
	Fraction();
	Fraction(int t);
	Fraction(int t, int b);
	Fraction operator+(const Fraction &p);
	Fraction operator-(const Fraction &p);
	Fraction operator*(const Fraction &p);
	Fraction operator/(const Fraction &p);
	friend void convertF(int *x,int *y);
	friend ostream & operator<<(ostream &out, const Fraction &p);
	void ip();
};

　　

#pragma once
#include"Fraction.h"
class iFraction :virtual public Fraction {
private:
	int m, n;
public:
	iFraction(int x,int y):m(x),n(y),Fraction(x,y){}
	friend void convertF(int *x,int *y);
};

　　

#include"Fraction.h"
#include<iostream>
#include<cmath>
using namespace std;
Fraction::Fraction() :top(0), bottom(1) {
}
Fraction::Fraction(int t) : top(t), bottom(1) {
}
Fraction::Fraction(int t, int b) : top(t), bottom(b) {
}
Fraction Fraction::operator+(const Fraction &p) {
	int x = top * p.bottom + p.top*bottom;
	int y = bottom * p.bottom;
	return Fraction(x, y);
}
Fraction Fraction::operator-(const Fraction &p) {
	int x = top * p.bottom - p.top*bottom;
	int y = bottom * p.bottom;
	return Fraction(x, y);
}
Fraction Fraction::operator*(const Fraction &p) {
	int x = top * p.top;
	int y = bottom * p.bottom;
	return Fraction(x, y);
}
Fraction Fraction::operator/(const Fraction &p) {
	int x = top * p.bottom;
	int y = p.top*bottom;
	return Fraction(x, y);
}
void Fraction::ip() {
	cout << "输入分子" << endl;
	cin >> top;
	int bo;
	cout << "输入分母" << endl;
	cin >> bo;
	while (bo == 0) {
		cout << "请重新输入" << endl;
		cin >> bo;
	}
	bottom = bo;
}

　　

#include"iFraction.h"
#include<iostream>
#include<cmath>
using namespace std;
int gct(int a, int b) {
	return a % b == 0 ? b : gct(b, a%b);
}
void convertF(int *x,int *y) {
	if (*y<0) {
		*y *= -1;
		*x *= -1;
	}
	int g = gct(abs(*x), abs(*y));
	*x /= g;
	*y /= g;
}
ostream & operator<<(ostream &out, const Fraction &p) {
	int x =p.top;
	int y =p.bottom;
	convertF(&x,&y);
	int z = x / y;
	if (x == 0)
		out << "0";
	else if (x == y)
		out << "1";
	else if (x > y)
		out <<"("<<z<<"）" << x - z * y << "/" << y;
	else
	 out <<x << "/" <<y;
	return out;
}
int main() {
	Fraction a;
	Fraction b;
	iFraction d(7, 6);
	cout << d << endl;
	a.ip();
	b.ip();
	Fraction c;
	c = a + b;
	cout << c << endl;
	c = a - b;
	cout << c << endl;
	c = a * b;
	cout << c << endl;
	c = a / b;
	cout << c << endl;
	return 0;
}

　　

#pragma once
class Vehicle {
private:
	int maxspeed, weight;
public:
	Vehicle(int, int);
	Vehicle(Vehicle &p);
	void run();
	void stop();
	~Vehicle() {}
};

　　

#pragma once
#include"vehicle.h"
class Bicycle :virtual public Vehicle{
private:
	int height;
public:
	Bicycle(int x,int y,int z):height(x),Vehicle(y,z){}
	~Bicycle(){}
};

　　

#pragma once
#include"vehicle.h"
class Motorcar :virtual public Vehicle {
private:
	int seatnum;
public:
	Motorcar(int x,int y,int z):seatnum(x),Vehicle(y,z){}
	~Motorcar(){}
};

　　

#include"vehicle.h"
#include<iostream>
using namespace std;
Vehicle::Vehicle(int x, int y) :maxspeed(x),weight(y){ }
Vehicle::Vehicle(Vehicle &p) {
	maxspeed = p.maxspeed;
	weight = p.weight;
}
void Vehicle::run(){
	cout << "run" << endl;
}
void Vehicle::stop(){
	cout << "stop" << endl;
}

　　

#include<iostream>
#include"motorcycle.h"
using namespace std;
int main() {
	Vehicle car(1, 1);
	Vehicle car2(car);
	Bicycle bike(1, 1, 1);
	Motorcar motorcar(1, 1, 1);
	Motorcycle motorcycle(1, 1, 1, 1, 1, 1);
	car.run();
	bike.stop();
}

　　

#pragma once
#include"bicycle.h"
#include"motorcar.h"
class Motorcycle :virtual public Bicycle, virtual public Motorcar {
public:
	Motorcycle(int x, int y,int z, int a, int b,int c) :Vehicle(x,y),Bicycle(x, y,z), Motorcar(a, b,c) {}
	~Motorcycle(){}
};