精华内容
下载资源
问答
  • 前面的笔记学习了如何在...C++中包含单目(一元)运算符、双目二元运算符和三目(三元)运算符,相应的构成了多种表达式。运算符具有优先级和结合性,优先级指先后计算次序,结合性指同级运算符时按照自左向右...

    6046a18e8dc68201d9383b1e1cfc65d8.png

    前面的笔记学习了如何在C++中定义各种数据类型, 本文将继续学习如何使用表达式,对这些数据类型进行处理。

    在编程语言中“表达式”可以近似于“公式”,也就是按照自己的预期进行某种计算,表达式由运算符合操作数等构成。C++中包含单目(一元)运算符、双目(二元)运算符和三目(三元)运算符,相应的构成了多种表达式。运算符具有优先级和结合性,优先级指先后计算次序,结合性指同级运算符时按照自左向右还是自右向左进行计算。

    (1)算术表达式

    算术表达式由算术运算符、操作数和括号构成,基本运算符包含:加+、减-、乘*、除、取余%,只有“加、减”在做“正、负”符号时是一元运算符,其余情况都是二元运算符。C++拥有自加++和自减--两个一元运算符(python应该没有自加和自减,因为python中数值是不可变类型,改变值会申请新的内存),当表达式中存在自加或者自减运算时,一定要注意自加和自减是在操作数之前还是操作数之后,在操作数之前表示先自加再计算整个表达式,在操作数之后表示先计算整个表达式再自加,比如下面的代码:

    int age_1 = 22;
    int age_2 = 22;
    int new_age_1;
    int new_age_2;
    new_age_1 = age_1++;
    new_age_2 = ++age_2;
    

    第5行计算new_age_1时,先计算完整个表达式,再进行age_1的自加,所以new_age_1

    等于22;第6行计算new_age_2时,先对age_2进行自加,再进行表达式计算,所以new_age_2等于23。自己在写代码时最好不要给自己挖坑,少使用过于复杂的表达式。

    (2)赋值运算符

    赋值运算符“=”是双目运算符,结合性是自右向左,允许连续赋值:

    int x, y, z;
    x = y = z = 1;

    此外,C++还有+=、*=、/=等等运算符,结合性都是自右向左。

    (3)逗号运算符

    逗号运算符可以分隔两个表达式,先计算左边表达式再计算右边的表达式,但是由于逗号运算符的优先级低于赋值运算符,所以采用逗号运算符进行赋值时必须把逗号表达式括起来,下面两行代码得到的x值是不同的:

    x = (2, 3);
    x = 2, 3;

    第一行x等于3,第二行x等于2,因为逗号运算符的优先级低于赋值运算符,自己在使用中必须小心。

    (4)关系运算符

    关系运算符是逻辑表达式的基础,C++包含的关系运算符分两个优先级,较高的优先级为:大于、小于、大于等于和小于等于四种,分别用<、<=、>、>=来表示;较低的优先级为:等于、不等于,分别用==、!=表示。逻辑表达式返回的值为布尔类型,判断为真返回True(0),判断为假返回False(1),如下:

    int x = 2;
    int y = 3;
    bool result;
    result = (x >= y);

    C++还拥有三个逻辑运算符:与、或、非,分别用||、&&、!三个符号表示。

    (5)三元表达式

    据自己目前所知,C++唯一的三元运算符是条件运算符,其语法如下:

    条件判断? 表达式1:表达式2

    当判断条件成立时,执行表达式1;当判断条件不成立时,执行表达式2,代码如下:

    int x = 2;
    int y = 3;
    int result;
    result = (x>y? 10: 1000);

    由于x>y不成立,所以执行表达式2,也就是result被赋值为1000。

    (6)sizeof函数

    书中称sizeof为单独的运算符,为了便于理解这里把其视为函数。sizeof可以求取对象的占用的字节数,下面的例子计算了int类型占用的字节数:

    int result=1000;
    cout << sizeof(result) <<endl;

    输出为4,表示int占用4个字节,这和理论上是一致的。

    (7)数据类型转换

    数据类型转换是编程语言面临的共同问题,对于表达式中存在多种数据类型的情况必须采用有效的处理策略。C++数据类型转换包含显式转换和隐式转换两种,下面分别进行介绍。

    (7.1)显式转换

    如果自己清晰的知道表达式中各个对象是什么类型,并且清晰的知道想要将对象变为何种新的类型,那么可以使用:类型说明符(表达式)进行显式的类型转换,比如将float类型的x转换为int类型的y:

    float x = 6.66;
    int y = int(x);   

    上述代码运行后y的值为6,仅仅取x的整数部分。显式类型转换时,如果自己选择的类型说明符的精度较低,比如上述代码中x为高精度,但是类型说明符int为低精度,则数据类型转换过程中造成了精度丢失

    (7.2)隐式转换

    如果表达式中有高精度和低精度两种数据参与计算,会自动将低精度数据转换为高精度数据进行计算,这种隐式转换是没有精度丢失的安全转换

    float x = 6.66;
    int y = 2;
    cout << x+y <<endl;

    上述代码中浮点x和整型y进行加法时,按照浮点类型进行计算输出6.66。

    另外,逻辑表达式中0和非0数据分别会被转换为true和false,赋值表达式自动将等号右边的类型转换为等号左边的类型。

    (8)总结:

    C++的包含的运算符和表达式总体来说和python差不多,类型转换的规则也很符合直观的理解。位运算符部分暂时没进行记录是因为其并不常用,等用到的时候再学习。

    参考:

    【1】郑莉《C++语言程序设计》

    【2】https://www.runoob.com/cplusplus/cpp-operators.html

    展开全文
  • 什么是运算符的重载?运算符与类结合,产生新的含义。...: :: 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<

    展开全文
  • 二元运算符又称为双目运算符,即需要2个操作数的运算符,例如 + - * / 等。 运算符重载可以分为3种方式:类的非静态成员函数、类的友元函数、普通函数。 例如有 2 个操作数 a b,二元运算符 ?

    来自:http://www.cnblogs.com/LubinLew/p/CppOperatorOverload-BinaryOperator.html

    1、重载二元操作符的方法

    二元运算符又称为双目运算符,即需要2个操作数的运算符,例如 + - * / 等。

    运算符重载可以分为3种方式:类的非静态成员函数、类的友元函数、普通函数。

    例如有 2 个操作数 a 和 b,二元运算符 ? (表示一个二元运算符),a ? b 的操作会被解释为下面2种形式之一 

    //a ? b
    a.operator?(b);    //类的非静态成员函数
    operator(a, b);  //友元函数 和 普通函数

     第一种形式是运算符被重载为类的非静态成员函数,

    这种方式要求运算符左边的的操作数(即第一个操作数a)必须是一个对象,operator?是这个对象的非静态成员函数

    并且只能有一个参数。

     

    第二种形式是运算符被重载为类的友元函数 或 普通函数,

    这种方式需要2个参数,

    重载为 类的友元函数 和 普通函数的区别是 类的友元函数可以直接访问类的私有成员,而普通函数不可以。

     

    2、应用举例(对象 ? 对象)

    下例中有3个complex类 ComplexA、ComplexB 和 ComplexC,3个类都重载了加减乘除 运算符。

    其中ComplexA使用类的非静态成员函数方式重载,ComplexB使用类的友元函数方式重载,ComplexC使用普通函数方式重载。

    需要注意的是复数的加减乘除运算的算法是有问题的,只是一个说明重载方法的例子,

    另外重载函数的参数最好使用const关键字限定,至于返回值是否用const限定,需要取决于你的设计,比如允许C3 = ++(C1+C2)这种情况,就不能用cosnt限定。

    至于不同类型的对象间的操作,通常是没有意义的。

    复制代码
    #include <iostream>
    using namespace std;
    
    class ComplexA
    {
    public:
        //默认构造函数(Default constructor)
        ComplexA(){cout<<"Default Constructor"<<endl;}
        //带参数的构造函数(The constructor with parameters)
        ComplexA(double re, double im):real(re),image(im){cout<<"Parameter Constructor"<<endl;}
        //拷贝构造函数(Copy constructor)
        ComplexA(const ComplexA& ref){real = ref.real; image = ref.image; cout<<"Copy Constructor"<<endl;}
        //析构函数(destructor)
        ~ComplexA(){cout<<"Destructor"<<endl;}
    
        //Operator Overload : +
        ComplexA operator+(ComplexA& ref)
        {
            return ComplexA(real + ref.real, image + ref.image);
        }
    
        //Operator Overload : -
        ComplexA operator-(ComplexA& ref)
        {
            return ComplexA(real - ref.real, image - ref.image);
        }
    
        //Operator Overload : *
        ComplexA operator*(ComplexA& ref)
        {
            return ComplexA(real * ref.real, image * ref.image);
        }
    
        //Operator Overload : /
        ComplexA operator/(ComplexA& ref)
        {
            return ComplexA(real / ref.real, image / ref.image);
        }
    
        //display
        void display(void){cout<<real<<"+"<<image<<"i"<<endl;}
    private:
        double real;    //复数的实部
        double image;   //复数的虚部
    };
    
    class ComplexB
    {
    public:
        //默认构造函数(Default constructor)
        ComplexB(){cout<<"Default Constructor"<<endl;}
        //带参数的构造函数(The constructor with parameters)
        ComplexB(double re, double im):real(re),image(im){cout<<"Parameter Constructor"<<endl;}
        //拷贝构造函数(Copy constructor)
        ComplexB(const ComplexB& ref){real = ref.real; image = ref.image; cout<<"Copy Constructor"<<endl;}
        //析构函数(destructor)
        ~ComplexB(){cout<<"Destructor"<<endl;}
    
        //Operator Overload : +
        friend ComplexB operator+(ComplexB& ref1, ComplexB& ref2)
        {
            return ComplexB(ref1.real + ref2.real, ref1.image + ref2.image);
        }
    
        //Operator Overload : -
        friend ComplexB operator-(ComplexB& ref1, ComplexB& ref2)
        {
            return ComplexB(ref1.real - ref2.real, ref1.image - ref2.image);
        }
    
        //Operator Overload : *
        friend ComplexB operator*(ComplexB& ref1, ComplexB& ref2)
        {
            return ComplexB(ref1.real * ref2.real, ref1.image * ref2.image);
        }
    
        //Operator Overload : /
        friend ComplexB operator/(ComplexB& ref1, ComplexB& ref2)
        {
            return ComplexB(ref1.real / ref2.real, ref1.image / ref2.image);
        }
    
        //display
        void display(void){cout<<real<<"+"<<image<<"i"<<endl;}
    private:
        double real;    //复数的实部
        double image;   //复数的虚部
    };
    
    
    class ComplexC
    {
    public:
        //默认构造函数(Default constructor)
        ComplexC(){cout<<"Default Constructor"<<endl;}
        //带参数的构造函数(The constructor with parameters)
        ComplexC(double re, double im):real(re),image(im){cout<<"Parameter Constructor"<<endl;}
        //拷贝构造函数(Copy constructor)
        ComplexC(const ComplexC& ref){real = ref.real; image = ref.image; cout<<"Copy Constructor"<<endl;}
        //析构函数(destructor)
        ~ComplexC(){cout<<"Destructor"<<endl;}
    
        //Get Data
        double GetReal(void){return real;}
        double GetImage(void){return image;}
    
      //display
        void display(void){cout<<real<<"+"<<image<<"i"<<endl;}
    private:
        double real;    //复数的实部
        double image;   //复数的虚部
    };
    
    //Operator Overload : +
    ComplexC operator+(ComplexC& ref1, ComplexC& ref2)
    {
        return ComplexC(ref1.GetReal() + ref2.GetReal(), ref1.GetImage() + ref2.GetImage());
    }
    
    //Operator Overload : -
    ComplexC operator-(ComplexC& ref1, ComplexC& ref2)
    {
        return ComplexC(ref1.GetReal() - ref2.GetReal(), ref1.GetImage() - ref2.GetImage());
    }
    
    //Operator Overload : *
    ComplexC operator*(ComplexC& ref1, ComplexC& ref2)
    {
        return ComplexC(ref1.GetReal() * ref2.GetReal(), ref1.GetImage() * ref2.GetImage());
    }
    
    //Operator Overload : /
    ComplexC operator/(ComplexC& ref1, ComplexC& ref2)
    {
        return ComplexC(ref1.GetReal() / ref2.GetReal(), ref1.GetImage() / ref2.GetImage());
    }
    
    int main(void)
    {
        ComplexA C1(2,4), C2(1, 2), C3;
        C3 = C1 + C2; C3.display();
        C3 = C1 - C2; C3.display();
        C3 = C1 * C2; C3.display();
        C3 = C1 / C2; C3.display();
        cout <<"--------------------------------------"<<endl;
        ComplexB C4(2,4), C5(1, 2), C6;
        C6 = C4 + C5; C6.display();
        C6 = C4 - C5; C6.display();
        C6 = C4 * C5; C6.display();
        C6 = C4 / C5; C6.display();
        cout <<"--------------------------------------"<<endl;
        ComplexC C7(2,4), C8(1, 2), C9;
        C9 = C7 + C8; C9.display();
        C9 = C7 - C8; C9.display();
        C9 = C7 * C8; C9.display();
        C9 = C7 / C8; C9.display();
        return 0;
    }
    复制代码

     3、应用举例(对象 ? 基本数据类型 or 基本数据类型 ? 对象)

    上面的例子中是对象 和 对象之间的运算符重载,如果需要一个是对象 + char/int/float/double,或者反过来 char/int/float/double + 对象,这时上面的程序的重载方式就不适用了。

    需要定义新的重载,如下列程序所示。

     

    复制代码
    #include <iostream>
    using namespace std;
    
    class ComplexD
    {
    public:
        ComplexD(double re = 0, double im = 0):real(re),image(im){}
    
        ComplexD operator+(ComplexD& ref){return ComplexD(real+ref.real, image+ref.image);};
        ComplexD operator+(int a){cout<<"IN\t int \t\t";return ComplexD(real+a, image);};
        ComplexD operator+(double d){cout<<"IN\t double \t";return ComplexD(real+d, image);};
        ComplexD operator+(float f){cout<<"IN\t float \t\t";return ComplexD(real+f, image);};
    
        void display(void){cout<<real<<"+"<<image<<"i"<<endl;}
        double GetReal(void){return real;}
        double GetImage(void){return image;}
    private:
        double real;
        double image;
    };
    
    ComplexD operator+(int a, ComplexD& ref){cout<<"OUT\t int \t\t";return ComplexD(ref.GetReal()+a, ref.GetImage());};
    ComplexD operator+(double d, ComplexD& ref){cout<<"OUT\t double \t";return ComplexD(ref.GetReal()+d, ref.GetImage());};
    ComplexD operator+(float f, ComplexD& ref){cout<<"OUT\t float \t\t";return ComplexD(ref.GetReal()+f, ref.GetImage());};
    
    int main(void)
    {
        ComplexD D1(2,4), D2;
        D2 = D1 + 2; D2.display();
        D2 = D1 + 2.1f; D2.display();
        D2 = D1 + 2.1; D2.display();
    
        D2 = 2 +D1; D2.display();
        D2 = 2.1f + D1; D2.display();
        D2 = 2.1 +D1; D2.display();
    
        return 0;
    }
    复制代码

    展开全文
  • 重载双目运算符时,运算符函数中应该具有两个参数,若运算符函数作为类的成员函数(当运算符重载函数作为类的成员函数时,要求操作数左边必须是一个对象,而函数的参数可以是同类的对象也可以是普通的变量),则只需要...

    重载双目运算符时,运算符函数中应该具有两个参数,若运算符函数作为类的成员函数(当运算符重载函数作为类的成员函数时,要求操作数左边必须是一个对象,而函数的参数可以是同类的对象也可以是普通的变量),则只需要一个参数。

    双目运算符

    双目运算符就是具有两个操作数的运算符。如 +、-、==等。

    对双目运算符而言,成员函数重载运算符的函数参数表中只有一个参数,而用友元函数重载运算符函数参数表中含有两个参数。

    成员函数重载 == 、>运算符:

        bool operator==(CTime& time);
        bool operator>(CTime& time);
    //判断对象的每个成员变量是否相等
    bool CTime::operator==(CTime& time)
    {
        if (m_nHour == time.m_nHour&&m_nMinute == time.m_nMinute&&m_nSecond == time.m_nSecond)
        {
            return true;
        }
        return false;
    }
    
    bool CTime::operator>(CTime& time)
    {
        if (m_nHour > time.m_nHour) //先判断两个对象的小时数的大小
        {
            return true;
        }
        else if (m_nHour < time.m_nHour)
        {
            return false;
        }
        else //这是两个对象小时数相等的情况,接下来就判断分钟数
        {
            if (m_nMinute> time.m_nMinute) //再判断两个对象的分钟数的大小
            {
                return true;
            }
            else if (m_nMinute < time.m_nMinute)
            {
                return false;
            }
            else //这是两个对象的时钟和分钟相等的情况下
            {
                if (m_nSecond>time.m_nSecond) //最后比较秒钟
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
    
        }
    
        return false;  //最后就是两个对象相等,也不满足一个对象大于另外一个对象的情况,返回false
    }

    成员函数重载++运算符

        CTime operator++();//前置的++
        CTime operator++(int);//后置++,这个int类型的参数只是为了区分,我们并不会使用这个参数,所以我们不需要形参的名字
    //前置的++
    CTime CTime::operator++() //重载++(前置)运算符
    {
        CTime time(0,0,1); //定义了一个秒数为1的对象
        *this = *this + time;//由于前面的函数已经重载了加号运算符,里面已经定义好了相关的操作,所以这句代码调用了加号运算符的重载函数,并将对象的秒数加一
        return *this; //前置++的操作顺序就是先加再返回它的值
    }
    
    CTime CTime::operator++(int) //重载++(后置)运算符
    {
        CTime time = *this;//后置++的操作规则是先返回再加,所以需要创建一个临时变量保存好这个对象的值
        CTime time2(0, 0, 1);//定义了一个秒数为1的对象
        *this = *this + time2;//同上调用了加法运算符的重载函数
        return *this;//返回加法操作之前的对象的值
    }
        CTime time(10, 50, 20);
    
        ++time;
        std::cout << time.getHour() << ":" << time.getMinute() << ":" << time.getSecond() << endl;
    
        time++;
        std::cout << time.getHour() << ":" << time.getMinute() << ":" << time.getSecond() << endl;
    

    结果

    源代码下载地址:

    GITHUB源码下载地址:点我进行下载

    本文章由[谙忆]编写, 所有权利保留。
    欢迎转载,分享是进步的源泉。

    转载请注明出处:http://chenhaoxiang.cn

    本文源自人生之旅_谙忆的博客

    展开全文
  • 运算符和表达式

    2016-09-05 10:50:57
    C++编程入门系列之五(运算符和表达式)有些运算符需要两个操作数,使用形式为:操作数 运算符 操作数,这样的运算符就叫做二元运算符双目运算符,只需要一个操作数的运算符叫做一元运算符或单目运算符。...
  • 1. 重载双目运算符 例如一个 == 的demo 调用如下 #include "Time.h" #include "Date.h" #include &lt;iostream&gt; using namespace std; int main() { CTime time1(12, 12,...
  • 运算符 '+' 为 双目运算符(二元运算符), 即: 有两个目标量直接参与加法运算 */ printf("1.3-(-0.15)=%f\n",1.3-(-0.15)); /* 运算符'-' 为 双目运算符 或 单目运算符 即: 有两个目标量直接参与减法运算 或 ...
  • 五、运算符和表达式

    2015-04-02 10:10:36
     有些运算符需要两个操作数,形式为:操作数 运算符 操作数,这样的运算符就叫做二元运算符双目运算符,只需要一个操作数的运算符叫做一元运算符或单目运算符。运算符具有优先级和结合性。  1.算术运算符和...
  • 运算符的分类:根据操作数个数不同分类:单目运算符(一元运算符)、双目运算符(二元运算符)、三目运算符(三元运算符)根据性质或用途不同分类:算术运算符(+、-、*、/、%、++、--)、关系运算符(>、<、>=、<...
  • 有些运算符需要两个操作数,使用形式为:操作数 运算符 操作数,这样的运算符就叫做二元运算符双目运算符,只需要一个操作数的运算符叫做一元运算符或单目运算符。运算符具有优先级结合性。如果一个表达式中有多...
  • 1)根据参与运算对象的多少可分为:单目(也称为一元运算符),双目(也称作二元运算符),三目(也称为三元运算符) 2)根据运算作用不同可分为:算术运算符、条件运算符、关系运算符、赋值运算符、逻辑运算符、...
  • 逻辑运算符

    2020-02-29 23:06:54
    逻辑运算符分为一元运算符和二元运算符,主要用于两个操作对象之间的连接。与(&&),或(||),非(!)。前两种为双目运算符, 有左结核性, 后一种为单目运算符,有又结核性。(!)的优先级最高,高于算数...
  • +、-被称为二元双目运算符。 3.符号运算符:+、- 使用负号时是单目运算符。 4.乘法除法运算符:*、/ 5.运算符的优先级: 先乘除后加减,先单目运算符后双目运算符 二、其他运算符: 1.sizeof运算符和size_t...
  • Java的操作符和运算符

    2019-07-01 20:48:10
    写程序的目的就是管理运算数据。 可以对数据进行什么样的运算。 ** “运算符” 概念: ...二元运算符:需要两个操作数的运算符。双目运算符。 三元运算符:需要三个操作数的运算符。三目运算符。...
  • 一、加减乘除运算符二、正负号也是运算符,属于单目运算符,一元运算符,上面我们介绍的是双目运算符或者叫二元运算符!之后可能会遇到三目运算符等……三、 取余运算符 %四、赋值运算符五、自增自减运算符六、特殊...
  •  有些运算符需要两个操作数,使用形式为:操作数 运算符 操作数,这样的运算符就叫做二元运算符双目运算符,只需要一个操作数的运算符叫做一元运算符或单目运算符。运算符具有优先级结合性。如果一个表达式中有...
  • 前面的笔记学习了如何在...C++中包含单目(一元)运算符、双目二元运算符和三目(三元)运算符,相应的构成了多种表达式。运算符具有优先级和结合性,优先级指先后计算次序,结合性指同级运算符时按照自左向右...
  • 运算符 ...双目|二元运算符:操作数有两个的 + - > < += 三目|三元运算符:操作数有三个的 ? : 算数运算符 +: 正号,表示正负。 加减 字符串链接符 -: 负号,表示正负。 减号 % ...
  • 双目二元):+ - * / % %: 取余操作取模操作的区别,在于商 取余操作:商向0取整 模操作:商向下取整 ++:前置++ 后置++ 无论是前置还是后置,都对原来的变量进行+1, 对于表达式的结果不同,后置++(会缓存变量...
  • C++共有三类运算符:单目(或一元)运算符、双目(或二元运算符和三目(或三元)运算符三类。 1、单目运算符:一般位于操作数的前面,如对x取负为-x; 2、双目运算符:一般位于两个操作数之间,如两个数a和b相加...
  • C++ 运算符笔记

    2015-08-05 10:31:00
    按照运算符要求操作数个数的多少,可把C++运算符分为单目(或一元)运算符、双目(或二元运算符和三目(或三元)运算符三类。单目运算符一般位于操作数的前面,如对x取负为-x;双目运算符一般位于两个操作数...
  • 什么是运算符? 链接操作数,根据操作返回一个值,运算符是一个符号。 什么是表达式?...双目运算符 二元运算符(链接两个操作数) +,-,*,/,%,,=,>,=, 单目运算符 一元运算符(只连接一个操作数)
  • 前面的笔记学习了如何在...C++中包含单目(一元)运算符、双目二元运算符和三目(三元)运算符,相应的构成了多种表达式。运算符具有优先级和结合性,优先级指先后计算次序,结合性指同级运算符时按照自左向右...
  • 06-运算符

    2019-09-11 22:48:06
    二元双目运算符 增1减1 三元(三目)运算符 类型强转 关系运算符 逻辑运算符运算符 2. 算术运算符 包括+、-、*、/、%、++、--。 3. 关系运算符 包括< 、> 、<= ...
  • 运算符及其应用

    2013-09-10 16:43:00
    按照运算符要求操作数个数的多少,可把C++运算符分为单目(或一元)运算符、双目(或二元运算符和三目(或三元)运算符三类。单目运算符一般位于操作数的前面,如对x取负为-x;双目运算符一般位于两个操作数之间,...
  • c++运算符及其作用

    2013-02-15 14:00:49
     按照运算符要求操作数个数的多少,可把C++运算符分为单目(或一元)运算符、双目(或二元运算符和三目(或三元)运算符三类。单目运算符一般位于操作数的前面,如对x取负为-x;双目运算符一般位于两个操作数之间...

空空如也

空空如也

1 2 3
收藏数 47
精华内容 18
关键字:

双目运算符和二元运算符