精华内容
下载资源
问答
  • 1.如果两个函数的参数表相同但是返回类型不同 ...函数的返回类型足以区分两个重载函数   2.typedef 名为现有的数据类型提供了一个替换名它并没有创建一个新类型因此如果 两个函数参数表的区别

    1.如果两个函数的参数表相同但是返回类型不同

    会导致一个重复申明的编译错误,例如
     unsigned int max( int i1, int i2 );
     int max( int , int ); // 错误: 只有返回类型不同
    函数的返回类型不足以区分两个重载函数

     

    2.typedef 名为现有的数据类型提供了一个替换名它并没有创建一个新类型因此如果
    两个函数参数表的区别只在于一个使用了typedef 而另一个使用了与typedef 相应的类型
    则该参数表不被视为不同的下列calc()的两个函数声明被视为具有相同的参数表第二个
    声明导致编译时刻错误因为虽然它声明了相同的参数表但是它声明了与第一个不同的返
    回类型
    // typedef 并不引入一个新类型
    typedef double DOLLAR;
    // 错误: 相同参数表不同返回类型
    extern DOLLAR calc( DOLLAR );
    extern int calc( double );

     

    3.当一个参数类型是const 或volatile 时在识别函数声明是否相同时并不考虑const 和
    volatile 修饰符例如下列两个声明声明了同一个函数
    // 声明同一函数
    void f( int );
    void f( const int );
    参数是const 这只跟函数的定义有关系它意味着函数体内的表达式不能改变参数的
    值但是对于按值传递的参数这对函数的用户是完全透明的用户不会看到函数对按值
    传递的实参的改变按值传递的实参以及参数的其他传递方式在7.3 节中讨论当实参
    被按值传递时将参数声明为const 不会改变可以被传递给该函数的实参种类任何int 型的
    实参都可以被用来调用函数f(const int) 因为两个函数接受相同的实参集所以刚才给出的
    两个声明并没有声明一个重载函数函数f()可以被定义为
    void f( int i ) { }

    void f( const int i ) { }
    然而在同一个程序中同时提供这两个定义将产生错误因为这些定义把一个函数定义了两次


    但是如果把const 或volatile 应用在指针或引用参数指向的类型上则在判断函数声明
    是否相同时就要考虑const 和volatile 修饰符
    // 声明了不同的函数
    void f( int* );
    void f( const int* );
    // 也声明了不同的函数
    void f( int& );
    void f( const int& );

     

    展开全文
  • , [], ()可以是全局域重载(即不能重载为友员函数),这是为什么呢? 现在先说说赋值运算符“=”的重载 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++规定有四个运算符 =, ->, [], ()可以是全局域重载(即不能重载为友员函数),这是为什么呢? 现在先说说赋值运算符“=”的重载 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的友元函数时,程序就会出现跟把赋值运算符重载友元一样的情况,即产生矛盾性。


    FROM:  http://www.jb51.net/article/40143.htm

    展开全文
  • 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
    展开全文
  • 函数重载

    2015-12-23 10:43:18
    可与下列哪个函数构成重载( ) A.int Func(int,int,int); B.double Func(int,int);C.double Func(double,double); D.double Func(int,double); 答案:B 参数类型,数目不同,可以构成重载,返回...
  • C++中不能重载的运算符

    千次阅读 2018-12-26 20:23:32
    C++中不能重载的运算符有5个,分别为:“?:” “.” “::” “sizeof” “.*” 。  重载:让操作符可以有新的语义,而不是更改语法,否则会引起混乱。  重载的部分规则:运算函数的参数至少有一个必须是类的对象...
  • 重载函数

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

    千次阅读 2014-09-04 22:09:34
    1、函数重载和重复声明的区别 如果两个函数声明的返回类型和形参表完全匹配,则将第二个函数声明视为第一个的重复声明。如果两个函数的形参表完全相同,但返回类型不同,则第二个声明是错误的: Record ...
  • 1.函数重载定义   函数重载函数重载是指在同一作用域内,可以有一组具有相同函数名,不同参数列表的函数,这组函数被称为重载函数。重载函数通常用来命名一组功能相似的函数,这样做减少了函数名的数量,避免了...
  • C++ 重载运算符和重载函数

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

    千次阅读 2019-04-14 20:40:38
    一个程序,多个函数如果具有相同的函数名,这些函数可以完成不同的功能,并有不同的参数个数或参数类型,这些函数就叫做重载函数,也就是说,函数重载时,要求函数的参数个数或参数类型不同,也就是行参列表必须...
  • C++的函数重载

    千次阅读 多人点赞 2018-07-11 13:44:56
    ——每个现象后面都隐藏一个本质,关键在于我们是否去挖掘 ...函数重载的重要性言而明,但是你知道C++中函数重载是如何实现的呢(虽然本文谈的是C++中函数重载的实现,但我想其它语言也是类似的)
  • C++函数重载

    2015-05-12 20:34:07
    函数重载是什么? 是指在同一作用域内,可以有一组...C++为什么将函数返回类型考虑到函数重载中? 这样设计能够保证函数调用能够独立于上下文,依赖与上下文 重载函数的调用时如何匹配的? 为了估计哪
  • 1、重载函数要求:两个重载函数必须在下列一个或两个方面有所区别: (1)函数有不同参数。 (2)函数有不同参数类型 2、C++运算符重载的相关规定: (1)不能改变运算符的优先级; (2)不能改变运算符的结合...
  • C++重载函数

    2018-03-10 22:06:40
    1,重载函数 重载函数函数的一种特殊情况,为方便使用,C++允许在同一范围声明几个功能类似的同名函数,但是这些同名函数的形式参数(指参数的个数、类型或者顺序)必须不同,也就是说用同一个运算符完成不同的...
  • 为什么C++赋值运算符重载函数不能被继承? (zz:http://www.cqumzh.cn/topic_show.php?tid=134570) 这个问题曾经困扰过我一阵子。请先看一下下面的源代码: class A1 { public:  int perator=(int a) ...
  • C++函数重载详解

    2017-03-29 16:07:53
    C++重载函数其实是一种特殊的函数。它满足以下性质: 1,同一作用域 2,函数名相同 3,参数列表不同(参数...函数重载使得我们可以定义以下一组函数,它们的名字都是lookup,但是查找的依据不用。 Record lookup(const
  • 因为调用时不能指定类型信息,编译器知道你要调用哪个函数。 例如: 1.float max(int a, int b); 2.int max(int a, int b); 当调用 max(1, 2);时无法确定调用的是哪个,单从这一点上来说,仅返回值类型不同的...
  • 但是有时,重载为成员函数不能满足使用要求,重载为普通函数不能访问类的私有成员,所以需要将运算符重载为友元。 比如如果运算符=为成员函数,Complex operator+(double r) 可以计算c=c+5;//相当与c=c....
  • 函数重载的条件: 两个重载函数必须在下列一个或两个方面有所区别: 1.、函数有不同参数。 2、函数有不同参数类型, C++的这种编程机制给编程者极大的方便,需要为功能相似、参数不同的函数选用不同的函数名,也...
  • 函数重载的理解

    千次阅读 2015-04-14 00:40:18
    一、介绍 我们引进重载函数之后不但可以省去我们为实现同一个功能的函数去很多个名字的麻烦,...函数重载是指在同一作用域内,可以有一组具有相同函数名,不同参数列表的函数,这组函数被称为重载函数。重载函数通常
  • 重载为成员函数: 一般情况下,当一元运算符的操作数,或者二元运算符的左操作数是该类的一个对象时 。 函数原型为:类名&类名::operator运算符(变量表) 例如:用重载函数实现字符串的连接(重载运算符“+”...
  • c++之重载运算符、重载函数

    千次阅读 2018-02-09 10:13:03
    C++ 重载运算符和重载函数C++ 允许在同一作用域的某个函数和运算符指定多个定义,分别称为函数重载和运算符重载。重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明,但是它们的参数...
  • C++函数重载的理解

    2013-04-20 17:25:06
    函数重载 写在前面: 函数重载的重要性不言而明,...(抛开函数重载不谈,using就是一种解决命名冲突的方法,解决命名冲突还有很多其它的方法,这里就不论述了) 2、当我们调用一个重载的函数时,又是如何去解析的

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,921
精华内容 14,368
关键字:

下列函数中不能重载