单目运算符的重载
c 运算符的重载习题答案
1.概念填空题1.1运算符重载是对已有的运算符赋予多重含义,使同一个运算符在作用于不同类型对象时导致不同的行为。
运算符重载的实质是函数重载,是类的多态性特征。
1.2可以定义一种特殊的类型转换函数,将类的对象转换成基本数据类型的数据。
但是这种类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。
类类型转换函数既没有参数,也不显式给出返回类型。
类类型函数中必须有return 表达式的语句返回函数值。
一个类可以定义多个类类型转换函数。
1.3运算符重载时其函数名由operator运算符构成。
成员函数重载双目运算符时,左操作数是对象,右操作数是函数参数。
2.简答题2.2简述运算符重载的规则。
2.2简述重载单目运算符++、--,前置和后置时的差别。
2.3 C++中重运算符是否都可以重载?是否都可以重载成类的成员函数?是否都可以重载成类的友元函数?2.4 构造函数作为类型转换函数的条件是什么。
3.选择题3.1在下列运算符中,不能重载的是(B)A.!B. sizeofC. newD. delete3.2 不能用友员函数重载的是(A)。
A.=B.==C.<=D.++3.3下列函数中,不能重载运算符的函数是(B)。
A.成员函数B.构造函数C.普通函数D.友员函数3.4如果表达式++i*k时中的”++”和”*”都是重载的友元运算符,则采用运算符函数调用格式,该表达式还可表示为(B)。
A.operator*(i.operator++(),k) B.operator*(operator++(i),k)C.i.operator++().operator*(k) D.k.operator*(operator++(i))3.5已知在一个类体中包含如下函数原型:VOLUME operator-(VOLUME)const;下列关于这个函数的叙述中,错误的是(B )。
A.这是运算符-的重载运算符函数B.这个函数所重载的运算符是一个一元运算符C.这是一个成员函数D.这个函数不改变数据成员的值3.6在表达式x+y*z中,+是作为成员函数重载的运算符,*是作为非成员函数重载的运算符。
C++基础系列——运算符重载
C++基础系列——运算符重载1. 运算符重载简介所谓重载,就是赋予新的含义。
函数重载(Function Overloading)可以让⼀个函数名有多种功能,在不同情况下进⾏不同的操作。
同样运算符重载(Operator Overloading)可以让同⼀个运算符可以有不同的功能。
可以对 int、float、string 等不同类型数据进⾏操作<< 既是位移运算符,⼜可以配合 cout 向控制台输出数据也可以⾃定义运算符重载:class Complex{public:Complex();Complex(double real, double imag);Complex operator+(const Complex &a) const;void display() const;private:double m_real;double m_imag;};// ...// 实现运算符重载Complex Complex::operator+(const Complex &A) const{Complex B;B.m_real = this->m_real + A.m_real;B.m_imag = this -> m_imag + A.m_imag;return B;// return Complex(this->m_real + A.m_real, this->m_imag + A.m_imag);}int main(){Complex c1(4.3, 5.8);Complex c2(2.7, 3.7);Complex c3;c3 = c1 + c2; // 运算符重载c3.display();return 0;}运算结果7 + 9.5i运算符重载其实就是定义⼀个函数,在函数体内实现想要的功能,当⽤到该运算符时,编译器会⾃动调⽤这个函数,它本质上是函数重载。
运算符重载
// 顺序错误
.
27
由于使用友元会破坏类的封装,要尽量将运算 符重载函数定义为成员函数。
除非有特殊需要,才使用友元函数重载运算符。
.
28
4.5重载双目运算符
双目的意思是运算符左边和右边的操作数均参 加运算。
如果要重载 B 为类的成员函数,使之能够实 现表达式 oprd1 B oprd2,其中 oprd1 为A 类 对象,则 B 应被重载为 A 类的成员函数,形 参类型应该是 oprd2 所属的类型。
.
24
加法运算符重载为友元函数,C++ 在编译时将表达式 c1+c2解释为
operator + ( c1, c2) 即相当于执行以下函数
Complex operator + ( Complex & c1, Complex & c2 ) {
return Complex( c1.real + c2.real , c1.imag + c2.imag ) ; }
.
3
运算符重载的实质
运算符重载是对已有的运算符赋予多重含义。
必要性:C++中预定义的运算符其运算对象只 能是基本数据类型,而不适用于用户自定义类 型(如类)
实现机制
将指定的运算表达式转化为对运算符函数的调用, 运算对象转化为运算符函数的实参。
编译系统对重载运算符的选择,遵循函数重载的选 择原则。
friend Complex operator + ( int & i , Complex & c )
{
return Complex( c.real + i , c.imag ) ;
详解C++编程中的单目运算符重载与双目运算符重载
详解C++编程中的单⽬运算符重载与双⽬运算符重载C++单⽬运算符重载单⽬运算符只有⼀个操作数,如!a,-b,&c,*p,还有最常⽤的++i和--i等。
重载单⽬运算符的⽅法与重载双⽬运算符的⽅法是类似的。
但由于单⽬运算符只有⼀个操作数,因此运算符重载函数只有⼀个参数,如果运算符重载函数作为成员函数,则还可省略此参数。
下⾯以⾃增运算符”++“为例,介绍单⽬运算符的重载。
[例] 有⼀个Time类,包含数据成员minute(分)和sec(秒),模拟秒表,每次⾛⼀秒,满60秒进⼀分钟,此时秒⼜从0开始算。
要求输出分和秒的值。
#include <iostream>using namespace std;class Time{public:Time( ){minute=0;sec=0;} //默认构造函数Time(int m,int s):minute(m),sec(s){ } //构造函数重载Time operator++( ); //声明运算符重载函数void display( ){cout<<minute<<":"<<sec<<endl;} //定义输出时间函数private:int minute;int sec;};Time Time::operator++( ) //定义运算符重载函数{if(++sec>=60){sec-=60; //满60秒进1分钟++minute;}return *this; //返回当前对象值}int main( ){Time time1(34,0);for (int i=0;i<61;i++){++time1;time1.display( );}return 0;}运⾏情况如下:34:134:2┆34:5935:035:1 (共输出61⾏)可以看到:在程序中对运算符“++”进⾏了重载,使它能⽤于Time类对象。
第7章 函数重载和运算符重载
7.3 运算符重载
•7.3.2 单目运算符的重载 单目运算符重载时参数只有一个。
class Matrix{ public: Matrix operator –( ); //其他成员 //成员函数,参数表为空
}; Matrix Matirx::operator –( ) { Matirx m(rows,cols); //临时对象 for(int i=0;i<rows;i++) for(int j=0;j<cols;j++) m(m,j)= –(*this)(i,j); return m; }
7.3 运算符重载
Matrix & Matrix::operator=(Matrix &src) { //将 src 的所有元素都复制过来 for(int i=0;i<rows*cols;i++) mem[i]=src.mem[i]; return *this; }
7.3 运算符重载
3. 插入抽取运算符的重载 我们可以通过重载插入和抽取运算符来 获得这种效果。重载的运算符形式如下:
7.3 运算符重载
•7.3.4 特殊运算符的重载 1. 自增自减运算符的重载 如果将自增自减运算符定义为类的成员函数, 则应该没有参数。但是为了区分前缀和后缀, C++规定:后缀自增自减运算符定义时带有一 个整型参数,而前缀自增自减运算符时不带 参数,这样在编译时,系统就知道所重载的 是前缀还是后缀运算符了。
7.3 运算符重载
运算符的重载形式有两种,一种是重载为类 的成员函数,另一种是重载为独立的运算符 函数,一般是作为类的友元函数。运算符重 载的语法形式如下: <函数类型> operator <运算符> (<形参表>) { <函数体> }
c++学习资料第 06 章 运算符重载
第 6 章 运 算 符 重 载
{ return Complex( c.Real, c.Image ); } void Complex::print()const { cout << '(' << Real << " , " << Image << ')' << endl; } void main() { Complex c1( 2.5,3.7 ), c2( 4.2, 6.5 ) ; Complex c ; c = c1 c2 ; // operator(c1,c2) c.print() ; c = 25 + c2 ; // operator+(25,c2) c.print() ; c = c2 + 25 ; // operator+(c2,52) c.print() ; c = c1 ; // operator(c1) c.print() ; } 当一个运算符的操作需要修改类对象状态时,应该以成员函数重载。例如,需要左值操 作数的运算符(如 =,*=,++ 等)应该用成员函数重载。如果以友员函数重载,可以使用 引用参数修改对象。 当运算符的操作数(尤其是第一个操作数)希望有隐式转换,则重载算符时必须用友员 函数或普通函数。 C++中不能用友员函数重载的运算符有 = () [] -> 6.3 几个典型运算符重载 本节讨论在数学类中常用的几个运算符重载的特点和应用。 6.3.1 重载 ++ 与 自增和自减运算符有前置和后置两种形式。每个重载运算符的函数都必须有明确的特 征,使编译器确定要使用的版本。C++规定,前置形式重载为一元运算符函数,后置形式重 载为二元运算符函数。 【例 64】例 62 中使用了成员函数重载++和运算符。本例用友员函数重载++运算符。 设有简单类定义 class Increase { public : Increase() ; … friend Increase operator ++ ( Increase & ) ; friend Increase operator ++ ( Increase & , int ) ; private : unsigned value ; } ; 则前置重载的实现为: Increase operator++ ( Increase & a ) { a.value ++ ;
4第四章 运算符重载
const complex operator - (const complex &c) const; void display(); //输出复数 private: //私有数据成员 1.是为了堵塞a+b=c的漏洞。 double real; //复数实部 2. 3.是为了扩大适应性。 double imag; //复数虚部 };
17
[ ]运算符重载为成员函数
下标运算符[]可以重载: 重载形式为:operator[](int); 当 X x; 隐含调用。 x[y] 可被解释为: 显式调用。 x. operator [ ](y); 只能重载为成员函数,不能使用友元函数。 这个类显然是个‚数组类‛。
18
前置++和后置++重载为成员函数
9
使用
void main(){
complex c1(5,4),c2(2,10),c3; //三个复数类的对象 cout<<"c1="; cout<<"c2="; c1.display(); c2.display();
c3=c1-c2; //使用重载运算符完成复数减法 cout<<"c3=c1-c2="; c3.display(); 程序输出结果为:
这三个运算符是许多 教课书没有提到的。
唯一的一个三目运 算符不能重载。
3
运算符重载的基础
设计运算符重载函数,首先要了解运算符原本的运算语义。重
载函数要忠实遵守该运算符作用于基本数据类型时的语义,
并表现出自身所特有的性质。 例如:+ 、+= 、=、++(前)、++(后) ....
C++运算符重载讲解与经典实例 (2)
5.重载运算符有哪些限制:
(1)不可臆造新的运算符。必须把重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中。
(c1+c2)*(c1-c2)*c2/c1=9.61538+25.2308i
在程序中,类complex定义了4个成员函数作为运算符重载函数。将运算符重载函数说明为类的成员函数格式如下:
<类名>operator<运算符>(<参数表>)
其中,operator是定义运算符重载函数的关键字。
程序中出现的表达式:
位操作运算符:&,|,~,^,<<,>>
逻辑运算符:!,&&,||;
比较运算符:<,>,>=,<=,==,!=;
赋值运算符:=,+=,-=,*=,/=,%=,&=,|=,^=,<<=,>>=;
其他运算符:[],(),->,,(逗号运算符),new,delete,new[],delete[],->*。
double real;
double imag;
};
complex a(10,20),b(5,8);
“a+b”运算如何实现?这时候我们需要自己编写程序来说明“+”在作用于complex类对象时,该实现什么样的功能,这就是运算符重载。运算符重载是对已有的运算符赋予多重含义,使同一个运算符作用于不同类型的数据导致不同类型的行为。
运算符重载形式有两种,重载为类的成员函数和重载为类的友元函数。
运算符重载为类的成员函数的一般语法形式为:
简述运算符重载的规则。
简述运算符重载的规则。
运算符重载是指可以为自定义的类类型或枚举类型定义新的含义和功能。
在
C++中,运算符重载遵循以下一般规则:
1. 运算符重载必须至少有一个操作数是用户自定义的类类型或枚举类型的对象,否则将无法重载。
2. 运算符重载可以作为成员函数或非成员函数来实现。
3. 对于成员函数的运算符重载,操作数的数量为运算符的操作数减去1。
例如,重载双目运算符时(如+、-、*等),成员函数需要接受一个参数,用于表示另一个操作数。
4. 对于非成员函数的运算符重载,所有操作数都作为参数传递给函数。
可以通过将重载运算符函数声明为友元函数来访问类的私有成员。
5. 对于重载一元运算符(如++、),如果是成员函数,则返回一个修改后的对象;如果是非成员函数,则返回一个新的对象。
6. 对于重载二元运算符(如+、-、*等),如果是成员函数,则一个对象被修改,另一个对象不变;如果是非成员函数,则返回一个新的对象。
7. 运算符重载不能改变原有运算符的优先顺序和结合性。
8. 运算符重载遵循函数重载的规则,即可以根据参数类型和参数数量进行重载,实现不同的功能。
需要注意的是,运算符重载应该遵循语义上的合理性并不滥用。
C++运算符重载三种形式(成员函数,友元函数,普通函数)详解
C++运算符重载三种形式(成员函数,友元函数,普通函数)详解三种重载⽅式⾸先,介绍三种重载⽅式:1//作为成员函数重载(常见)2class Person{3 Private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8bool operator<(const Person& b);910 };11bool Person::operator<(const Person& b)12 {13//作为成员函数时,*this即为左操作数a14 ...15 }1//作为友元函数重载2class Person{3private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8 friend bool operator<(const Person& a,const Person& b);910 };11bool operator<(const Person& a,const Person& b)12 {13 ...14 }1//作为普通函数重载(不推荐)2class Person{3public://注意,重载运算符为普通函数时,使⽤到的类成员必须为public4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}89 };10bool operator<(const Person& a,const Person& b)11 {12 ...13 }作为成员函数重载先介绍第⼀种:bool Person::operator<(const Person& b),bool是函数返回类型,Person::只是指定了成员函数所属类名。
第八讲 运算符重载
8.2
算术运算符、 算术运算符、赋值运算符和逻辑运算符的重载
8.2.1 重载算术运算符
class Complex { //…… public: Complex operator+(double) { //…… } //…… }; Complex a, b; a=b+10.0; a=10.0+b; b.operator(10.0) 10.0.operator(b)
#include <iostream.h> class HowMany{ public: HowMany() {cout<<"Constructor"<<endl;} ~HowMany() {cout<<"Disconstructor"<<endl;} HowMany(const HowMany& ) {cout<<"Copy Constructor"<<endl;} void print(){cout<<"Member function"<<endl;} }; HowMany f(HowMany x) { x.print(); return x; } void main(){ HowMany h; HowMany h1=f(h); h1.print(); HowMany h2; h2=f(h); }
赋值运算符一般 用预定义的
单目运算符重载: 单目运算符重载:
Complex Complex:: operator-() { Complex temp; temp.rpart=-rpart; temp.ipart=-ipart; return temp; }
第四章运算符重载
2、对于任意一元运算符α:
(1)成员函数重载运算符
定义
type x::operator α( )
{…}
显式调用
objX.operator α( )
隐式调用
αobjX 或:ojbXα
(2)友元函数重载运算符
定义
type operator α(Xobj)
{…}
显式调用
operatorα(obj X)
隐式调用
友元函数重载运算符时,需要明确给出参数,不会出错。 3、不能用友元函数重载的运算符:
= 、 ( )、[]、- > 4、注意: (1)对THIS所指向的数据的任何改变都会影响到激活运算数函数的对象。 (2)可使用引用参数(指针)来解决重载时的二义性。
4.1.5 重载++和--
一、关于++和- 1、C中的++和- -的两种形式: 前缀:++i; 后缀:i--; 2、在C++中的约定 (显式地区分前缀和后缀) (1)对于前缀方式++i:
例4-1 1、重载“+”、“=”、“++”;读懂几个成员函数; 2、成员函数重载运算符,激活运算符的对象都是由THIS指针隐含传递的。
4.1.4 用友元函数重载运算符
1、成员函数重载可能造成的麻烦:成员函数重载的运算符不具有交换性。 原因:成员函数仅能被一个“实际对象”所调用,如果引起成员函数
调用的是一个值(非一个对象),成员函数将不能正确工作。 2、可用友元函数解决这一问题:
5、除“=”以外,重载的运算符可以被任何派生类所继承, “=”需要每个类明确定义自己的解释;
6、 重载可能让程序的可读性下降,在使用时应模仿运算符的 习惯用法 。
《C++程序设计》电子教案第7章 运算符重载
7.1 7.2 7.3 7.4 7.5 运算符重载概述 运算符重载的实现 一元运算符重载 二元运算符重载 特殊运算符重载
7.1 运算符重载概述
运算符重载是对已有的运算符赋予多重含义, 运算符重载是对已有的运算符赋予多重含义, 同一个运算符作用于不同类型的数据导致不同 类型的行为。 类型的行为。 运算符重载的实质就是函数重载。 运算符重载的实质就是函数重载。在实现过程 中,首先把指定的运算表达式转化为对运算符 函数的调用, 函数的调用,运算对象转化为运算符函数的实 参,然后根据实参的类型来确定需要调用的函 这个过程是在编译过程中完成的。 数,这个过程是在编译过程中完成的。
返回首页
算符有前缀和后缀两 如同 “ ++ ” 运 算符有前缀和 后缀两 种 使用形式 一样 , 运算符有前缀和后缀两 种使用形式 “++”和“--”重载运算符也有前缀和后缀两种运算符 ” ” 重载形式, 重载形式 , 以 “ ++” 重载运算符为例 , 其语法格式如 ” 重载运算符为例, 下: <函数类型 operator ++(); 函数类型> ( //前缀运算 前缀运算 函数类型 <函数类型 operator ++(int); //后缀运算 函数类型> 函数类型 ( ) 后缀运算 使用前缀运算符的语法格式如下: 使用前缀运算符的语法格式如下: ++<对象 对象>; 对象 使用后缀运算符的语法格式如下: 使用后缀运算符的语法格式如下: <对象 对象>++; 对象
static char* str; String String::operator+(const String& a) { strcpy(str,name); strcat(str,); return String(str); } void main() { str=new char[256]; String demo1("Visual c++"); String demo2("6.0"); demo1.display(); demo2.display();
C 程序设计(谭浩强完整版)运算符重载
运算符重载
1
函数的重载 所谓函数的重载是指完成不同功能的函数可以具 有相同的函数名。 C++的编译器是根据函数的实参来确定应该调用 哪一个函数的。
int fun(int a, int b) void main(void) { cout<<fun(3,5)<<endl; cout<<fun(5)<<endl; }
由这个函数来完成该运算符应该完成的操作。这 种函数称为运算符重载函数,它通常是类的成员 函数或者是友元函数。运算符的操作数通常也应 该是类的对象。
6
重载为类的成员函数
格式如下:
关键字 <类名> operator<运算符>(<参数表>)
{ 函数体 } 函数名 运算的对象
运算的对象
返回类型
A operator + (A &);
15
class A { int i; public:A(int a=0){ i=a; } void Show(void){ cout<<"i="<<i<<endl; } A operator +(A &a) //重载运算符+ { A t; t.i=i+a.i; return t; } void operator+=(A &a) { i=i+a.i; } 由左操作符调用右操 }; 作符,没有返回值, void main(void) 故函数类型为void。 { A a1(10),a2(20),a3; a1.Show (); a2.Show (); 相当于a3=a1.operator+(a2) a3=a1+a2; a1+=a2; 相当于a1.operator+=(a2) a3.Show (); }
C++学习之路—运算符重载(二)运算符重载作为类的成员函数和友元函数
C++学习之路—运算符重载(⼆)运算符重载作为类的成员函数和友元函数对运算符重载的函数有两种处理⽅式:(1)把运算符重载的函数作为类的成员函数;(2)运算符重载的函数不是类的成员函数,在类中把它声明为友元函数。
1 把运算符重载函数作为类的成员函数例1:为了便于说明问题,将重载函数的定义重写如下:1: Complex Complex :: operator + ( Complex& c2 )2: {3: Complex c ;4: c.real = real + c2.real ;5: c.imag = imag + c2.imag ;6:return c ;7: }有⼈可能会提出这样的疑问:“+”是双⽬运算符,为什么重载函数只有⼀个参数呢?实际上,运算符重载函数应当有两个参数,但是,由于重载函数是Complex类中的成员函数,因此有⼀个参数是隐含的,运算符函数是⽤this指针隐式的访问类对象的成员。
可以看到operator+访问了两个对象中的成员,⼀个是this指针指向的对象中的成员,⼀个是形参对象中的成员。
2 把运算符重载函数作为类的友元函数运算符重载函数除了可以作为类的成员函数外,还可以是⾮成员函数。
在有关的类中把它声明为友元函数,即友元运算符重载函数。
例2:将运算符+重载为适⽤于复数加法,重载函数不作为成员函数,⽽放在类外,作为Complex类的友元函数。
1:class Complex2: {3:public:4: ...5:friend Complex operator + ( Complex& c1 , Complex& c2 ) ; //重载函数作为友元函数6:private:7:double real ;8:double imag ;9: };10:11: Complex operator + ( Complex& c1 , Complex& c2 ) //定义运算符+重载函数12: {13: Complex c ;14: c.real = c1.real + c2.real ;15: c.imag = c1.imag + c2.imag ;16:return c ;17: }这个程序和把运算符重载函数作为类的成员函数相⽐,只做了⼀处改动,就是将运算符重载函数作为类外的普通函数,并在Complex类中声明它为友元函数。
C++程序设计04737 第4章 运算符重载
//成员函数
myComplex &operator=(double);
//成员函数 };
myComplex::myComplex(){ real=0;imag=0;}
myComplex::myComplex(double r,double i)
{real=r;imag=i;}
myComplex myComplex::addCom(myComplex c1) {return myComplex(this->real+c1.real,this->imag+c1.imag); } void myComplex::outCom(){cout<<"("<<real<<","<<imag<<")";} void myComplex::outCom(string s) {cout<<s<<"=("<<real<<","<<imag<<")"<<endl;} void myComplex::changeReal(double r) {this->real=r;} myComplex operator+(const myComplex &c1,const myComplex &c2) //c1+c2 {return myComplex(c1.real+c2.real,c1.imag+c2.imag);}//返回一个临时对象 myComplex operator+(const myComplex &c1,double r) //c1+r {return myComplex(c1.real+r,c1.imag);} //返回一个临时对象 myComplex operator+(double r,const myComplex &c1) //r+c1 {return myComplex(r+c1.real,c1.imag);} //返回一个临时对象 myComplex operator-(const myComplex &c1,const myComplex &c2)//c1-c2 {return myComplex(c1.real-c2.real,c1.imag-c2.imag);}//返回一个临时对象 myComplex operator-(const myComplex &c1,double r) //c1-r {return myComplex(c1.real-r,c1.imag);//返回一个临时对象} myComplex operator-(double r,const myComplex &c1) //r-c1 {return myComplex(r-c1.real,-c1.imag); //返回一个临时对象} myComplex &myComplex::operator=(const myComplex &c1) {this->real=c1.real;this->imag=c1.imag;return *this; } myComplex &myComplex::operator=(double r) {this->real=r;this->imag=0;return *this;}
简述运算符重载的规则。
简述运算符重载的规则。
运算符重载是C语言中的一种语法特性,允许程序员在函数内部重载运算符,以改变其操作类型和参数类型。
运算符重载可以用于实现一些复杂的逻辑,也可以用于提高代码的灵活性和可重用性。
运算符重载的规则如下:
1. 运算符重载只能重载算术运算符和逻辑运算符,不能重载关系运算符(如+、-、*、/等)。
2. 运算符重载的重载点必须在函数内部,不能跨越函数调用。
3. 运算符重载的参数类型必须与运算符的类型相同或相似,且参数类型之间的运算符必须兼容。
4. 运算符重载的函数必须声明在头文件中,并且必须在文件定义之前声明。
5. 运算符重载的函数可以重载多个运算符,但是不能重复重载同一个运算符。
6. 运算符重载的函数可以修改原始运算符的行为,比如将一个算术运算符重载为逻辑运算符。
7. 运算符重载的函数可以改变运算符的顺序,比如将一个逻辑运算符重载为算术运算符。
8. 运算符重载的函数可以改变运算符的优先级,比如将一个逻辑运算符重载为算术运算符或者赋值运算符。
通过运算符重载,程序员可以实现一些复杂的逻辑,比如将一个算术运算符重载为逻辑运算符,以进行条件判断和流程控制。
运算符重载还可以提高代码的
灵活性和可重用性,因为不同的函数可以分别实现不同的逻辑,而不必共享相同的代码。
除了常见的算术运算符重载和逻辑运算符重载外,C语言还支持一些其他的运算符重载,比如字符串比较运算符重载、字符串拼接运算符重载等。
程序员可以根据具体的需求和场景,灵活地使用运算符重载来实现不同的逻辑。
运算符重载详解
运算符重载详解1.运算符重载定义:C++中预定义的运算符的操作对象只能是基本数据类型。
但实际上,对于许多⽤户⾃定义类型(例如类),也需要类似的运算操作。
这时就必须在C++中重新定义这些运算符,赋予已有运算符新的功能,使它能够⽤于特定类型执⾏特定的操作。
运算符重载的实质是函数重载,它提供了C++的可扩展性,也是C++最吸引⼈的特性之⼀。
运算符重载是通过创建运算符函数实现的,运算符函数定义了重载的运算符将要进⾏的操作。
运算符函数的定义与其他函数的定义类似,惟⼀的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。
运算符函数定义的⼀般格式如下:<返回类型说明符> operator <运算符符号>(<参数表>){<函数体>} 2.运算符重载时要遵循以下规则:(1) 除了类属关系运算符"."、成员指针运算符".*"、作⽤域运算符"::"、sizeof运算符和三⽬运算符"?:"以外,C++中的所有运算符都可以重载。
(2) 重载运算符限制在C++语⾔中已有的运算符范围内的允许重载的运算符之中,不能创建新的运算符。
(3) 运算符重载实质上是函数重载,因此编译程序对运算符重载的选择,遵循函数重载的选择原则。
(4) 重载之后的运算符不能改变运算符的优先级和结合性,也不能改变运算符操作数的个数及语法结构。
(5) 运算符重载不能改变该运算符⽤于内部类型对象的含义。
它只能和⽤户⾃定义类型的对象⼀起使⽤,或者⽤于⽤户⾃定义类型的对象和内部类型的对象混合使⽤时。
(6) 运算符重载是针对新类型数据的实际需要对原有运算符进⾏的适当的改造,重载的功能应当与原有功能相类似,避免没有⽬的地使⽤重载运算符。
(7)重载运算符的函数不能有默认的参数,否则就改变了运算符的参数个数,与前⾯第3点相⽭盾了;(8)重载的运算符只能是⽤户⾃定义类型,否则就不是重载⽽是改变了现有的C++标准数据类型的运算符的规则了,会引会天下⼤乱的;(9)⽤户⾃定义类的运算符⼀般都必须重载后⽅可使⽤,但两个例外,运算符“=”和“&”不必⽤户重载;(10)运算符重载可以通过成员函数的形式,也可是通过友元函数,⾮成员⾮友元的普通函数。
运算符号重载:前置与后置单目运算++
运算符号重载:前置与后置单⽬运算++区别:就在于函数的形参,语法规定,前置单⽬运算符重载为成员函数时没有形参,后置单⽬运算符重重载为成员函数时需要⼀个int型形参,这个int型参数在函数体中并不使⽤,纯粹⽤来区别前置与后置。
课本上⼀个例⼦:#include<iostream>using namespace std;class Clock{public:Clock(int NewH=0,int NewM=0,int NewS=0);void ShowTime();Clock& operator ++();//前置单⽬运算符重载Clock operator ++(int);//后置单⽬运算符private:int Hour,Minute,Second;};Clock::Clock(int NewH,int NewM,int NewS){if(0<=NewH&&NewH<24&&0<=NewM&&NewM<60&&0<=NewS&&NewS<60){Hour=NewH;Minute=NewM;Second=NewS;}elsecout<<"Time error!"<<endl;}void Clock::ShowTime(){cout<<Hour<<":"<<Minute<<":"<<Second<<endl;}Clock& Clock::operator ++() //前置++,如++n,最后返回的是n.使⽤对象的引⽤{Second++;if(Second>=60){Second=Second-60;Minute++; if(Minute>=60) { Minute=Minute-60; Hour++; Hour=Hour%24; } } return *this;}Clock Clock::operator ++(int) //后置++,如n++,返回的是运算前的对象值n,不⽤引⽤。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Ending… 谢谢
//等价于d operator++(0); //等价于d operator++(); //等价于 operator--(d,0); //等价于 operator--(d);
输出结果: 5,6,7,7 7,6,5,5
#include<iostream.h> class counter { unsigned int value; public: counter() {value=o;} void operator++(); //前缀方式重载 void operator--(); //前缀方式重载 unsigned int operator()(); }; void counter::operator++() { If(value<8) value++; } Void counter::operator--() { If(value>6) value--; } unsigned int counter::operator()() { return value; }
单目运算符的重载
万军 通信1403 31402145
单目运算符只有一个操作符,如!a,-b,&c,*p,还有最常 用的++i和--i等。重载单目运算符的方法与重载双目运算符 的方法是类似的。但由于单目运算符只有一个操作数,因此 运算符重载函数只有一个参数,如果运算符重载函数作为成 员函数,则还可省略此参数。
单目运算符的重载
单目运算符只有一个操作符,在这里,我们只介绍自加++和自减--运算符。 ++,--运算符有前置,后置之分 前置运算符作为一元运算符重载
1.重载为成员函数: T operator++(); T operator--(); 2.重载为友元函数: T operator++(T); T operator--(T);
单目运算符的重载
后置运算符作为二元运算符重载 多写一个参数,具体无意义 1.重载为成员函数: T operator++(int); T operator--(int); 2.重载为友元函数: T operator++(T,int); T operator--(T,int);
以重载+说,单目运算符最好被重载为成员函数;对双目运算符最好被重载友元 函数。 前置单目运算符重载为类的成员函数时,不需要显式说明参数,即 函数没有形参。 后置单目运算符重载为类的成员函数时,函数要带有一个整型形参。 用成员函数实现运算符的重载时,运算符的左操作数为当前对象, 并且要用到隐含的this指针。运算符重载函数不能定义为静态的成员函 数,因为静态的成员函数中没有this指针
在程序中对运算符“++”进行了 重载,使它能用于Time类对象.
例1
Int main(){ cdemo d(5); cout << (d++) << “ , ”; cout << d << “ , ”; cout << (++d) <<“ , ”; cout << d << endl; cout << (d--) << “ , ”; cout << d << “ , ”; cout << (--d) <<“ , ”; cout << d << endl; return 0; }
成员函数重载
前缀式 后缀式 对象.operator++() 对象.operator++(int)
友元函数重载
operator++(类&对象) operator++(类&对象,int)
下面以自增运算符”++“为例,介绍单目运算符的重载 例:有一个Time类,包含数据成员minute(分)和sec(秒),模拟秒表,每次走一秒,满 60秒进一分钟,此时秒又从0开始算。要求输出分和秒的值。
main() { counter my_counter; for(int i=0;i<12;i++) { ++my_counter; cout<<“\n my_counter=”<<my_counter(); } --my_counter; --my_counter; --my_counter; cout<<“\n my_counter=”<<my_counter(); return0; }