精华内容
下载资源
问答
  • Java 构造函数和函数重载
    千次阅读
    2021-03-01 08:44:38

    构造函数:⑴方法名和类名相同,而且没有返回类型(包括 void 也没有);

    ⑵没有返回值;

    ⑶如果没有输入构造函数,jvm会自动帮我们创建一个不带参数,没有任何函数体的的构造函数;

    如果我们手动的创建了其他构造函数,就不会帮我们创建这个不带参数的构造函数了;

    ⑷一般情况下,如果想要实现自己的构造方法,最好重载一个不带参数的构造方法。

    函数重载:指多个函数可以使用同一个函数名,只要它们参数列表不同,将意义相近的函数,命名为相同的名称。

    重载总结:⑴函数重载是指多个函数使用同一个名称;

    ⑵重载的条件是参数的数量和类型不同;

    ⑶重载作用:降低调用的难度;

    ⑷当调用重载的函数时,计算机层根据实参自己匹配。

    例题:

    public Noddle(){

    this.bowlType = "大碗";

    }

    public Noddle(String b){

    bowlType = b;

    }

    public Noddle(String bowlType, String type, boolean moreMeat){

    this.bowlType = bowlType;

    this.type = type;

    this.moreMeat = moreMeat;

    }

    更多相关内容
  • C++规定有四个运算符 =, ->, [], ()可以是全局域中的重载(即不能重载为友员函数),这是为什么呢?现在先说说赋值运算符“=”的重载C++规定赋值运算符“=”只能重载为类的非静态成员函数,而可以重载为类的友元...
  • C++中友元函数不能重载的四个运算符

    千次阅读 多人点赞 2019-06-28 07:06:11
    C++中友元函数不能重载的四个运算符 C++规定有四个运算符 =, ->, [], ()可以是全局域中的重载(即不能重载为友员函数),这是为什么呢? 现在先说说赋值运算符“=”的重载 C++规定赋值运算符“=”只能重载为类...

    C++中友元函数不能重载的四个运算符

    C++规定有四个运算符 =, ->, [], ()不可以是全局域中的重载(即不能重载为友员函数),这是为什么呢?

    现在先说说赋值运算符“=”的重载

    C++规定赋值运算符“=”只能重载为类的非静态成员函数,而不可以重载为类的友元函数。

    不能重载为类的静态成员应该比较容易理解,因为静态成员函数是属于整个类的,不是属于某个对象的,它只能去操作类静态数据成员。而赋值运算符“=”是基于对象操作的。

    那么为什么赋值运算符不可以重载为类的友元函数?像同样都是双目运算符的+为什么它就可以呢?

    在讨论这问题之前,先看一测试的程序:

    代码如下:

    #include <iostream>
    using namespace std;
    class A
    {
    private:
      int x;
    public:
         A(){x=99;}
         A(int xx)
         {
                   cout<<"Call A(int xx)"<<endl;
                   x = xx;
         }
    };
    int main(){
         A a;
         a = 7;
    }
    

    程序执行结果为:

    Call A(int xx)

    说明执行a = 7这程序语句时,程序去调用类A中的带参构造函数。

    在类A中加入一赋值运算重载成员函数,如下:

    代码如下:

    #include <iostream>
    using namespace std;
    class A
    {
    private:
         int x;
    public:
         A(){x=99;}
         A(int xx)
         {
                   cout<<"Call A(int xx)"<<endl;
                   x = xx;
         }
         A operator=(int xx)   //重载赋值运算符运算
         {
                   cout<<"Call A operator=(int xx)"<<endl;
                   x = xx;
                   return *this;
         }
    };
    int main()
    {
         A a;
         a = 7;
    }
    

    程序运行结果:

    Call A operator=(int xx)
    

    说明在类A中已经有相应赋值运算符重载函数的时候,执行赋值语句a = 7;程序会去调用类A中相应的赋值运算符重载函数,而不会像上面原来那样去调用有参构造函数。

    在此,我们可以对C++规则做出以下的判断:

    当类中没有定义赋值运算符重载成员函数时(注意,在未定义形参数据类型为该类类型的赋值运算符重载函数时,编译器会自动生成加入),当程序执行到某一赋值语句时,程序就会调用与赋值语句中右值类型匹配的构造函数,而把这右值当作此构造函数的实参。像最初的赋值语句a = 7,执行时,实际做的操作是a(7)。而当类中有定义赋值运算符重载成员函数,执行赋值语句时,程序就只会去调用相应的赋值运算符重载函数。

    当明白上面的规则后,现在就可以回过来,讨论为什么赋值运算符不可以重载为类的友元函数了。

    我们知道友元函数不是类的成员函数,它只是类的“朋友“,具有访问把它声明为“朋友”的类的数据成员的权限而已。

    那么当把赋值运算符重载为类的友员函数,在程序中执行类对象的赋值语句时,程序就会出现两种矛盾的选择。

    1、因为它认为类中并没有重载赋值运算符的成员函数,所以它根据C++的规则,会去调用相应的构造函数。

    2、但是在全局里,我们已经重载了参数类型为此类类型的赋值运算符函数,而这赋值语句刚好和这函数匹配上了,根据C++的规则,也会去调用这函数。

    程序是不允许有矛盾不确定选择的,所以当赋值运算符重载为类的友元函数时,编译器就会提示错误。

    对于剩下的3个运算符 ->, [], () 为什么不能重载为友元函数,也是跟上面一样的道理。即编译器发现当类中没有定义这3个运算符的重载成员函数时,就会自己加入默认的运算符重载成员函数。

    例当类A中没有定义运算符->的重载成员函数,但是我们仍然可以对类A对象指针用->的形式调用指针指向的对象里的成员。像类A里有成员函数f(),当复制代码

    代码如下:

    A a;
    A* p = &a;
     p->f();   //虽然类A中没有自己定义运算符->重载成员函数,但这里仍可这样使用
    

    然而,当我们把->运算符重载为类A的友元函数时,程序就会出现跟把赋值运算符重载友元一样的情况,即产生矛盾性。

    展开全文
  • C++函数重载(2) - 不能被重载的函数

    千次阅读 2015-05-23 23:26:52
    C++中,符合下面这些情况的函数不能重载
    C++中,符合下面这些情况的函数不能被重载。
     
    1) 仅仅是返回值不同
    例如,下面的程序会编译失败。
    #include<iostream>
    int foo() {
      return 10;
    }
    char foo() {
      return 'a';
    }
    int main()
    {
      char x = foo();
      getchar();
      return 0;
    }
    2) 成员函数名称以及参数完全相同,仅仅其中一个是static成员函数。
    例如,下面程序会编译失败。
    #include<iostream>
    class Test {
      static void fun(int i) {}
      void fun(int i) {}
    };
    int main()
    {
      Test t;
      getchar();
      return 0;
    }
    3) 函数参数仅仅是指针与数组的差别。这样实际上是相等的。
    例如,下面程序会编译失败。
    int fun(int *ptr);
    int fun(int ptr[]);  //相当于fun(int *ptr)的重复声明
    4) 函数差别仅在于参数类型,其中一个是函数类型,另一个是相同类型的函数指针。这样实际上是相等的。
    例如,下面程序会编译失败。
    void h(int ());
    void h(int (*)()); //相当于h(int())的重复声明
    如果只是这样的声明两个函数,也许可以编译通过。但是,写上函数主体后,如下所示,编译会报错。
    void h(int())
    {
    }
    void h(int(*)())
    {
    }
    visual studio 2015编译器提示:“error C2084: 函数“void h(int (__cdecl *)(void))”已有主体”
     
    5) 函数参数差别仅在于有无const或volatile。
    当编译器决定哪个函数被声明,定义或调用时,每个参数的const和volatile类型修饰会被忽略掉。
    例如,下面的程序会编译失败,提示error “redefinition of `int f(int)’ ”
    #include<iostream>
    #include<stdio.h>
    using namespace std;
    int f ( int x) {
        return x+10;
    }
    int f ( const int x) {
        return x+10;
    }
    int main() {
      getchar();
      return 0;
    }
    只有当const和volatile是在参数类型修饰的最外层(左侧)使用时,编译器才会进行区别;如果const和volatile被包围在了参数类型修饰的里边,则不能用来区分重载函数声明。特别地,对于任意类型T, “pointer to T,” “pointer to const T,” and “pointer to volatile T” 可以用来区别参数类型, 后面的引用也同样如此, “reference to T,” “reference to const T,” and “reference to volatile T.” 具体参加下面例子:
     
    void f(int * x)
    void f(const int *x)或void f(int const *x)   // 编译正常
    但是,第二个不能为void f(int * const x)
     
    void f(int * x)
    void f(volatile int *x)或void f(int volatile *x)   // 编译正常
    但是,第二个不能为void f(int * volatile x)
     
    void f(int& x)
    void f(const int& x)或void f(int const &x)  //编译正常
    但是,第二个不能为void f(int & const x)   //这样写本身就不合法
     
    6) 函数之间的差别仅在于默认参数值的不同。这样实际上也是相等的. 
    例如,下面程序会编译错误“redefinition of `int f(int, int)’ “
    #include<iostream>
    #include<stdio.h>
    using namespace std;
    int f ( int x, int y) {
        return x+10;
    }
    int f ( int x, int y = 10) {
        return x+y;
    }
    int main() {
      getchar();
      return 0;
    }
    参考文献:
    http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1905.pdf
    展开全文
  • 重载函数

    千次阅读 2021-04-02 15:53:01
    (3)main函数不能重载 (4)只有返回类型不同不算重载 二、顶层const影响传入函数的对象,一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开来 : Record lookup(Phone); Record lookup(co...

    一、重载函数

    (1)对于重载的函数来说, 它们应该在形参数量或形参类型上有所不同。

    (2)类成员函数的声明为const和非const也是重载

    (3)main函数不能重载

    (4)只有返回类型不同不算重载

    二、顶层const不影响传入函数的对象,一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开来 :

    Record lookup(Phone);
    Record lookup(const Phone);//报错
    //重复声明了Record lookup (Phone)
    
    Record lookup(Phone*);
    Record lookup(Phone* const);//报错
    
    //重复声明了Record lookup (Phone*)
    

    三、另一方面,如果形参是某种类型的指针或引用,则通过区分其指向的是常量对象还是
    非常量对象可以实现函数重载,此时的const是底层的 :

    //对于接受引用或指针的函数来说,对象是常量还是非常量对应的形参不同.
    //4个独立的重载函数
    Record lookup(Account&);
    //函数作用于Account的引用
    Record lookup(const Account&);
    // 新函数, 作用于常量引用
    Record lookup(Account*);
    //新函数,作用于指向Account的指针
    Record lookup(const Account*);
    //新函数,作用于指向常量的指针
    

    四、当我们传递一个非常量的对象或者指向非常量对象的指针时,编译器会优先选择非常量版本的函数。

    我们只能把const对象传给const形参,但是可以把非const对象传给const形参(非const可以转换为const)

    /*
    如果重载函数的区别在于它们的引用类型的形参是否引用了const, 或者指针类型的
    形参是否指向const
    则当调用发生时编译器通过实参是否是常量来决定选择哪个函数 :
    */
    Record lookup(Account&);  // 函数的参数是Account的引用
    Record lookup(const Account&);  //函数的参数是一个常量引用
    int main() {
        const Account a;
        Account b;
        lookup(a);
        //调用lookup (const Account&)
        lookup(b);
        //调用lookup (Account&)
    }
    

    五、重载函数的指针

    当我们使用重载函数时,上下文必须清晰的界定到底使用哪个函数

    //如果定义了指向重载函数的指针
    void ff(int*);
    void ff(unsigned int);
    void (*pf1) (unsigned int) = ff; // pf1指向ff (unsigned)
    //编译器通过指针类型决定选用哪个函数,指针类型必须与重载函数中的某一个精确匹配
    void (*pf2) (int) = ff;
    //错误:没有任何一个ff与该形参列表匹配.
    double (*pf3) (int*) = ff;
    //错误: ff和pf3的返回类型不匹配
    
    展开全文
  • 关于运算符重载1.首先我们通过operator+加号运算符来了解成员函数与...首先我们来看一下operator+加号运算符,因为他的重载继可实现成员函数重载,也可以实现友元函数重载。 1.加号运算符的成员函数 我们来看一下加号运
  • C语言为什么支持函数重载

    千次阅读 2019-04-30 17:55:25
    函数重载 在我们中国的文化中,一个词可能是有多种含义,在这种情况下就可以通过上下文来判断这个词到底是什么意思,在这里我们就可以理解为这个词被重载了。 例:又是晴朗的而又美好的一天,可是小明的妈妈却让...
  • c++之哪些成员函数不能被继承

    千次阅读 2020-06-14 21:25:50
    C++中,并是所有的成员函数被子类继承,有三类成员函数不能被子类继承,分别是:构造函数(包括拷贝构造)、析构函数、赋值运算符重载函数。 一,构造函数  构造方法用来初始化类的对象,与父类的其它成员...
  • C/C++_两种函数不能重载的情况

    万次阅读 2015-07-28 14:58:57
    情况一: 参数完全相同,只有...由于只有返回值不同故无法区分到底调用那个函数,因此不能重载 情况二: 语意明确 示例: KK(int x , int y = 10){ this->x = 10; this->y = y; } KK(int x){ this->x = 10; this-
  • 1、原因:C语言不能函数重载与函数编译后函数名有关。 2、C原因编译后的代码名称为”_函数名” //C语言 int Add(int a,int b); //这里是有意只给声明给定义, int Add(int a,char b); //出错后会在显示框显示...
  • JAVA函数重载和重写

    千次阅读 2021-02-12 10:32:57
    一、什么是重载(overlording)在JAVA中,可以在同一个类中存在多个函数函数名称相同但参数列表不同。这就是函数重载(overlording)。这是类的多太性表现之一。二、重载的作用:举个现实生活中的实例。假如你是个...
  • C++的重载函数

    2022-03-11 14:36:00
    在C语言中,一个函数名只能用于一个函数不能出现多个函数用一个函数名的情况,即使这些函数的类型和参数一样。 如在C语言中,求绝对值函数函数原型: int abs(int); long labs(long); double fabs(double);...
  • C++哪些函数不能声明为虚函数

    千次阅读 2019-02-25 11:37:29
    普通函数只能被重载不能被重写,因此声明为虚函数没有意义。因为编译器会在编译时绑定函数。 而多态体现在运行时绑定。通常通过基类指针指向子类对象实现多态。 2)友元函数 友元函数不属于类的成员函数不能...
  • 因为构造函数可以有多个且可以带参数,而析构函数只能有一个且不能带参数 class Test { public: Test(int x,int y):x_(x),y_(y) { cout << "Test()" } ~Test() { cout << "~Test()" << ...
  • C++函数重载详解

    千次阅读 2021-08-03 22:28:03
    在实际开发中,有时候我们需要实现几个功能类似的函数,只是有些细节不同。例如希望交换两个变量的值,这两个变量有多种类型,可以是 int、float、char、bool 等,我们需要通过参数把变量的地址传入函数内部。在...
  • c++函数重载为什么不能以返回值类型区分? 看一段简单代码 #include <iostream> #include<string> using namespace std; void fun(int a, int b) { cout << "a+b=" << a + b << ...
  • TS 函数重载

    千次阅读 2021-07-08 15:03:28
    在实现某个功能的时候, 要写一个时间转换的函数, 大概就是传递一个Moment对象进去, 然后给我返回一个格式为YYYY-MM-DD HH:mm:ss的字符串, 如果参数是undefined, 就做处理,返回undefined; 然后写了这样一...
  • C++的函数重载

    万次阅读 多人点赞 2018-07-11 13:44:56
    ——每个现象后面都隐藏一个本质,关键在于我们是否去挖掘 ...函数重载的重要性言而明,但是你知道C++中函数重载是如何实现的呢(虽然本文谈的是C++中函数重载的实现,但我想其它语言也是类似的)
  • 那么,有哪些函数可以成为虚函数?那些函数不可以成为虚函数? 要成为虚函数必须满足两点,一就是这个函数依赖于对象调用,因为虚函数就是依赖于对象调用,因为虚函数是存在于虚函数表中,有一个虚函数指针指向这个...
  • C++类-构造函数重载

    千次阅读 2021-06-09 09:54:13
    这些构造函数具有相同的名字,而参数的个数或参数的类型相同。这称为构造函数重载。所以,在一个类中定义多个构造函数,构造函数的名称都是相同,只有构造函数的参数不同,那么,就称为构造函数重载。如下是...
  • 为什么operator运算符重载一定要为友元函数呢? 如果是重载双目操作符(即为类的成员函数),就只要设置一个参数作为右侧运算量,而左侧运算量就是对象本身。。。。。。而 >> 或左侧运算量是 cin或cout 而不是对象...
  • C++函数运算符重载

    千次阅读 2021-11-20 11:03:34
    2、哪些运算符需要重载哪些不需要重载? 答:可以重载的运算符: 算术运算符:+,-,*,/,%,++,–; 位操作运算符:&,|,~,^,,>> 逻辑运算符:!,&&,||; 比较运算符:,>,>=,,==,!=; 赋值运算符:=,+
  • 虚函数和函数重载在使用上的区别

    千次阅读 2020-05-08 22:56:18
    3.如果对成员函数进行重载,重载的函数与被重载的函数应该是用一个类中的成员函数,不能分属于两个不同继承层次的类,函数重载处理的是横向的重载。虚函数是对同一类族中的基类和派生类的同名函数的处理,即允许在...
  • 函数模板与函数重载的区别

    千次阅读 2020-02-22 22:26:05
    所谓函数模板,实际上是建立一个通用函数,其函数类型和形参类型具体指定,用一个虚拟的类型来代表。这个通用函数就称为函数模板。凡是函数体相同的函数都可以用这个模板来代替,不必定义多个函数,只需在模板中...
  • C++ 中的函数重载

    千次阅读 2021-03-12 23:12:15
    函数重载 函数重载的概念: 函数重载是函数的一种特殊情况,C++中允许同一作用域中声明几个功能类似的同名函数,这些同名函数的形参列表(参数个数、类型、顺序)不同。 注意:顺序不同指的是不同类型的参数顺序...
  • 重载为成员函数: 一般情况下,当一元运算符的操作数,或者二元运算符的左操作数是该类的一个对象时 。 函数原型为:类名&类名::operator运算符(变量表) 例如:用重载函数实现字符串的连接(重载运算符“+”...
  • 什么叫重载 名字相同 ,参数类型不同 方法重载 方法重载在类中定义多个同名的方法,但是每一个同名的方法要求不同数据类型和不同参数 下面来实现一个方法重载 以...使用简写为 public element:Array<Object&g
  • C++函数模版与重载的区别

    千次阅读 2018-05-03 16:46:29
    //C++函数模版两种定义方式 //template &lt; typename T&gt; 或 template &lt;class T&gt; template &lt;typename T1&gt; T1 check_max(T1 x, T1 y); template ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 523,755
精华内容 209,502
关键字:

哪些函数不能重载