面向对象程序设计-实验四 类的运算符重载

已于 2024-04-06 13:51:54 修改
阅读量193 收藏 4
点赞数 4
分类专栏： 面向对象程序设计 文章标签： 算法 c++ 开发语言
于 2024-04-06 13:42:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60211220/article/details/137427033
版权
2022/4/24
1.补充完成以下程序
#include<iostream.h>
#include<stdlib.h>
class vector
{ public :
     vector( int size =1 ) ;       ~vector() ;
     int & operator[] ( int i ) ;
     friend ostream & operator << ( ostream & output , vector & ) ;
     friend istream & operator >> ( istream & input, vector & ) ;
  private :  
      int * v ;
int len ;
};
void main()
{ int k ;
  cout << "Input the length of vector A :\n" ;     cin >> k ;
  vector A( k ) ;
  cout << "Input the elements of vector A :\n" ;     cin >> A ;
  cout << "Output the elements of vector A :\n" ;
  cout << A ;
}

#include<iostream>
#include<stdlib.h>
using namespace std;
class vector{
public:
    vector(int size = 1);
    ~vector();
    int& operator[] (int i);
    friend ostream& operator << (ostream& output, vector&);
    friend istream& operator >> (istream& input, vector&);
private:
    int* v;
    int len;
};
vector::vector(int size) :len(size) {
    if (size == 0) {
        v = nullptr;
    }
    else {
        v = new int[size];
    }
}//开辟数组空间
vector::~vector(){
    if (v) {
        delete[]v;
    }
}//析构函数
int& vector::operator[](int i) {
    return v[i];
}//访问数组元素
ostream& operator<<(ostream& output, vector& x) {
    for (int i = 0; i < x.len; i++) {
        output << x.v[i] << " ";
    }
    return output;
}//流输出
istream& operator>>(istream& input, vector& x) {
    for (int i = 0; i < x.len; i++) {
        input >> x.v[i];
    }
    return input;
}//流插入
int main(){
    int k;
    cout << "Input the length of vector A :\n";
    cin >> k;
    vector A(k);
    cout << "Input the elements of vector A :\n";
    cin >> A;
    cout << "Output the elements of vector A :\n";
    cout << A;
}
2.建立一个数组类，它能检测范围，以确保数组下标不会越界，允许用赋值运算符把一个数组赋给另外一个数组。数组对象自动知道数组的大小，不需要将数组的大小传递给函数。
#include<iostream>
#include<string>
using namespace std;
class CArray {
public:
    CArray(int s = 5);
    ~CArray();
    CArray(CArray& a);
    int& operator[] (int i);
    CArray& operator=(const CArray& a);
    friend ostream& operator << (ostream& output, CArray& a);
    friend istream& operator >> (istream& input, CArray& a);
private:
    int* ptr;
    int size = 5;//数组长度为5
};
CArray::CArray(int s) {
    ptr = new int[s];
}//开辟数组空间
CArray::~CArray() {
    if (ptr) {
        delete[]ptr;
    }
}//析构函数
CArray::CArray(CArray& a) {
    if (!a.ptr) {
        ptr = nullptr;
        size = 0;
        return;
    }
    ptr = new int[a.size];
    memcpy(ptr, a.ptr, sizeof(int) * a.size);
    size = a.size;
}
int& CArray::operator[](int i) {
    return ptr[i];
}//访问数组元素
CArray& CArray::operator=(const CArray& a) {
    if (ptr == a.ptr) {
        return *this;
    }
    if (a.ptr == nullptr) {
        if (ptr) {
            delete[]ptr;
        }
        ptr = nullptr;
        size = 0;
        return *this;
    }
    memcpy(ptr, a.ptr, sizeof(int) * a.size);
    size = a.size;
    return *this;
}//赋值
ostream& operator<<(ostream& output, CArray& x) {
    for (int i = 0; i < x.size; i++) {
        output << x.ptr[i] << " ";
    }
    return output;
}//流输出
istream& operator>>(istream& input, CArray& x) {
    int i = 0;
    do {
        if (i >= 5) {
            cout << "下标越界" << endl;
            return input;
        }
        input >> x.ptr[i];
        i = i + 1;
    } while (cin.get() != '\n');
    return input;
}//流插入
int main() {
    CArray a, b;
    cout << "请输入数组a：" << endl;
    cin >> a;
    cout << "请输入数组b：" << endl;
    cin >> b;
    cout << "将数组b赋值给数组a 输出数组a" << endl;
    a = b;
    cout << b;
    return 0;
}
3.RationalNumber（分数类）

1）建立构造函数，它能防止分母为0，当分数不是最简形时进行约分以及避免分母为负数
2）重载加法、减法、乘法以及除法运算符
3）重载关系运算符和相等运算符。
4）能利用类型转换方法，实现分数与整数类型相加

#include<iostream>
using namespace std;
void f(double& x, double& y) {
	int k = x;
	if (x > y) {
		k = y;
	}
	for (int i = 2; i < k; i++) {
		if ((int)x % i == 0 && (int)y % i == 0) {
			x = x / i;
			y = y / i;
		}
	}
	if (y < 0) {
		x = -x;
		y = -y;
	}
}//化简函数
class RationalNumber {
public:
	RationalNumber(double z = 0, double m = 1) :fz(z), fm(m) {
		f(fz, fm);
	}//构造函数
	RationalNumber(int i);//类型转换函数
	void display() {
		cout << fz << "/" << fm << endl;
	}
	friend RationalNumber operator+(const RationalNumber& a, const RationalNumber& b);//重载运算符+
	friend RationalNumber operator-(const RationalNumber& a, const RationalNumber& b);//重载运算符-
	friend RationalNumber operator*(const RationalNumber& a, const RationalNumber& b);//重载运算符*
	friend RationalNumber operator/(const RationalNumber& a, const RationalNumber& b);//重载运算符/
	friend bool operator>(const RationalNumber& a, const RationalNumber& b);//重载运算符>
	friend bool operator>=(const RationalNumber& a, const RationalNumber& b);//重载运算符>=
	friend bool operator<(const RationalNumber& a, const RationalNumber& b);//重载运算符<
	friend bool operator<=(const RationalNumber& a, const RationalNumber& b);//重载运算符<=
	friend bool operator==(const RationalNumber& a, const RationalNumber& b);//重载运算符==
	friend bool operator!=(const RationalNumber& a, const RationalNumber& b);//重载运算符!=
private:
	double fz;//分子
	double fm;//分母
};
RationalNumber::RationalNumber(int i) {
	fz = i;
	fm = 1;
	f(fz, fm);
}
RationalNumber operator+(const RationalNumber& a, const RationalNumber& b) {
	return RationalNumber(a.fz * b.fm + a.fm * b.fz, a.fm * b.fm);
}
RationalNumber operator-(const RationalNumber& a, const RationalNumber& b) {
	return RationalNumber(a.fz * b.fm - a.fm * b.fz, a.fm * b.fm);
}
RationalNumber operator*(const RationalNumber& a, const RationalNumber& b) {
	return RationalNumber(a.fz * b.fz, a.fm * b.fm);
}
RationalNumber operator/(const RationalNumber& a, const RationalNumber& b) {
	return RationalNumber(a.fz * b.fm, a.fm * b.fz);
}
bool operator>(const RationalNumber& a, const RationalNumber& b) {
	if (a.fz * b.fm > a.fm * b.fz) {
		return 1;
	}
	else {
		return 0;
	}
}
bool operator>=(const RationalNumber& a, const RationalNumber& b) {
	if (a.fz * b.fm >= a.fm * b.fz) {
		return 1;
	}
	else {
		return 0;
	}
}
bool operator<(const RationalNumber& a, const RationalNumber& b) {
	if (a.fz * b.fm < a.fm * b.fz) {
		return 1;
	}
	else {
		return 0;
	}
}
bool operator<=(const RationalNumber& a, const RationalNumber& b) {
	if (a.fz * b.fm <= a.fm * b.fz) {
		return 1;
	}
	else {
		return 0;
	}
}
bool operator==(const RationalNumber& a, const RationalNumber& b) {
	if (a.fz * b.fm == a.fm * b.fz) {
		return 1;
	}
	else {
		return 0;
	}
}
bool operator!=(const RationalNumber& a, const RationalNumber& b) {
	if (a.fz * b.fm != a.fm * b.fz) {
		return 1;
	}
	else {
		return 0;
	}
}
int main() {
	double x, y;
	cout << "请输入分子和分母：";
	cin >> x >> y;
	RationalNumber Rational1(x, y);
	cout << "请输入加上的数：";
	cin >> x;
	Rational1 = Rational1 + x;
	cout << "请输入减去的数的分子和分母：";
	cin >> x >> y;
	RationalNumber Rational2(x, y);
	Rational1 = Rational1 - Rational2;
	cout << "请输入乘上的数的分子和分母：";
	cin >> x >> y;
	RationalNumber Rational3(x, y);
	Rational1 = Rational1 * Rational3;
	cout << "请输入除以的数的分子和分母：";
	cin >> x >> y;
	RationalNumber Rational4(x, y);
	Rational1 = Rational1 / Rational4;
	cout << "分数1为：";
	Rational1.display();
	cout << "分数2为：";
	Rational2.display();
	cout << "分数1是否大于分数2：";
	if (Rational1 > Rational2) {
		cout << "True" << endl;
	}
	else {
		cout << "False" << endl;
	}
	cout << "分数1是否大于等于分数2：";
	if (Rational1 >= Rational2) {
		cout << "True" << endl;
	}
	else {
		cout << "False" << endl;
	}
	cout << "分数1是否小于分数2：";
	if (Rational1 < Rational2) {
		cout << "True" << endl;
	}
	else {
		cout << "False" << endl;
	}
	cout << "分数1是否小于等于分数2：";
	if (Rational1 <= Rational2) {
		cout << "True" << endl;
	}
	else {
		cout << "False" << endl;
	}
	cout << "分数1是否等于分数2：";
	if (Rational1 == Rational2) {
		cout << "True" << endl;
	}
	else {
		cout << "False" << endl;
	}
	cout << "分数1是否不等于分数2：";
	if (Rational1 != Rational2) {
		cout << "True" << endl;
	}
	else {
		cout << "False" << endl;
	}
	return 0;
}
4.开发一个多项式类Polynomial，多项式的每一项用数组表示，每项包含一个系数和一个指数。

开发一个完整的Polynomial类，包含构造函数、析构函数以及 get函数和set函数，该类还要提供下述重载的运算符
a)重载+
b)重载-
c)重载赋值运算符
d)重载乘法运算符
e)重载+=

#include<iostream>
#include<string>
using namespace std;
class Polynomial {
public:
    Polynomial(int s = 0);
    ~Polynomial();
    Polynomial(const Polynomial& po);
    int get(int ex);
    int gets();
    void set(double co, int ex);
    Polynomial& operator=(const Polynomial& po);//重载运算符=
    friend Polynomial operator+(const Polynomial& po1, const Polynomial& po2);//重载运算符+
    friend Polynomial operator-(const Polynomial& po1, const Polynomial& po2);//重载运算符-
    friend Polynomial operator*(const Polynomial& po1, const Polynomial& po2);//重载运算符*
    friend Polynomial& operator+= (Polynomial& po1, Polynomial& po2);//重载运算符+=
private:
    double* coef;
    int size;
};
Polynomial::Polynomial(int s) {
    size = s;
    coef = new double[size];
    int i = 0;
    for (int i = 0; i < size; i++) {
        coef[i] = 0;
    }
}//开辟数组空间
Polynomial::~Polynomial() {
    if (coef) {
        delete[] coef;
    }
}//析构函数
Polynomial::Polynomial(const Polynomial& po) {
    int i = 0;
    size = po.size;
    coef = new double[size];
    while (i < size) {
        this->set(po.coef[i], i);
        i = i + 1;
    }
}//复制构造函数
int Polynomial::get(int ex) {
    return coef[ex];
}
int Polynomial::gets() {
    return size;
}
void Polynomial::set(double co, int ex) {
    coef[ex] = co;
}
Polynomial& Polynomial::operator=(const Polynomial& po) {
    int i = 0;
    size = po.size;
    delete[] coef;
    coef = new double[size];
    while (i < size) {
        this->set(po.coef[i], i);
        i = i + 1;
    }
    return *this;
}
Polynomial operator+(const Polynomial& po1, const Polynomial& po2) {
    int i = 0;
    Polynomial po3(max(po1.size, po2.size));
    while (i < po3.size) {
        if (i < min(po1.size, po2.size)) {
            po3.coef[i] = po1.coef[i] + po2.coef[i];
        }
        else {
            if (po1.size > po2.size) {
                po3.coef[i] = po1.coef[i];
            }
            else {
                po3.coef[i] = po2.coef[i];
            }
        }
        i = i + 1;
    }
    return po3;
}
Polynomial operator-(const Polynomial& po1, const Polynomial& po2) {
    int i = 0;
    Polynomial po3(max(po1.size, po2.size));
    while (i < po3.size) {
        if(i < min(po1.size, po2.size)) {
            po3.coef[i] = po1.coef[i] - po2.coef[i];
        }
        else {
            if (po1.size > po2.size) {
                po3.coef[i] = po1.coef[i];
            }
            else {
                po3.coef[i] = -po2.coef[i];
            }
        }
        i = i + 1;
    }
    return po3;
}
Polynomial operator*(const Polynomial& po1, const Polynomial& po2) {
    int i = 0;
    Polynomial po3(po1.size + po2.size - 1);
    while (i < po1.size) {
        int j = 0;
        while (j < po2.size) {
            po3.coef[i + j] = po3.coef[i + j] + po1.coef[i] * po2.coef[j];
            j = j + 1;
        }
        i = i + 1;
    }
    return po3;
}
Polynomial& operator+= (Polynomial& po1, Polynomial& po2) {
    po1 = po1 + po2;
    return po1;
}
void display(Polynomial po) {
    int flag = 1;
    for (int i = 0; i < po.gets(); i++) {
        if (flag) {
            if (po.get(i) != 0) {
                if (i == 0) {
                    cout << po.get(i);
                }
                else {
                    cout << po.get(i) << "x^" << i;
                }
                flag = 0;
            }
        }
        else {
            if (po.get(i) > 0) {
                cout << "+" << po.get(i) << "x^" << i;
            }
            else if (po.get(i) < 0) {
                cout << po.get(i) << "x^" << i;
            }
        }
    }
    cout << endl;
}
int main() {
    Polynomial po1(5);
    po1.set(2, 0);
    po1.set(3, 4);
    cout << "多项式1为：";
    display(po1);
    Polynomial po2(6);
    po2.set(2, 1);
    po2.set(1, 2);
    cout << "多项式2为：";
    display(po2);
    Polynomial po3(po1);
    cout << "多项式3为：";
    display(po3);
    Polynomial po4(po3);
    po4 = po1 + po3;
    cout << "多项式1加多项式3为：";
    display(po4);
    po4 = po2 - po3;
    cout << "多项式2减多项式3为：";
    display(po4);
    po4 = po1 * po3;
    cout << "多项式1乘多项式3为：";
    display(po4);
    po3 += po2;
    cout << "多项式3加上多项式2后为：";
    display(po3);
    return 0;
}
实验总结
  1. 注意new和delete的使用
  2. 注意指针的深拷贝
  3. 注意运算符重载函数是成员函数还是友元函数
  4. 注意项数相乘数目下标变化
  5. 注意函数中指针数组的越界
闻闻闻闻笛声
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【C++面向对象程序设计】实验四 运算符重载
m0_72318954的博客
10-31 1115
运算符重载实验题目
【C++面向对象程序设计】CH4 运算符重载
m0_72318954的博客
10-24 1039
运算符重载相关介绍
广州大学面向对象程序设计1-7实验报告.zip
03-27
实验1-类与对象 实验2-运算符重载 实验三-继承与多态性 实验四-模板 实验5 综合应用程序一 实验六-MFC类库的使用 实验7 综合应用程序二
C++面向对象程序设计 - 运算符重载
觉醒法师的专栏
04-20 1177
函数重载就是对一个已有的函数赋予新的含义，使之实现新的功能。因此一个函数名就可以用来代表不同功能的函数，也就是一名多用。运算符也可以重载，即运算符重载（operator overloading）。运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。运算符重载实质上是函数的重载。
（面向对象程序设计）实验四 运算符重载
weixin_44209522的博客
06-12 1019
一、实验目的 ·学习掌握重定义与类有关的运算符。 ·把握重载运算符的时机。 ·学习掌握把一个类对象转换为另一个类对象。 ·学习掌握重载为成员与友元的区别及其带参数的情况。 ·学习掌握值返回与引用返回的区别及应用时机。 二、实验内容 (1) 生成一个表示复数的类FS。复数的实部sb和虚部xb作为其数据成员。提供成员函数disp()显示复数（格式：-3+5i或6-2i）,重载“+”、“-”为FS类的成员函数,用来计算两个复数的和、差。 思路导航： ① 定义类，设计构造函数和显示函数print(); ② 重
面向对象程序设计实验 - 实验7 多态性：函数与运算符重载
qq_41626672的博客
08-10 1450
实验七 多态性—函数与运算符重载 目录 实验七 多态性—函数与运算符重载 7.1 实验目的 7.2 实验内容 7.2.1程序阅读 7.2.2 程序设计 7.3思考题 7.1 实验目的 1．理解动态联编和动态联编的概念； 2．理解掌握成员函数方式运算符重载； 3．理解掌握友元函数方式运算符重载； 4．理解掌握++、--、=运算符的重载。 7.2 实验内容 7.2.1程序阅读 1．理解下面的程序，并在VC++6.0下运行查看结果，回答程序后面的问题。 #include "iost
桂电C++面向对象程序设计实验 : 实验四 运算符重载
老权仔的博客
05-08 1360
桂电C++面向对象程序设计实验: 实验四 运算符重载 实验内容： （1）声明一个复数类Complex，重载运算符“+”，“-”，“*”，“/”，使之能用于复数的加、减、乘、除，运算符重载函数作为Complex 类的成员函数。编程序，分别求两个复数之和、差、积和商。本题是《C++面向对象程序设计》第4章第2题。 请思考：你编的程序能否用于一个整数与一个复数的算术运算？如4 + ( 5 - 2...
面向对象程序设计第八章：运算符重载
zombotany的博客
04-08 1914
对时钟类进行运算符重载 【问题描述】对时钟类进行重载【输入形式】 【输出形式】 【样例输入】 【样例输出】 【样例说明】 【评分标准】 #include <iostream> using namespace std; class Clock //时钟类声明 { public: //外部接口 Clock(int NewH=0, int NewM=0, int NewS=0); void ShowTime(); Clock operator ++(); //前置单目运算符重载
面向对象程序设计——运算符重载
Liyolo007的博客
05-22 1120
运算符重载 运算符重载的概念 实质 为运算符定义新的运算功能，使它除具备有原来系统规定的功能外，还具备新定义的功能。运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的C++多态。目的在于让人能够用同名的函数来完成不同的基本操作。要重载运算符，需要使用被称为运算符函数的特殊函数形式，运算符函数形式：operator p（argument-list）//operator 后面的’p’为要重载的运算符符号。 规则 C++规定重载后的运算符的操作对象必须至少有一个是用户定义的类型（防止二义性）
程序设计与算法（三）C++面向对象程序设计笔记 第四周 运算符重载
zimuzi2019的博客
10-20 545
程序设计与算法（三）C++面向对象程序设计笔记 第四周 运算符重载
面向对象程序设计语言C++---第5章-运算符重载.ppt
07-04
面向对象程序设计语言C++---第5章-运算符重载.ppt
实验四 运算符重载.zip
11-30
C++面向对象程序设计实验报告
四、运算符重载_面向对象程序设计..pptx
11-26
四、运算符重载_面向对象程序设计..pptx
面向对象程序设计C++运算符重载
05-18
计算机中的颜⾊采⽤RGB颜⾊系统，也就是每种颜色红、绿...3. 用运算符重载的方式运算。 4. 在上述运算过程中，实现颜色值的边界检查，即运算过程中，某个颜色分量值大于255，则直接赋值255，如果值小于0，则直接赋值0。
面向对象程序设计上机练习十二（运算符重载
Horizonhui
12-02 375
面向对象程序设计上机练习十二（运算符重载） Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 处理一个复数与一个double数相加的运算，结果存放在一个double型变量d1中，输出d1的值。定义Complex(复数)类，在成员函数中包含重载类型转换运算符：operat
Leecode---347：输出前k个高频元素（使用unordered_map）
最新发布
qq_41920323的博客
05-30 194
unordered_map实现输出前k个高频元素
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 430
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
算法训练营day41
stmfresher的博客
05-27 321
动态规划理论基础（主要就是确定动态规划的几个步骤）
并查集拓展（扩展域并查集）
Qlarkstar的博客
05-29 768
事实证明，扩展域并查集应该在带权并查集前面讲的，因为比较好理解，而且回过头看带权并查集可能也会更轻松一些。
程序设计二（面向对象）_实训7_赋值运算符重载
04-29
赋值运算符重载是指为一个类定义一个赋值运算符，以实现在对象间赋值的操作。在 C++ 中，赋值运算符重载函数的函数名必须为 operator=，其格式如下： ``` class_name& operator=(const class_name& rhs){ //实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闻闻闻闻笛声

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值