精华内容
下载资源
问答
  • 在C++中,const成员函数与非const成员函数可以重载的。 这是一段引自 C++ How to Porgram, Sixth Edition 的话: A const member function can be overloaded with a non-const version. The compiler chooses ...

    在C++中,const成员函数与非const成员函数是可以重载的。

    这是一段引自 C++ How to Porgram, Sixth Edition 的话:

    A const member function can be overloaded with a non-const version. The compiler chooses which overloaded member function to use based on the object on which the function is invoked. If the object is const, the compiler use the const version. If the object is not const, the compiler uses the non-const version.

    [例]

    #include <iostream>
    using std::cout;
    using std::endl;
    
    class C
    {
    public:
    	C() {}
    	void display() const
    	{
    		cout << "void display() const called" << endl;
    	}
    	void display()
    	{
    		cout << "void dislapy()       called" << endl;
    	}
    };
    
    int main()
    {
    	C a;
    	const C b;
    
    	a.display();
    	b.display();
    
    	return 0;
    }

    输出为:

    void dislapy()       called
    void display() const called
    



    展开全文
  • 运算符重载,是C++多态的表现形式之一,可以通过对运算符进行重载来实现运算符特定的功能。 运算符重载一般具有以下原则: (1)不可重载不存在的运算符,如重载**来表示平方等; (2)重载后的运算符与原来的运算符...

    运算符重载,是C++多态的表现形式之一,可以通过对运算符进行重载来实现运算符特定的功能。
    运算符重载一般具有以下原则:
    (1)不可重载不存在的运算符,如重载**来表示平方等;
    (2)重载后的运算符与原来的运算符优先级、结合性以及操作数数目相同,如双目运算符不能重载为单目;
    (3)保留运算符本身的含义,如“+”号重载后应该保持其“求和”的自然含义;
    (4)操作数中至少有一个为自定义类型,如重载运算符中参数都是int、double等类型是不允许的;

    对于运算符重载可通过成员函数和非成员函数实现,这二者的区别如下:
    (1)成员函数运算符重载时,运算符的左值为调用对象,右值为参数对象,举个例子,a,b均是类A的对象,重载“+”实现a+b,可以将其认为是:a对象调用“+”函数,函数的参数为b对象;而在事实上,a对象和b对象都是这个“+”函数的参数,只不过a对象被隐式调用,由this指针所绑定。因此成员函数运算符重载的显式参数比实际运算参数少一个;而在非成员函数运算符重载中,必须将操作数全部显式添加在参数列表中,运算符左值为第一个参数,运算符右值为第二个参数。如下:

    class Stu
    {
     public:
        int age;
        string name;
        Stu(){};
        Stu(int a,string b)
        {
            age=a;
            name=b;
        }
        ~Stu(){}
        Stu operator+(const Stu &ss)const       //成员函数运算符重载
        {
            Stu n;
            n.age=this->age+ss.age;   //this可去掉
            n.name=ss.name;
            return n;
        }
        friend int operator+(const int s1,const Stu &s2);
    };
    int operator+(const int s1,const Stu &s2)    //非成员函数运算符重载
    {
        int n;
        n=s1*s2.age;
        return n;
    }
    int main()
    {
        Stu s(3,"lili");
        Stu s2(5,"yaya");
        s=s+s2;
        int x=s.age+s2;
        cout<<s.age<<" "<<s.name<<" "<<x<<endl;
        return 0;
    }
    //运行结果
    Stu constructor1 called!
    Stu constructor1 called!
    Stu constructor called!
    Stu destructor called!
    8 yaya 40
    Stu destructor called!
    Stu destructor called!
    

    在该例中,s=s+s2为成员函数运算符重载,重载函数定义中参数只有一个,s作为隐式调用参数,被this指针绑定,即可用this->member来访问s的成员,而this指针往往也是隐式存在的,因此在这里也可以省略掉this->;非成员函数在进行运算符重载时,由于需要访问Stu类中的成员,因此应当将该非成员函数声明为友元函数。因此,非成员函数运算符重载一般都是友元函数。
    (2)成员函数运算符重载时,运算符左值类型必须为所在类类型;而非成员函数运算符重载则不必。

    一般来说,对于双目运算符,应当将其重载为非成员函数(友元函数),而对于单目运算符,则应将其重载为成员函数。但这也不是绝对的,双目运算符中,“=”、“[]”、“->”和“()”是必须重载为成员函数的。而"<<"运算符由于其第一个运算符必须是ostream的,所以只能重载为友元函数。

    个人认为,“=”、“[]”、“->”和“()”运算符之所以必须作为类成员函数进行重载,其原因是因为:在成员函数重载时,会自动将this指针绑定到左值上,这样也就强制规定了运算符左值的类型,如果不这样,而是通过非成员函数进行重载,那么很有可能会出现类似“3=a”、“3[a]”、“3->a”以及“3(a)”的情况,单从运算符重载函数上说,这些似乎都是对的,但是实际上这些在语法上都是错误的,是需要坚决避免的,为了避免出现这些情况,就应当将这四种运算符重载限定在成员函数中。

    参考出处:参考

    展开全文
  • 一、运算符重载 运算符重载允许把标准运算符(如+、-、*、/、&lt;、&gt;等)应用于自定义数据类型的对象 直观自然,可以提高程序的可读性 体现了C++的可扩充性 ...二、成员函数重载 成员函数原型的格式: ...

    一、运算符重载

    运算符重载允许把标准运算符(如+、-、*、/、<、>等)应用于自定义数据类型的对象
    直观自然,可以提高程序的可读性
    体现了C++的可扩充性
    运算符重载仅仅只是语法上的方便,它是另一种函数调用的方式
    运算符重载,本质上是函数重载
    不要滥用重载、因为它只是语法上的方便,所以只有在涉及的代码更容易写、尤其是更易读时才有必要重载

     

    二、成员函数重载

    成员函数原型的格式:

    函数类型 operator 运算符(参数表);

    成员函数定义的格式:

    函数类型 类名::operator 运算符(参数表)

    {

    函数体;

    }


    三、非成员函数重载

    友元函数原型的格式:

    friend 函数类型 operator 运算符(参数表);

    友元函数定义的格式:

    函数类型 类名::operator 运算符(参数表)

    {

    函数体;

    }


    四、运算符重载的原则

    运算符重载不允许发明新的运算符。
    不能改变运算符操作对象的个数。
    运算符被重载后,其优先级和结合性不会改变。
    不能重载的运算符:

    作用域解析运算符 ::

    条件运算符 ? :

    直接成员访问运算符 .

    类成员指针引用的运算符 .*

    sizeof运算符 sizeof

    注:.*是C++的类成员函数指针调用运算符,是用来调用一个类函数指针的。
    举例:
    假设有一个ClassA类拥有一个成员函数void ClassA::func(int i),则可以这么用:
    void (ClassA::*fp)(int i) // 定义一个类函数指针。
    ClassA obj; 
    fp = &ClassA::func; // 给这个类函数指针赋值
    (obj.*fp)(5); // 这么用,相当于调用obj.func(5);

    一般情况下,单目运算符最好重载为类的成员函数;双目运算符则最好重载为类的友元函数。
    以下一些双目运算符不能重载为类的友元函数:=、()、[]、->。
    类型转换运算符只能以成员函数方式重载(见这里
    流运算符只能以友元的方式重载(见这里

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
     
    #ifndef _COMPLEX_H_
    #define _COMPLEX_H_


    class Complex
    {
    public:
        Complex(int real, int imag);
        Complex(void);
        ~Complex(void);

        Complex &Add(const Complex &other);

        void Display() const;

        Complex operator+(const Complex &other);

        friend Complex operator+(const Complex &c1, const Complex &c2);

    private:
        int real_;
        int imag_;
    };

    #endif
     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
     

    #include "Complex.h"
    #include<iostream>
    using namespace std;

    Complex::Complex(int real, int imag): imag_(imag), real_(real)
    {

    }
    Complex::Complex(void)
    {
    }

    Complex::~Complex(void)
    {
    }

    Complex &Complex::Add(const Complex &other)
    {
        real_ += other.real_;
        imag_ += other.imag_;
        return *this;
    }


    void Complex::Display() const
    {
        cout << real_ << "+" << imag_ << "i" << endl;
    }


    Complex Complex::operator+(const Complex &other)
    {
        int r = real_ + other.real_;
        int i = imag_ + other.imag_;

        return Complex(r, i);
    }

    Complex operator+(const Complex &c1, const Complex &c2)
    {
        int r = c1.real_ + c2.real_;
        int i = c1.imag_ + c2.imag_;

        return Complex(r, i);
    }
     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
     
    #include "Complex.h"

    int main(void)
    {
        Complex c1(3, 5);
        Complex c2(4, 6);

        c1.Add(c2);
        c1.Display();

        Complex c3 = c1 + c2; // 等价于c1.opertor+(c2); 或 operator+(c1, c2);

        c3.Display();

        return 0;
    }

    我们实现了Add成员函数,但c1.Add(c2); 改变的是c1 本身;如果我们想实现加号表达式,c3 = c1 + c2; 那么可以实现operator+ 运算符重载,可以是成员函数形式,也可以是友元形式,如果两者共存的话成员函数优先。


    参考:

    C++ primer 第四版
    Effective C++ 3rd
    C++编程规范

    展开全文
  • 类的成员函数重载

    千次阅读 2018-03-17 22:12:39
    与普通函数一样,成员函数也可以带有默认的参数值,也可以重载。在类外定义成员函数时,函数名应该包括:类名 + 作用域符(::)+ 原函数名在类体内定义的成员函数默认为内联的,而要在类体外定义内联的成员函数,则...

    成员函数必须在类体内给出原型说明,至于它的出现,可以放在类体内,也可以放在类体外。

    与普通函数一样,成员函数也可以带有默认的参数值,也可以重载。

    在类外定义成员函数时,函数名应该包括:

    类名 + 作用域符(::)+ 原函数名

    在类体内定义的成员函数默认为内联的,而要在类体外定义内联的成员函数,则需在函数返回值前加上关键字inline。

    展开全文
  • 从零开始学C++之运算符重载(一):以成员函数方式重载、以友元函数方式重载 标签: 运算符重载 一、运算符重载 运算符重载允许把标准运算符(如+、-、*、/、等)应用于自定义数据类型的对象 直观...
  • 成员函数重载

    2020-04-07 10:02:36
    大部分运算符可以重载为友元函数或成员函数 友元函数不能显式调用(a.operator@(参数)) 在两个操作数类型不同的情况下,要使用友元函数重载(当然必须要有适当构造函数完成隐式的类型转化) ...
  • 分为成员操作符重载(number function)和非成员操作符重载(non-number functon),并不是所有的操作符都可以进行非成员函数操作符重载的,具体可以参考官网:http://www.cplusplus.com/doc/tutorial/templates/ ...
  • 成员函数重载在继承之后有所提高,这是人类进步的一个重要方式。 那么,如何使fillRect类比Rectangle类有所提高呢?我们可以用如下代码来实现一个新的drawRect成员函数,它将大大缩短代码,并能填充矩形,而不是...
  • 在C++中void func() const 和void func()可以形成重载函数,如果void func() const和void func()写同样的代码实现func功能,这样就造成了代码浪费(重复写代码)。这种问题的解决方式就是利用static_cast达到代码复用...
  • const成员函数的重载问题   class classA {  void f(){}  void f() const{} //这样两个函数不算重载 ...为什么这样的函数可以重载,而什么时候才能调用第二个f()呢? 先回答第二个问题。 classA a; a
  • 成员函数用const重载总共有三种方式,有三个地方可以写const,要注意const在不同的地方的意义。 #include #include #include using namespace std; void fun(const int& i)//fun(10)这能用这个函数 { cout<<
  • 什么是函数重载: 在C++程序中,可以将语义,功能相似的函数用同一个名字表示,即...(因为c++规定构造函数与类同名,构造函数只能有一个名字,若要有不同的方法创建对象,只能依靠重载成员函数重载的特征: (1
  • 以下是对类成员函数重载、覆盖与隐藏之间的区别进行了详细的总结分析,需要的朋友可以过来参考下。希望对大家有所帮助
  •  允许把标准运算符(如+ - * /等运算符)应用于自定义数据类型的对象,可以提高程序的可读性,运算符的重载本质上还是函数重载。运算符仅仅是语法上的方便,它是另一种函数调用的方式,只有在设计涉及的代码更容易...
  • 一、成员函数重载 重载是指在同一个类定义中,同名函数之间存在的关系。这些同名函数的参数类型和数目均不同。返回值类型可以相同也可以不同。因此不能够参数列表相同,而仅仅依靠返回值类型来区分函数。另外,...
  • 1.对双目运算符而言,成员函数重载运算符的函数参数表中只有一个参数,而用友元函数重载运算符...2.双目运算符一般可以用友元函数重载成员函数重载,但有一种情况只可以用友元函数重载。  即:双目运算符左边的变
  • 虽然基类的成员可以被直接访问,但是它们仍然...如果一定要重载两个函数的话,有以下两种方法:1,在需要调用基类实例的派生类申明一个重载函数集合.2,我们可以使用using声明获得同样的结果using base:function.实际上,usin
  • [C++]VS环境报错:不是类的成员 未知重写说明符 已经定义或声明成员函数 没有重载函数可以接受 跳过明显的函数体 意外的标记位于";"前 的问题解决 今日在写代码中添加一个类后,触发了诸多错误,且错误均是在编译后...
  • C++深度解析 类中的函数重载 -- 全局函数,普通成员函数,静态成员函数(28)       函数重载的回顾 ...类中的成员函数可以进行重载 构造函数的重载 普通成员函数的重载 静态成员函数的重载    ...
  • const成员函数重载

    2019-09-18 12:38:12
    除了常规的函数重载函数后加上一个const也可以实现重载,即使参数列表完全相同 调用时,根据对象的const性选择重载函数
  • 1. 常量对象:如果不希望某个对象的值被改变,则定义该对象的时候可以在前面加const关键字 eg. class Demo{ private: ...2. 常量成员函数:在类的成员函数说明后面可以加const关键字,则该成员函
  • 类的const和非const成员函数重载 我们从一个例子说起,来看上一篇文章中的String类, 我们为它提供一个下标操作符([ ])以读写指定位置的字符(char)。 只要了解过C++的操作符重载的语法,很快就可以写出...
  • 类的成员函数重载是指在同一个类中有多个同名的方法,这些方法的参数类型、参数个数或者方法属性(const属性)不同。  成员函数的覆盖是指父类中定义了一个虚方法,子类又重新定义了该方法。通过覆盖父类的虚方法,...
  • 小谈C++的函数重载成员函数覆盖与成员函数隐藏 ...注意同一作用域不单单指类作用域内的成员函数,非成员的全局函数也可以进行重载。 其规则为:相同的函数名,不同的参数列表。不同的参数列表包括参数的类型不同
  • c++中成员函数重载

    2021-02-21 11:11:27
    函数重载简单说是一个函数实现多个...以上三个函数函数名称相同,但参数类型或个数不同,在c语义中分别实现后可以实现函数重载,调用时通过参数类型的不同可以调用不同的功能; c++中函数重载的功能通过虚函数实现 ...

空空如也

空空如也

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

成员函数可以重载