精华内容
下载资源
问答
  • Java 语言支持如下运算符:  算术运算符: +,-,*,/,%,++,--  赋值运算符 =  关系运算符: >,=,  逻辑运算符: &&,||,!  位运算符: &,|,^,~ , >>,>>(了解!!!)  条件运算符 ?:  扩展...

    运算符可以是一元、二元或三元的。

    一元运算符有1个操作数。例如,递增运算符"++"就是一元运算符。

    二元运算符有2个操作数。例如,除法运算符"/"有2个操作数。

    三元运算符有3个操作数。例如,条件运算符"?:"具有3个操作数。

    运算符的行为还可能因所提供的操作数的数量而异。减法运算符"-"既是一元运算符又是二元运算符。对于减法运算符,如果只提供一个操作数,则该运算符会对操作数取反并返回结果;如果提供两个操作数,则减法运算符返回这两个操作数的差。例如:

     
    1. // 将减法运算符用作一元运算符(取反运算符)  
    2. trace(-5); // -5  
    3. // 将减法运算符用作二元运算符  
    4. trace(9-3); // 6  

     Java 语言支持如下运算符:

      算术运算符:  +,-,*,/,%,++,--

      赋值运算符 =

      关系运算符:  >,<,>=,<=,==,!=  instanceof

      逻辑运算符:  &&,||,!

      位运算符:  &,|,^,~ , >>,<<,>>>(了解!!!)

      条件运算符 ?:

      扩展赋值运算符:+=,-=,*=,/= 


    一元运算符

    int a = 3;

           int b = a++;  //执行完后,b=3。先给b赋值,再自增。

           int c= ++a;   //执行完后,c=5。先自增,再给b赋值

     

    注意:java中的乘幂处理:

           int a = 3^2;    //java中不能这么处理, ^是异或符号。

           double b = Math.pow(3,2);

    Math类提供了很多科学和工程计算需要的方法和常数。


    二元运算符

    整数运算:

    如果两个操作数有一个为Long, 则结果也为long

    没有long时,结果为int。即使操作数全为shot,byte,结果也是int.

    浮点运算:

             如果两个操作数有一个为double,则结果为double.

             只有两个操作数都是float,则结果才为float.


    取模运算

    其操作数可以为浮点数,一般使用整数。如:5.9%3.9=2.000000004

    要点:

      负数%负数=负数;
      负数%正数=负数;
      正数%负数=正数;

     

    注:一般都是正整数运算,不用考虑这么细!


    布尔逻辑表达符

    逻辑与:&&和&,逻辑或:||和|,逻辑非:!。

    逻辑与和逻辑或采用短路的方式。从左到右计算,如果确定值则不会再计算下去。

    逻辑与只要有一个为false, 则直接返回false.

    逻辑或只要有一个为true, 则直接返回true;

    boolean c = 1>2&&2>(3/0);


    位运算符

    (了解)

             ~-- 取反          &   -- 按位与          

             |  -- 按位或  ^  -- 按位异或  

             <<:左移运算符,>>:右移运算符 >>>:无符号移位运算符

     

    右移一位相当于除2取商。

    左移一位相当于乘2。

           int a = 3*2*2;

           int b =3<<2;  //相当于:3*2*2;

           int a = 12/2/2;

           int b = 12>>2;


    扩展运算符

    运算符

    用法举例

    等效的表达式

    +=

        a += b

        a = a+b

    -=

        a -= b

        a = a-b

    *=

        a *= b

        a = a*b

    /=

        a /= b

        a = a/b

    %=

        a %= b

        a = a%b


    字符串连接符

    “+”运算符两侧的操作数中只要有一个是字符串(String)类型,系统会自动将另一个操作数转换为字符串然后再进行连接。

           int c = 12;

           System.out.println("c="+ c);


    三目条件运算符(三元运算符)

    三目条件运算符,语法格式:

    x ? y : z

    其中 x 为 boolean 类型表达式,先计算 x 的值,若为true,则整个三目运算的结果为表达式 y 的值,否则整个运算结果为表达式 z 的值。

    举例:

           int score = 80; int x = -100;

           String type = score < 60 ?"不及格" :"及格";

           intflag = x > 0 ? 1 : (x == 0 ? 0 : -1);

           System.out.println("type= " +type);

           System.out.println("flag= "+flag);

    运算符优先级的问题



    R to L

    .   ( )   { }   ;   ,
    ++ --   ~ ! (data type)

    L to R

    * / %

    L to R

    + -

    L to R

    << >> >>>

    L to R

    <  >  <=  >=  instanceof

    L to R

    == !=

    L to R

    &

    L to R

    ^

    L to R

    |

    L to R

    &&


    展开全文
  • c++(重载双目运算符

    千次阅读 2019-04-18 22:38:55
    重载加法运算符,实现对象的直接加法运算。例如,下面这个feetinches类: class FeetInches { private: int feet; int inches; //对feetinches的值进行调整 void simplify(); public: FeetInches(int f=0,...

    重载加法运算符,实现对象的直接加法运算。例如,下面这个feetinches类:

    class FeetInches
    {
    private:
        int feet;
        int inches;
        //对feet和inches的值进行调整
        void simplify();
    
    public:
        FeetInches(int f=0, int i=0)
        {
            feet = f;
            inches = i;
            simplify();
        }
        void setData(int f,int i)
        {
            feet = f;
            inches = i;
            simplify();
        }
        int getFeet(){return feet;}
        int getInches(){return inches;}
    
        //重载加法运算符
        FeetInches operator+(const FeetInches &right)
        {
            FeetInches temp;
            temp.feet = this->feet + right.feet;
            temp.inches = this->inches + right.inches;
            temp.simplify();
            return temp;
        }
    };

    其中simplify函数实现对feet和inches的调整,具体实现如下:

    void FeetInches::simplify()
    {
        if(inches >= 12)
        {
            feet+=inches/12;
            inches = inches%12;
        }else if(inches < 0)
        {
            feet-=abs(inches)/12 + 1;
            inches = 12 - abs(inches)%12;
        }
    }

    注意:

    • 在上述的重载函数中,函数首先定义了一个局部对象temp,用于存储当前对象和形参对象相加运算的结果,然后返回temp,并复制给等号左边的对象。

    • 当执行两个feetinches对象的加法运算时,将自动调用上面类中的重载函数,例如下面两句的意思完全相同:

        FeetInches length1(3,5),length2(1,2),length3;
    
        length3 = length1 + length2;
        length3 = length1.operator+(length2);    //意义和上句一样
    • 任何一个双目运算符V被重载之后,当执行如下形式的二元运算时:

    obj1 V obj2

    都完全等价于:obj1.operator B (obj2)

    也就是对象obj调用函数成员operator B,其中obj2作为函数实参。

    主函数测试:

    //重载加法双目运算符
    int main()
    {
        FeetInches length1(3,5),length2(1,2),length3;
    
    
        length3 = length1 + length2;
    
    
        cout <<"the data of the length3 is:"<< endl;
        cout<<"feet: "<<length3.getFeet()<<endl;
        cout<<"inches: "<<length3.getInches()<<endl;
        return 0;
    }

    输出结果:

    展开全文
  • 重载单目运算符的方法与重载双目运算符的方法是类似的。但由于单目运算符只有一个操作数,因此运算符重载函数只有一个参数,如果运算符重载函数作为成员函数,则还可省略此参数。下面以自增运算符”++“为例,介绍单...

    C++单目运算符重载

    单目运算符只有一个操作数,如!a,-b,&c,*p,还有最常用的++i和--i等。重载单目运算符的方法与重载双目运算符的方法是类似的。但由于单目运算符只有一个操作数,因此运算符重载函数只有一个参数,如果运算符重载函数作为成员函数,则还可省略此参数。

    下面以自增运算符”++“为例,介绍单目运算符的重载。

    [例] 有一个Time类,包含数据成员minute(分)和sec(秒),模拟秒表,每次走一秒,满60秒进一分钟,此时秒又从0开始算。要求输出分和秒的值。

    #include

    using namespace std;

    class Time

    {

    public:

    Time( ){minute=0;sec=0;} //默认构造函数

    Time(int m,int s):minute(m),sec(s){ } //构造函数重载

    Time operator++( ); //声明运算符重载函数

    void display( ){cout<

    private:

    int minute;

    int sec;

    };

    Time Time::operator++( ) //定义运算符重载函数

    {

    if(++sec>=60)

    {

    sec-=60; //满60秒进1分钟

    ++minute;

    }

    return *this; //返回当前对象值

    }

    int main( )

    {

    Time time1(34,0);

    for (int i=0;i<61;i++)

    {

    ++time1;

    time1.display( );

    }

    return 0;

    }

    运行情况如下:

    34:1

    34:2

    34:59

    35:0

    35:1 (共输出61行)

    可以看到:在程序中对运算符“++”进行了重载,使它能用于Time类对象。“++”和“--”运算符有两种使用方式,前置自增运算符和后置自增运算符,它们的作用是不一样的,在重载时怎样区别这二者呢?

    针对“++”和“--”这一特点,C++约定,在自增(自减)运算符重载函数中,增加一个int型形参,就是后置自增(自减)运算符函数。

    [例] 在上面例子程序的基础上增加对后置自增运算符的重载。修改后的程序如下:

    #include

    using namespace std;

    class Time

    {

    public:

    Time( ){minute=0;sec=0;}

    Time(int m,int s):minute(m),sec(s){}

    Time operator++( );//声明前置自增运算符“++”重载函数

    Time operator++(int);//声明后置自增运算符“++”重载函数

    void display( ){cout<

    private:

    int minute;

    int sec;

    };

    Time Time::operator++( )//定义前置自增运算符“++”重载函数

    {

    if(++sec>=60)

    {

    sec-=60;

    ++minute;

    }

    return *this;//返回自加后的当前对象

    }

    Time Time::operator++(int)//定义后置自增运算符“++”重载函数

    {

    Time temp(*this);

    sec++;

    if(sec>=60)

    {

    sec-=60;

    ++minute;

    }

    return temp; //返回的是自加前的对象

    }

    int main( )

    {

    Time time1(34,59),time2;

    cout<

    time1.display( );

    ++time1;

    cout<

    time1.display( );

    time2=time1++; //将自加前的对象的值赋给time2

    cout<

    time1.display( );

    cout<

    time2.display( ); //输出time2对象的值

    }

    请注意前置自增运算符“++”和后置自增运算符“++”二者作用的区别。前者是先自加,返回的是修改后的对象本身。后者返回的是自加前的对象,然后对象自加。请仔细分析后置自增运算符重载函数。

    运行结果如下:

    time1 : 34:59(time1原值)

    ++time1: 35:0 (执行++time1后time1的值)

    time1++: 35:1 (再执行time1++后time1的值)

    time2 : 35:0 (time2保存的是执行time1++前time1的值)

    可以看到,重载后置自增运算符时,多了一个int型的参数,增加这个参数只是为了与前置自增运算符重载函数有所区别,此外没有任何作用。编译系统在遇到重载后置自增运算符时,会自动调用此函数。

    C++双目运算符重载

    双目运算符(或称二元运算符)是C++中最常用的运算符。双目运算符有两个操作数,通常在运算符的左右两侧,如3+5,a=b,i<10等。在重载双目运算符时,不言而喻在函数中应该有两个参数。

    [例] 定义一个字符串类String,用来存放不定长的字符串,重载运算符“==”、“”,用于两个字符串的等于、小于和大于的比较运算。

    为了使读者便于理解程序,同时也使读者了解建立程序的步骤,下面分几步来介绍编程过程:

    1) 先建立一个String类:

    #include

    using namespace std;

    class String

    {

    public:

    String( ){p=NULL;} //默认构造函数

    String(char *str); //构造函数

    void display( );

    private:

    char *p;//字符型指针,用于指向字符串

    };

    String::String(char *str) //定义构造函数

    {p=str;} //使p指向实参字符串

    void String::display( ) //输出p所指向的字符串

    {cout<

    int main( )

    {

    String string1("Hello"),string2("Book");

    string1.display( );

    cout<

    string2.display( );

    return 0;

    }

    运行结果为:

    Hello

    Book

    2) 有了这个基础后,再增加其他必要的内容。现在增加对运算符重载的部分。为便于编写和调试,先重载一个运算符“>”。程序如下:

    #include

    #include

    using namespace std;

    class String

    {

    public:

    String( ){p=NULL;}

    String(char *str);

    friend bool operator>(String &string1,String &string2);//声明运算符函数为友元函数

    void display( );

    private:

    char *p;//字符型指针,用于指向字符串

    };

    String::String(char *str)

    {p=str;}

    void String::display( ) //输出p所指向的字符串

    {cout<

    bool operator>(String &string1,String &string2)//定义运算符重载函数

    {

    if(strcmp(string1.p,string2.p)>0)

    return true;

    else return false;

    }

    int main( )

    {

    String string1("Hello"),string2("Book");

    cout<string2)<

    }

    程序运行结果为1。

    这只是一个并不很完善的程序,但是,已经完成了实质性的工作了,运算符重载成功了。其他两个运算符的重载如法炮制即可。

    3) 扩展到对3个运算符重载。

    在String类体中声明3个成员函数:

    friend bool operator> (String &string1, String &string2);

    friend bool operator< (String &string1, String &string2);

    friend bool operator==(String &string1, String& string2);

    在类外分别定义3个运算符重载函数:

    bool operator>(String &string1,String &string2) //对运算符“>”重载

    {

    if(strcmp(string1.p,string2.p)>0)

    return true;

    else

    return false;

    }

    bool operator

    {

    if(strcmp(string1.p,string2.p)<0)

    return true;

    else

    return false;

    }

    bool operator==(String &string1,String &string2) //对运算符“==”重载

    {

    if(strcmp(string1.p,string2.p)==0)

    return true;

    else

    return false;

    }

    再修改主函数:

    int main( )

    {

    String string1("Hello"), string2("Book"), string3("Computer");

    cout<string2)<

    cout<

    cout<

    return 0;

    }

    运行结果为:

    1

    0

    0

    结果显然是对的。到此为止,主要任务基本完成。

    4) 再进一步修饰完善,使输出结果更直观。下面给出最后的程序。

    #include

    using namespace std;

    class String

    {

    public:

    String( ){p=NULL;}

    String(char *str);

    friend bool operator>(String &string1, String &string2);

    friend bool operator

    friend bool operator==(String &string1, String &string2);

    void display( );

    private:

    char *p;

    };

    String::String(char *str)

    {p=str;}

    void String::display( ) //输出p所指向的字符串

    {cout<

    bool operator>(String &string1, String &string2)

    {

    if(strcmp(string1.p, string2.p)>0)

    return true;

    else

    return false;

    }

    bool operator

    {

    if(strcmp(string1.p, string2.p)<0)

    return true;

    else

    return false;

    }

    bool operator==(String &string1, String &string2)

    {

    if(strcmp(string1.p, string2.p)==0)

    return true;

    else

    return false;

    }

    void compare(String &string1, String &string2)

    {

    if(operator>(string1, string2)==1)

    {string1.display( );cout<";string2.display( );}

    else

    if(operator

    {string1.display( );cout<

    else

    if(operator==(string1, string2)==1)

    {string1.display( );cout<

    cout<

    }

    int main( )

    {

    String string1("Hello"), string2("Book"), string3("Computer"), string4("Hello");

    compare(string1, string2);

    compare(string2, string3);

    compare(string1, string4);

    return 0;

    }

    运行结果为:

    Hello>Book

    Book

    Hello==Hello

    增加了一个compare函数,用来对两个字符串进行比较,并输出相应的信息。这样可以减轻主函数的负担,使主函数简明易读。

    通过这个例子,不仅可以学习到有关双目运算符重载的知识,而且还可以学习怎样去编写C++程序。由于C ++程序包含类,一般都比较长,有的初学C++的读者见到比较长的程序就发怵,不知该怎样着手去阅读和分析它。轮到自己编程序,更不知道从何入 手,往往未经深思熟虑,想到什么就写什么,一口气把程序写了出来,结果一运行,错 误百出,光为找出错位置就花费了大量的时间。根据许多初学者的经验,上面介绍的方法是很适合没有编程经验的初学者的,能使人以清晰的思路进行程序设计,减少出错机会, 提高调试效率。

    这种方法的指导思想是:先搭框架,逐步扩充,由简到繁,最后完善。边编程,边调试,边扩充。千万不要企图在一开始时就解决所有的细节。类是可扩充的,可以一步一步地扩充它的功能。最好直接在计算机上写程序,每一步都要上机调试,调试通过了前面一步再做下一步,步步为营。这样编程和调试的效率是比较高的。大家可以试验一下。

    展开全文
  • 运算符重载

    2021-03-14 21:17:42
    什么是运算符的重载?运算符与类结合,产生新的含义。...: :: sizeof友元函数成员函数的使用场合:一般情况下,建议一元运算符使用成员函数,二元运算符使用友元函数1、运算符的操作需要修改类...

    什么是运算符的重载?

    运算符与类结合,产生新的含义。

    为什么要引入运算符重载?

    作用:为了实现类的多态性(多态是指一个函数名有多种含义)

    怎么实现运算符的重载?

    方式:类的成员函数 或 友元函数(类外的普通函数)

    规则:不能重载的运算符有 .  和 .* 和 ?: 和 ::  和 sizeof

    友元函数和成员函数的使用场合:一般情况下,建议一元运算符使用成员函数,二元运算符使用友元函数

    1、运算符的操作需要修改类对象的状态,则使用成员函数。如需要做左值操作数的运算符(如=,+=,++)

    2、运算时,有数和对象的混合运算时,必须使用友元

    3、二元运算符中,第一个操作数为非对象时,必须使用友元函数。如输入输出运算符<>

    具体规则如下:

    运算符

    建议使用

    所有一元运算符

    成员函数

    = ( ) [ ]  ->

    必须是成员函数

    += -= /= *= ^= &= != %= >>= <<= , 似乎带等号的都在这里了

    成员函数

    所有其它二元运算符, 例如: –,+,*,/

    友元函数

    << >>

    必须是友元函数

    2. 参数和返回值

    当参数不会被改变,一般按const引用来传递(若是使用成员函数重载,函数也为const).

    对于返回数值的决定:

    1) 如果返回值可能出现在=号左边, 则只能作为左值, 返回非const引用。

    2) 如果返回值只能出现在=号右边, 则只需作为右值, 返回const型引用或者const型值。

    3) 如果返回值既可能出现在=号左边或者右边, 则其返回值须作为左值, 返回非const引用。

    运算符重载举例:

    +和 -运算符的重载:

    classPoint

    {private:intx;public:

    Point(intx1)

    { x=x1;}

    Point(Point&p)

    { x=p.x;}const Point operator+(const Point& p);//使用成员函数重载加号运算符

    friend const Point operator-(const Point& p1,const Point& p2);//使用友元函数重载减号运算符

    };const Point Point::operator+(const Point&p)

    {return Point(x+p.x);

    }

    Pointconst operator-(const Point& p1,const Point&p2)

    {return Point(p1.x-p2.x);

    }

    输出:

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    Point a(1);

    Point b(2);

    a+b; //正确,调用成员函数

    a-b; //正确,调用友元函数

    a+1; //正确,先调用类型转换函数,把1变成对象,之后调用成员函数

    a-1; //正确,先调用类型转换函数,把1变成对象,之后调用友元函数

    1+a; //错误,调用成员函数时,第一个操作数必须是对象,因为第一个操作数还有调用成员函数的功能

    1-a; //正确,先类型转换 后调用友元函数

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    总结:

    1、由于+ -都是出现在=号的右边,如c=a+b,即会返回一个右值,可以返回const型值

    2、后几个表达式讨论的就是,数和对象混合运算符的情况,一般出现这种情况,常使用友元函数

    3、双目运算符的重载:

    重载运算符函数名:operator@(参数表)

    隐式调用形式:obj1+obj2

    显式调用形式:obj1.operator+(OBJ obj2)---成员函数

    operator+(OBJ obj1,OBJ obj2)---友元函数

    执行时,隐式调用形式和显式调用形式都会调用函数operator+()

    ++和--运算符的

    classPoint

    {private:intx;public:

    Point(intx1)

    { x=x1;}

    Pointoperator++();//成员函数定义自增

    const Point operator++(int x); //后缀可以返回一个const类型的值

    friend Point operator--(Point& p);//友元函数定义--

    friend const Point operator--(Point& p,int x);//后缀可以返回一个const类型的值

    };

    Point Point::operator++()//++obj

    {

    x++;return *this;

    }const Point Point::operator++(int x)//obj++

    {

    Point temp= *this;this->x++;returntemp; // 需要返回一个临时对象,效率不如 ++obj 高

    }

    Pointoperator--(Point& p)//--obj

    {

    p.x--;returnp;//前缀形式(--obj)重载的时候没有虚参,通过引用返回*this 或 自身引用,也就是返回变化之后的数值

    }const Point operator--(Point& p,int x)//obj--

    {

    Point temp=p;

    p.x--;returntemp;//后缀形式obj--重载的时候有一个int类型的虚参, 返回原状态的拷贝

    }

    调用:

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    Point b(2);

    a++;//隐式调用成员函数operator++(0),后缀表达式

    ++a;//隐式调用成员函数operator++(),前缀表达式

    b--;//隐式调用友元函数operator--(0),后缀表达式

    --b;//隐式调用友元函数operator--(),前缀表达式

    cout<

    cout<

    cout<

    cout<

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    总结:

    1、a++

    函数返回:temp(临时变量)

    函数返回是否是const类型:返回是一个拷贝后的临时变量),不能出现在等号的左边(临时变量不能做左值),函数的结果只能做右值,则要返回一个const类型的值

    ++a

    函数返回:*this;

    函数返回是否是const类型:返回原状态的本身,返回值可以做左值,即函数的结果可以做左值,则要返回一个非const类型的值

    2、前后缀仅从函数名(operator++)无法区分,只能有参数区分,这里引入一个虚参数int x,x可以是任意整数。

    3、单目运算符的重载:

    重载运算符函数名:operator@(参数表)

    隐式调用形式:obj1@  或 @obj1

    显式调用形式:

    成员函数:

    obj1.operator@( )//前缀

    obj1.operator@(0)//后缀

    友元函数:

    operator@(OBJ obj)//前缀

    operator@(OBJ obj,int x)//后缀

    执行时,隐式调用形式和显式调用形式都会调用函数operator@()

    重载下标运算符[ ]

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    class Point

    {

    private:

    int x[5];

    public:

    Point()

    {

    for (int i=0;i<5;i++)

    {

    x[i]=i;

    }

    }

    int& operator[](int y);

    };

    int& Point::operator[](int y)

    {

    static int t=0;

    if (y<5)

    {

    return x[y];

    }

    else

    {

    cout<

    return t;

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    调用:

    Point a;

    for (int i=0;i<10;i++)

    {

    cout<

    }

    a[0]=10;

    重载下标运算符[ ]的目的:

    1、对象[x]  类似于 数组名[x],更加符合习惯

    2、可以对下标越界作出判断

    语法:

    重载方式:只能使用成员函数重载

    函数名:operator[ ](参数表)

    参数表:一个参数,且仅有一个参数,该参数设定了下标值,通常为整型,但是也可以为字符串( 看成下标)。

    函数调用:显式调用:Obj[arg]-对象[下标]

    隐式调用:obj.operator[ ](arg)

    返回类型:

    1、返回函数引用 + 返回成员的实际类型(由程序员根据函数体定义)

    2、因为返回值可以做左值和右值,应该不使用返回值为const类型

    但是,为了能访问const对象,下标运算符重载有非const和const两个版本。(待定写)

    如:int&  Point::operator[](int y)//为什么使用返回引用:返回的值可以做左值,也可以做右值,则必须使用返回引用

    重载运算符( )

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    class Point

    {

    private:

    int x;

    public:

    Point(int x1)

    { x=x1;}

    const int operator()(const Point& p);

    };

    const int Point::operator()(const Point& p)

    {

    return (x+p.x);

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    调用:

    调用:

    Point a(1);

    Point b(2);

    cout<

    展开全文
  • 一、赋值运算符和赋值表达式1、赋值运算符C语言的赋值运算符为等号,表示形式“=”。此外,还有复合赋值运算符,后续陆续介绍。2、赋值表达式“=”的左侧是变量,右侧是常量、变量、表达式、函数等,“=”的含义是将...
  • Kotlin(二)之运算符与表达式

    千次阅读 2019-05-21 22:42:16
    kotlin的运算符都是以方法形式来实现的,这些运算符都具有特定的符号(如+、*)固定的优先级。各种运算符对应的方法名都是固定的,我们只要为某类型提供特定名称的方法,成员方法或者扩展方法即可。Kotlin的所有...
  • 重载双目运算符时,运算符函数中应该具有两个参数,若运算符函数作为类的成员函数(当运算符重载函数作为类的成员函数时,要求操作数左边必须是一个对象,而函数的参数可以是同类的对象也可以是普通的变量),则只需要...
  • 1. 重载双目运算符 例如一个 == 的demo 调用如下 #include "Time.h" #include "Date.h" #include &lt;iostream&gt; using namespace std; int main() { CTime time1(12, 12,...
  • 第4章C世界中的加减乘除 运算符和表达式 C中的运算符和表达式算术运算符和表达式关系运算符和表达式逻辑运算符和表达式条件运算符和表达式赋值运算符和表达式自增 自减运算符逗号运算符和表达式运算符的优先级 4 1C...
  • 第十二讲:重载单、双目、插入、提取运算符 ... 双目运算符(或称二元运算符)是中最常用的运算符。双目运算符有两个操作数,通常在运算符的左右两侧,如3+5,a=b,i 例4 定义一个字符串类String,用来
  • 运算符 进行特定操作的符号。例如:“+” 表达式:用运算符连起来的式子叫做表达式。例如:20+5。又例如:a+b 四则运算: + - * / 取模(取余数):% 首先计算得到表达式的结果,然后打印输出这个结果 除法公式...
  • C++一元和二元作用域

    2021-04-09 09:00:46
    C++一元和二元作用域 #区别 1)就是表示这个操作符能作用于几个变量上,一个变量就是一元,两个就是二元。。。 2)::作一元作用域分辨符作用是:当局部变量全局变量同名时 ,在局部变量所在作用域中访问全局变量 :...
  • 一个双目运算符作为类的成员函数重载时,重载函数的参数表中有()个参数。 A.1 B.2 C.3 D.0 A 若为成员函数重载,参数一般为类对象的引用,另一个参数由this 指针所指向,故不显示。 若为友元函数重载,则有两个参数...
  • 4 ** -2 =0.0625 (即 4 ** (-2)) 三 操作符分类 1 一元(单目)操作符:一个操作数 取反- 2 二元双目)操作符:两个操作数 + - * / ** // 比较操作符 逻辑操作符 四 课后作业 (一) 测试题答案 0....
  • 运算符 名称或含义 使用形式 结合方向 说明 1 [] 数组下标 数组名[整型表达式] 左到右 () 圆括号 (表达式)/函数名(形参表) . 成员选择(对象) 对象.成员名...
  • 1)根据参与运算对象的多少可分为:单目(也称为一元运算符),双目(也称作二元运算符),三目(也称为三元运算符) 2)根据运算作用不同可分为:算术运算符、条件运算符、关系运算符、赋值运算符、逻辑运算符、...
  • b = ++a //先将变量a的值加1,然后赋予b,此时a=6,b=6 b = a++ //先将变量a的值赋给b,然后a的值加1,此时a=6,b=5 4、比较运算符 比较运算符属于二元运算符,用于程序中的变量之间、变量自变量之间以及其他类型...
  • 1、对双目运算符而言,成员...2、双目运算符一班可以被重载为友元运算符和成员函数运算符,但是当一个整数与一个复数相加时,必须使用友元函数。 例:友元运算符重载函数实现一个复数与一个整数相加#include<iostream
  • 运算符重载,就是对已有的运算符重新进行定义,赋予其另一种功能,使他适应不同的数据类型。 运算符重载的本质:函数重载 关键字:operator...定义一个Coordinate坐标类,分别通过成员函数友元函数对负号运算符进...
  • 1、单元运算符和括号。2、常规算术运算符。3、位移运算符。4、比较运算符。5、逻辑运算符。6、各种赋值运算符。7、右位(后缀)单元运算符。 1、在这一级中,有++、--(做为前缀)、()、+、-(做为单元运算符)、!、~。这...
  • 1.对双目运算符而言,成员函数重载运算符的函数参数表中只有一个参数,而用友元函数重载运算符...2.双目运算符一般可以用友元函数重载成员函数重载,但有一种情况只可以用友元函数重载。  即:双目运算符左边的变
  • C语言课件(运算符和表达式).ppt运算符与表达式第二讲 运算符和表达式,引例 概念及分类 优先级和结合性 算术运算 关系运算 逻辑运算 位运算 赋值运算符 逗号运算符 条件运算符,引例,引例 问题 输入一个四位的正整数,...
  • 第五章 运算符重载

    2020-07-17 02:15:12
    文章目录第五章 运算符重载(类对象)...特殊运算符的重载①自增自减运算符 ++ -- 的重载②赋值运算符 = 的重载③函数调用运算符 () 的重载④下标访问运算符 [] 的重载⑤成员访问运算符 -> * 的重载⑥输入输出流运算
  • 双目运算符:又称二元运算符,连接两个操作数。大部分运算符属于此类。 3.三目运算符:连接三个操作数。C语言中唯一的三目运算符为条件运算符(?:)。 运算符有优先级结合性。运算先后顺序受运算符的优先级...
  • C语言教案(运算符和表格达式)运算符与表达式 第二讲 运算符和表达式 引例 概念及分类 优先级和结合性 算术运算 关系运算 逻辑运算 位运算 赋值运算符 逗号运算符 条件运算符 引例 引例 问题 输入一个四位的正整数,...
  • 其实在很多情况下,C++ 重载运算符和重载函数的使用是非常关键的,所以下面我将以实例来介绍其使用方法: C++ 允许在同一作用域中的某个函数和运算符指定多个定义,分别称为函数重载和运算符重载。 重载声明是指一...
  • ++ 与 -- 运算符详解篇

    千次阅读 2020-08-22 16:09:36
    实际当中大家常见到的可能是算术运算符和比较运算符,适用于各种运算场景,是不是很常见呢。今天要说的就是算术运算符中的 ++和 --,分别有什么作用呢。其实 ++相当于 +( 加法),--相当于 - (减法),在语言版本...
  • 运算符的使用通常表达式是密不可分的,通常作为表达式的一个部分组合计算使用。C++语言中运算符可以分为算术运算符、关系运算符、逻辑运算符、条件运算符等。根据运算符需要的操作数个数不同又可以分为单目运算符...
  • 二元运算符又称为双目运算符,即需要2个操作数的运算符,例如 + - * / 等。 运算符重载可以分为3种方式:类的非静态成员函数、类的友元函数、普通函数。 例如有 2 个操作数 a b,二元运算符 ?

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,304
精华内容 521
关键字:

双目运算符和二元运算符