精华内容
下载资源
问答
  • 基本都可以重载不能重载的只有少数5个: 成员运算符“.”、指针运算符“*”、作用域运算符“::”、“sizeof”、条件运算符“?:”

    在这里插入图片描述
    基本都可以重载,不能重载的只有少数5个:
    成员运算符“.”、指针运算符“*”、作用域运算符“::”、“sizeof”、条件运算符“?:”

    展开全文
  • 该楼层疑似违规已系统折叠隐藏此楼查看此楼大工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: 错

    正确答案:

    展开全文
  • 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的友元函数时,程序就会出现跟把赋值运算符重载友元一样的情况,即产生矛盾性。

    展开全文
  • 运算符重载之友元运算符重载

    千次阅读 2019-01-05 21:08:02
    友元运算符重载函数: 把运算符重载函数定义为某个类的友元函数。 1、定义友元运算符重载函数的语法形式 (1)在类的内部,定义友元运算符重载函数的格式如下: friend 函数类型 operator 运算符(形参表) { 函数体 ...

    友元可以参考:https://blog.csdn.net/aaqian1/article/details/84427884

    友元运算符重载函数: 把运算符重载函数定义为某个类的友元函数。

    1、定义友元运算符重载函数的语法形式

    (1)在类的内部,定义友元运算符重载函数的格式如下:

    friend 函数类型 operator 运算符(形参表)
    {
    	函数体
    }
    

    (2)友元运算符重载函数也可以在类中声明友元函数的原型,在类外定义。
    在类中,声明友元运算符重载函数原型的格式:

    class X{
    	friend 函数类型 operator 运算符(形参表);
    }
    

    在类外,定义友元运算符重载函数的格式如下:

    函数类型 operator 运算符(形参表){
    	函数体 
    }
    

    由于友元运算符重载函数不是该类的成员函数,所以在类外定义时不需要缀上类名。
    若友元运算符重载函数重载的是双目运算符,则参数表中有两个操作数;若重载的是单目运算符,则参数表中只有一个操作数。

    2、双目运算符重载

    例 1:用友元运算符重载函数进行复数运算。

    两个复数 a+bi 和 c+di 进行加、减、乘、除的方法如下:
    加法:(a+bi)+(c+di)=(a+b)+(c+d)i
    减法:(a+bi)-(c+di)=(a-b)+(c-d)i
    乘法:(a+bi) * (c+di)=(ac-bd)+(ad+bc)i
    除法:(a+bi) / (c+di)=(a+bi) * (c-di) / (cc+dd)
      在 C++ 中,不能直接进行复数的加、减、乘、除运算,不过可以定义四个友元运算符重载函数,通过重载“+、-、*、/ ”运算符来实现复数运算。
    代码如下:

    #include<iostream>
    using namespace std;
    class Complex{
    	private:
    		double real;    //复数实部 
    		double imag;	//复数虚部 
    	public:
    		Complex(double r=0.0,double i=0.0); //https://blog.csdn.net/aaqian1/article/details/83894795。带默认参数的构造函数 
    		void print();
    		friend Complex operator+(Complex& a,Complex& b);	//声明运算符,重载函数
    		friend Complex operator-(Complex& a,Complex& b);	//声明运算符,重载函数
    		friend Complex operator*(Complex& a,Complex& b);	//声明运算符,重载函数
    		friend Complex operator/(Complex& a,Complex& b);	//声明运算符,重载函数
    };
    Complex::Complex(double r,double i){	//构造函数 
    	real=r;
    	imag=i;
    } 
    Complex operator+(Complex& a,Complex& b){
    	Complex temp;
    	temp.real=a.real+b.real;
    	temp.imag=a.imag+b.imag;
    	return temp;
    }
    Complex operator-(Complex& a,Complex& b){
    	Complex temp;
    	temp.real=a.real-b.real;
    	temp.imag=a.imag-b.imag;
    	return temp;
    }
    Complex operator*(Complex& a,Complex& b){
    	Complex temp;
    	temp.real=a.real*b.real-a.imag*b.imag;
    	temp.imag=a.real*b.imag+a.imag*b.real;
    	return temp; 
    }
    Complex operator/(Complex& a,Complex& b){
    	Complex temp;
    	double t;
    	t=1/(b.real*b.real+a.imag*b.imag);
    	temp.real=(a.real*b.real+a.imag*b.imag)*t;
    	temp.imag=(b.real*a.imag-a.real*b.imag)*t;
    	return temp;
    }
    void Complex::print(){	//显示输出复数 
    	cout<<real;
    	if(imag>0)
    		cout<<"+";
    	if(imag!=0)
    		cout<<imag<<'i'<<endl;
    }
    int main(){
    	Complex A1(2.3,1),A2(3.6,2.8),A3,A4,A5,A6;
    	A3=A1+A2;
    	A4=A1-A2;
    	A5=A1*A2;
    	A6=A1/A2;
    	A3.print();
    	A4.print();
    	A5.print();
    	A6.print();
    	return 0;
    }
    

    执行结果如下:
    在这里插入图片描述
      一般而言,如果在类 X 中采用友元函数重载双目运算符 @ ,而 aa 和 bb 是类 X 的两个对象,则以下两种函数调用方法是等价的:

    aa@bb;		//隐式调用
    operator@(aa,bb);		//显示调用
    

    说明:
    (1)有时,在函数返回的时候,可直接用类的构造函数来生成一个临时对象,而不对该对象进行命名,如可将例 1 中的重载运算符“ + ”的友元运算符重载函数

    Complex operator+(Complex& a,Complex& b){
    	Complex temp;
    	temp.real=a.real+b.real;
    	temp.imag=a.imag+b.imag;
    	return temp;
    }
    

    改为:

    Complex operator+(Complex& a,Complex& b){
    	return Complex(a.real+b.real,a.imag+b.imag);
    }
    

    其中 return 语句中的

    Complex(a.real+b.real,a.imag+b.imag);
    

    是建立的一个临时对象,它没有对象名,是一个无名对象。在建立临时对象过程中调用构造函数。return 语句将此临时对象作为函数返回值。
    这种方法的执行的效率比较高,但是前一种方法的可读性比较好。
    (2)有的 C++ 系统(如 Visual C++ 6.0)没有完全实现 C++ 标准,它所提供的不带后缀的“ .h ”的头文件不支持友元运算符重载函数,在 Visual C++ 6.0 中编译会出错,这时可采用带后缀的“ .h ”头文件。将程序中的

    #include<iostream>
    using namespace std;
    

    改为

    #include<iostream.h>
    

    即可顺利运行。

    3、单目运算符重载

      单目运算符只有一个操作数,如 -a、&b、!c、++p等。

    例 2:用友元函数重载单目运算符“-”

    #include<iostream>
    using namespace std;
    class Coord{
    	private:
    		int x,y;
    	public:
    		Coord(int x1=0,int y1=0){
    			x=x1;
    			y=y1;
    		}
    		friend Coord operator-(Coord &obj);	//声明为单目运算符 "-" 重载函数
    		void print(); 
    };
    Coord operator-(Coord &obj){	//定义单目运算符 "-" 重载函数
    	obj.x=-obj.x;
    	obj.y=-obj.y;
    	return obj;
    }
    void Coord::print(){
    	cout<<"x="<<x<<"y="<<y<<endl;
    }
    int main(){
    	Coord ob1(50,60),ob2;
    	ob1.print();
    	ob2=-ob1;
    	ob2.print();
    	return 0;
    }
    

    输出结果:
    在这里插入图片描述

    例 3:用友元函数重载单目运算符“++”

    #include<iostream>
    using namespace std;
    class Coord{
    	private:
    		int x,y;
    	public:
    		Coord(int x1=0,int y1=0){
    			x=x1;
    			y=y1;
    		}
    		friend Coord operator++(Coord &obj);	//声明为单目运算符 "-" 重载函数
    		void print(); 
    };
    Coord operator++(Coord &obj){	//定义单目运算符 "-" 重载函数
    	++obj.x;
    	++obj.y;
    	return obj;
    }
    void Coord::print(){
    	cout<<"x="<<x<<";y="<<y<<endl;
    }
    int main(){
    	Coord ob1(50,60);
    	ob1.print();
    	++ob1;
    	ob1.print();
    	operator++(ob1);
    	ob1.print();
    	return 0;
    }
    

    在这里插入图片描述
    如果将友元运算符重载函数定义为以下格式:

    friend Coord operator++(Coord op){	
    	++obj.x;
    	++obj.y;
    	return obj;
    }
    

    在这里插入图片描述
      这个运行结果是错误的,原因是这个函数的形参是对象,是通过传值的方法传递参数的,函数体内对形参 obj 的所有修改都无法传到函数体外。即,实际上 operator++ 函数中 obj.x 和 obj.y 的增加并没有引起实参 ob1.x 和 ob1.y 的增加,因此造成了运行结果的错误。
      而形参是对象的引用时,是通过传址的方式传递参数的,函数形参 obj.x 和 obj.y 的改变将引起实参 ob1 的变化。

      一般而言,如果在类 X 中采用友元函数重载单目运算符 @ ,而 aa 是类 X 的两个对象,则以下两种函数调用方法是等价的:

    @aa;	//隐式调用
    operator@(aa);		//显式调用
    

    说明:
    (1)运算符重载函数 operator@ 可以返回任何类型,甚至可以是 void 类型,但通常返回的类型与它操作的类的类型相同,这样可以使重载运算符用在复杂的表达式中。
    (2)有的运算符不能定义为友元运算符重载函数,如赋值运算符 “=”,下标运算符“[ ]”、函数调用运算符“ () ”等。

    展开全文
  • 运算符重载之成员运算符重载

    千次阅读 2019-01-05 22:30:20
    成员运算符重载函数 成员运算符重载函数,即把运算符重载函数定义为某个类的成员函数。 1、定义成员运算符重载函数的语法形式 (1)在类的内部,定义成员运算符重载函数的格式如下: 函数类型 operator 运算符(形参...
  • C++ 运算符重载

    2021-05-21 09:35:53
    C++ 运算符重载C++ 实现了在类(class)之间使用语言标准操作符,而只是在基本数据类型之间使用。例如:int a, b, c;a = b + c;是有效操作,因为加号两边的变量都是基本数据类型。然而,我们是否可以进行下面的操作...
  • 标题的问题同样可以是:为什么赋值...有一篇文章说得比较好,连接在此:为什么C++赋值运算符重载函数不能被继承?,推测过程如下:class A1 { public: int operator=(int a) { return 8; } int operator+(...
  • 函数重载、运算符重载1.函数重载2.运算符重载 1.函数重载 1.1函数重载的定义 函数重载是函数的一种特殊情况,C++允许在同一作用域中声明几个功能类似的同名函数,这些同名函数的形参列表(参数个数 或 类型 或 顺序)...
  • 运算符重载(看完这篇彻底掌握重载问题)

    千次阅读 多人点赞 2019-09-21 16:57:15
    3.默认参数不能和重载的运算符一起使用,也就是说,在设计运算符重载成员函数时不能使用默认函数。 4.不能改变运算符的操作数的个数。 5.不能创建新的运算符,只有已有运算符可以重载 6.运算符作用于C++内部提供的...
  • C++规定有四个运算符 =, ->, [], ()不可以是全局域中的重载(即不能重载为友员函数),这是为什么呢? 现在先说说赋值运算符“=”的重载 C++规定赋值运算符“=”只能重载为类的非静态成员函数,而不可以重载为类的...
  • 运算符重载(超详细)

    千次阅读 多人点赞 2019-09-15 20:37:39
    运算符重载 operatop( argument-list) 例如,operator+() 重载+运算符
  • 重载的一元运算符如下: !(逻辑“非”) &(取址) ~(二进制反码) *(取消指针引用) +(一元加) -(一元求反) ++(递增) –(递减) 转换运算符 后缀递增和递减运算符(++ 和 ––)在递增和递减...
  • 原标题:C++ 运算符重载讲解与经典实例(点击上方公众号,可快速关注)来源:dingyuanpu链接:http://blog.csdn.net/dingyuanpu/article/details/5852825C++中预定义的运算符的操作对象只能是基本数据类型,实际上,...
  • 以下是对C++运算符重载 成员函数与友元函数进行了介绍,需要的朋友可以过来参考下
  • C++哪些运算符重载能够重载?

    千次阅读 2018-09-04 09:13:53
    运算符重载是C++极为重要的语言特性之中的一个。本文将用代码实例回答——C++哪些运算符能够重载?怎样重载?实现运算符重载时须要注意哪些?   哪些运算符能够重载,哪些可重载? C++98,C++0x,C++11对...
  • 运算符重载

    千次阅读 2018-05-27 22:39:30
    一、运算符重载运算符重载,就是对...以下运算符不能被重载:.和.*和::和?:和sizeof。不能创建新的运算符,只有系统预定义的运算符才能被重载。语法形式。运算符函数是一种特殊的成员函数或友元函数。成员函数的语句...
  • 让那些为我付出过的人失望! </div><!--end: blogTitle 博客的标题和副标题 --> <div id="navigator"> 博客园 首页 新随笔 联系 订阅 管理 <div ...
  • 为什么 Java 支持运算符重载

    千次阅读 2020-04-30 09:08:00
    点击上方“朱小厮的博客”,选择“设为星标”后台回复"加群",加入新技术群来源:8nn.co/aecp为什么 C++ 支持运算符重载而 Java 支持? 有人可能会说 +...
  • C++运算符重载大全

    2019-08-01 22:28:57
    重载运算符后就可以将自己定义的类用于各种运算,如数学运算符+-*/,以下列出各类运算符重载示例,先上完整代码 class OperatorTest { public: int data; //双目算术运算符 +,-,*,/,% int operator+(const ...
  • java重载运算符 Manifold扩展依赖项插入Java中,以提供无缝的运算符重载功能。 通过实现一个或多个预定义的运算符方法,可以为任何类类型安全地提供算术,关系和单位运算符 。 您可以直接在您的类中实现运算符方法,...
  • C++中重载的5个运算符

    千次阅读 2017-06-19 20:33:30
    C++中的大部分运算符都是可以重载的,只有以下5个运算符不可以重载,他们是:   1 .(点运算符)通常用于去对象的成员,但是->(箭头运算符),是可以重载的   2 ::(域运算符)即类名+域运算符,取成员,可以...
  • 加号运算符重载

    2021-06-10 19:38:07
    加号运算符重载的作用:实现两个自定义数据类型相加的运算。以下代码是由C++实现两个自定义类型的相加。 #include"iostream" using namespace std; class Person { public: Person operator+(Person &p) { ...
  • 一、运算符重载的几个问题 1、那些运算符可以重载(下述运算符可以重载) 算术运算符:+,-,*,/,%,++,-- ; 位操作运算符:&,|,~,^,<< , >> ; 比较运算符:> , < ,>= ,<= ...
  • 1、运算符重载是为了对用户自定义数据类型的数据的操作与内定义的数据类型的数据的操作形式一致。不能重载的5个运算符:*成员指针访问运算符;::域运算符;sizeof长度运算符;?:条件运算符;.成员访问符。运算...
  • 如果是重载双目操作符(即为类的成员函数),就只要设置一个参数作为右侧运算量,而左侧运算量就是对象本身。。。。。。 而 >> 或 如果一定要声明为成员函数,只能成为如下的形式: ostream & operator {  ...
  • 常用的几种运算符重载

    千次阅读 2019-08-27 16:26:19
    以下为常用的几种运算符重载 1、加号、减号运算符的重载 2、++、--运算符的重载 3、赋值运算符的重载 4、==与!=运算符的重载 5、[]与<<运算符的重载 注意: []返回值为左值需要返回一个引用。 <&...
  • C++ 规定,运算符重载不改变运算符的优先级。 一下运算符不能被重载:".",".*","::","?:",sizeof 。 重载运算符 “()”、"[]"、"->"或者赋值运算符 “=” 时,只能将它们重载为成员函数,不能重载为全局函数...
  • 为什么C++赋值运算符重载函数不能被继承? (zz:http://www.cqumzh.cn/topic_show.php?tid=134570) 这个问题曾经困扰过我一阵子。请先看一下下面的源代码: class A1 { public:  int perator=(int a) ...

空空如也

空空如也

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

以下运算符不能被重载