实验四运算符重载

最新推荐文章于 2023-03-30 09:00:00 发布
最新推荐文章于 2023-03-30 09:00:00 发布
阅读量736 收藏 13
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/galaxyrt/article/details/118251906
版权

Singer类

描述

实现一个Singer类，通过以下测试：

输入

输入包含两行，第一行为歌手s1的信息，第二行为歌手s2的信息，每位歌手的信息包括姓名（不包含空格）、性别、年龄 和 分数；姓名、性别、年龄和分数之间用空格分隔

输出

输出为三行，前两行分别是歌手s1和s2的信息，第三行根据s1和s2比较结果输出（s1和s2的比较结果和他们的分数的比较结果一致），具体参见主函数

nt main()

{

Singer s1,s2;

cin>>s1>>s2;

cout<<s1<<"\n"<<s2<<endl;

if(s1>s2)

cout<<s1.getName()<<"'s score is higher than "<<s2.getName()<<"'s.\n";

else if(s1==s2)

cout<<s1.getName()<<"'s score is equal to "<<s2.getName()<<"'s.\n";

else

cout<<s1.getName()<<"'s score is lower than "<<s2.getName()<<"'s.\n";

return 0;

}

输入样例 1 

Mary F 28 99.5
Peter M 26 98

输出样例 1

Mary F 28 99.5
Peter M 26 98
Mary's score is higher than Peter's.
#include<iostream>
using namespace std;
class Singer
{
private:
    string name;
    char sex;
    int age;
    double grade;
public:
    string getName();
    Singer(string name = "", char s = '?', int a = 0, double n = 0);
    friend istream& operator>>(istream& stream, Singer& s);
    friend ostream& operator<<(ostream& stream, const Singer& s);
    friend bool operator>(const Singer& s1, const Singer& s2)
    {
        if (s1.grade > s2.grade)
            return true;
        else
            return false;
    }
    friend bool operator==(const Singer& s1, const Singer& s2)
    {
        if (s1.grade == s2.grade)
            return true;
        else
            return false;
    }
};

Singer::Singer(string name, char s, int a,double n ):name(name),sex(s),age(a),grade(n){}  

istream& operator>>(istream& stream, Singer& s)
{
    stream >> s.name >> s.sex >> s.age >> s.grade;
    return stream;
}

ostream& operator<<(ostream& stream, const Singer& s)  
{
    stream << s.name << " " << s.sex << " " << s.age << " " << s.grade;
    return stream;
}

string Singer::getName()
{
    return name;
}

int main()
{

    Singer s1, s2;
    cin >> s1 >> s2;
    cout << s1 << "\n" << s2 << endl;

    if (s1 > s2)
        cout << s1.getName() << "'s score is higher than " << s2.getName() << "'s.\n";
    else if (s1 == s2)
        cout << s1.getName() << "'s score is equal to " << s2.getName() << "'s.\n";
    else
        cout << s1.getName() << "'s score is lower than " << s2.getName() << "'s.\n";

    return 0;
}

第二题：

Sales_data类

描述

实现以下Sales_data类（包括它的友元函数）：

class Sales_data {

//依次输入书号、销量和收入

friend istream & operator>>(istream&, Sales_data &);

//依次输出书号、销量、收入和均价

friend ostream & operator<<(ostream &, const Sales_data &);

friend bool operator==(const Sales_data &, const Sales_data &);

friend bool operator!=(const Sales_data &, const Sales_data &);

// for "+", assume that both objects refer to the same book

friend Sales_data operator+(const Sales_data &, const Sales_data &);

public:

Sales_data(): units_sold(0), revenue(0.0) {}

Sales_data(const string & s, unsigned n, double r): bookNo(s), units_sold(n), revenue(r) {}

string get_bookNo() const;

// for "+=", assume that both objects refer to the same book

Sales_data & operator+=(const Sales_data &);

private:

double avg_price() const;  //均价，等于收入除以销量

string bookNo;        //书号

unsigned units_sold; //销量

double revenue;      //收入

};

通过以下main函数的测试

int main(){

Sales_data item1,item2;

while(cin>>item1>>item2){

cout<

if(item1==item2)

cout<

if(item1!=item2)

cout<

cout<<(item1+item2)<<"\n";

item1 += item2;

cout<

}

return 0;

}

输入

输入多组数据，每组数据两行，每行表示1个Sales_data对象，依次是书号、销量和收入

输出

对于每组数据，输出5行，具体参见main函数和输出样例

输入样例 1 

001 10 100.0
001 10 100.0

输出样例 1

001 10 100 10
001 10 100 10
001 equals 001
001 20 200 10
001 20 200 10

输入样例 2 

002 5 250
003 8 400

输出样例 2

002 5 250 50
003 8 400 50
002 doesn't equal 003
002 13 650 50
002 13 650 50
#include<iostream>
using namespace std;

class Sales_data
{
	//依次输入书号、销量和收入
	friend istream& operator>>(istream&, Sales_data&);
	//依次输出书号、销量、收入和均价
	friend ostream& operator<<(ostream&, const Sales_data&);
	friend bool operator==(const Sales_data&, const Sales_data&);
	friend bool operator!=(const Sales_data&, const Sales_data&);
	// for "+", assume that both objects refer to the same book
	friend Sales_data operator+(const Sales_data&, const Sales_data&);
public:
	Sales_data() : units_sold(0), revenue(0.0) {}
	Sales_data(const string& s, unsigned n, double r) : bookNo(s), units_sold(n), revenue(r) {}
	string get_bookNo() const;
	// for "+=", assume that both objects refer to the same book
	Sales_data& operator+=(const Sales_data&);
private:
	double avg_price() const;  //均价，等于收入除以销量
	string bookNo;        //书号
	unsigned units_sold; //销量
	double revenue;      //收入
};

double Sales_data::avg_price() const
{
	return(revenue / units_sold);
}
ostream& operator<<(ostream& stream, const Sales_data& s)
{
	stream << s.bookNo << " " << s.units_sold << " " << s.revenue << " " << s.avg_price();    //函数的调用 
	return stream;
}
istream& operator>>(istream& stream, Sales_data& s)
{

	stream >> s.bookNo >> s.units_sold >> s.revenue;
	return stream;
}



bool operator==(const Sales_data& s1, const Sales_data& s2)
{
	if (s1.units_sold == s2.units_sold)
		return true;
	else
		return false;
}


bool operator!=(const Sales_data& s1, const Sales_data& s2)
{
	if (s1.units_sold != s2.units_sold)
		return true;
	else
		return false;
}

Sales_data operator+(const Sales_data& s1, const Sales_data& s2)
{
	Sales_data s;
	s.bookNo = s1.bookNo;
	s.units_sold = s1.units_sold + s2.units_sold;
	s.revenue = s1.revenue + s2.revenue;
	return s;
}

string Sales_data::get_bookNo() const
{
	return bookNo;
}
Sales_data& Sales_data::operator+=(const Sales_data& s2)  
{

	units_sold += s2.units_sold;
	revenue += s2.revenue;
	return *this;
}


int main() {
	Sales_data item1, item2;
	while (cin >> item1 >> item2) {
		cout << item1 << "\n" << item2 << "\n";
		if (item1 == item2)
			cout << item1.get_bookNo() << " equals " << item2.get_bookNo() << "\n";
		if (item1 != item2)
			cout << item1.get_bookNo() << " doesn't equal " << item2.get_bookNo() << "\n";
		cout << (item1 + item2) << "\n";
		item1 += item2;
		cout << item1 << "\n";
	}
	return 0;
}

Complex类

描述

实现以下复数类Complex，通过运算符重截，实现复数的输入输出以及相关运算。

class Complex

{

private:

double x;

double y;

public:

Complex(double x = 0.0, double y = 0.0);

Complex & operator+=(const Complex &);

Complex & operator-=(const Complex &);

Complex & operator*=(const Complex &);

Complex & operator/=(const Complex &);

friend Complex operator+(const Complex &, const Complex &);

friend Complex operator-(const Complex &, const Complex &);

friend Complex operator*(const Complex &, const Complex &);

friend Complex operator/(const Complex &, const Complex &);

friend bool operator==(const Complex &, const Complex &);

friend bool operator!=(const Complex &, const Complex &);

friend ostream & operator<<(ostream &, const Complex &);

friend istream & operator>>(istream &, Complex &);

};

通过以下主函数测试：

int main()

{

Complex c1, c2;

cin >> c1 >> c2;

cout << "c1 = " << c1 << "\n" << "c2 = " << c2 << endl;

cout << "c1+c2 = " << c1 + c2 << endl;

cout << "c1-c2 = " << c1 - c2 << endl;

cout << "c1*c2 = " << c1 * c2 << endl;

cout << "c1/c2 = " << c1 / c2 << endl;

cout << (c1 += c2) << endl;

cout << (c1 -= c2) << endl;

cout << (c1 *= c2) << endl;

cout << (c1 /= c2) << endl;

cout << (c1 == c2) << " " << (c1 != c2) << endl;

return 0;

}

输入

输入有两行，每行输入两个表示复数c1和c2的浮点数。

输出

输出一共有11行，分别表示复数之间的各项操作，具体参见主函数和输出样例

输入样例 1 

-4 6
2 5

输出样例 1

c1 = -4 + 6i
c2 = 2 + 5i
c1+c2 = -2 + 11i
c1-c2 = -6 + 1i
c1*c2 = -38 + -8i
c1/c2 = 0.758621 + 1.10345i
-2 + 11i
-4 + 6i
-38 + -8i
-4 + 6i
0 1

提示

复数加法公式：(a + bi) + (c + di) = (a + c) + (b + d)i

复数减法公式：(a + bi) - (c + di) = (a - c) + (b - d)i

复数乘法公式：(a + bi) * (c + di) = (ac - bd) + (ad + bc)i

复数除法公式：(a + bi) / (c + di) = [(ac + bd) / (c * c + d * d)] + [(bc - ad) / (c * c + d * d)]i

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

class Complex
{
private:
    double x;
    double y;
public:
    Complex(double x = 0.0, double y = 0.0);
    Complex& operator+=(const Complex&);
    Complex& operator-=(const Complex&);
    Complex& operator*=(const Complex&);
    Complex& operator/=(const Complex&);
    friend Complex operator+(const Complex&, const Complex&);
    friend Complex operator-(const Complex&, const Complex&);
    friend Complex operator*(const Complex&, const Complex&);
    friend Complex operator/(const Complex&, const Complex&);
    friend bool operator==(const Complex&, const Complex&);
    friend bool operator!=(const Complex&, const Complex&);
    friend ostream& operator<<(ostream&, const Complex&);
    friend istream& operator>>(istream&, Complex&);
};

Complex::Complex(double x, double y) {
    this->x = x;
    this->y = y;
}

Complex operator*(const Complex& b1, const Complex& b2)
{
    Complex s;
    s.x = b1.x * b2.x - b1.y * b2.y;
    s.y = b1.x * b2.y + b1.y * b2.x;
    return s;
}

Complex& Complex::operator+=(const Complex& s)
{
    x += s.x;
    y += s.y;
    return *this;
}

Complex& Complex::operator-=(const Complex& s)
{
    x -= s.x;
    y -= s.y;
    return *this;
}

Complex operator/(const Complex& s1, const Complex& s2)
{
    Complex s;
    s.x = (s1.x * s2.x + s1.y * s2.y) / (s2.x * s2.x + s2.y * s2.y);
    s.y = (s1.y * s2.x - s1.x * s2.y) / (s2.x * s2.x + s2.y * s2.y);
    return s;
}

Complex& Complex::operator*=(const Complex& c)   
{
    *this = *this * c;
    return *this;
}

Complex& Complex::operator/=(const Complex& p)
{
    *this = *this / p;
    return *this;
}
Complex operator+(const Complex& s1, const Complex& s2)
{
    Complex s;
    s.x = s1.x + s2.x;
    s.y = s1.y + s2.y;
    return s;
}

Complex operator-(const Complex& s1, const Complex& s2)
{
    Complex s;
    s.x = s1.x - s2.x;
    s.y = s1.y - s2.y;
    return s;
}


bool operator==(const Complex& s1, const Complex& s2)
{
    if (s1.x == s2.x || s1.y == s2.y)
        return true;
    else
        return false;
}

bool operator!=(const Complex& s1, const Complex& s2)
{
    if (s1.x != s2.x || s1.y != s2.y)
        return true;
    else
        return false;
}

istream& operator>>(istream& stream, Complex& s)
{
    stream >> s.x >> s.y;
    return stream;
}
ostream& operator<<(ostream& stream, const Complex& s)
{
    stream << s.x << " + " << s.y << "i";
    return stream;
}



int main()
{
    Complex c1, c2;
    cin >> c1 >> c2;
    cout << "c1 = " << c1 << "\n" << "c2 = " << c2 << endl;
    cout << "c1+c2 = " << c1 + c2 << endl;
    cout << "c1-c2 = " << c1 - c2 << endl;
    cout << "c1*c2 = " << c1 * c2 << endl;
    cout << "c1/c2 = " << c1 / c2 << endl;
    cout << (c1 += c2) << endl;
    cout << (c1 -= c2) << endl;
    cout << (c1 *= c2) << endl;
    cout << (c1 /= c2) << endl;
    cout << (c1 == c2) << " " << (c1 != c2) << endl;
    return 0;
}

String类

描述

实现以下String类：

class Complex

{

private:

double x;

double y;

public:

Complex(double x = 0.0, double y = 0.0);

Complex & operator+=(const Complex &);

Complex & operator-=(const Complex &);

Complex & operator*=(const Complex &);

Complex & operator/=(const Complex &);

friend Complex operator+(const Complex &, const Complex &);

friend Complex operator-(const Complex &, const Complex &);

friend Complex operator*(const Complex &, const Complex &);

friend Complex operator/(const Complex &, const Complex &);

friend bool operator==(const Complex &, const Complex &);

friend bool operator!=(const Complex &, const Complex &);

friend ostream & operator<<(ostream &, const Complex &);

friend istream & operator>>(istream &, Complex &);

};

通过以下主函数测试：

int main()

{

Complex c1, c2;

cin >> c1 >> c2;

cout << "c1 = " << c1 << "\n" << "c2 = " << c2 << endl;

cout << "c1+c2 = " << c1 + c2 << endl;

cout << "c1-c2 = " << c1 - c2 << endl;

cout << "c1*c2 = " << c1 * c2 << endl;

cout << "c1/c2 = " << c1 / c2 << endl;

cout << (c1 += c2) << endl;

cout << (c1 -= c2) << endl;

cout << (c1 *= c2) << endl;

cout << (c1 /= c2) << endl;

cout << (c1 == c2) << " " << (c1 != c2) << endl;

return 0;

}
class Complex

{

private:

double x;

double y;

public:

Complex(double x = 0.0, double y = 0.0);

Complex & operator+=(const Complex &);

Complex & operator-=(const Complex &);

Complex & operator*=(const Complex &);

Complex & operator/=(const Complex &);

friend Complex operator+(const Complex &, const Complex &);

friend Complex operator-(const Complex &, const Complex &);

friend Complex operator*(const Complex &, const Complex &);

friend Complex operator/(const Complex &, const Complex &);

friend bool operator==(const Complex &, const Complex &);

friend bool operator!=(const Complex &, const Complex &);

friend ostream & operator<<(ostream &, const Complex &);

friend istream & operator>>(istream &, Complex &);

};

使用以下main函数进行测试：

int main()
{
String s;
s += "hello";
cout< String s1("String1");
String s2("copy of ");
s2 += "String1";
cout << s1 << "\n" << s2 << endl;
String s3;
cin >> s3;
cout << s3 << endl;
String s4("String4"), s5(s4);
cout << (s5 == s4) << endl;
cout << (s5 != s4) << endl;
String s6("End of "), s7("my string.");
s6 += s7;
cout << s6 << endl;
return 0;
}

输入

s3的值

输出

详见主函数和输出样例

输入样例 1 

String3

输出样例 1

hello
String1
copy of String1
String3
1
0
End of my string.
#include<iostream>
#include<cstring>
using namespace std;

class String {
private:
    char* s;
public:
    String();
    String(const char*);
    String(const String&);
    ~String();
    String& operator=(const char*);
    String& operator=(const String&);
    String operator+(const char*);
    String operator+(const String&);
    String& operator+=(const char*);
    String& operator+=(const String&);
    friend istream& operator>>(istream&, String&);
    friend ostream& operator<<(ostream&, const String&);
    friend bool operator==(const String&, const char*);
    friend bool operator==(const String&, const String&);
    friend bool operator!=(const String&, const char*);
    friend bool operator!=(const String&, const String&);
};

String::String()
{
    s = new char[100];
}
String::String(const char* c)
{
    s = new char[strlen(c) + 1];
    strcpy(s, c);
}
String::String(const String& c)
{
    s = new char[strlen(c.s) + 1];
    strcpy(s, c.s);
}
String::~String()
{
    delete[]s;
}
String& String::operator=(const char* c)
{
    return operator=(String(c));
}
String& String::operator=(const String& c)
{
    s = new char[strlen(c.s) + 1];
    strcpy(s, c.s);
    return *this;
}
String String::operator+(const char* c)
{
    return String(s) + String(c);
}
String String::operator+(const String& c)
{
    return String(s) + c;
}
String& String::operator+=(const char* c)
{
    return operator+=(String(c));
}


String& String::operator+=(const String& c)
{
    char* r = new char[strlen(s) + strlen(c.s) + 1];
    r = this->s;
    strcat(r, c.s);
    this->s = r;
    return *this;
}
istream& operator>>(istream& stream, String& c)
{
    stream >> c.s;
    return stream;
}
ostream& operator<<(ostream& stream, const String& c)
{
    stream << c.s;
    return stream;
}
bool operator==(const String& c1, const char* c2)
{
    if (strcmp(c1.s, c2) == 0)
        return true;
    else
        return false;
}
bool operator==(const String& c1, const String& c2)
{
    if (strcmp(c1.s, c2.s) == 0)
        return true;
    else
        return false;
}
bool operator!=(const String& c1, const char* c2)
{
    return(strcmp(c1.s, c2) != 0);

}
bool operator!=(const String& c1, const String& c2)
{
    return(strcmp(c1.s, c2.s) != 0);
}

int main() {
    String x;
    x += "hello";
    cout << x << endl;
    String s1("String1");
    String s2("copy of ");
    s2 += "String1";
    cout << s1 << "\n" << s2 << endl;
    String s3;
    cin >> s3;
    cout << s3 << endl;
    String s4("String4"), s5(s4);
    cout << (s5 == s4) << endl;
    cout << (s5 != s4) << endl;
    String s6("End of "), s7("my string.");
    s6 += s7;
    cout << s6 << endl;
    return 0;
}

CheckedPtr

描述

自增(++)和自减(--)操作符经常由诸如迭代器这样的类实现，这样的类提供类似于指针的行为访问序列中的元素。例如，定义以下类CheckedPtr，该类指向一个int数组并为该数组中的元素提供访问检查。

class CheckedPtr

{

public:

CheckedPtr(int * b, int * e) : beg(b), end(e), curr(b) {  }

CheckedPtr & operator ++(); // prefix ++

CheckedPtr & operator --(); // prefix --

CheckedPtr   operator ++(int); // postfix ++

CheckedPtr   operator --(int); // postfix --

int * GetBeg();

int * GetEnd();

int * GetCurr();

private:

int * beg;  // pointer to beginning of the array

int * end;  // one past the end of the array

int * curr; // current position within the array

};

实现CheckedPtr类并通过以下main函数测试。

int main(){

int n;

cin>>n;

int * array = new int[n];

for(int i=0;i

cin>>array[i];

CheckedPtr cp(array, array+n);

for(;cp.GetCurr()

cout<<*cp.GetCurr()<<" ";

cout<

for(--cp;cp.GetCurr()>cp.GetBeg();cp--)

cout<<*cp.GetCurr()<<" ";

cout<<*cp.GetCurr()<

delete [] array;

return 0;

}

输入

输入为两行，第一行表示数组的长度n，第二行表示这n个数

输出

输出为两行，第一行依次输出数组的第0个到最后一个元素，第二行反向输出数组的所有元素（参考输出样例）

输入样例 1 

5
1 2 3 4 5

输出样例 1

1 2 3 4 5 
5 4 3 2 1
#include<iostream>
#include<string>
using namespace std;
class CheckedPtr
{
public:
    CheckedPtr(int* a, int* e) : beg(a), end(e), curr(a) {}
    CheckedPtr& operator ++();
    CheckedPtr& operator --();
    CheckedPtr   operator ++(int);
    CheckedPtr   operator --(int);
    int* GetBeg();
    int* GetEnd();
    int* GetCurr();
private:
    int* beg;
    int* end;
    int* curr;
};

CheckedPtr& CheckedPtr::operator ++()
{
    ++curr;
    return *this;
}

CheckedPtr& CheckedPtr::operator--()
{

    --curr;
    return *this;
}

CheckedPtr CheckedPtr::operator++(int)
{
    CheckedPtr s(*this);
    ++* this;

    return s;
}

CheckedPtr CheckedPtr::operator--(int)
{
    CheckedPtr s(*this);
    --* this;

    return s;
}

int* CheckedPtr::GetBeg() {
    return beg;
}

int* CheckedPtr::GetEnd()
{
    return end;
}
int* CheckedPtr::GetCurr()
{
    return curr;
}

int main() {
    int n;
    cin >> n;
    int* array = new int[n];
    for (int i = 0; i < n; i++)
        cin >> array[i];
    CheckedPtr cp(array, array + n);
    for (; cp.GetCurr() < cp.GetEnd(); cp++)
        cout << *cp.GetCurr() << " ";
    cout << endl;
    for (--cp; cp.GetCurr() > cp.GetBeg(); cp--)
        cout << *cp.GetCurr() << " ";
    cout << *cp.GetCurr() << endl;
    delete[] array;
    return 0;
}

Pink&Sakura
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++面向对象程序设计】实验四 运算符重载
m0_72318954的博客
10-31 1159
运算符重载实验题目
BJFU2023-C++程序设计-实验4-运算符重载
2301_76891302的博客
04-13 314
描述实现一个Singer类，通过以下测试：int main()if(s1>s2)elsereturn 0;输入输入包含两行，第一行为歌手s1的信息，第二行为歌手s2的信息，每位歌手的信息包括姓名（不包含空格）、性别、年龄 和 分数；姓名、性别、年龄和分数之间用空格分隔输出输出为三行，前两行分别是歌手s1和s2的信息，第三行根据s1和s2比较结果输出（s1和s2的比较结果和他们的分数的比较结果一致），具体参见主函数输入样例 1输出样例 1提示。
C++实验4——运算符重载
weixin_51703554的博客
01-18 4307
实验目的 掌握运算符重载 实现对Matrix类的运算符重载 实验内容 在之前的实验中，我们实现了矩阵类Matrix及其子类Image。本次实验我们给Matrix类添加一些重载的运算符，包括赋值运算符“=”，两个Matrix对象的“+”、“-”、“*”、“/”（都是矩阵对应元素间的运算，而不是矩阵的乘除），自加自减，矩阵（或图像）对象和一个数（标量）的“=”、“+”、“-”、“*”、“/”操作，判断两个矩阵（或图像）是否相等的“==”。 给Image类添加一个单目运算符“-”，作用是图像的像素值取反
C++重载＞＞和＜＜（输入和输出运算符）详解
Elanie1024的博客
03-30 3499
C++重载>>和
cin和cout重载实现详解
ifwecande的博客
08-06 5481
C++中重载输入cin和输出cout运算符 在C++中，标准库本身已经对左移运算符<<和右移运算符>>分别进行了重载，使其能够用于不同数据的输入输出，但是输入输出的对象只能是 C++内置的数据类型（例如 bool、int、double 等）和标准库所包含的类类型（例如 string、complex、ofstream、ifstream 等）。如果自己定义了一种新的数据类型，需要用输入输出运算符去处理，那么就必须对它们进行重载。本节以complex类为例来演示输入输出运算符的重载。 本节
实验四 运算符重载.zip
11-30
在"实验四 运算符重载"中，我们将深入探讨这一关键概念，以及如何在实践中应用。 首先，理解运算符重载的基本原理：它并不创建新的运算符，而是为已经存在的运算符提供不同的实现方式。这意味着当运算符用于内置...
实验二 运算符重载的应用.doc
02-25
实验二 运算符重载的应用.doc 本实验报告的主要内容是对运算符重载的应用，通过构造函数、引用、运算符重载的概念和使用方法的学习和掌握，为后续的面向对象程序设计打下基础。 一、实验目的 1. 进一步熟悉构造...
C++作业实验-运算符重载
06-20
本实验“C++作业实验-运算符重载”旨在深入理解这一概念，通过Visual Studio 2010开发环境进行实践。在这个实验中，我们将探讨如何在类的设计中使用运算符重载，以及它与类、友元函数的关系。 首先，让我们理解什么...
实验11 运算符重载.zip
最新发布
05-18
这个实验11的主题就是深入理解和实践运算符重载，这对于提升代码的可读性和简洁性至关重要。 在C++中，运算符重载并不是创建新的运算符，而是对已有的运算符进行函数化处理，使得这些运算符可以作用于自定义的数据...
C++实验报告实验七-运算符重载
03-14
实验七 运算符重载 一、实验目的 （1）.编写程序熟悉运算符重载函数的定义和使用； （2）.编写程序熟悉重载单目和双目运算符的方法； （3）.编写程序熟悉流插入和提取运算符的重载； 二、实验要求 1、创建一个二维...
C++实验四 运算符重载的应用 课程实验报告
06-11
C++实验四 运算符重载的应用 课程实验报告 老师布置的作业~~参考！
设计复数类Complex，实现运算符重载。
Amonglnm的博客
03-18 2337
设计复数类Complex，实现运算符重载。
C++实现输入输出运算符重载、友元函数和成员函数实现复数类Complex
热门推荐
好儿郎~志在四方
11-29 1万+
题目要求如下： 1） 基本的构造函数； 2） 成员运算符+、-实现复数的加减运算； 3） 友元运算符+、-实现更合理的加减运算； 4） 运算符<<和>>实现复数类的输出输入。
c++多态（设计一个复数Complex类，实现复数的加、减运算，并实现复数的输入、输出。）
Kerryliuyue的博客
05-13 9385
法一：友元函数 #include<iostream> #include<cmath> using namespace std; class Complex { public: Complex() { real=0; imag=0; } Complex(float re,float im) { real=re; imag=im; } Complex(float re) {
通过重载输入和输出运算符实现复数的输入和输出
meishadevs的个人博客
06-16 9336
程序代码: #include using namespace std; class Complex { public: Complex( )//定义默认构造函数初始化复数 { real=0; imag=0; } //使用初始化表初始化复数 Complex(dou
c/c++开发，无可避免的操作符operator（篇一），操作符重载
技术需要分享
03-11 817
c/c++开发，无可避免的操作符operator（篇一），操作符重载，较全面阐述了各种常规运算符、操作符和特殊运算符、操作符的重载设计，给出演示代码及演示结果。
运算符重载
cxkong1392661293的专栏
04-24 902
#include using namespace std; class Complex { public: Complex(){real=0;imag=0} Complex(double r,double i){real=r;imag=i;} friend Complex  operator+(Complex &c1,Complex &c2); void display(); pr
C++ Primer(第5版) 课后答案 第一章
Hhhh_Jy的博客
06-28 867
C++ Primer课后练习
【C++】操作符重载及实现简单的复数类Complex
Begin
05-18 668
操作符重载： 重载操作符是具有特殊函数名的函数，关键字operator后面接需要定义的操作符符号。 操作符重载也是一个函数，具有返回值和形参表。它的形参数目与操作符的操作数目相同。 函数调用操作符可以接受任意数目的操作数。 使用运算符重载可以提高代码的可读性。 返回类型 operate 操作符(参数列表)；
运算符重载实验简短小结
05-31
运算符重载是C++的一个重要特性，它允许我们为自定义类型定义行为与内置类型相似的运算符。通过重载运算符，我们可以使自定义类型的对象支持各种算术、逻辑、比较等运算符的操作，使得代码更加简洁、易读、易维护。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值