精华内容
下载资源
问答
  • 重载函数

    千次阅读 2016-09-27 18:45:01
    C++重载函数的详细分析 今天我使用函数时使用了重载函数,那么我们就来说说重载函数。. 问题:什么是重载函数? 答:重载函数是函数的一种特殊情况,为方便使用,C++允许在同一范围中声明几个功能类似的同名函数,...

    C++重载函数的详细分析

    今天我使用函数时使用了重载函数,那么我们就来说说重载函数。.


    问题:什么是重载函数?

    答:重载函数是函数的一种特殊情况,为方便使用,C++允许在同一范围中声明几个功能类似的同名函数,但是这些同名函数的形式参数(指参数的个数、类型或者顺序)必须不同,也就是说用同一个运算符完成不同的运算功能。

    函数定义为:

    1.函数名相同

    2.参数不同

    a.参数个数不同。//这个大家都理解就不要解释了

    b.参数类型不同。//如:inta(charc)和inta(int c)就是指参数不同,但是这也是重载函数。

    c.参数顺序不同。//如:inta(int a,char b)和inta(char a,int b)就是顺序不同但是却是重载函数,从数学角度说就是组合相同(他们都是int,char组成),但是排列不同的参数能实现函数重载。


    问题:满足上述两个条件就是重载函数?那么函数的返回类型不同函数可以重载吗?

    答:对,满足上述条件就是重载函数,返回类型不同也可以重载。

    如图:


    函数能运行,不报错能够重载。


    问题:重载函数返回值不同,参数相同能重载吗?

    答:不能,因为不能满足重载函数基本条件,如果定义再编译时系统会提示 error:‘long int A::aa(int)’ cannot be overloaded 表示:“longint A::(int)'不能超载|,同时再第一个函数定义的地方提示函数错误。



    问题:重载函数的参数有符号类型,和无符号类型能够重载吗?

    答:能,如图:


    无符号与有符号是有区别的,所以,虽然都是int但是取值范围不一样,同时定义的的方法不同,根据定义变量时的数据类型可以区分传送的参数的数据类型是否是有符号,还是无符号。从而实现重载。所以有符号,无符号可以重载。



    问题:当定义重载时,定义通过但是传的参数是一个满足多个参数的数字,编译器会怎样运行?

    答:如图:


    输出结果是:


    系统会默认选择参数是intc对应的函数进行运行。当把intc参数对应的函数注释掉时系统会提示以下

    错误:/home/dc123/桌面/Test/main.cpp|22|error:call of overloaded ‘aa(int)’ is ambiguous|

    翻译为:重载的调用(int)”是模糊的!

    当然,如果满足条件的参数对应的函数只用一个,那么系统会执行满足条件的对应函数。

    经上所诉总结如下:当传送的参数是满足多个参数类型的数时,系统会根据系统默认参数类型进行选择对应函数,如果没用对应的默认系统类型的函数,系统将无法找到对应函数(注:默认的数值数据类型为int)。


    问题:能不能写函数体完全相同,参数排列不同的的重载函数?

    答:能写函数体完全相同参数组合相同排列不同的重载函数,编译器通过不会报错同时也能正常运行,但是函数声明不同,函数体相同的函数实现的功能相同,重载函数就是为了通过不同的参数实现不同的功能。所以可以写,但是完全没必要,反而会造成程序代码的冗余,不是不能,而是完全没必要。


    问题:写不同的函数也能实现重载能实现的功能,为什么还要用重载?

    答:不同的函数确实能完成重载函数能实现的功能,但是不同的函数调用时需要判定何时调用该调用的函数,同时不能确保索吊有的函数不出错。但是如果使用重载,那么系统会根据你传送不同的参数去自动查找对应参数的函数。这样不但可以节省判断语句的汇编指令,同时可避免自己失误造成的耗时等问题。


    问题:重载与多态的比较?

    答:一句话概括,'重载是编译时的多态,多态是运行时的重载”。因为查重载是在编译时确定函数,多态是再运行时确定调用的函数。一个是编译时状态,一个是运行时状态。多态是通过父类的对象指针指向子类的虚表,通过子类所在的虚表找到对应的函数。重载是通过参数的不同找到对应函数实现不同的功能。

    为什么说重载是编译时的多态,因为重载再编译时,系统会根据参数的不同而 找到对应当的函数进行编译,编译后所有调用重载函数的地方都会根据参数的不同找到对应的重载函数

    为什么说多态是运行时的重载,因为多态是在运行时通过类实例化对象时,通过本类的对象指针找到虚表的地址,通过虚表地址中存的函数地址找到对应的函数的。

    当然,为了更好的面向对象编程我们应该尽量的把编译时选择,改成运行时选择,这样会更大的提高变成效率。就像我们写编码时应该把,运行时错误写成编译时错误,这样可一节约出错时查找出错原因的时间。如:



    如图:这样编写代码就是把运行时错误,改为编译时错误。如果你少写一个等号,那么编译器就会报错,但是你把条件写成a=1那么系统不会报错,但是你却没有达到要判定的目的,同时自己查找原因也会浪费大量的时间。


    问题:重载与模板的比较?

    答:模板函数是参数个数相同,函数体处理流程相同,参数类型不同的函数,且模板是重载的一个特殊形式。

    相同点:为什么说模板是重载的特殊形式,因为他满足上述的重载条件。都是函数名相同,函数参数不同的函数。

    不同点:重载函数:比模板更灵活,因为函数体不同,能实现的功能更加的多,重载能更加灵活。

    模板:只有函数的参数不同,函数体的汇编代码不同。能更好的实现流程相同参数不同的函数代码,提高编程效率。

    展开全文
  • 当您调用一个重载函数或重载运算符时,编译器通过把您所使用的参数类型与定义中的参数类型进行比较,决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程,称为重载决策。 C++ 中的函数重载...

    摘要

    C++ 允许在同一作用域中的某个函数运算符指定多个定义,分别称为函数重载运算符重载

    重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明,但是它们的参数列表和定义(实现)不相同。

    当您调用一个重载函数重载运算符时,编译器通过把您所使用的参数类型与定义中的参数类型进行比较,决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程,称为重载决策

     

    C++ 中的函数重载

    在同一个作用域内,可以声明几个功能类似的同名函数,但是这些同名函数的形式参数(指参数的个数、类型或者顺序)必须不同。您不能仅通过返回类型的不同来重载函数

     

     

     

    为什么要对运算符进行重载

    C++预定义中的运算符的操作对象只局限于基本的内置数据类型,但是对于我们自定义的类型(类)是没有办法操作的。但是大多时候我们需要对我们定义的类型进行类似的运算,这个时候就需要我们对这么运算符进行重新定义,赋予其新的功能,以满足自身的需求。

     

    C++运算符重载的实质

    运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的C++多态。目的在于让人能够用同名的函数来完成不同的基本操作。要重载运算符,需要使用被称为运算符函数的特殊函数形式,运算符函数形式:operatorp(argument-list)//operator后面的'p'为要重载的运算符符号。

     

    可重载运算符/不可重载运算符

    下面是可重载的运算符列表:

    双目算术运算符

    + (加),-(减),*(乘),/(除),% (取模)

    关系运算符

    ==(等于),!= (不等于),< (小于),> (大于>,<=(小于等于),>=(大于等于)

    逻辑运算符

    ||(逻辑或),&&(逻辑与),!(逻辑非)

    单目运算符

    + (正),-(负),*(指针),&(取地址)

    自增自减运算符

    ++(自增),--(自减)

    位运算符

    | (按位或),& (按位与),~(按位取反),^(按位异或),,<< (左移),>>(右移)

    赋值运算符

    =, +=, -=, *=, /= , % = , &=, |=, ^=, <<=, >>=

    空间申请与释放

    new, delete, new[ ] , delete[]

    其他运算符

    ()(函数调用),->(成员访问),,(逗号),[](下标)

    下面是不可重载的运算符列表:

    • .:成员访问运算符
    • .*->*:成员指针访问运算符
    • :::域运算符
    • sizeof:长度运算符
    • ?::条件运算符
    • #: 预处理符号
    展开全文
  • 成员运算符重载函数与友元运算符重载函数的比较

    千次阅读 多人点赞 2019-01-06 22:00:36
    (1)对双目运算符而言,成员运算符重载函数参数表中含有一个参数,而友元运算符重载函数参数表中含有两个参数;对单目运算符而言,成员运算符重载函数参数表中没有参数,而友元运算符重载函数参数表中含有两个参数...

    (1)对双目运算符而言,成员运算符重载函数参数表中含有一个参数,而友元运算符重载函数参数表中含有两个参数;对单目运算符而言,成员运算符重载函数参数表中没有参数,而友元运算符重载函数参数表中含有两个参数。

    (2)双目运算符一般可以被重载为友元运算符重载函数或成员运算符重载函数,但有一种情况,必须使用友元函数:
    例如,如果将一个复数与一个整数相加,可用成员运算符函数重载 “+”:

    Complex operator+(int a){
    	return (real+a,imag);
    }
    

    若 com 和 com1 是类 Complex 的对象,则以下语句是正确的:

    com1=com+100;
    

    这条语句被 C++ 编译系统解释为:

    com1=com.operator+(100);
    

      由于对象 com 是运算符 “+” 的左操作数,所以它可以调用 “+”运算符重载函数 operator+,执行结果是对象 com 的数据成员 real 被加上一个整数 100。

      然而,下面的语句是错误的

    com1=100+com;	//编译错误,运算符 + 的左侧是整数
    

    这条语句被 C++ 编译系统解释为:

    com1=100.operator+(com);
    

      由于运算符 “+” 的左操作数是一个整数 100,而不是该类的对象,编译时将出现错误。

      如果定义一下的两个友元运算符重载函数:

    friend Complex operator+(Complex com,int a){ 
    //运算符“+”的左侧是类对象,右侧是整数
    	return Complex(com.real+a,com.imag);
    }
    
    friend Complex operator+(Complex com,int a){ 
    //运算符“+”的左侧是整数,右侧是类对象
    	return Complex(a+com.real,com.imag);
    }
    

    当一个复数与一个整数相加时,无论整数出现在左侧还是右侧,使用友元运算符重载函数都能得到很好的解决。

    例 1:使用友元运算符重载函数实现一个复数与一个整数相加。

    #include<iostream>
    using namespace std;
    class Complex{
    	private:
    		int real,imag;
    	public:
    		Complex(int r=0,int i=0);	//构造函数
    		friend Complex operator+(Complex com,int a){
    		//定义友元运算重符载,"+"的左侧是类对象,右侧是整数函数
    			return Complex(com.real+a,com.imag); 
    		} 
    		friend Complex operator+(int a,Complex com){
    		//定义友元运算重符载,"+"的左侧是类对象,右侧是整数函数
    			return Complex(a+com.real,com.imag);
    		}
    		void show();
    };
    Complex::Complex(int r,int i){
    	real=r;
    	imag=i;
    }
    void Complex::show(){
    	cout<<"real="<<real<<",imag="<<imag<<endl;
    }
    int main(){
    	Complex com1(30,40),com2;
    	com2=com1+30;
    	com2.show();
    	com2=50+com1;
    	com2.show();
    	return 0;
    }
    

    (3)成员运算符函数和友元运算符函数都可以用习惯方式调用,也可以用它们专用的方式调用,下面列出了一般情况下运算符函数的调用形式:


    习惯调用形式 友元运算符重载函数调用形式 成员运算符重载函数调用形式
    a+b operator+(a,b) a.operator+(b)
    -a operator-(a) a.operator-()
    a++ operator++(a,0) a.operator++(0)

    (4)C++ 的大部分运算符既可说明为成员运算符重载函数,又可说明为友元运算符重载函数。取决于实际情况和习惯来选择合适的运算符函数。
      一般而言,对于双目运算符,将它重载为友元运算符比重载为成员运算符便于使用。对于单目运算符,则选择成员运算符较好。如果运算符所需的操作数(尤其是第一个操作数)希望有隐式类型转换,则运算符重载必须用友元函数。以下的经验可供参考:

    • 对于单目运算符,建议选择成员函数。
    • 对于运算符“=、()、[ ]、->” 只能作为成员函数。
    • 对于运算符“+=、-=、/=、*=、&=、!=、~=、%=、<<=、>>=”,建议重载为成员函数。
    • 对于其他运算符,建议重载为友元函数。
    展开全文
  • 5.2.4 成员运算符重载函数和友元运算符重载函数的比较(1)对双目运算符而言,成员运算符重载函数参数表中含有一个参数,而友元运算符重载函数参数表中有两个参数;对于单目运算符而言,成员运算符重载函数参数表中...

    5.2.4 成员运算符重载函数和友元运算符重载函数的比较

    (1)对双目运算符而言,成员运算符重载函数参数表中含有一个参数,而友元运算符重载函数参数表中有两个参数;对于单目运算符而言,成员运算符重载函数参数表中没有参数,而友元运算符重载函数参数表中有一个参数。

    (2)双目运算符一般可以被重载为友元运算符重载函数或成员运算符重载函数,但有一种情况必须使用友元函数。

    例如,如果将一个复数与一个整数相加,可用成员运算符重载函数"+"运算符:
    Complex operator+(int a)
    {
         return (real+a,imag);
    }
    若com和com1是类Complex的对象,则以下语句是正确的;
    com = com+100; //正确,运算符+的左侧是类对象
    这条语句被C++编译系统解释为:
    com = com.operator(100); 

    由于对象com是运算符"+"的左操作数,所以它可以调用"+"运算符重载函数operator+,
    执行结果是对象com的数据成员real被加上一个整数100.

    然而,以下语句就不能工作了:
    com = 100+com; //运算符+的左侧是整数
    这条语句被C++编译系统解释为:
    com = 100.operator(com);

    由于运算符"+"的左操作数是一个整数100,而不是该类的对象。编译时将会出错,因为整数100不能调用成员运算符重载函数。


    如果定义以下的两个友元运算符重载函数
    friend Complex operator+(Complex com,int x) //运算符+的左侧是类的对象,右侧是整数 
    {
          return Complex(com.real+x,com.imag); 
    }

    friend Complex operator+(int a,Complex com) //运算符+的左侧是整数,右侧是类的对象
    {
          return Complex(a+com.real,com.imag); 
    }

    当一个复数与一个整数相加时,无论整数出现在左侧还是右侧,使用友元运算符重载函数都能得到很好的解决。这就解决了使用成员运算符重载函数时,由于整数出现在运算符+的左侧而出现的错误。 

    //例5.7 使用友元运算符重载函数实现一个复数与整数的相加。

    复制代码
    #include<iostream>
    using namespace std;
    class Complex{
      public:
        Complex(int r=0,int i=0)
         {
          real = r;
          imag = i;
         }
         void print();
         friend Complex operator+(int a,Complex &c2); //声明友元运算符重载函数,+的左侧是整数,右侧是类的对象 
         friend Complex operator+(Complex c1,int a);//声明友元运算符重载函数,+的右侧是整数,左侧是类的对象 
      private:
        int real;
        int imag;
    };
    Complex operator+(int a,Complex &c2)  //定义友元运算符重载函数,+的左侧是整数,右侧是类的对象 
    {
      Complex temp;
      temp.real = a+c2.real;
      temp.imag = c2.imag;
      return temp;
    }
    Complex operator+(Complex c1,int a)//定义友元运算符重载函数,+的右侧是整数,左侧是类的对象 
    {
      Complex temp;
      temp.real = c1.real+a;
      temp.imag = c1.imag;
      return temp;
    } 
    void Complex::print()
    {
     cout<<real<<"+"<<imag<<'i'<<endl;
    }
    int main()
    {
     Complex co1(30,40),co2(30,40),co3;
     co1.print();
     
     co3=100+co1;  //co3=operator+(100,co1); 
     co3.print();
     
     co3=co2+100;  //co3=operator+(co2,100);
     co3.print();
     
     return 0;
    }
    复制代码

    (3)成员运算符函数和友元运算符函数都可以用习惯方式调用,也可以用它们专用的方式调用。
    表5.2 运算符函数调用形式
    ------------------------------------------------------------------------------------------ 
    习惯调用形式 友元运算符重载函数的调用形式 成员运算符重载函数的调用形式
    a+b operator+(a,b) a.operator+(b) 
    -a operator-(a) a.operator-()
    a++ operator++(a,0) a.operator++(0)
    ------------------------------------------------------------------------------------------

    (4)C++大部分运算符既可以说明为成员运算符重载函数,又可以说明为友元运算符重载函数。
    一般而言,对于双目运算符,将它重载为友元运算符重载函数比重载为成员运算符函数便于使用。
    对于单目运算符,则选择成员运算符重载函数比较好。
    如果运算符所需要的操作数(尤其是第一个操作数)希望有隐式类型转换,则运算符重载必须使用
    友元函数,而不能使用成员函数。

    a.对于单目运算符,建议选择成员函数
    b.对于运算符"=、()、[]、->"只能作为成员函数
    c.对于运算符"+=、-=、/=、*=、/=、!=、~=、%=、<<=、>>=",建议重载为成员函数
    d.对于其他运算符,建议重载为友元函数。

     

    程序猿神奇的手,每时每刻,这双手都在改变着世界的交互方式!
    本文转自当天真遇到现实博客园博客,原文链接:http://www.cnblogs.com/XYQ-208910/p/4912555.html,如需转载请自行联系原作者
    展开全文
  • C++ 重载运算符和重载函数

    千次阅读 多人点赞 2019-01-28 10:24:12
    C++ 重载运算符和重载函数 C++ 允许在同一作用域中的某个函数和运算符指定多个定义,分别称为函数重载和运算符重载。 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明,但是它们的参数...
  • javascript 重载函数

    千次阅读 2014-09-30 20:52:26
    1.javascript 中是没有重载函数这个概念的! 首先javascript是没有重载函数这个概念的,很久以前,我用javascript做网页的时候,写一些简单的效果,根本不需要用到重载函数,当写游戏的时候,有大量的函数的时候,...
  • C++重载函数

    千次阅读 2017-06-20 21:12:15
    这就是重载函数重载函数常用来实现功能类似而所处理的数据类型不同的问题。函数重载有什么好处? 重载函数通常用来命名一组功能相似的函数,这样做减少了函数名的数量,避免了名字空间的污染,对于程序的可读性...
  • 一、重载函数: (1)出现在相同作用域两个函数,如果具有相同的名字而形参表不同,则称为重载函数; (2)局部声明一个函数则该函数将屏蔽而不是重载最外层作用域中声明的同名函数,在c++中,名字查找发生在类型...
  • java重载函数

    2018-07-27 09:10:46
    个人问题:概念不清晰,遗忘 解析问题:函数名、参数列表、返回值 重载的特点: 1、函数名必须同名 2、参数个数、参数类型不同 3、重载与返回类型无关 ...4、重载函数在同一个类中 5、提高函数的复用性...
  • 重载函数,例题

    千次阅读 2019-04-14 20:40:38
    一个程序中,多个函数如果具有相同的函数名,这些函数可以完成不同的功能,并有不同的参数个数或参数类型,这些函数就叫做重载函数,也就是说,函数重载时,要求函数的参数个数或参数类型不同,也就是行参列表必须...
  • 1 重载函数要求函数具有相同的返回值类型和函数名称,并具有不同的参数序列,而虚函数则要求这三项(函数名,返回值类型,参数序列)完全相同 2 重载函数可以是成员函数或友元函数 而虚函数只能是成员函数 3 重载...
  • C++中的赋值运算符重载函数(operator=)

    万次阅读 多人点赞 2018-06-11 18:27:00
    本文主要介绍C++中的赋值运算符重载函数(operator=)的相关知识。 1. 概述 1.1 why 首先介绍为什么要对赋值运算符“=”进行重载。某些情况下,当我们编写一个类的时候,,并不需要为该类重载“=”运算符,因为...
  • c++之重载运算符、重载函数

    千次阅读 2018-02-09 10:13:03
    C++ 重载运算符和重载函数C++ 允许在同一作用域中的某个函数和运算符指定多个定义,分别称为函数重载和运算符重载。重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明,但是它们的参数...
  • 用运算符重载函数作为类成员函数的方法重载运算符+ 下面的例子来自于课本: #include using namespace std; class Complex { public: Complex() //无参构造函数 { real = 0; imag = 0; } Co
  • C++重载函数与重载运算符

    千次阅读 2016-04-29 16:30:41
    C++ 重载运算符和重载函数 C++ 允许在同一作用域中的某个函数和运算符指定多个定义,分别称为函数重载和运算符重载。 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明,但是它们的...
  • 重载函数的重载确定过程
  • Python仿重载函数

    千次阅读 2020-08-11 11:40:10
    今天看见一个问题,python自身不支持重载函数,但是怎样使python达到这个目的 def test(*args): print(len(args)) 通过使用args,表名,参数为不定参数,是一个列表格式。 函数通过args传进的参数个数不同执行同一...
  • 重载函数是完全不同的几个函数,有不同的函数地址,当我们调用函数时,编译器根据实参确定要调用哪一个重载函数。有时候我们需要不调用函数的情况下获取某个重载函数的地址(比如将重载函数作为接口导出),该怎么做呢...
  • C++程序设计 重载函数

    千次阅读 2020-01-26 03:19:40
    编写4个重载函数,分别求整数和字符的最小值(10分) 题目 编写四个重载函数,函数求对应参数中的最小值并返回该值。 四个函数的原型是: char min( char c1, char c2 ); char min( char c1, char c2, char c3 ); ...
  • C++之重载函数

    2019-08-01 18:32:02
    重载函数 在实际应用中会遇到这样的问题,同一项功能,由于有不同类型的需求,需要分别编制不同的函数。例如求一个数的绝对值,由于类型不同的需要,有下述不同名字的函数 Intabs(int); Longlabs(long); ...
  • 例10.2中对运算符“+”进行了重载,使之能用于两个复数的相加。...实际上,运算符重载函数有两个参数,由于重载函数是Complex类中的成员函数,有一个参数是隐含的,运算符函数是用this指针隐式地访问类对象的成员。可以
  • 一、提供默认赋值运算符重载函数的时机 当程序没有显示地提供一个以本类或者本类的引用为参数的赋值运算符重载函数时,编译器会自动生成这样一个赋值运算符重载函数。#include using namespace std;class Data { ...
  • C++ 重载函数匹配

    千次阅读 2015-07-20 22:43:06
    C++ 重载函数匹配规则

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,680
精华内容 22,672
关键字:

重载函数