C++. Operator overloading.Fraction's operation

=========Fraction.h=========

#include <iostream>
using namespace std;
class Fraction{
private:
	int n,d;                           //numerator, denominator
public:
	Fraction(int Num = 0, int Den = 1) :n(Num), d(Den){};
	Fraction operator+(Fraction);
	Fraction operator-(Fraction);
	Fraction operator*(Fraction);
	Fraction operator/(Fraction);
	friend ostream &operator<<(ostream &,Fraction);
	int GCD(int, int)const;           //greatest common divisor
	Fraction simplify(Fraction,int);
};

=========Fraction.cpp========

#include "Fraction.h"
Fraction Fraction::operator+(Fraction F){
	Fraction a;
	a.n = (this->n) * (F.d) + (this->d) * (F.n);
	a.d = (this->d) * (F.d);
	if (GCD(a.n, a.d) != 1)
		a = simplify(a, GCD(a.n, a.d));
	return a;
}
Fraction Fraction::operator-(Fraction F){
	Fraction a;
	a.n = (this->n) * (F.d) - (this->d) * (F.n);
	a.d = (this->d) * (F.d);
	if (GCD(a.n, a.d) != 1)
		a = simplify(a, GCD(a.n, a.d));
	return a;
}
Fraction Fraction::operator*(Fraction F){
	Fraction a;
	a.n = this->n * F.n;
	a.d = this->d * F.d;
	if (GCD(a.n, a.d) != 1)
		a = simplify(a, GCD(a.n, a.d));
	return a;
}
Fraction Fraction::operator/(Fraction F){
	Fraction a;
	a.n = this->n * F.d;
	a.d = this->d * F.n;
	if (GCD(a.n, a.d) != 1)
		a = simplify(a, GCD(a.n, a.d));
	return a;
}
ostream &operator<<(ostream &os, Fraction F){
	if (F.n == F.d)
		os << 1;
	else
		os << F.n << "/" << F.d;
	return os;
}
int Fraction::GCD(int m, int n)const{
	int r, t;
	if (m < n){
		t = m;
		m = n; 
		n = t;
	}
	r = m%n;
	while (r){
		m = n;
		n = r;
		r = m%n;
	}
	return n;
}
Fraction Fraction::simplify(Fraction F, int g){
	F.n = F.n / g;
	F.d = F.d / g;
	return F;
}

==========main.cpp===========

#include "Fraction.h"
void main(){
	Fraction F1(2, 3), F2(4, 5);
	cout << F1 << "+" << F2 << " = " << F1 + F2<<endl;
	cout << F1 << "-" << F2 << " = " << F1 - F2<<endl;
	cout << F1 << "×" << F2 << " = " << F1 * F2<<endl;
	cout << F1 << "÷" << F2 << " = " << F1 / F2<<endl;
}