C++题目练习09

C++题目练习09

9.1 类型转换：Rational

实现 有理数 Rational 类 与 int类型、double类型 的相互转换。

#include <iostream>
#include <iomanip>
using namespace std;

class Rational {
public:
    /// 默认构造函数
    Rational();

    /// 构造函数
    Rational(int x, int y);

    explicit Rational(int x);/// 转换构造函数
    

    friend ostream& operator << (ostream& ou, Rational& a );  /// 重载流插入运算符

    Rational operator + ( Rational b );  /// 重载 运算符+
    //friend Rational operator + ( Rational a, Rational b ); 友元函数方式，导致更多地方出现二义性

    operator int();  /// 类型转换函数，相当于 toInt()。 最好加上 explicit

    operator double();  /// 类型转换函数，相当于 toDouble()。 最好加上 explicit

private:
    int nume;  /// 分子
    int deno;  /// 分母
    void optimize();  /// 化简
    int gcd( int m, int n );  /// 求最大公约数
};

/// 类内部函数，求最大公约数
int Rational::gcd( int m, int n ){
    int r = 0;
    while( n ) {
        r = m % n;
        m = n;
        n = r;
    }
    return m;
}

/// 类内部函数，分数化简
void Rational::optimize() {
    int n = nume;
    if ( nume < 0 )  /// 负数时
        n = -nume;
    int r = gcd( n, deno );
    nume = nume / r;
    deno = deno / r;

    /// 若分子和分母均为负数，则结果为正，所以均改为正
    if( nume < 0 && deno < 0 ) {
        nume = -nume;
        deno = -deno;
    }
    /// 若分子和分母中只有一个为负数，则调整为分子取负，分母取正
    else if( nume < 0 || deno < 0 ) {
        nume = -abs(nume);
        deno = abs(deno);
   }
}

Rational::Rational()
{
	nume = 0;
	deno = 1;
}
Rational::Rational(int x,int y)
{
	nume = x;
	deno = y;
}
Rational::Rational(int x)
{
      nume = x;
      deno = 1;
 }

ostream& operator << (ostream& out, Rational& a )
{
	out<<a.nume<<"/"<<a.deno;
	return out;
 } 
Rational Rational::operator +(Rational b)
{
	Rational r;
	r.nume = nume * b.deno + deno * b.nume;
	r.deno = deno * b.deno;
	r.optimize();
	return r;
}
Rational::operator int()
{
	return nume/deno;
}
Rational::operator double()
{
	return (double)nume/deno;
}
int main() {
    Rational r1(3, 5), r2(9, 4), r3, r4;
    cout << "r1 : " << r1 << endl;
    cout << "r2 : " << r2 << endl;

    int n = 3;
    r3 = r2 + Rational(n);
    //r3 = r2 + n;  /// 禁止了隐式转换构造函数，所以不能使用
    cout << "r3 = r2 + 3 : " << r3 << endl;

    r4 = Rational(n) + r1;  /// 显式调用转换构造函数 Rational(n)
    cout << "r4 = Rational(n) + r1 : " << r4 << endl;

    int a = n + int(r2);  /// 显式调用类型转换函数 int(n)
    //int a = n + r2;  /// 已禁止了隐式调用类型转换函数 Rational(n)
    cout << "a = n + int(r2) : " << a << endl;
    a = Rational(n) + r2;  /// 显式调用转换构造函数 Rantional(n) 转换为 Rational对象 后，再与 r2 运算，然后把结果转成 int 类型，赋值给 a
    cout << "a = Rational(n) + r2 : " << a << endl;

    cout << fixed << setprecision(2);
    double b = 3.14 + double(r2);  /// 显式调用类型转换函数 double(n)
    cout << "b = 3.14 + double(r2) : " << b << endl;
    b = Rational(3.14) + r2;  /// 先显式调用转换构造函数 Rational(3.14) 转换为 Rational对象 后，与 r2 运算，然后把结果转成 int 类型，赋值给 b
    cout << "b = Rational(3.14) + r2 : " << b << endl;

    return 0;
}

9.2 重载单目运算符：前后自增自减

设计屏幕上的点 Point类，实现：
1、私有数据成员：x坐标值，y坐标值，均取非负值，x不超过4096，y不超过2160
2、默认构造函数
3、两个整形参数的构造函数
4、前、后自增运算符，重载为成员函数
5、前、后自减运算符，重载为友元函数
6、流插入运算符

#include <iostream>
using namespace std;

class Point
{
	private:
		int x,y;
	public:
		Point()
		{
			x = 0;
			y = 0;
		}
		Point(int a, int b)
		{
			if(a>0 && a<=4096)
			 x = a;
			if(b>0 && b<=2160)
			 y = b;
		}
		Point& operator++()
		{
			++x;
			++y;
			return *this;
		 } 
		Point operator++(int)
		{
			Point t = *this;
			x++;
			y++;
			return t;
		}
		friend Point&operator--(Point& p)
		{
			--p.x;
			--p.y;
			return p;
		}
		friend Point operator--(Point& p,int)
		{
			Point t = p;
			p.x--;
			p.y--;
			return t;
		}
		friend ostream&operator<<(ostream& out,Point& p)
		{
			return out<<" ("<<p.x<<","<<p.y<<")";
		}
		
};

int main() {
    Point p1(10, 10), p2(150, 150), p3(20, 20), p4(160, 160), p5;

    cout << "p1 = " << p1 << endl;

    /// 测试前置自增
    ++p1;
    cout << "++p1 = " << p1 << endl;

    cout << "p3 = " << p3 << endl;
    /// 测试后置自增
    p5 = p3++;
    cout << "p5 = p3++ ,  p3 : " << p3 << "   p5 : " << p5 << endl;

    cout << "p2 = " << p2 << endl;

    /// 测试前置自减
    --p2;
    cout << "--p2 = " << p2 << endl;

    cout << "p4 = " << p4 << endl;
    /// 测试后置自增
    p5 = p4--;
    cout << "p5 = p4-- ,  p4 : " << p4 << "   p5 : " << p5 << endl;

    return 0;
}