精华内容
下载资源
问答
  • class重载运算符
    2021-05-09 09:48:16

    运算符重载
    什么是运算符重载

    运算符重载的本质是一个函数

    运算符重载的作用
    1为什么会用运算符重载机制
    用复数类举例
    //Complex c3 = c1 + c2;
    //原因 Complex是用户自定义类型,编译器根本不知道如何进行加减
    //编译器给提供了一种机制,让用户自己去完成,自定义类型的加减操作。。。。。
    //这个机制就是运算符重载机制
    运算符重载入门
    View Code

    运算符重载的限制

    运算符重载基础

    运算符重载的方法步骤
    全局函数、类成员函数方法实现运算符重载步骤
    1)要承认操作符重载是一个函数,写出函数名称operator+ ()
    2)根据操作数,写出函数参数
    3)根据业务,完善函数返回值(看函数是返回引用 还是指针 元素),及实现函数业务
    运算符重载的两种方法

    重载++ 需要注意
    ++重载例子

    友元函数 重载 << 还有链式编程
    复制代码
    //a)用全局函数方法实现 << 操作符
    ostream& operator<<(ostream &out, Complex &c1)
    {
    //out<<“12345,生活真是苦”<<endl;
    out<<c1.a<<" + "<<c1.b<<"i "<<endl;
    return out;
    }
    //调用方法
    cout<<c1;
    //链式编程支持
    cout<<c1<<“abcc”;
    //cout.operator<<(c1).operator<<(“abcd”);
    //函数返回值充当左值 需要返回一个引用
    b)类成员函数方法无法实现 << 操作符重载
    //因拿到cout这个类的源码
    //cout.operator<<(c1);
    复制代码
    注意点

    友员函数重载运算符常用于运算符的左右操作数类型不同的情况
    在第一个参数需要隐式转换的情形下,使用友员函数重载运算符是正确的选择
    友员函数没有 this 指针,所需操作数都必须在参数表显式声明,很容易实现类型的隐式转换
    C++中不能用友员函数重载的运算符有
    = () [] ->

    所以这个可以在写一个operator + 或者写一个友元函数重载

    更多相关内容
  • C#重载运算符详解

    2021-01-20 07:00:12
    本文较为详细的描述了重载运算符的方法。一般来说,重载运算符在实际的项目开发中会经常的用到,但如果某些自定义类型通过简短几行代码重载一些常用的运算符(如:+-*/),就能让编程工作带来方便;重载运算符就是...
  • Point类重载运算符

    2019-11-03 11:54:39
    利用C++实现Point类重载运算符。利用C++实现Point类重载运算符
  • 重载运算符

    2021-05-25 12:16:41
    运算符重载的语法 定义一个重载运算符与定义一个函数类似,只是这个函数的名称必须以operator开头。 运算符重载函数的一般形式为: 类型 类名::operator 重载运算符(参数表) { 函数体 } 参数的个数...

    输入带有空格的字符串

    cin.getline(a[i])

    运算符重载的语法

    • 定义一个重载的运算符与定义一个函数类似,只是这个函数的名称必须以operator开头。

    运算符重载函数的一般形式为:
    
    类型	类名::operator 重载的运算符(参数表)
    {
    		函数体
    }
    

     

    参数的个数由以下两个因素决定:

    1. 该操作符是一元操作符还是二元操作符。
    2. 重载为成员函数还是友元函数。

     

    运算符重载的两种形式

     

    运算符重载函数是如何调用的?

     

    运算符重载函数作为类的成员函数

     

    成员运算符重载函数在类中的声明格式为:
    class  X
    {   …… 
        <返回数据类型> operator <运算符> (<参数表>);
        ……
    };
    
    成员运算符重载函数在类外定义的格式为:
    <返回数据类型>  X:: operator <运算符> (<参数表>)
    { 
         <函数体>
    }
    

    举例:

    class CComplex
    {
    	public:
    	CComplex(double r=0.0,double i=0.0){real=r,imag=i;}
    	void print() const;
    	CComplex operator++();		//前缀
    	CComplex operator++(int);		//后缀
    	CComplex operator--();		//前缀
    	CComplex operator--(int);		//后缀
    };

    常对象

     

    运算符重载的限制

    • 只能重载已经存在的C++运算符
    • 运算符重载不能改变运算符操作数的个数,优先级和结合性
    • 运算符的操作数必须至少有一个某个类的类对象,否则不能对运算符进行重载
    • 重载运算符不可以使用缺省参数;
    • 除了赋值运算符 = 外,重载运算符可由派生类继承下去;
    • 下列运算符不能重载:   ::            .*    .    ?:    sizeof

     

    运算符重载函数作为友元函数

    • 运算符重载函数可以用友元函数的形式来实现。
    • 函数参数的个数与运算符原有操作数个数相同
    1. 第一个参数表示左操作数
    2. 第二个参数表示右操作数
    3. 第一个参数类型为类对象的引用
    • 赋值运算符‘=’、下标运算符‘[]’、成员选择运算符‘->’和函数调用运算符‘()’等不能用友元函数形式重载
    友元运算符重载函数在类中的声明格式为:
          class  X
          {  …… 
               friend  <返回数据类型> operator <运算符> (<参数表>);
             ……
          };
    友元运算符重载函数在类外定义的格式为:
         <返回数据类型>  operator <运算符> (<参数表>)
          { 
                  <函数体>
          } 
    

     

    重载为成员函数与重载为友元函数的比较

    “+”重载为成员函数
    CComplex   CComplex::operator+(const CComplex&  c)
    {
    		return CComplex(real+c.real, image+c.image);
    }
    “+”重载为友元函数
    CComplex  operator+(const CComplex&  c1,const CComplex& c2)
    {
    		return Complex(c1.real+c2.real,  c1.image+c2.image);
    }										
    

     

    运算符重载应用

    • 以下运算符经常需要重载:

                 1.算术运算符   2.关系运算符

                 3.逻辑运算符   4.赋值运算符

                 5.下标运算符   6.函数调用运算符

     

    特殊运算符的重载

    = 运算符的重载

    class Complex
    {
    	public:
    	Complex(double r=0.0,double i=0.0){real=r,imag=i;}
    	void display();
    	Complex& operator=(const Complex& r_c);
    };
    

    【*如果类没有定义赋值运算符重载函数,则编译程序会提供缺省的赋值运算符,就是将赋值运算符右边对象的数据域复制给其左边对象的数据成员。】

    注意:分配空间

     

    重载下标运算符“[ ]”

    • 下标运算符“[ ]”用来取某个向量的某个元素,或直接对向量中某个元素赋值,它被视为一个二元运算符。
    • 下标运算符只能作类成员运算符进行重载,不可作为友元运算符。
    • 重载下标运算符的最大好处是提供一种向量访问的安全方法。

     

    重载()运算符

    • 函数调用运算符”()”可以看作一个双目运算符,它的两个操作数分别为函数名和函数参数列表。             f (x,y)        f ()    
    • 函数调用运算符只能采用非静态的成员函数重载。
    • 函数调用运算符重载可以不带或带任意个参数。

    举例

    数学函数的抽象:f(x,y) = 2x+y
    
    
    class Function {
    public:
       double operator() (double x, double y) const
       {
    	   return 2*x+y;
       }
    };
    
    int main( ){
        Function fun;
        cout << fun(1.5, 2.2) << endl;
    	
    	return 1;
    }
    

     

    new和delete的重载

    例:重载new和delete运算符。
    #include <iostream>
    using namespace std;
    #include <stddef.h>
    class memmanager{
    public:
    	memmanager(){cout<<"default constructor"<<endl;}
    	void *operator new(size_t size);
    					//分配一块大小为size的内存
    	void *operator new(size_t size,char tag);
     					//分配一块大小为size的内存,并且用字符tag赋值
     	void operator delete(void *p);
    					//释放指针p所指向的一块内存空间
    };
    void *memmanager::operator new(size_t size)
    {
     	cout<<"new1 operator"<<endl;
    	char *s=new char[size];   		//分配大小为size的内存空间
    	*s='a';                    		//用字符'a'赋值
    	return s;                    		//返回指针
    }
    void *memmanager::operator new(size_t size,char tag)
    {
      	cout<<"new2 operator"<<endl;
      	char *s=new char[size];
      	*s=tag;                    		//用字符tag赋值
      	return s;                   		//返回指针
    }
    void memmanager::operator delete(void *p)
    {
      	cout<<"delete operator"<<endl;
      	char *s=(char *)p;          		//强制类型转换
      	delete[] s;                 		//释放内存空间
    } 
    void main()
    {
     	memmanager *m=new memmanager();
     	delete m;
     	memmanager *m1=new('B') memmanager();
     	delete m1;
    }
    

     

    类型之间的转换

    C++语言允许的类型转换有4种:

    • 标准类型->标准类型。
    • 标准类型->类类型。
    • 类类型->标准类型。
    • 类类型->类类型。

    【标准类型是除class,struct和union类型外的其他所有类型】

    对于标准类型,C++语言提供了两种类型转换:

    • 隐式类型转换。
    • 显式类型转换。

    举例:

     

    自定义类对象的输入输出

    • 插入运算符<<  和  抽取运算符>>的重载
    • 重载插入和抽取运算符只能用访问类的私有成员的友元函数来实现,因为插入和抽取运算符为双目运算符,且运算符的左操作数为流,右操作数为类对象,因而插入和抽取运算符的重载不能以类成员函数形式出现

    举例:

    
    class CComplex		//复数类声明
    {
    	double real;
    	double image;
    public:
    	CComplex(double r=0.0,double i=0.0):real(r),image(i){}
    	friend ostream& operator<<(ostream& stream, CComplex &obj);
    	friend istream& operator>>(istream&	stream, CComplex &obj);
    };
    
    //注意:在oj上,往往需要
    // friend ostream& operator<<(ostream& stream, const Complex &obj);
    
    
    ostream& operator<<(ostream& stream, CComplex &obj)
    {
    	if (obj.image < 0)
    		stream<< obj.real << obj.image << "i"<<endl;
        else if (obj.image > 0)
    		stream << obj.real << "+" << obj.image << "i"<<endl;
        else
    		stream << obj.real << endl;
    
    	return stream;
    }
    
    
    istream& operator>>(istream& stream, CComplex &obj)
    {
    	stream>>obj.real;
    	stream>>obj.image;
    
    	return stream;
    }
    
    int main()
    {
    
        CComplex obj;
        cin>>obj;
        cout<<obj;
        return 1;
    }
    
    
    

     

     

    展开全文
  • (1)C++不允许用户自己定义新的运算符,只能对已有的C++运算符进行重载。例如,有人觉得BASIC中用“* *”作为幂运算符很方便,也想在C++中将“* *”定义为幂运算符,用“3* *5”表示35,这是不行的。 (2)C++允许...
  • 当您调用一个重载函数或重载运算符时,编译器通过把您所使用的参数类型与定义中的参数类型进行比较,决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程,称为重载决策。 C++ 中的函数重载 在同一个作用...
  • C++ ,VS2010平台编辑,下载后可以直接使用,模拟打分及求平均分的过程
  • C++ 重载运算符和重载函数 C++ 允许在同一作用域中的某个函数和运算符指定多个定义,分别称为函数重载和运算符重载。 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明,但是它们的参数...
  • 以友元函数作为重载运算符的方式重载运算符+ 下面的例子来自于课本 #include using namespace std; class Complex { public: Complex() { real = 0; imag = 0; } Complex(double

    以友元函数作为重载运算符的方式重载运算符+

    下面的例子来自于课本

    #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); //声明重载运算符
            void display();
    
        private:
            double real;
            double imag;
    };
    
    Complex operator +(Complex &c1,Complex &c2)
    {
        return Complex(c1.real + c2.real, c1.imag + c2.imag);
    }
    
    void Complex::display()
    {
        cout<<"("<<real<<","<<imag<<"i)"<<endl; //输出复数形式
    }
    
    int main()
    {
        Complex c1(3,4), c2(5,-10), c3;
        c3 = c1 + c2; //运算符+ 用于复数运算
    
        cout<<"c1= ";
        c1.display();
    
        cout<<"c2= ";
        c2.display();
    
        cout<<"c1+c2= ";
        c3.display();
    
        return 0;
    }
    

    此主函数中执行c3 = c1 + c2调用了重载运算符operator +;

    并且此重载运算符函数是Complex的友元函数。

    必须是Complex对象相加才可以。

    运行结果:



    读者可以自行对比一下友元函数为重载运算符函数和成员函数作为重载运算符函数的区别:http://blog.csdn.net/z_dream_st/article/details/78044481


    展开全文
  • C++复数定义和重载运算符,包括加减乘除,取实部,虚部等
  • java重载运算符 Manifold扩展依赖项插入Java中,以提供无缝的运算符重载功能。 通过实现一个或多个预定义的运算符方法,可以为任何类类型安全地提供算术,关系和单位运算符 。 您可以直接在您的类中实现运算符方法,...

    java重载运算符

    Manifold扩展依赖项插入Java中,以提供无缝的运算符重载功能。 通过实现一个或多个预定义的运算符方法,可以为任何类类型安全地提供算术,关系和单位运算 。 您可以直接在您的类中实现运算符方法,也可以使用扩展方法为您原本无法控制的类实现运算符。 例如,使用扩展方法ManifoldBigDecimal提供了运算符实现,因此您可以编写如下代码:

    BigDecimal result = bigValue1 + bigValue2;

    使用单位表达式,可以更轻松地使用BigDecimal和其他类型:

    BigDecimal result = 3.14bd * 10.75bd; // `bd` makes BigDecimals

    通过单元和操作员过载进行精确测量:

    Length distance = 65 mph * 3.2 hr;
    HeatCapacity kBoltzmann = 1.380649e-23r J/dK;

    算术和否定运算符

    任何类型都可以通过实现以下一种或多种运算符方法来支持算术运算符:

    算术

    操作方式 方法
    a + b a.plus(b)
    a - b a.minus(b)
    a * b a.times(b)
    a / b a.div(b)
    a % b a.rem(b)

    否定

    操作方式 方法
    -a a.unaryMinsu()

    注意运算符方法不属于您实现的类或接口。 相反,您可以通过定义具有相同签名的方法来简单地在结构上实现它们。 请注意,您可以实现同一方法的多个不同版本,具体取决于参数类型。

    这是一个简单的示例,演示如何实现+运算符:

    public class Point {
      public final int x, y;
      public Point(int x, int y) {this.x = x; this.y = y;}
      
      public Point plus(Point that) {
        return new Point(x + that.x, y + that.y);
      }
    }
    
    var a = new Point(1, 2);
    var b = new Point(3, 4);
    
    var sum = a + b; // Point(4, 6)

    由于运算符方法是结构性的,因此可以定义多个 plus()方法:

    public Point plus(int[] coord) {
      if(coord.length != 2) {
        throw new IllegalArgumentException();
      }
      return new Point(x + coord[0], y + coord[1]);
    }

    关系运算符

    您可以使用ComparableUsing和/或Comparable接口的组合来实现关系运算符。

    manifold.ext.api.ComparableUsing

    关系运算符可以与ComparableUsing接口一起全部实现,该接口扩展了Comparable以提供特定于运算符的API。

    boolean compareToUsing( T that, Operator op );

    其中Operator是一个enum ,它为关系运算符指定常数。

    操作方式 可比的使用Impl 可比的Impl
    a > b a.compareToUsing(b, GT) a.compareTo(b) > 0
    a >= b a.compareToUsing(b, GE) a.compareTo(b) >= 0
    a < b a.compareToUsing(b, LT) a.compareTo(b) < 0
    a <= b a.compareToUsing(b, LE) a.compareTo(b) <= 0

    ComparableUsing提供了compareToUsing()的默认实现,该默认实现委托给关系运算符的>>=<<=子集的ComparablecompareTo()实现。 对于==!=子集, ComparableUsing委托给该类型的equals()方法(稍后将详细介绍平等性)。 此行为适用于大多数类型,因此通常您只需要向您的类型的implementsextends子句中添加ComparableUsing即可ComparableUsing仅实现Comparable 。 因此,在Point示例中增加了关系运算符支持:

    public class Point implements ComparableUsing {
      public final int x, y;
      public Point(int x, int y) {this.x = x; this.y = y;}
      
      public Point plus(Point that) {
        return new Point(x + that.x, y + that.y);
      }
      
      public int compareTo(Point that) {
        return x - that.x;
      }
    }

    现在,您可以像这样轻松地比较“点”值:

    if (pt1 >= pt2) ...

    java.lang.Comparable

    如果您对支持==!=不感兴趣,并且您的类型实现了Comparable接口,它将自动支持关系运算符的>>=<<=子集。 例如,既java.lang.Stringjava.time.LocalDate实现compareTo()从方法Comparable ,这意味着它们可以在关系表达式中使用的:

    String name1;
    String name2;
    ...
    if (name1 > name2) {...}
    LocalDate date1;
    LocalDate date2;
    ...
    if (date1 > date2) {...}

    还请参见:

    平等经营者

    要实现关系运算符的==!=子集,必须实现ComparableUsing接口。 默认情况下, ComparableUsing委托给您类型的equals()方法,但是您可以通过重写CopmarableUsing实现中的CopmarableUsing equalityMode()方法来轻松覆盖此行为。 EqualityMode枚举提供了可用的模式:

    /**
     * The mode indicating the method used to implement {@code ==} and {@code !=} operators.
     */
    enum EqualityMode
    {
      /** Use the {@code #compareTo()} method to implement `==` and `!=` */
      CompareTo,
    
      /** Use the {@code equals()} method to implement `==` and `!=` (default) */
      Equals,
    
      /** Use {@code identity} comparison for `==` and `!=`, note this is the same as Java's normal {@code ==} behavior } */
      Identity
    }

    根据您的CompareToUsing#equalityMode()实现返回的EqualityMode==!=运算符使用以下方法进行编译:

    操作方式 Equals <small>(默认)</ small> CompareTo Identity
    a == b a.equals(b) a.compareToUsing(b, EQ) a == b
    a != b !a.equals(b) a.compareToUsing(b, NE) a != b

    注意:歧管为==!=生成有效的, 空安全的代码。 例如,使用Equals模式的a == b编译为:

    a == b || a != null && b != null && a.equals(b)
    
    If you need something more customized you can override compareToUsing() with your own logic for any of the operators, including == and != . To enable == on Point more effectively, you can accept the default behavior of ComparableUsing and implement equals() :
    public boolean equals(Object that) {
      return this == that || that != null && getClass() == that.getClass() && 
             x == ((Point)that).x && y == ((Point)that).y;
    }

    请注意,如果实现equals() ,请始终考虑实现hashCode() ,否则在与Map和其他数据结构一起使用时,您的类型可能无法正常工作:

    public int hashCode() {
      return Objects.hash(x, y); 
    }

    有时最好使用CompareTo模式。 例如, RationalBigDecimalBigInteger==!=实现使用CompareTo模式,因为在那些类中, compareTo()反映了它们所建模数字的面值的相等性,例如1.0 == 1.00,即在许多用例中的期望行为。 在那种情况下,只需重写equalityMode()以返回CompareTo

    @Override
    public EqualityMode equalityMode() {
      return CompareTo;
    }

    还请参见:

    单位经营者

    单位或“绑定”操作对于歧管框架是唯一的。 它们提供了功能强大且简洁的语法,可以应用于广泛的应用程序。 您可以使用prefixBind()postfixBind()方法实现运算符:

    操作方式 后缀绑定 前缀绑定
    ab b.postfixBind(a) a.prefixBind(b)

    如果类型a工具R prefixBind(B)其中B距离的类型分配的b ,则ab编译作为方法调用a.prefixBind(b)具有式R 否则,如果类型b器具R postfixBind(A)其中A是从分配的类型a ,然后ab编译作为方法调用b.postfixBind(a)具有式R

    此功能启用以下表达式:

    Mass m = 5 kg;
    Force f = 5 kg * 9.8 m/s/s;
    for (int i: 1 to 10) {...}

    阅读更多有关单位表达式的信息

    扩展方法运算符

    使用扩展方法,您可以为原本无法控制的类提供操作员实现。 例如,Manifold为BigDecimalBigInteger提供了运算符扩展。 这些扩展是在manifold-science依赖中实现的。

    这是BigDecimal+扩展名:

    @Extension
    public abstract class ManBigDecimalExt implements ComparableUsing {
      /** Supports binary operator {@code +} */
      public static BigDecimal plus(@This BigDecimal thiz, BigDecimal that) {
        return thiz.add(that);
      }
      ...
    }
    ```
    Now you can perform arithmetic and comparisons using operator expressions:
    ```java
    if (bd1 >= bd2) {
      BigDecimal result = bd1 + bd2;
      . . .
    }

    请注意, manifold-sciencemanifold-collections模块广泛使用运算符重载和单位表达式。

    翻译自: https://jaxenter.com/manifold-operator-overloading-java-163232.html

    java重载运算符

    展开全文
  • C++类的运算符重载,包括 = ++ -- -(负号运算符) + - * / % == != < > <= >= << >>
  • 定义一个复数类Complex,重载运算符+,使之能用于复数的加法运算,要求将运算符+函数重载为非成员、非友元的普通函数;重载运算符-、采用友元函数方式; 重载运算符X、/,以成员函数方式实现。 分析当参加运算+的两个...
  • __add__ 和 __mul__ 方法是为了展示如何使用特殊方法重载运算符,不过有些小问题被我们忽视了。此外,我们定义的Vector2d.__eq__ 方法认为 Vector(3, 4) == [3, 4] 是真的(True),这可能并不合理。下面来一起看看...
  • python中重载运算符Operators are used in Python to perform specific operations on the given operands. The operation that any particular operator will perform on any predefined data type is already ...
  • C++ operator重载运算符详解

    千次阅读 多人点赞 2019-10-04 19:06:56
    C++ operator 重载运算符的作用: 主要是代替成员函数的方式为自建类型完成基本任务 当然, 用成员函数完全可以代替operator的功能, 但是使用起来绝对没有operator方便 operator 重载运算符方式: 既然是用于自建类型的...
  • c++运算符重载,重载运算符
  • C++重载运算符

    千次阅读 2019-05-15 15:39:49
    首先回顾一下重载运算符的相关知识: 1.重载运算符的函数一般格式: 函数类型 operator 运算符名称(形参表) { 对运算符的重载处理 } 2.重载运算符规则 ( 1 )C++不允许用户自己定义新的运算符,只能对已有的C++...
  • 用成员或友元函数重载运算符

    千次阅读 2020-06-14 17:33:25
    用成员函数重载运算符 1.当一元运算符的操作数,或者二元运算符的左操作数是类的对象时,定义重载算符函数为成员函数。 2. 二元运算符op 如果要重载op 为类的成员函数,使之能够实现表达式oprd1 op oprd2,其中...
  • 用成员函数重载运算符“+”和“-”,将两个二维数组相加和相减。要求第一个二维数组的值由构造函数设置,另一个二维数组的值由键盘输入。
  • C++重载运算符以及operator=的重载

    千次阅读 多人点赞 2019-10-11 14:41:16
    重载运算符 问题引入 int a=10 int b=20 int c=a+b 对于内置数据类型编译器知道如何运算(+) 然后对于自定义类型 People p1+People p2 编译器是处理不了的,因为People类内部没有定义 操作符 +, 在People...
  • 运算符重载的限制 可以重载运算符 + - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> >>= <<...
  • 其他文件不变 ... // 用友元函数实现运算符重载 friend Pork operator+(const Cow &c1, const Cow &c2); friend Pork operator+(const Sheep &s1, const Cow &c2); private: int
  • 重载运算符 您可以重定义或重载大部分 C++ 内置的运算符。这样,您就能使用自定义类型的运算符。 重载的运算符是带有特殊名称的函数,函数名是由关键字 operator 和其后要重载的运算符符号构成的。 与其他函数一样,...
  • 重载运算符/不可重载运算符下面是可重载的运算符列表:双目算术运算符+ (加),-(减),*(乘),/(除),% (取模)关系运算符==(等于),!= (不等于),&lt; (小于),&gt; (大于&gt;,&lt;=(小于等于),...
  • 运算符重载

    2016-01-31 16:54:09
    1. 如果用户想要实现CUser对象与一个整数相加,可以通过修改重载运算符的参数来实现。 CUser operator + (int nData)与CUser operator + (CUser & refUser)函数是可以同时存在的,即表示重载函数。这样在CUser类中即...
  • 用运算符重载函数作为类成员函数的方法重载运算符+ 下面的例子来自于课本: #include using namespace std; class Complex { public: Complex() //无参构造函数 { real = 0; imag = 0; } Co

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 176,633
精华内容 70,653
关键字:

重载运算符