精华内容
下载资源
问答
  • 运算符重载为成员函数

    千次阅读 2016-05-10 20:14:23
    运算符重载实质上就是通过函数重载,重载为成员函数,它就可以自由的访问本类的数据成员,实际使用时,总是通过该类的某个对象来访问重载的运算符。如果是双目运算符,左操作数是对象本身的数据,由this指针指出,就...

    运算符重载实质上就是通过函数重载,重载为成员函数,它就可以自由的访问本类的数据成员,实际使用时,总是通过该类的某个对象来访问重载的运算符。如果是双目运算符,左操作数是对象本身的数据,由this指针指出,就不再需要任何参数。下面分别介绍这两种情况。
    对于双目运算符B,如果要重载为类的成员函数,使之能够实现表达式oprd1 B oprd2,其中oprd1为A类的对象,则应当把B重载为A类的成员函数,该函数只有一个形参,形参的类型是oprd2所属的类型。经过重载之后,表达式就相当于函数调用orpd.operator B(oprd2).
    对于前置单目运算符U,如“-”(负号)等,如果要重载为类的成员函数,用来实现表达式U oprd,其中oprd为A类的对象,则U应当重载为A类的成员函数,函数没有形参,经过重载之后,表达式U oprd相当于函数调用oprd.operator U().
    再来看看后置运算符“++”和“–”,如果要重载为类的成员函数,用来实现表达式oprd++或oprd–,其中oprd为A类的对象,那么运算符就应当重载为A类的成员函数,这时函数要带有一个整型(int)形参。重载之后,表达式oprd就相当于调用oprd.oprator++(0)和oprd.oprator–(0)。这里的int类型参数在运算中不起任何作用,只是区别于前置后置。
    复数类加减法运算重载为成员函数形式

     #include<iostream>
     #include<cassert>
    using namespace std;
    class complex
    {
    public:
        complex(double r=0.0,double i=0.0):real(r),imag(i){}
        complex operator+(const complex &c2) const;//运算符+重载成员函数
        complex operator-(const complex &c2) const;//运算符-重载成员函数
        void display() const;
    private:
        double real;
        double imag;
    };
    complex complex::operator+(const complex &c2) const
    {
        return complex(real+c2.real,imag+c2.imag);//创建一个临时无名对象作为返回值
    }
    complex complex::operator-(const complex &c2) const
    {
        return complex(real-c2.real,imag-c2.imag);
    }
    void complex::display() const
    {
        cout<<"("<<real<<","<<imag<<")"<<endl;
    }
    int main()
    {
        complex c1(5,4),c2(2,10),c3;
        cout<<"c1="; c1.display();
        cout<<"c2="; c2.display();
        c3=c1-c2;//使用重载运算符完成复数减法
        cout<<"c3=c1-c2="; c3.display();
        c3=c1+c2;
        cout<<"c3=c1+c2="; c3.display();
        return 0;
    }
    
    
    将单目运算符“++”重载为成员函数形式。
    
     #include<iostream>
     #include<cassert>
    using namespace std;
    class clock
    {
        public:
            clock(int hour=0,int minute=0,int second=0);
            void showtime() const;
            clock& operator++();
            clock operator++(int);
        private:
            int hour,minute,second;
    };
    clock::clock(int hour,int minute,int second)
    {
        if(0<=hour&&hour<24&&0<=minute&&minute<60&&0<=second&&second<60)
        {
            this->hour=hour;
            this->minute=minute;
            this->second=second;
        }
        else
        {
            cout<<"time error!"<<endl;
        }
    }
    void clock::showtime() const
    {
        cout<<hour<<":"<<minute<<":"<<second<<endl;
    }
    clock &clock::operator++()//前置单目运算符重载函数
    {
        second++;
        if(second>=60)
        {
            second-=60;
            minute++;
            if(minute>=60)
            {
                minute-=60;
                hour=(hour+1)%24;
            }
        }
        return *this;
    }
    clock clock::operator++(int)//后置单目运算符重载
    {
        clock old=*this;
        ++(*this);//调用前置“++”运算符
        return old;
    }
    int main()
    {
        clock myclock(23,59,59);
        cout<<"first time output: ";
        myclock.showtime();
        cout<<"show myclock++   ";
        (myclock++).showtime();
        cout<<"show ++myclock   ";
        (++myclock).showtime();
        return 0;
    }
    
    
    展开全文
  • 重载运算符是函数重载的一种,针对类对象进行操作,重载的函数中至少有一个是类对象int operator +(ass numone, int num){...}重载为类的成员函数,单目运算符重载-操作数是访问本身的数据,由this指出双目运算符...
    重载运算符是函数重载的一种,
    针对类对象进行操作,重载的函数中至少有一个是类对象
    int operator +(ass numone, int num){...}
    重载为类的成员函数,
    单目运算符重载-操作数是访问本身的数据,由this指出
    双目运算符重载-左操作数由this指针给出,右操作数由函数参数给出
    显示调用-aa.operator(bb);
    隐式调用-aa++bb;
    重载为友元函数,

    单目重载运算符时,由于要改变操作数自身的值,应采用引用参数传递

    class point
    {
    private:
            int num;
    public:
            point()
            {
                    num = 0;
            }
            point(int n)
            {
                    num = n;
            }
            point operator +(point mn);
            point operator ++();
            friend point operator -(point m, point n);
            friend point operator --(point &m);
            int get_num();
    };
    int point::get_num()
    {
            return num;
    }
    point point::operator +(point mn)
    {
            point item;
            item = num + mn.num;
            return item;
    }
    point point::operator ++()
    {
            ++num;
            return *this;
    }
    point operator -(point m, point n)
    {
            point temp;
            temp.num = m.num + n.num;
            return temp;
    }
    point operator --(point &m)
    {
            --m.num;
            return m;
    }

    展开全文
  • 双目运算符重载为成员函数[1]重载为类成员的运算符函数定义形式(重载为类的成员函数的形式)函数类型 双目运算符重载规则如果要重载 B 为类成员函数,使之能够实现表达式 oprd1 B oprd2,其中 oprd1 为A 类对象,则 B...

    双目运算符重载为成员函数[1]

    重载为类成员的运算符函数定义形式(重载为类的成员函数的形式)

    函数类型  

    双目运算符重载规则

    • 如果要重载 B 为类成员函数,使之能够实现表达式 oprd1 B oprd2,其中 oprd1 为A 类对象,则 B 应被重载为 A 类的成员函数,形参类型应该是 oprd2 所属的类型。
    • 经重载后,表达式 oprd1 B oprd2 相当于 oprd1.operator B(oprd2)

    例8-1复数类加减法运算重载为成员函数

    • 要求:
      • 将+、-运算重载为复数类的成员函数。
    • 规则:
      • 实部和虚部分别相加减。
    • 操作数:
      • 两个操作数都是复数类的对象。

    源代码:

    #include 

    程序运行结果

    9444d618b662a4bf4264b34ea1cb2b2f.png

    参考

    1. ^http://www.xuetangx.com/courses/course-v1:TsinghuaX+00740043_2x_2015_T2+sp/courseware/93f0d3a029d84059a84d02745a1e2bfd/4e3fe66cfdf14439903f61fbfe990e1a/
    展开全文
  • 平时++/--这两个单目运算符...单目运算符重载为成员函数>的时候,我才真正的搞明白,不禁感叹:C++机制 !!!举个完整的例子 :《将前置++和后置++重载为时钟类的成员函数》.hpp文件:```#ifndef ________hpp ``...

    dcf894542ee2cbe9a6776d30677692ad.png

    平时++/--这两个单目运算符基本都会用在for循环,之前理解他们的区别只是:

    1、++i:先++,再循环

    2、i++:先循环,再++

    其实,这种说话是有道理的,但是很模糊,直到学到<单目运算符重载为成员函数>的时候,我才真正的搞明白,不禁感叹:C++机制 !!!

    举个完整的例子 :《将前置++和后置++重载为时钟类的成员函数》

    .hpp文件:

    ```

    #ifndef ________hpp
    

    ```

    .cpp文件

    ```

    #include 

    ```

    main.cpp

    ```

    #include 

    ```

    运行结果:

    ```

    23

    ```

    其实,大家已经在.cpp文件中发现了,前置++/后置++返回的东西是不一样的:

    前置++返回的是引用类型,是将++后的地址返回了,当然就是用+完之后的结果进行循环或者显示了;也可以理解成&的加入,实现了参数的双向传递;

    后置++返回的是副本,是用+1前的结果进行循环或者显示,但此时内存地址上的变量已经暗自+1,只是返回的是之前的副本而已;同样可以理解成是参数的单向传递。

    因为前置++/后置++的重载函数名字都是operator ++,所为为了区分,

    前置++的重载函数没有形参;

    后置++的重载函数有形参(int);

    仅仅是为了区分,函数体的实现是不应该使用这个参数的。

    其实,这里说的,和我之前的《拷贝构造函数的歪解》是很类似的,道理相通。希望大家好好看一下:

    https://blog.csdn.net/weixin_45826012/article/details/102865017blog.csdn.net

    本人技术水平有限,若有错误或不当之处,可以在本号内反馈给我,一起交流一起学习!

    b50901d3cb25b16cb9e54417d92f9886.png
    展开全文
  • 单目运算符重载为成员函数[1]前置单目运算符重载规则如果要重载 U 为类成员函数,使之能够实现表达式 U oprd,其中 oprd 为A类对象,则 U 应被重载为 A 类的成员函数,无形参。经重载后,表达式 U oprd 相当于 oprd....
  • 单目运算符重载为成员函数>的时候,我才真正的搞明白,不禁感叹:C++机制????????!!! 举个完整的例子????:《将前置++和后置++重载为时钟类的成员函数》 .hpp文件: #ifndef ________hpp ...
  • //单目运算符重载为成员函数 后++ 采用了哑元 #include using namespace std; class CPoint { private: int x,y; public: CPoint(int a = 0,int b = 0){ x = a; y = b; } CPoint operator
  • #include&lt;iostream&gt; using namespace std; class point { private:  int x,y; public:  point(int xx=0,int yy=0) ... point operator ++(int)//后置++加上一个int 前置不用加 ... x+...
  • 调用Complex构造函数创建一个临时对象并返回它 // Complex c(real+c2.real,imag+c2.imag); // return c; } Complex Complex:: operator - ( const Complex &c2) const { return Complex(real-c2.real,...
  • # 重载前置++和后置++时钟类成员函数 #include <iostream> using namespace std; class Clock{// 时钟类定义 public: Clock(int hour=0, int minute=0; int second=0); void showTime() const; // 前置单...
  • 我把 = 重载为Teacher类的成员函数,希望实现的功能是将Student类的对象中的数据成员的值赋给Teacher类的对象(假设这个学生当上老师了,呵呵) 我已经在Student类中将&teacher Teacher::operator =(Student&...
  • **【问题描述】** 请定义一个复数类,将+/-运算符重载为成员函数,实现复数与复数的加减及复数与浮点数的加减。 请根据给定的main函数,设计Complex类。
  • 但是有些情况下,将运算符重载为成员函数并不能有效的解决问题,这个时候考虑将运算符重载为全局函数。但是将运算符重载为全局函数也有一些不足。遇到这种情况的一种策略就是把运算符重载为友元函数。 Complex x,y...
  • 1.单目运算符只能重载为类的成员函数 Clock& operator ++ ();...重载为成员函数时: Complex operator + (const Complex &c2) const; +两边有一个空格,只有一个形参。 重载为非成员函数时:
  • 一、运算符重载扩展C++中提供的运算符适用范围,以用于类所表示的抽象数据类型运算符重载实质是函数重载运算符重载成员函数时,a+b的 a.operator+b,a 相当于对象,只传入后面的参数class A { public: A(double r...
  • ## **运算符重载为成员函数** 对于 前置 ++ 后置++ 运算符重载为成员函数 后置++ clock clock::operator ++(int); 参数列表中并未使用的参数,不允许给出参数名,仅为区别前置++ 前置++ clock& clock...
  • 运算符重载 对于面向对象的程序设计来说,运算符重载可以完成两个对象之间的复杂操作...为了重载运算符,首先要定义运算符重载函数,它通常是类的非静态成员函数或者友元函数,运算符的操作数通常也应对象。 定...
  • 可以看到,重载函数operator+访问了两个对象中的成员,一个是this指针指向的对象中的成员,一个是形参对象中的成员。如this->real+c2.real,this->real就是c1.real。上节中已说明,在将运算符函数重载为成员函数后,如果...
  • 5.2.3 成员运算符重载函数 在C++中可以把运算符重载函数定义为某个类的成员函数,称之为成员运算符重载函数。 1. 定义成员运算符重载函数的语法形式 (1)在类的内部,定义成员运算符重载函数的格式如下: 函数类型 ...
  • 一般将运算符重载为类的成员函数,重载为友元函数的情况...将运算符重载为成员函数的情况: class Complex { double real, imag; public: Complex(double r, double i):real(r),imag(i){} Complex operator+(...
  • 成员运算符重载函数,即把运算符重载函数定义某个类的成员函数。 1、定义成员运算符重载函数的语法形式 (1)在类的内部,定义成员运算符重载函数的格式如下: 函数类型 operator 运算符(形参表){ 函数体 } (2...
  • 第四周 运算符重载 1.运算符重载的基本概念 2.赋值运算符的重载 3.运算符重载为友元函数 ...但有时,重载为成员函数不能满足使用要求,重载为普通函数,又不能访问类的私有成员,所以需要将运算符重载为友...

空空如也

空空如也

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

运算符重载为成员函数