精华内容
下载资源
问答
  • 2013-11-10 12:30:05

    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& );

     

    更多相关内容
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼大工20秋《CC语言程序设计》在线作业1答案(单选题)1: 下列运算符中,( )运算符在C++中不能重载。A: &&B: []C: ::D: new正确答案:(单选题)2: 如果一个类至少有一个...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    大工20秋《CC语言程序设计》在线作业1答案

    (单选题)1: 下列运算符中,( )运算符在C++中不能重载。

    A: &&

    B: []

    C: ::

    D: new

    正确答案:

    (单选题)2: 如果一个类至少有一个纯虚函数,那么就称该类为( )。

    A: 抽象类

    B: 虚基类

    C: 派生类

    D: 以上都不对

    正确答案:

    (单选题)3: 在C++中,用于实现运行时多态性的是( )。

    A: 内联函数

    B: 重载函数

    C: 模板函数

    D: 虚函数

    正确答案:

    (单选题)4: 以下基类中的成员函数,表示纯虚函数的是( )。

    A: virtual void vf(int);

    B: void vf(int)=0;

    C: virtual void vf( )=0;

    D: virtual void vf(int){ }

    正确答案:

    (单选题)5: 在C++中,可以从一个类派生出另一个类,前者称为(),后者称为派生类或子类。

    A: 基类或父类

    B: 继承类

    C: 多态类

    D: 虚类

    正确答案:

    (单选题)6: 一个派生类可以从一个基类派生,也可以从多个基类派生。从一个基类派生的继承称为()。

    A: 单继承

    B: 多继承

    C: 有效继承

    D: 以上都不是

    正确答案:

    (单选题)7: 派生类有3种继承方式,公有继承、私有继承和()。

    A: 单继承

    B: 多继承

    C: 有效继承

    D: 保护继承

    正确答案:

    (单选题)8: ()是指联编工作出现在编译连接阶段,这种联编又称为早期联编,因为这种联编过程是在程序开始运行之前完成的。

    A: 动态联编

    B: 静态联编

    C: 多态联编

    D: 以上都不是

    正确答案:

    (单选题)9: 在析构函数前面加上关键字virtual进行说明,则称该析构函数为()。

    A: 虚构造函数

    B: 虚成员函数

    C: 虚析构函数

    D: 以上都不是

    正确答案:

    (单选题)10: I/O操作分别由两个类istream和ostream提供,由它们派生出一个类(),提供双向I/O操作。

    A: iostream

    B: cin

    C: cout

    D: void

    正确答案:

    (判断题)11: 虚基类的构造函数在非虚基类之前调用。

    A: 对

    B: 错

    正确答案:

    (判断题)12: 若同一层次中包含多个虚基类,这些虚基类的构造函数按它们说明的顺序调用。

    A: 对

    B: 错

    正确答案:

    (判断题)13: 运算符重载仍然保持其原来的优先级、结合性和语法结构。

    A: 对

    B: 错

    正确答案:

    (判断题)14: 纯虚函数是一个在基类中声明的虚函数,它在该基类中没有定义具体的操作内容,要求各派生类根据实际需要定义自己的版本。

    A: 对

    B: 错

    正确答案:

    (判断题)15: 在C++中,打开一个文件,就是将这个文件与一个流建立关联;关闭一个文件,就取消这种关联。

    A: 对

    B: 错

    正确答案:

    (判断题)16: 在多继承中,公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规则完全不同。

    A: 对

    B: 错

    正确答案:

    (判断题)17: 进行文件操作时需要包含fstream.h文件。

    A: 对

    B: 错

    正确答案:

    (判断题)18: 在ios中提供控制格式的标志位中,oct是转换为十六进制形式的标志位。

    A: 对

    B: 错

    正确答案:

    (判断题)19: 控制格式I/O的操作中,setw()是设置域宽的。

    A: 对

    B: 错

    正确答案:

    (判断题)20: friend是说明友元函数的关键字。

    A: 对

    B: 错

    正确答案:

    展开全文
  • 函数重载

    2020-03-02 23:29:20
    函数重载 在同一作用域内相同的函数名对应不同的函数实现即是函数重载。 两个同名函数作为重载必须满足其中一个条件: 每个函数的参数个数不同。 参数个数相同,但至少有一个参数的类型不同。 int max(int ...

    函数的重载

    在同一作用域内相同的函数名对应不同的函数实现即是函数的重载。

    两个同名函数作为重载必须满足其中一个条件:

    • 每个函数的参数个数不同。
    • 参数个数相同,但至少有一个参数的类型不同。
    int max(int a, int b){}
    int max(int a, int b, int c){}
    或
    int max(int a, int b){}
    float max(float a, float b){}

    注意:

    函数名和其参数类型组合在一起,就定义了函数的唯一特征,称为函数签名函数的类型不能作为判别重载的依据

    引用参数和默认参数

    不能把参数为某类型的函数重载为同一类型的引用形式的函数,如

    int fun(int num);
    int fun(int& num);

    如果调用语句为:

    fun(value);

    此时编译器无法确定调用哪个版本的函数。为了增强数据的安全性,下面使用 const 对引用参数进行限制,防止在函数中对参数进行修改。下面的两个函数可以实现重载:

    int fun(const int& num);
    int& fun(int& num);

    即是以上两个函数的函数体相同,运行也是不同的。第一个函数可以接收常量或变量作为参数,函数调用不能作为左值;而第二个函数的参数不能为常量,但该函数调用形式可以作为左值,修改引用参数

    如果函数使用默认参数,并和重载函数同时使用,容易产生歧义。

    int max(int a,int b,int c=0);
    int max(int a,int b);
    int max(int a,int b,int c);

    定义在同一个作用域中,当调用函数max(a,b)时,编译器不知道应该调用带参数的函数还是选择两个参数的函数。

    运算符重载

    运算符重载的本质是函数的重载。

    运算符重载格式如下:

    返回类型 operator + (形参列表)
    {    函数实现————对运算符重载操作    }

    重载 “+” 运算符,实现复数的求和。代码如下:

    class Complex
    {
    public:
        Complex(){dReal = 0;dImag = 0;}
        Complex(doublle r,double i){dReal = r;dImag = i;}
        Complex operator + (Complex &c2);                    //声明复数相加函数
        void print();
    private:
        double dReal;                                        //实部
        double dImag;                                        //虚部
    };
    
    Complex Complex::operator + (Complex &c2)
    {
        Complex c;
        c.dReal = dReal + c2.dReal;
        c.dImag = dImag + c2.dImag;
        return c;
    }
    
    void Complex::print()
    {
        cout<<'('<<dReal<<","<<dImag<<')'<<endl;
    }
    
    int main()
    {
        Complex c1(-3,4),c2(0,-10),c3;
        cout<<"c1=";
        c1.print();
        cout<<"c2=";
        c2.print();
        c3 = c1 + c2;
        cout<<"c1+c2=";
        c3.print();
        return 0;
    }
    
    结果
    c1=(-3,4)
    c2=(0,-10)
    c1+c2=(-3,-6)

    将运算符 “+” 重载为复数类的成员函数后,C++编译系统将表达式c1+c2解释为 c1.operator + (c2),即对象c1调用运算符重载函数operator + ()。将实参对象c2按照引用的方式传递给该函数。

    重载的规则

    重载运算符的功能应类似于该运算符作用与基本数据类型时所完成的功能。在把重载运算符用于类的对象时,避免不合理的使用。

    运算符被重载后的基本语法特征不应改变,使用运算符重载必须遵循如下规则:

    • C++不允许创建新的运算符,只能对已有的运算符进行重载。
    • 程序员只能使用C++提供的运算符集,而不能随意使用其他的表示方法。如BASIC中表示指数运算的符号**,虽然用2**10表示2^{10}很简洁,但在C++中不识别。
    • 重载运算符重载不改变运算符所需要的操作数数目。重载的一元运算符仍然是一元运算符,如++和--;重载的二元运算符仍然是二元运算符,如关系运算符和逻辑运算符;C++唯一的三元运算符(?:)不能够被重载。重载运算符不能有参数,否则就改变了运算符参数的个数
    • 运算符重载不改变运算符的优先级和结合性。如果要改变优先级,可以使用加括号的形式强行改变。
    • 运算符重载不能改变该运算符用于基本类型变量时的含义。
    • 用于类对象的运算符一般必须重载,但有两个例外(“=”和“&”)。赋值运算符和地址运算符无需重载就可用于每一个类。“&”返回对象在内存中的起始地址。
    C++允许和禁止重载的运算符
    允许重载的运算符双目算术运算符+    -    *    /    %
    关系运算符==    !=    <    >    >=    <=
    逻辑运算符&&    ||    !
    单目算术运算符+    -    *    &
    自增自减运算符++    --
    位运算符&    |    ~    ^!    <<    >>
    赋值运算符==    +=    -=    *=    /=    %=    ^=    &=    |=
    空间申请和释放new    delete    new[]    delete[]
    其他运算符->*    ,    ->    [ ]    ( )
    不能重载的运算符

    .(成员访问运算符)    .*(成员指针访问运算符)    ::(作用域解析符)    sizeof(长度运算符)    ? : (条件运算符)                                                                         #(预处理器指令符)    ##(标志传送符)

    重载函数作为成员函数和友元函数

    运算符重载函数可以是类的成员函数,也可以是类的友元函数,还可以是类的普通函数。由于普通函数不能直接访问类的私有成员,运算符不能方便地直接作用于类对象,因此只有在少数情况下才使用普通函数实现运算符的重载。因此,重载运算符函数往往为类的成员函数和友元函数

    class Complex
    {
    public:
        Complex(){dReal = 0;dImag = 0;}
        Complex(doublle r,double i){dReal = r;dImag = i;}
        Complex operator + (Complex &c2);                    //两个复数相加函数
        //实现c1+c2时,重载函数operator +中访问了两个对象中的成员,一个是用this指针隐式地访问 
        //this->real(c1.real),另一个是 c2.real;
        //friend Complex operator + (const Complex &c1,const Complex &c2); 友元函数表示
    
        Complex operator + (double &d);                      //复数和实数相加
        void print();
        friend Complex operator + (double &d, Complex &c);   //实数和复数相加
    private:
        double dReal;                                        //实部
        double dImag;                                        //虚部
    };
    
    Complex Complex::operator + (Complex &c2)
    {
        return Complex(dReal + c2.dReal,dImag + c2.dImag);
    }
    
    Complex Complex::operator + (double &d)
    {
        return Complex(dReal + d,dImag);
    }
    
    void Complex::print()
    {
        cout<<'('<<dReal<<","<<dImag<<')'<<endl;
    }
    
    Complex operator + (double &d, Complex &c)                //友元函数实现
    {
        return Complex(d + c.dReal,c.dImag);
    }
    
    int main()
    {
        Complex c0,c1(-3,4),c2(0,-10);
        double d1=5.5,d2=0.5;
        d1 = d1 + d2;
        c0 = c1 + c2;
        cout<<"c1 + c2=";
        c0.print();
        c0 = c1 + d1;
        cout<<"c1 + d1=";
        c0.print();
        c0 = d1 + c1;
        cout<<"d1 + c1=";
        c0.print();
        return 0;
    }
    
    结果
    c1 + c2=(-3,-6)
    c1 + d1=(3,4)
    d1 + c1=(3,4)

    我们通过三个重载运算符 “+” 函数,使其实现了两个复数的加法,实数和复数的加法,并用友元函数满足了实数复数加法的交换律

    为了保证参与加法操作的两个对象的安全性,可以使用关键字 const 加以限制,重载运算符作为成员函数和友元函数分别可声明为:

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

    由于友元的使用会破坏类的封装,因此从原则上说,要尽量将运算符函数作为成员函数。Complex operator + (double &d, Complex &c) 不能用成员函数实现,必须声明为友元函数。

    注意:

    C++规定,赋值运算符=,下标运算符[ ],函数调用运算符( )等,必须定义为类的成员函数。而像流插入运算符 << 和流提取运算符 >>,类型转换运算符,不能定义为类的成员函数。

    展开全文
  • C 运算符中不能重载的是哪些

    千次阅读 2021-08-13 00:11:53
    C 运算符中不能重载的有:1、条件运算符“?:”;2、成员访问运算符“.”;3、域运算符“::”;4、长度运算符“sizeof”;5、成员指针访问运算符“->*”和“.*” 。重载...

    C 运算符中不能重载的有:1、条件运算符“?:”;2、成员访问运算符“.”;3、域运算符“::”;4、长度运算符“sizeof”;5、成员指针访问运算符“->*”和“.*” 。

    重载:让操作符可以有新的语义,而不是更改语法,否则会引起混乱。

    重载的部分规则:运算函数的参数至少有一个必须是类的对象或者是类的对象的引用。

    而C 中不能重载的运算符有5个,分别为:

    “?:”(条件运算符)

    “.”(成员访问运算符)

    “::”(域运算符)

    “sizeof”(长度运算符)

    “->*”和“.*” (成员指针访问运算符)

    那么这几个运算符为什么不能进行重载?原因介绍:

    (1)“?:”

    假设可以重载,那么我们来看下列的代码:

    exp1 ? exp2 : exp3
    该运算符的含义是执行exp2和exp3中的一个,假设重载了,就不可以保证执行一个还是两个,还是都没执行,该运算符的跳转性质就不复存在了。所以,“?:”不能被重载。

    (2)“.”

    假设可以重载,我们可以假设一种情况,创建一个对象,调用该对象的函数。

    class Y{
    public:
    void fun();
    };
    class X{
    public:
    Y* p;
    Y& operator.(){
    return *p;
    }
    void fun();
    }
    void g(X& x){
    x.fun();
    }


    这个例子中,x.fun()就不知道是调用哪一个fun函数了。 
    “.”运算符的含义是引用对象成员,然而被重载后就不能保证了,导致运算符意义的混淆。

    (3)“::”

    该运算符只是在编译的时候域解析,而没有运算参与。根据重载的规则,如果重载该运算符,就赋予了新的语义,可能会出现混淆。

    (4)“sizeof”

    不能被重载的原因主要是内部许多指针都依赖sizeof。

    (5)“->*”和“.*”

    引用指向类成员的指针

    声明:

    本文于网络整理,版权归原作者所有,如来源信息有误或侵犯权益,请联系我们删除或授权事宜。

    展开全文
  • C++中不能重载的运算符

    万次阅读 多人点赞 2018-12-26 20:23:32
    C++中不能重载的运算符有5个,分别为:“?:” “.” “::” “sizeof” “.*” 。  重载:让操作符可以有新的语义,而不是更改语法,否则会引起混乱。  重载的部分规则:运算函数的参数至少有一个必须是类的对象...
  • c++中不能重载的运算符有:1. .点2. ,逗号3. .* 4. ::5. ?:6.sizeof7.typeid
  • C++函数重载(2) - 不能被重载的函数

    千次阅读 2015-05-23 23:26:52
    C++,符合下面这些情况的函数不能重载
  • C++的重载函数

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

    千次阅读 2021-08-03 22:28:03
    在实际开发,有时候我们需要实现几个功能类似的函数,只是有些细节不同。例如希望交换两个变量的值,这两个变量有多种类型,可以是 int、float、char、bool 等,我们需要通过参数把变量的地址传入函数内部。在...
  • C++的函数重载

    万次阅读 多人点赞 2018-07-11 13:44:56
    ——每个现象后面都隐藏一个本质,关键在于我们是否去挖掘 ...函数重载的重要性言而明,但是你知道C++中函数重载是如何实现的呢(虽然本文谈的是C++中函数重载的实现,但我想其它语言也是类似的)
  • 1.不能被重载的运算符有五个,分别是 . .* :: ?: sizeof 有两个运算符系统提供默认重载版本: (1.)赋值运算符“=”,系统默认重载为对象数据成员的复制。...使用非成员,非友元的普通函数重载访问private,...
  • 不能重载为类的静态成员应该比较容易理解,因为静态成员函数是属于整个类的,不是属于某个对象的,它只能去操作类静态数据成员。而赋值运算符“=”是基于对象操作的。当把赋值运算符重载为类的友员函数,在程序...
  • 运算符重载 对于面向对象的程序设计来说,运算符重载可以完成两个对象之间的复杂操作...为了重载运算符,首先要定义运算符重载函数,它通常是类的非静态成员函数或者友元函数,运算符的操作数通常也应为对象。 定...
  • 有些运算符只能用成员函数进行重载 “=” 号便是 原因:在进行赋值的时候会调用构造函数,比如int a, a = 5. 会执行两次构造函数,如果没重载"=",会调用默认的;如果重载了会调用重载后的。如果对"="用友元函数进行...
  • 函数重载

    万次阅读 多人点赞 2016-06-27 17:27:58
    1、什么是函数重载???  在同一个作用域,如果有多个函数的名字相同,但是形参列表不同(参数类型不同或参数个数不同),返回值类型可同也可不同,我们称之为重载函数。重载的函数是通过形参列表区分的,与...
  • 史上最详细的C++函数重载机制

    千次阅读 2020-08-03 19:24:58
    文章目录函数重载1. 例子引入(现象)1.1 什么是函数重载(what)?1.2 为什么需要函数重载(why)?...函数重载的重要性言而明,但是你知道 C++ 函数重载是如何实现的吗?这个可以分为下面两个问题 声明
  • 用成员函数和友元函数重载运算符

    千次阅读 2019-05-20 10:25:04
    友元函数和成员函数选择 1.当无法修改左操作数的类时,使用...用友元函数重载<<、>>操作符 ostream& operator<<(ostream &out, Complex &c) istream& operator>>(istr...
  • 例10.2对运算符“+”进行了重载,使之用于两个复数的相加。在该例运算符重载函数operator+作为Complex类的成员函数。 可能有的读者会提出这样的问题:”+“是双目运算符,为什么在例10.2程序重载函数中...
  •   下列重载为非成员函数的运算符函数原型,其中错误的是( )。  A.Fraction operator +(Fraction, Fraction);  B.Fraction operator -(Fraction);  C.Fraction&amp; operator =(Fraction&amp;, ...
  • 与运算符重载为成员函数时不同的是,重载的友元函数不属于任何类,运算符的操作数都需要通过函数的形参表传递。操作数在形参表从左到右出现的顺序就是用运算符写表达式时操作数的顺序。 这里也分双目运算符和单目...
  • ,其左操作数是标准库的流类,您不能更改它们。 对于必须选择将其实现为成员函数或非成员函数的所有运算符,请使用以下经验法则来确定: 如果它是一元运算符,请将其实现为成员函数。 如果二..
  • C++重载函数

    2018-03-10 22:06:40
    1,重载函数 重载函数函数的一种特殊情况,为方便使用,C++允许在同一范围声明几个功能类似的同名函数,但是这些同名函数的形式参数(指参数的个数、类型或者顺序)必须不同,也就是说用同一个运算符完成不同的...
  • 重载为成员函数: 一般情况下,当一元运算符的操作数,或者二元运算符的左操作数是该类的一个对象时 。 函数原型为:类名&类名::operator运算符(变量表) 例如:用重载函数实现字符串的连接(重载运算符“+”...
  • 因为普通函数(非成员函数)只能被重载不能被重写。声明为虚函数也没有什么意思,因此编译器会在编译时绑定函数。 2、构造函数不能被声明为虚函数; 首先说下什么是构造函数,构造函数是用来初始化对象的。虚函数...
  • 只能使用成员函数重载的运算符

    千次阅读 多人点赞 2019-07-03 22:24:18
    只能使用成员函数重载的运算符有:=、()、[]、-> 只能使用成员函数重载是为了防止出现:1=x,1[x],1->x,1(x)这样的合法语句
  • 分为成员操作符重载(number function)和非成员操作符重载(non-number functon),并是所有的操作符都可以进行非成员函数操作符重载的,具体可以参考官网:http://www.cplusplus.com/doc/tutorial/templates/ ...
  • c++之哪些成员函数不能被继承

    千次阅读 2020-06-14 21:25:50
    C++,并是所有的成员函数被子类继承,有三类成员函数不能被子类继承,分别是:构造函数(包括拷贝构造)、析构函数、赋值运算符重载函数。 一,构造函数  构造方法用来初始化类的对象,与父类的其它成员...
  • (1)不可重载不存在的运算符,如重载**来表示平方等; (2)重载后的运算符与原来的运算符优先级、结合性以及操作数数目相同,如双目运算符不重载为单目; (3)保留运算符本身的含义,如“+”号重载后应该保持其...
  • 要成为虚函数必须满足两点,一就是这个函数依赖于对象调用,因为虚函数就是依赖于对象调用,因为虚函数是存在于虚函数,有一个虚函数指针指向这个虚表,所以要调用虚函数,必须通过虚函数指针,而虚函数指针是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,087
精华内容 15,634
关键字:

下列函数中 不能重载