你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

C++——操作符重载

[复制链接]
gaosmile 发布时间:2020-8-13 21:23
一、操作符重载:
1、我们先来看一个问题实现,下面的复数解决方案是否可行,复数大家应该都不陌生(分为实部和虚部):
class Complex2 o* d9 |$ z* f- K
{# O1 H' q' U+ z6 F5 m9 g
   public:8 L% g& N7 J$ G: W6 V4 Y" f5 Z
         int a;2 p5 `9 ^) j( _+ a
         int b;: i+ W$ b8 I# K" F4 |0 O8 n
};4 A  d) J% u2 y* W
& ~) A) T, @" v7 z# o/ |7 q
/*--------------------------*/
: \" M  _& r& @% T/ Sint main(): Y0 C8 B, }# h& G7 R5 Y2 [
{
+ v# J( `$ ~9 v; I   Complex c1 = {1,2};% P& c. R# V9 I3 x
   Complex c2 = {3,4};
& W, E0 _, ?4 Y7 j% A9 j! Z   Complex c3 = c1 + c2;//也就是复数的实部加实部,虚部叫虚部。
/ ]0 V- ?6 u% o) h4 I3 g0 Y$ T. \4 T- e   / W% f# }0 P# h; C
   return 0;
+ w# K3 K9 o$ u) }# x4 O$ X7 D$ L}
7 n0 V4 }! S& E& b" U, o
2 |7 C+ P) X, f( J4 b! X2 m注:成员变量为公有且没有自定义构造函数的时候,可以通过大括号来分别初始     化成员变量;
7 }# U- u9 }1 @7 J$ P

+ V3 o$ T# s+ F: Z" |3 ]
代码版本一:
#include <stdio.h>
8 N9 j  d) a0 p' l' S. b' j
' W% o7 J+ z; E+ `0 O* F2 }class Complex - a" J9 T' t1 I2 y8 k* [, y& \& y
{
/ m7 Z7 O9 |7 |) P    int a;2 Q- Z8 x" l/ b- ]
    int b;
9 E0 q+ u# B. M8 q+ Ypublic:" I$ y2 P+ F( ~  k
    Complex(int a = 0, int b = 0)
1 N- s4 W2 G+ s3 j( b9 L* {. Q$ _    {
1 u, x" d7 K$ B/ C1 m, ~4 M        this->a = a;+ F" I- g4 X* [1 g( S9 W
        this->b = b;
" ?0 K5 U( p5 `$ }  A, c    }
  b: e  u% |* M5 X    5 E) q5 h! Z: T6 p6 x( \
    int getA()% r, o( r. }( D5 r9 Y& z
    {
5 y- T0 z' Z/ W0 s! u. D! e) b        return a;0 `+ s3 K+ }5 \
    }  E4 W! j2 A; e5 d1 b! S
   
: ^9 E( o& x* F    int getB()6 E; x% |9 m3 f. n7 G
    {
) V2 \+ }8 w; |$ g$ ?+ M+ Z) T% b- g. M        return b;0 m& b( F( w7 h+ g6 G% p
    }; B% h6 ~4 l+ q) ^$ _! i. |
   
( W6 `0 h$ r3 z    friend Complex Add(const Complex& p1, const Complex& p2);
8 f8 i8 @1 Y# Q};
, x; R9 c2 D* U5 Y5 o# o+ G7 V" Y1 H7 L
Complex Add(const Complex& p1, const Complex& p2)9 X& E% n$ o( B* i
{
7 h( S5 @( D4 a6 s/ G, c/ z! T: {    Complex ret;- O# Z" n4 D& Y
    ! b, f& k8 ]- ^. V! y. h; E
    ret.a = p1.a + p2.a;
' o  J- _% G- d. g1 y    ret.b = p1.b + p2.b;1 u9 O, w. s( A- @" q4 t5 _* v
    ( X9 J/ S9 `1 V( A  |9 m1 _
    return ret;+ _  z6 E" r. x/ A
}
3 X7 I1 t8 S, |; g# e/ f/ Z1 C. K5 T9 O- j( X& D: ?! D
int main()- y3 V; @# R1 ]- L5 h) w
{
; m# _8 E& [& T3 o# A( Y# Q5 E3 k: L' z/ X/ G5 p
    Complex c1(1, 2);+ z5 V' y2 a9 {' U/ n) ^
    Complex c2(3, 4);
) X+ V+ V- z( A$ T; N8 b* g8 y    Complex c3 = Add(c1, c2); // c1 + c2
8 ?8 ]0 I. T2 t0 i! v- l    3 E+ S$ K) r" }+ \0 \! e5 z  I
    printf("c3.a = %d, c3.b = %d\n", c3.getA(), c3.getB());7 {6 Q6 v" j* b+ K% s  m& T
   
* }& C" K6 r  Y& h7 [  I% ~$ {    return 0;
4 F" L! Q5 }4 h}4 ~- z0 V' j, h; T! I

+ r5 o' P6 v: e! g& ~
运行结果:
root@txp-virtual-machine:/home/txp# ./a.out* b% Q- m7 S$ j
c3.a=4,c3,b=6
' I  |* c0 U" ?) W) f
% [" u9 [, g9 F. W1 ^$ V' T
这里通过Add函数可以解决Complex对象相加的问题,但是在我们数学运算里面就是直接实部加实部,虚部加虚部,和正常的实数相加一样,所以说,为什么不直接这样操作呢,这就涉及到符号"+"的问题。
2、操作重载符的引出
  • c++中的重载能够扩展操作符的功能
  • 操作符的重载以函数的方式进行
  • 本质:用特殊形式的函数扩展操作符的功能
    0 |9 C& L+ t. m+ N
3、操作重载符的语法:
  • 通过operator关键字可以定义特殊的函数
  • operator的本质是通过函数重载操作符
  • 语法格式:

    : g: B' T7 F' n
Type operator Sign(const Type& p1,const Type& p2)3 D& ]9 Z3 K$ D1 Q* g6 F
{7 {( A3 Z$ R* Y8 C0 Y, O
      Type ret;7 j/ @8 z/ ~3 U
      2 O7 R' B0 b: A1 G1 s2 w/ ~; |2 R
      return ret;' B6 b, G) N' \; `! q5 Q
}  @7 t! n' W! U1 I

3 r, l9 U9 P, F, p# ?+ b* w8 F1 {注:Sign为系统中预定义的操作符,比如:+、-、*、/ 等
/ X; A8 o+ y) K: C, c8 W' Z) U7 t; A
代码版本二:
#include <stdio.h>
! d' w3 o$ B7 d: Y: [9 ~8 U8 v% B8 c$ ~6 g3 f- g# a+ F
class Complex
4 W8 {6 {& `- L! A{8 _: ~! ]4 @  X0 o
    int a;7 I) J- M1 U( q! z. N
    int b;5 c6 _+ o% }. Q. R8 Y. o
public:4 S% E5 y# p9 h
    Complex(int a = 0, int b = 0)
$ Y- P9 K: |6 y& e+ N3 X    {
! E5 b8 W# P: A5 |1 [        this->a = a;
; {, _& A. [1 d8 U        this->b = b;) ], k/ F2 p; f: x2 `* u
    }1 G+ P2 N9 F+ a9 J6 W
      Y* }+ h0 \4 b3 |8 q. b
    int getA()( w5 _9 ~% t- @& F
    {
& f9 g) f- e# N/ j8 A        return a;. M* g3 X& x* z' K/ s: K
    }
- Y" L9 s7 \1 R& S) w    7 @7 b! `! C: |% O/ E) b
    int getB()+ h# {8 ?( `4 u; f% I
    {
( e3 @7 P4 ?; Y, o; [1 W! `/ {        return b;8 z- d5 b0 Q! X8 `( u  T4 z# O
    }. `8 r" q2 w- M5 b
   
* `7 z$ U0 y; A3 Q$ C    friend Complex operator + (const Complex& p1, const Complex& p2);4 ]" c% S5 e. l2 ]& h4 S# ^3 b. V
};7 ]4 m8 P6 U8 m
7 e  Q7 V# i0 G* i  R4 o% @
Complex operator + (const Complex& p1, const Complex& p2)
+ n# Z. N3 R6 s9 R- N1 k{
: t. o3 F( R: p! n- A5 Z1 s* m/ ?    Complex ret;
* ]: E: L8 y# e/ E+ d. W# }( U   
  K4 X# P- D6 N6 S    ret.a = p1.a + p2.a;, n# e6 g: P! O. t5 j6 K+ C  W5 I
    ret.b = p1.b + p2.b;
5 T$ O) p" R, Q& g7 r" C   
& S8 }# u/ U8 n    return ret;0 E! y8 H4 X+ z9 i
}
) M2 e( y! S" Q1 y" d1 [
& u; @6 ]8 `; B( eint main()
2 {% j! u% j( ]; {{  J3 P  ?* ?/ p; W3 h1 V: @

' e; @% p1 K6 B+ I4 D  g    Complex c1(1, 2);5 \0 h2 g; p6 q. G# }
    Complex c2(3, 4);
2 D1 F+ W2 |1 ]4 g9 B# W: f$ \0 u    Complex c3 = c1 + c2; // operator + (c1, c2)
6 j: r+ O6 h+ y" P    1 ^: [& v" @" T) ]1 L, Q
    printf("c3.a = %d, c3.b = %d\n", c3.getA(), c3.getB());, M" x4 |6 f* D7 A4 z. o2 S* @5 x9 B
    ( G1 ^0 A* m/ s  _# Q# O6 D
    return 0;$ G, P* T( F! P
}
& {: i3 i4 D+ ^

1 ~# B% [* U7 H5 o
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out: C) V9 [. P0 W' W0 Q7 q2 g/ s- C5 m
c3.a=4,c3,b=65 P, P) T. C2 Y/ A: G
) h  k' M9 J, A/ E5 C" J
4、再次改进代码:
  • 可以将操作符重载函数定义成为类的成员函数(前面我们学过,友元现代软件开发不允许)
  • 比全局操作符重载函数少一个参数(左操作数,成员函数中隐藏的 this 参数可以充当左操作数的角色)
  • 不需要依赖友元就可以完成操作符重载
  • 编译器优先在成员函数中寻找操作符重载(一旦在成员函数中找到,就不会去全局找)

    + d8 r8 O0 ^0 d! }3 J1 t
class Type( b3 v1 V% I8 a- J' S: w
{9 r( k. i0 y$ P! J
   public:
4 P. w' f0 T( X2 E/ Y0 Y      Type operator Sign(const Type& p)
* w4 _; f1 G" [9 v& l5 i& `( Z      {; ~/ A- W" q3 T1 q
          Type ret;
' c, @* S2 E; a          return ret;
: X, Y9 I! u6 }2 w* i1 K0 J2 v      }: r+ M* f1 G) T( i" }: F
};

; j! _4 Y$ w0 W$ H& J9 d' \$ D
代码版本三:
#include <stdio.h>
' x) w" P& Q3 l; k8 |7 l9 ~$ t/ {. [- _. L: w
class Complex
# F  b! U1 _' [. m9 q# B{
0 Q/ A5 J; k7 v5 }! h    int a;- }6 r9 w" ~4 b
    int b;
4 ^- l3 }3 b3 x! @8 \public:
2 g: u$ f$ L* c: k  c    Complex(int a = 0, int b = 0)
7 q2 [* S, |( M    {9 p0 I; n" D* l# }
        this->a = a;
% K. Z6 W  Y0 |; J! X  ~        this->b = b;
0 r- z( b( R$ o. A    }. o; [* s# l7 I4 H& F7 M
   
! N5 O  Z8 H0 I    int getA()# k- c7 `3 A$ A6 S: P/ ?3 d
    {+ x/ K4 ~3 U, T6 k
        return a;
( n# y& B/ i6 O. L4 U* V    }
2 T8 @/ f" _0 R, _. k   
* j( A2 B# Z. |    int getB()5 R+ K& I  W3 N5 c& n3 v, }
    {4 f: |3 H) }2 B  _8 C
        return b;; r6 Q& S  J  I  z# v
    }
1 g. D/ \  v9 B0 K7 r: Z    ( i/ X8 y: N! C4 r" b+ m
    Complex operator + (const Complex& p)) |2 I8 ?4 k/ ^( {. O& L
    {9 y8 S! e# u/ ]
        Complex ret;& ?3 X. k$ l* T0 \( ]  Q  y
        printf("Complex operator + (const Complex& p)\n");' a) g1 _' o, f( }
        ret.a = this->a + p.a;$ u3 a5 P# j  N8 z$ p0 p
        ret.b = this->b + p.b;3 [- G* Z! f9 ^* N  S
        
) a4 |- ~% j0 J( Q        return ret;0 L( a; B) m5 j6 y- Z
    }9 W9 {; t3 r" D% i
    8 [  M5 K9 W% e
    friend Complex operator + (const Complex& p1, const Complex& p2);5 X+ m9 C+ X0 Y# c6 I9 n5 A5 G2 M
};
3 N. J+ j- W1 ~% G- X
% Q# P! f; h0 K7 g& d) V3 x! _" o9 TComplex operator + (const Complex& p1, const Complex& p2)6 J3 A4 I3 W' ~9 s& k# j' k6 v! s
{
* ?* V4 D$ a$ m    Complex ret;# N% G+ m" `4 _
    printf("Complex operator + (const Complex& p1, const Complex& p2)\n");
0 c3 R/ }, Y+ `$ u    ret.a = p1.a + p2.a;
) B* W8 j1 k) K- B" o    ret.b = p1.b + p2.b;
7 G$ _3 F+ Z2 _) ?( s2 ?; M    ( V' b# p- l! m7 `; S# t
    return ret;8 r* L' g% Y  D
}
6 B4 p! M( y" J( r% z2 j. |' C( D, o( n  N
int main()
6 j7 j% q2 r; M; `$ [  s{
% Z: k; M. d& F/ T
& W3 W, X  i" ?1 |4 o( _/ @; A. f    Complex c1(1, 2);
$ J/ _! c% A/ J    Complex c2(3, 4);
3 x' U& a+ c( Q' L    Complex c3 = c1 + c2; // c1.operator + (c2)2 Q! _- n% _4 e, p; T! g$ a( P
    3 P  Q& ?; |& ^& t8 ?3 R5 R
    printf("c3.a = %d, c3.b = %d\n", c3.getA(), c3.getB());( X( ]1 H+ E* K4 H- B9 _! M
   
/ u$ K/ ^8 P* p' |  c    return 0;
6 U! T% ~7 |: F! z}
/ C  W+ g/ @( a8 Q/ T: t5 z

4 {5 Q- s' b- c
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out
, R/ X: @; l3 [, v4 ]1 qComplex operator +(const Complex& p)' f/ P* a/ D7 C* r# [
c3.a=4,c3,b=6
  D6 \% P" k6 U" Q9 i( f/ A5 u2 f
: C8 j' e+ \. \8 ^& z  ^
二、总结:
  • 操作符重载是c++的强大特性之一
  • 操作符重载的本质是通过函数扩展操作符的功能
  • operator 关键字是实现操作符重载的关键
  • 操作符重载遵循相同的函数重载规则
  • 全局函数和成员函数都可以实现对操作符的重载
    : R, V3 {# U  o" w0 r/ b
好了,今天的分享就到这里,如果文章中有错误或者不理解的地方,可以交流互动,一起进步。
赞 收藏 评论0 发布时间:2020-8-13 21:23

举报

0个回答
关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版