实验6

1

#include<iostream>
using namespace std;

class Xinpian {
public:
	Xinpian(int a, int b);
	int plus();
protected:
	int x;
	int y;
};

class A :public Xinpian {
public:
	A(int a, int b) :Xinpian(a, b) {};
	int minus();

};

class B :public Xinpian {
public:
	B(int a, int b) :Xinpian(a, b) {};
	int mul();
};

class C :public Xinpian {
public:
	C(double a, double b) :Xinpian(a, b) {};
	double div();
};



Xinpian::Xinpian(int a, int b)
{
	x = a;
	y = b;
}

int Xinpian::plus() {
	return x + y;
}

int A::minus() {
	return x - y;
}

int B::mul() {
	return x * y;
}

double C::div() {
	return x / y;
}

int main() {
	A x1(2,3);
	B x2(2,3);
	C x3(2.0,3.0);
	
	cout << "2+3=" << x1.plus() << " " << "2-3=" <<x1.minus() << endl;
	cout << "2+3=" << x2.plus ()<< " " << "2*3=" << x2.mul() << endl;
	cout << "2+3=" << x3.plus() << " " << "2/3=" << x3.div()<< endl;
	return 0;
}

2

#include<iostream>
using namespace std;

class Vehicle {
public:
	Vehicle(int m,int w);
	~Vehicle();
	void run();
	void stop();
private:
	int maxspeed;
	int weight;
};

class bicycle :virtual Vehicle {
public:
	bicycle(int m,int w,int h);
	~bicycle();
private:
	int height;

};

class motorcar :virtual Vehicle {
public:
	motorcar(int m,int w,int s);
	~motorcar();
private:
	int seatnum;

};

class motorcycle :public bicycle,public motorcar {
public:
	motorcycle(int m, int w, int h, int s);
	~motorcycle();

};


void Vehicle::run() {
	cout << "run" << endl;
}

void Vehicle::stop() {
	cout << "stop" << endl;
}

Vehicle::Vehicle(int m, int w) :maxspeed(m), weight(w) {
	cout << "Vehicle constructor called."<<endl;
}

Vehicle::~Vehicle() {
	cout << "Vehicle constructor called."<<endl;
}

bicycle::bicycle(int m,int w,int h) :Vehicle(m,w),height(h){
	cout << "bicycle constructor called."<<endl;
}

bicycle::~bicycle()
{
	cout << "bicycle destructor called."<<endl;
}

motorcar::motorcar(int m, int w, int s) :Vehicle(m, w), seatnum(s) {
	cout << "motorcar constructor called."<<endl;
}

motorcar::~motorcar(){
	cout << "motorcar destructor called."<<endl;
}

motorcycle::motorcycle(int m, int w, int h, int s) :Vehicle(m, w),motorcar(m, w, s),bicycle(m, w, h){
	cout << "Motorcycle constructor called." << endl;
}

motorcycle::~motorcycle()
{
	cout << "Motorcycle destructor called." << endl;
}

int main() {
	motorcycle x1(2,4,5,3);
	Vehicle x2(2,1);
	x2.run();
	x2.stop();
	return 0;
}

3

#pragma once
class Fraction {
public:
	Fraction();
	Fraction(int a);
	Fraction(int a, int b);
	void compare(Fraction &p);
	void output();
	Fraction operator+(const Fraction &p);
	Fraction operator-(const Fraction &p);
	Fraction operator*(const Fraction &p);
	Fraction operator/(const Fraction &p);

protected:
	int top;
	int bottom;

};

#pragma once
class iFraction :public Fraction {
public:
	iFraction(int x,int y);
	iFraction(int x, int y,int z);
	void show();
	void convertF();

private:
	int before;
	int top;
	int bottom;

};

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

Fraction::Fraction() {
	top = 0;
	bottom = 1;
	
}
Fraction::Fraction(int a) {
	top = a;
	bottom = 1;
}
Fraction::Fraction(int a, int b) {
	top = a;
	bottom = b;
}

void Fraction::compare(Fraction &p) {
	if (p.top / p.bottom > top / bottom)
		cout << "t>b" << endl;
	else if (p.top / p.bottom < top / bottom)
		cout << "t<b" << endl;
	else if (p.top / p.bottom == top / bottom)
		cout << "t=b" << endl;
}
void Fraction::output() {
	cout << "The result is:" << top << '/' << bottom << endl;
}

Fraction Fraction::operator+(const Fraction &p){
	Fraction sum;
	sum.top = p.top*bottom + p.bottom*top;
	sum.bottom = p.bottom*bottom;
	return sum;
}

Fraction Fraction::operator-(const Fraction &p) {
	Fraction diff;
	diff.top = p.top*bottom - p.bottom*top;
	diff.bottom = p.bottom*bottom;
	return diff;
}

Fraction Fraction::operator*(const Fraction &p){
	Fraction result;
	result.top = p.top*top;
	result.bottom = p.bottom*bottom;
	return result;
}

Fraction Fraction::operator/(const Fraction &p){
	Fraction quotien;
	quotien.top = p.top*bottom;
	quotien.bottom = p.bottom*top;
	return quotien;
}

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

iFraction::iFraction(int x,int y) {
	top = x;
	bottom = y;
}

iFraction::iFraction(int x, int y,int z)
{
	top = x;
	bottom = y;
	before = z;
}

void iFraction::show() {
	cout<<"The result is:" << before << " " << top << "/" << bottom << endl;
}

void iFraction::convertF() {
	int t = 0, x, y;
	if (top >= bottom) {
		x = top;
		y = bottom;
		if (x%y != 0)
		{
			while (x>y)
			{
				x = x - y;
				t++;
			}
			cout<<"The result is:" << t << " " << x << "/" << y << endl;
		}
		if (x%y == 0)
			cout << x / y << endl;
	}
	if (top<bottom)
		cout << top << "/" << bottom << endl;
}

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

int main() {
	Fraction a;
	Fraction b(3, 4);
	Fraction c(5);
	Fraction d;
	iFraction e(2, 3,1);
	iFraction f(5, 3);
	d.compare(b);
	d.output();
	d=b + c;
	d.output();
	d=b - c;
	d.output();
	d=b*c;
	d.output();
	d=b / c;
	d.output();
	e.show();
	f.convertF();
	return 0;
	
}