lab 7 函数超级多的类

#include<iostream>
#include<string>
#include<cmath>
using namespace std;

class Rational

{

public:

Rational();

Rational(long numerator, long denominator);

long getNumerator();

long getDenominator();

Rational add(Rational &secondRational);

Rational subtract(Rational &secondRational);

Rational multiply(Rational &secondRational);

Rational divide(Rational &secondRational);

int compareTo(Rational &secondRational);

bool equals(Rational &secondRational);

int intValue();

double doubleValue();

string toString();

// Define function operators for relational operators

bool operator<(Rational &secondRational);

bool operator<=(Rational &secondRational);

bool operator>(Rational &secondRational);

bool operator>=(Rational &secondRational);

bool operator!=(Rational &secondRational);

bool operator==(Rational &secondRational);

// Define function operators for arithmetic operators

Rational operator+(Rational &secondRational);

Rational operator-(Rational &secondRational);

Rational operator*(Rational &secondRational);

Rational operator/(Rational &secondRational);

// Define function operators for shorthand operators

Rational& operator+=(Rational &secondRational);

Rational& operator-=(Rational &secondRational);

Rational& operator*=(Rational &secondRational);

Rational& operator/=(Rational &secondRational);

// Define function operator [], 0 for numerator and 1 for denominator

long& operator[](const int &index);

// Define function operators for prefix ++ and --

Rational& operator++();

Rational& operator--();

// Define function operators for postfix ++ and --

Rational operator++(int dummy);

Rational operator--(int dummy);

// Define function operators for unary + and -

Rational operator+();

Rational operator-();

// Define the output and input operator

friend ostream &operator<<(ostream &stream, Rational rational);

friend istream &operator>>(istream &stream, Rational &rational);

// Define function operator for conversion

operator double();

private:

long numerator;

long denominator;

static long gcd(long n, long d);

};

Rational::operator double(){
   double a;
   a=1.0* this->numerator/this->denominator;
   return a;
  }

long Rational::gcd(long a,long b){
 if(a==0) return 1;
 if(a < 0) a = -a;
 if(b < 0) b = -b;
 if(a<b){
  long t;
  t=a;
  a=b;
  b=t;
 }
 while(a%b != 0){
  long t = a%b;
  a=b;
  b=t;
 }
 return b;
}

Rational::Rational(){
    this->numerator=0;
    this->denominator=1;
}

Rational::Rational(long numerator, long denominator){
    this->numerator = numerator;
    this->denominator = denominator;
    //cout<<gcd(8,12)<<endl;
}

long Rational::getNumerator(){
    return numerator;
}

long Rational::getDenominator(){
 
    return denominator;
}

Rational Rational::add(Rational &secondRational){
    Rational r;
    r.numerator = this->numerator *secondRational.denominator+ this->denominator * secondRational.numerator;
    r.denominator=this->numerator *secondRational.numerator;
    return r;
}

Rational Rational::subtract(Rational &secondRational){
    Rational r;
    r.numerator = -this->denominator *secondRational.numerator + this->numerator*secondRational.denominator;
    r.denominator=this->numerator *secondRational.numerator;
    return r;
}

Rational Rational::multiply(Rational &secondRational){
    Rational r;
    r.numerator = this->numerator * secondRational.numerator;
    r.denominator=this->denominator * secondRational.numerator;
    return r;
}

Rational Rational::divide(Rational &secondRational){
    Rational r;
    r.numerator = this->numerator * secondRational.denominator;
    r.denominator=this->denominator * secondRational.numerator;
    return r;
}

int Rational::compareTo(Rational &secondRational){
 if(this->denominator *secondRational.numerator - this->numerator*secondRational.denominator==0) return 0;
    else if(this->denominator *secondRational.numerator - this->numerator*secondRational.denominator<0) return 1;
    else return -1;
}

bool Rational::equals(Rational &secondRational){
    if(this->denominator *secondRational.numerator - this->numerator*secondRational.denominator==0) return true;
    else return false;
}

int Rational::intValue(){
    int t;
    t=int(this->numerator / this->denominator);
    return t;
}

double Rational::doubleValue(){
    double t;
    t=1.0*this->numerator / this->denominator;
    return t;
}

string Rational::toString(){
    string s;
    string s1;
    string s2;
    long a,b;
    int fuhao=0;
    long sm = gcd(this->numerator,this->denominator);
    a = this->numerator /sm;
    b = this->denominator /sm;
    if(a==0||b==0){
     return "0";
    }
    if(a<0) {
     fuhao++;
     a=(-1)*a;
    }
    if(b<0) {
     fuhao++;
     b=(-1)*b;
    }
    while(a!=0){
     char c=(a%10 +‘0‘);
     s1 = c+s1;
     a=a/10;
    }
     while(b!=0){
      char c=( b%10 + ‘0‘);
     s2=c+s2;
     b=b/10;
    }
  
    if(s2=="1"){
     if(fuhao==1)
     s1="-"+s1;
     return s1;
    }
    else{
     s=s1+"/"+s2;
     if(fuhao==1) s="-"+s;
     return s;
    }
}

// Define function operators for relational operators

bool Rational::operator<(Rational &secondRational){
      if(this->denominator *secondRational.numerator - this->numerator*secondRational.denominator>0) return true;
      else return false;
  }

bool Rational::operator<=(Rational &secondRational){
      if(this->denominator *secondRational.numerator - this->numerator*secondRational.denominator>=0) return true;
      else return false;
  }

bool Rational::operator>(Rational &secondRational){
      if(this->denominator *secondRational.numerator - this->numerator*secondRational.denominator<0) return true;
      else return false;
  }

bool Rational::operator>=(Rational &secondRational){
      if(this->denominator *secondRational.numerator - this->numerator*secondRational.denominator<=0) return true;
      else return false;
  }

bool Rational::operator!=(Rational &secondRational){
      if(this->denominator *secondRational.numerator - this->numerator*secondRational.denominator!=0) return true;
      else return false;
  }

bool Rational::operator==(Rational &secondRational){
      if(this->denominator *secondRational.numerator - this->numerator*secondRational.denominator==0) return true;
      else return false;
  }

// Define function operators for arithmetic operators

Rational Rational::operator+(Rational &secondRational){
      Rational r;
      r.numerator = this->numerator *secondRational.denominator+ this->denominator*secondRational.numerator;
      r.denominator=this->numerator *secondRational.numerator;
      return r;
  }

Rational Rational::operator-(Rational &secondRational){
      Rational r;
      r.numerator = this->numerator *secondRational.denominator - this->denominator*secondRational.numerator;
      r.denominator=this->denominator *secondRational.denominator;
      return r;
  }

Rational Rational::operator*(Rational &secondRational){
      Rational r;
      r.numerator = this->numerator * secondRational.numerator;
      r.denominator = this->denominator * secondRational.denominator;
      return r;
  }

Rational Rational::operator/(Rational &secondRational){
      Rational r;
      r.numerator = this->numerator * secondRational.denominator;
      r.denominator = this->denominator * secondRational.numerator;
      return r;
  }

// Define function operators for shorthand operators

Rational& Rational::operator+=(Rational &secondRational){
      this->numerator = this->denominator*secondRational.numerator + this->numerator*secondRational.denominator;
      this->denominator=this->denominator*secondRational.denominator;
      return *this;
  }

Rational& Rational::operator-=(Rational &secondRational){
      this->numerator = this->numerator*secondRational.denominator - this->denominator*secondRational.numerator;
      this->denominator=this->denominator *secondRational.denominator;
      return *this;
 
  }

Rational& Rational::operator*=(Rational &secondRational){
      this->numerator = numerator*secondRational.numerator;
      this->denominator=this->denominator *secondRational.denominator;
      return *this;
  }

Rational& Rational::operator/=(Rational &secondRational){
      this->numerator = numerator*secondRational.denominator;
      this->denominator=this->denominator*secondRational.numerator;
      return *this;
  }                   
 
  long& Rational::operator[](const int &index){
    if(index==0) return this->numerator;
    if(index==1) return this->denominator;
  }
 
 
  Rational& Rational::operator++(){
    this->numerator = this->numerator + this->denominator;
    return *this;
  }

Rational& Rational::operator--(){
    this->numerator = this->numerator - this->denominator;
    return *this;
  }
 
  Rational Rational::operator++(int dummy){
    Rational temp(*this);
    temp.numerator = temp.numerator;
    this->numerator = this->numerator + this->denominator;
    return temp;
  }

Rational Rational::operator--(int dummy){
    Rational temp(*this);
    temp.numerator = temp.numerator ;
    this->numerator = this->numerator - this->denominator;
    return temp;
  }
 
  Rational Rational::operator+(){
    Rational temp;
    temp.numerator = this->numerator;
    temp.denominator =  this->denominator;
    return temp;
   
  }

Rational Rational::operator-(){
    Rational temp;
    temp.numerator = this->numerator * (-1);
    temp.denominator =  this->denominator;
    return temp;
  }

ostream &operator<<(ostream &stream, Rational rational){
//     long a = rational.numerator%rational.denominator;
//     if(a==0) cout<<rational.numerator/rational.denominator;
//     else {
//       long s =  Rational::gcd(rational.numerator,rational.denominator);
//       rational.numerator = rational.numerator / s;
//   rational.denominator = rational.denominator / s;
//       stream<<rational.numerator<<"/"<<rational.denominator;
//     }
  stream << rational.toString();
      return stream;
  }

istream &operator>>(istream &stream, Rational &rational){
     stream>>rational.numerator>>rational.denominator;
     return stream;  
  }
 
 
 
 
 
 
  int main()

{

// Create and initialize two rational numbers r1 and r2.

Rational r1(3, 2);

Rational r2(2, 3);

// Test relational operators

cout << r1 << " > " << r2 << " is " << (r1 > r2) << endl;

cout << r1 << " >= " << r1 << " is " << (r1 >= r1) << endl;

cout << r1 << " < " << r2 << " is " << (r1 < r2) << endl;

cout << r1 << " <= " << r1 << " is " << (r1 <= r1) << endl;

cout << r1 << " == " << r2 << " is " << (r1 == r2) << endl;

cout << r1 << " == " << r1 << " is " << (r1 == r1) << endl;

cout << r1 << " != " << r2 << " is " << (r1 != r2) << endl;

cout << r1 << " != " << r1 << " is " << (r1 != r1) << endl;

// Test toString, add, substract, multiply, and divide operators

cout << r1 << " + " << r2 << " = " << r1 + r2 << endl;

cout << r1 << " - " << r2 << " = " << r1 - r2 << endl;

cout << r1 << " * " << r2 << " = " << r1 * r2 << endl;

cout << r1 << " / " << r2 << " = " << r1 / r2 << endl;

// Test shorthand operators

Rational r3(1, 2);

r3 += r1;

cout << "r3 is " << r3 << endl;

r3 -= r1;

cout << "r3 is " << r3 << endl;

// Test function operator []

Rational r4(1, 2);

r4[0] = 3; r4[1] = 4;

cout << "r4 is " << r4 << endl;

// Test function operators for

// prefix ++ and --

// postfix ++ and --

r3 = r4++;

cout << "r3 is " << r3 << endl;

cout << "r4 is " << r4 << endl;

r3 = r4--;

cout << "r3 is " << r3 << endl;

cout << "r4 is " << r4 << endl;

r3 = ++r4;

cout << "r3 is " << r3 << endl;

cout << "r4 is " << r4 << endl;

r3 = --r4;

cout << "r3 is " << r3 << endl;

cout << "r4 is " << r4 << endl;

// Test function operator for conversion

cout << "1 + " << r4 << " is " << (1 + r4) << endl;

cout<<r4.toString()<<endl;

return 0;

}

时间： 2024-12-09 10:10:35

lab 7 函数超级多的类的相关文章

4 C++基础4 类 const函数 转全局函数 返回*this 数组类。友元 函数 类 操作符重载

1,请问类中函数 const修饰的谁? [email protected]:~/c++$ cat main.cpp  #include <iostream> #include <stdlib.h> using namespace std; class A { public: //const的三种写法 //const void fun(int a,int b) //void const fun(int a,int b) //void fun(int a,int b) const vo

重拾C++之虚函数和虚基类以及抽象类

一.引言 好久没接触过C++了,今天突然要用一点感觉号蛋疼,用惯了python感觉C++一点都不会了. 声明了一个类的对象居然用这种方法,脑子绝对是被驴(python)踢了 class A{  ...  }  a=A();//尼玛这都能行,被踢大了 二.虚函数和一般函数 虚函数就是加了vritual关键字的函数,引入虚函数的目的是为了实现多态性(在此为运行时的多态性),即可以通过父类的指针调用子类的对象,从而产生不同的效果.     virtual void show(){         co

C++ 纯虚函数与抽象基类

在C++ 中,虚函数可以很好的实现多态,然而也有一定的局限,这个局限在于,虚函数必须在基类中定义,哪怕是空的实现. 例如下面这段代码编译时就会出错: class Base { virtual void print(); }; class Derived:Base { void print() { cout << "Derived" <<endl; } }; 因为Base类中的虚函数print()没有定义. 而在实际编程时我们往往会遇到无法给基类的函数定义的情况,

关于函数里和函数外的变量/类/常量的

关于函数里和函数外的变量/类/常量的     1 变量是不能跨越到函数里面的,即函数外面的变量不能直接在函数里面使用,函数里面的变量更不能被函数外面使用 2 类可以跨越到函数里面,但是不能实例化之后赋给一个变量再在函数里用,这样相当于变量,而变量是不能跨越到函数里的 3 常量 有些复杂,(其实也好理解) 常量的作用范围是本次页面   具体如下 ①: 函数外定义,函数里可以使用 define("AAA","Good"); function a(){ echo AAA;

纯虚函数与虚基类

纯虚函数 1.定义 纯虚函数是在基类中声明的虚函数,它在基类中没有定义,但要求任何派生类都要定义自己的实现方法.在基类中实现纯虚函数的方法是在函数原型后加"=0" virtual void funtion()=0: 虚函数的定义是:virtual void funtion(): 2.引入原因: 1.为了方便使用多态特性,我们常常需要在基类中定义虚函数. 2.但在很多情况下,基类本身生成对象是不合情理的.例如,动物作为一个基类可以派生出老虎.孔雀等子类,但动物本身生成对象明显不合常理.

Ruby七天入门(2 函数，数组和类)

DAY 2 第二天学习继续,今天重点学习函数,数组和类等编程的基本要素. 2.1 函数 2.1.1 简单定义 def tell_me puts true end 定义一个简单的函数(无参无返回值)很简单,使用def end包裹函数体即可. 2.1.2 参数 def tell_me(a) puts a end tell_me 1 1 => nil 使用参数和其他语言类似,加括号加变量名即可. 2.1.2.1 参数默认值 同样可以指定参数默认值: def tell_me(a='1',b) puts

用宏定义成员函数，VC6的类视图显示错误

用宏定义成员函数,VC6的类视图显示错误,实际函数可以使用. VC7没此问题. #define ConstGetMemFunMac2(varName,funName,retType)\ retType funName()const{return varName;}; class A { public: ConstGetMemFunMac2(m_x,GetX,int); int m_x; };

虚函数的使用 以及虚函数与重载的关系, 空虚函数的作用，纯虚函数-&gt;抽象类，基类虚析构函数使释放对象更彻底

为了访问公有派生类的特定成员,可以通过讲基类指针显示转换为派生类指针. 也可以将基类的非静态成员函数定义为虚函数(在函数前加上virtual) 1 #include<iostream> 2 using namespace std; 3 4 class base{ 5 public: 6 /*virtual*/ void who(){ //define this function to virtual will be normal 7 cout << "this is th

惊天发现之&quot;c#中的Main函数不能调同一个类中的非静态方法&quot;

这是什么原因呢?求大神指点!惊天发现之"c#中的Main函数不能调同一个类中的非静态方法"