2. 程式人生 > >C++實踐參考——複數類中的運算子過載

C++實踐參考——複數類中的運算子過載

阿新 • • 發佈：2019-01-12
【專案-實現複數類中的運算子過載】
（1）請用類的成員函式，定義複數類過載運算子+、-、*、/，使之能用於複數的加減乘除
class Complex 
{
public:
    Complex(){real=0;imag=0;}
    Complex(double r,double i){real=r; imag=i;}
    Complex operator+(const Complex &c2);
    Complex operator-(const Complex &c2);
    Complex operator*(const Complex &c2);
    Complex operator/(const Complex &c2);
    void display();
private:
    double real;
    double imag;
};
//下面定義成員函式


//下面定義用於測試的main()函式
int main()
{
    Complex c1(3,4),c2(5,-10),c3;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    c3=c1+c2;
    cout<<"c1+c2=";
    c3.display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    return 0;
}
[參考解答]
#include <iostream>
using namespace std;
class Complex
{
public:
    Complex(){real=0;imag=0;}
    Complex(double r,double i){real=r; imag=i;}
    Complex operator+(const Complex &c2);
    Complex operator-(const Complex &c2);
    Complex operator*(const Complex &c2);
    Complex operator/(const Complex &c2);
    void display();
private:
    double real;
    double imag;
};
//下面定義成員函式
//複數相加： (a+bi)+(c+di)=(a+c)+(b+d)i.
Complex Complex::operator+(const Complex &c2)
{
    Complex c;
    c.real=real+c2.real;
    c.imag=imag+c2.imag;
    return c;
}
//複數相減：(a+bi)-(c+di)=(a-c)+(b-d)i.
Complex Complex::operator-(const Complex &c2)
{
    Complex c;
    c.real=real-c2.real;
    c.imag=imag-c2.imag;
    return c;
}
//複數相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i.
Complex Complex::operator*(const Complex &c2)
{
    Complex c;
    c.real=real*c2.real-imag*c2.imag;
    c.imag=imag*c2.real+real*c2.imag;
    return c;
}

//複數相除：(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i
Complex Complex::operator/(const Complex &c2)
{
    Complex c;
    c.real=(real*c2.real+imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    c.imag=(imag*c2.real-real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    return c;
}

void Complex::display()
{
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
//下面定義用於測試的main()函式
int main()
{
    Complex c1(3,4),c2(5,-10),c3;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    c3=c1+c2;
    cout<<"c1+c2=";
    c3.display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    return 0;
}

（2）請用類的友元函式，而不是成員函式，再次完成上面提及的運算子的過載；[參考解答]
#include <iostream>
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);
    friend Complex operator-(Complex &c1, Complex &c2);
    friend Complex operator*(Complex &c1, Complex &c2);
    friend Complex operator/(Complex &c1, Complex &c2);
    void display();
private:
    double real;
    double imag;
};

//複數相加：(a+bi)+(c+di)=(a+c)+(b+d)i.
Complex operator+(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real+c2.real;
    c.imag=c1.imag+c2.imag;
    return c;
}

//複數相減：(a+bi)-(c+di)=(a-c)+(b-d)i.
Complex operator-(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real-c2.real;
    c.imag=c1.imag-c2.imag;
    return c;
}

//複數相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i.
Complex operator*(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real*c2.real-c1.imag*c2.imag;
    c.imag=c1.imag*c2.real+c1.real*c2.imag;
    return c;
}

//複數相除：(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i
Complex operator/(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=(c1.real*c2.real+c1.imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    c.imag=(c1.imag*c2.real-c1.real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    return c;
}

void Complex::display()
{
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}

int main()
{
    Complex c1(3,4),c2(5,-10),c3;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    c3=c1+c2;
    cout<<"c1+c2=";
    c3.display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    return 0;
}

　　事實上，運算子過載的函式還可以定義成一般函式，只不過這種做法並不好。下面給出使用一般函式完成運算子過載的程式。其中，加了序號的幾處註釋值得關注。

#include <iostream>
using namespace std;
class Complex
{
public:
    Complex()
    {
        real=0;
        imag=0;
    }
    Complex(double r,double i)
    {
        real=r;
        imag=i;
    }
    double getReal() const
    {
        return real;   //(1)定義公用的資料介面，可以為const成員函式
    }
    double getImag() const
    {
        return imag;
    }
    void setReal(double r)
    {
        real=r;   //(1)定義公用的資料介面
    }
    void setImag(double i)
    {
        imag=i;
    }


    void display();
private:
    double real;
    double imag;
};

//複數相加：(a+bi)+(c+di)=(a+c)+(b+d)i.
Complex operator+(const Complex &c1, const Complex &c2) //(3)將引數處理為const更符合需求
{
    Complex c;
    c.setReal(c1.getReal()+c2.getReal());   //(2)呼叫公用資料介面讀取和修改私有資料成員
    c.setImag(c1.getImag()+c2.getImag());
    return c;
}

//複數相減：(a+bi)-(c+di)=(a-c)+(b-d)i.
Complex operator-(const Complex &c1, const Complex &c2)
{
    Complex c;
    c.setReal(c1.getReal()-c2.getReal());
    c.setImag(c1.getImag()-c2.getImag());
    return c;
}

//複數相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i.
Complex operator*(const Complex &c1, const Complex &c2)
{
    Complex c;
    c.setReal(c1.getReal()*c2.getReal()-c1.getImag()*c2.getImag());
    c.setImag(c1.getImag()*c2.getReal()+c1.getReal()*c2.getImag());
    return c;
}

//複數相除：(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i
Complex operator/(const Complex &c1, const Complex &c2)
{
    Complex c;
    double d= (c2.getReal()*c2.getReal()+c2.getImag()*c2.getImag());
    c.setReal((c1.getReal()*c2.getReal()+c1.getImag()*c2.getImag())/d);
    c.setImag((c1.getImag()*c2.getReal()-c1.getReal()*c2.getImag())/d);
    return c;
}

void Complex::display()
{
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}

int main()
{
    Complex c1(3,4),c2(5,-10),c3;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    c3=c1+c2;
    cout<<"c1+c2=";
    c3.display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    return 0;
}

（3）定義一個定義完整的類（是可以當作獨立的產品釋出，成為眾多專案中的“基礎工程”）。這樣的類在(2)的基礎上，擴充套件+、-、*、/運算子的功能，使之能與double型資料進行運算。設Complex c; double d; c+d和d+c的結果為“將d視為實部為d的複數同c相加”，其他-、*、/運算子類似。
[參考解答]
#include <iostream>
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);
    friend Complex operator+(double d1, Complex &c2);
    friend Complex operator+(Complex &c1, double d2);
    friend Complex operator-(Complex &c1, Complex &c2);
    friend Complex operator-(double d1, Complex &c2);
    friend Complex operator-(Complex &c1, double d2);
    friend Complex operator*(Complex &c1, Complex &c2);
    friend Complex operator*(double d1, Complex &c2);
    friend Complex operator*(Complex &c1, double d2);
    friend Complex operator/(Complex &c1, Complex &c2);
    friend Complex operator/(double d1, Complex &c2);
    friend Complex operator/(Complex &c1, double d2);
    void display();
private:
    double real;
    double imag;
};

//複數相加：(a+bi)+(c+di)=(a+c)+(b+d)i.
Complex operator+(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real+c2.real;
    c.imag=c1.imag+c2.imag;
    return c;
}
Complex operator+(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c+c2; //按運演算法則計算的確可以，但充分利用已經定義好的程式碼，既省人力，也避免引入新的錯誤，但可能機器的效率會不佳
}
Complex operator+(Complex &c1, double d2)
{
    Complex c(d2,0);
    return c1+c;
}
//複數相減：(a+bi)-(c+di)=(a-c)+(b-d)i.
Complex operator-(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real-c2.real;
    c.imag=c1.imag-c2.imag;
    return c;
}
Complex operator-(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c-c2;
}
Complex operator-(Complex &c1, double d2)
{
    Complex c(d2,0);
    return c1-c;
}

//複數相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i.
Complex operator*(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real*c2.real-c1.imag*c2.imag;
    c.imag=c1.imag*c2.real+c1.real*c2.imag;
    return c;
}
Complex operator*(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c*c2;
}
Complex operator*(Complex &c1, double d2)
{
    Complex c(d2,0);
    return c1*c;
}

//複數相除：(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i
Complex operator/(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=(c1.real*c2.real+c1.imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    c.imag=(c1.imag*c2.real-c1.real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    return c;
}
Complex operator/(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c/c2;
}
Complex operator/(Complex &c1, double d2)
{
    Complex c(d2,0);
    return c1/c;
}

void Complex::display()
{
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}

int main()
{
    Complex c1(3,4),c2(5,-10),c3;
    double d=11;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    cout<<"d="<<d<<endl<<endl;
    cout<<"下面是過載運算子的計算結果: "<<endl;
    c3=c1+c2;
    cout<<"c1+c2=";
    c3.display();
    cout<<"c1+d=";
    (c1+d).display();
    cout<<"d+c1=";
    (d+c1).display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    cout<<"c1-d=";
    (c1-d).display();
    cout<<"d-c1=";
    (d-c1).display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    cout<<"c1*d=";
    (c1*d).display();
    cout<<"d*c1=";
    (d*c1).display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    cout<<"c1/d=";
    (c1/d).display();
    cout<<"d/c1=";
    (d/c1).display();
    return 0;
}

相關推薦

C++實踐參考——複數類中的運算子過載

【專案-實現複數類中的運算子過載】（1）請用類的成員函式，定義複數類過載運算子+、-、*、/，使之能用於複數的加減乘除class Complex { public: Complex(){real=0;imag=0;} Complex(double r,double i){real=r; im

C++實踐參考——分數類中的運算子過載

【專案1-分數類中的運算子過載】 　　（1）實現分數類中的運算子過載，在分數類中可以完成分數的加減乘除（運算後再化簡）、比較（6種關係）的運算。 class CFraction { private: int nume; // 分子 in

C++實踐參考——Time類中的運算子過載

【專案-Time類中的運算子過載】 　　實現Time類中的運算子過載。 class CTime { private: unsigned short int hour; // 時 unsigned short int minute;

C++定義一個複數類Complex，過載運算子“+”，使之能用於複數的加法運算。將運算子函式過載為非成員、非友元的普通函式。編寫程式，求兩個複數之和。

#include <iostream> #include <iomanip> using namespace std; class Complex { public: Complex(); Complex(double r,do

《C++第九周實驗報告3-1》----接第8周任務3，定義分數類中運算子過載，實現分數的輸入輸出

/* (程式頭部註釋開始) * 程式的版權和版本宣告部分 * Copyright (c) 2011, 煙臺大學計算機學院學生 * All rights reserved. * 檔名稱： CFraction.cpp *

C++實踐參考——形狀類族的中的純虛擬函式

【專案-形狀類族的中的純虛擬函式】寫一個程式，定義抽象基類Shape，由它派生出3個派生類，Circle（圓形）、Rectangle（矩形）、Triangle（三角形）。用如下的main()函式，求出定

C++實踐參考——陣列類運算的實現

【專案-陣列類運算的實現】 　　設計陣列類Array，為了實現測試函式中要求的功能，請補足相關的函式（構造、解構函式）和運算子過載的函式。 　　實現策略提示：可以將測試函式中的語句加上註釋，取消一句的註釋，增加相應的函式，以漸增地實現所有的功能，避免全盤考慮

C++實踐參考——點類派生直線類

【專案 - 點類派生直線類】定義點類Point，並以點類為基類，派生出直線類Line，從基類中繼承的點的資訊表示直線的中點。請閱讀下面的程式碼，並將缺少的部分寫出來。#include<iostre

C++實踐參考——立體類族共有的抽象類

【專案-立體類族共有的抽象類】    設計一個抽象類CSolid，含有用於求表面積及體積的兩個純虛擬函式。設計派生類CCube、CBall、CCylinder，分別表示正方體、球體及圓柱體。在main()函式中，定義CSolid *p;（p是指向基類的指標，且這個基類是個抽象類）。要求利用這個p指標，能夠求出

複數類的運算子過載

#include <iostream>   using namespace std;   class Complex   {   public:       Complex(){real=0;imag=0;}       Complex(double r,dou

string類中運算子過載的實現

#include<iostream> using namespace std; class MyString { public: MyString(); MyString(const int number); MyStri

第十二週上機實踐專案 專案1-實現複數類中的運算子過載 (2)

問題及程式碼： 【專案-實現複數類中的運算子過載】 （1）請用類的成員函式，定義複數類過載運算子+、-、*、/，使之能用於複數的加減乘除 class Complex { public: Complex(){real=0;imag=0;} Complex(d

第九周 專案一 複數類中的運算子過載（續）

問題及程式碼： /* *Copyright (c)2014,煙臺大學計算機與控制工程學院 *All rights reserved. *檔名稱：Project.cpp *作 者：chenqin. *完成日期：2015年4月25日 *版 本 號：v1.0 * *問題描述

【c++】用c++實現複數類及運算子的過載

#include<iostream> using namespace std; class Complex { public: Complex(double real = 0.0, double image = 0.0)//建構函式 :_real(real

第十二週專案1-實現複數類中的運算子過載（1.3實現複數與實數相加減乘除）

問題及程式碼： /* *Copyright (c) 2016，煙臺大學計算機學院 *All rights reserved. *檔名稱：zwj.cpp *作 者：張偉晶 *完成日期：2016年5月12日 *版 本 號：v1.0 * *問題描述：用類的友

第九周專案一：複數類中的運算子過載（續）

問題及程式碼： 在複數類中的運算子過載基礎上 （1）再定義一目運算子 -，-c相當於0-c。 （2）定義Complex類中的<<和>>運算子的過載，實現輸入和輸出，改造原程式中對運算結果顯示方式，使程式讀起來更自然。 解決程式碼： #include

YTUOJ——C++時間類的運算子過載

題目描述 C++時間類的運算子過載 定義一個時間類Time，其資料成員為表示時間的小時（hour）、分（minute），秒（second）。 過載運算子“+”，使之能用於時間物件的加法運算；過載運算子“<<”，使之能用於時間物件的輸出操作。 （1）參加運算的兩個運算元可以都是時間

定義一個複數類Complex，過載運算子“+”,“-”,“*”,“/”，使之能用於複數的加、減、乘、除。運算子過載函式作為Complex類的成員函式。編寫程式，分別求兩個複數之和、差、積和商。

#include <iostream> #include <iomanip> using namespace std; class Complex { public: Complex(); Complex(double r

定義一個複數類Complex，過載運算子“+”，使之能用於複數的加法運算。參加運算的兩個運算量可以都是類物件，也可以其中有一個是整數，順序任意。例如，c1+c2,i+c1,c1+i均合法(設i為整數,

#include <iostream> #include <iomanip> using namespace std; class Complex { public: Complex() { real=0;

C++實踐參考——長方柱類

【專案 - 長方柱類】　　編寫基於物件的程式，求3個長方柱（Bulk）的體積。資料成員包括長（length）、寬（width）、高（heigth）、體積，要求設計成員函式實現下面的功能：　　（1）由鍵盤