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

C++中的函数重载及进阶学习

[复制链接]
gaosmile 发布时间:2020-8-10 22:17
一、C++中的函数重载:
1、函数重载的概念:
  • 用同一个函数名定义不同的函数
  • 当函数名和不同的参数搭配时函数的含义不同
  • 注意:在c语言中是没有函数重载这个概念的。
    + U* o/ @! G+ Z( P! q
代码示例演示:
#include <stdio.h>2 t5 @& W! E) j
#include <string.h>
9 b1 x" O8 [" H& r* i0 \1 c. O$ M3 p% Xint func(int x)
" d/ l! }) k. `8 ~0 g6 t+ `2 O{7 b5 i, a) t/ c
    return x;( p/ ?' C$ @$ f  h- j
}
2 @6 P$ }3 N& F' P# n  w8 f* q2 }3 }' t3 g% ]' y
int func(int a, int b)
  ]0 Y7 `& M% h# i0 {% v. c{
' p. \( V; ]4 u+ a  q( y   return(a+b);9 H7 ?% g, `) N7 l# w. Z2 g
}
7 h6 t9 D; g! _# z* h6 A, M: K
+ [3 ?+ a, R# y8 P8 {' q& {7 Dint func(const char* s)
& x# [9 B) e1 c' _2 a1 z, l4 o{
0 {. B$ l7 b" J+ ?    return strlen(s);
: Q) U* y4 m$ u9 r# ^}
# Y; F. ?6 e$ i. i: q& X6 V- F" T# [9 A
int main()
1 B' h% K+ }) H1 p{5 V5 L: i5 j  T6 Z
, @! o% k9 l$ d1 O0 V
   return 0;
3 H, ^# L+ E7 ?$ \. \
  G, Z& f* A" I9 F1 z( j, ]- s0 d}
( E8 b$ Q7 l2 N: j/ \  J' |
6 `; H: _7 ]7 T& w! d- y
上面在c++编译器里面编译时没有问题的,如果放在c语言编译器里面编译是会报错的:
root@txp-virtual-machine:/home/txp# gcc test5.c
' R$ x. [7 K, n6 R( q/ {: ytest5.c:8:5: error: conflicting types for ‘func’
. s' C) j& E7 s int func(int a, int b)
  R3 q! L: V+ i* y( g0 s     ^
& U) f0 J. t8 `) a& p" itest5.c:3:5: note: previous definition of ‘func’ was here4 r$ ?7 i4 m5 S: e
int func(int x)
: e" U6 s0 _- w+ b9 |     ^
1 l7 @6 G  _) n. L. htest5.c:13:5: error: conflicting types for ‘func’
. S% g: t: @; }7 U, T+ p* J int func(const char* s)
% m- c2 j' x: O  y) I- S' t     ^
2 H9 k$ l+ w: Z1 E& }+ ctest5.c:3:5: note: previous definition of ‘func’ was here2 O' R- `! `( x' K6 ^  p
int func(int x)! Y, A$ m- V3 W" B% x$ ~0 U& o
* e  R0 J% u% |+ k- f
所以说c语言里面不支持函数重载。
2、函数重载至少要满足下面的一个条件:
  • 参数个数不同
  • 参数类型不同
  • 参数顺序不同

    ) U1 C& J  h/ E: ?0 I7 M
比如下面两个函数可以构造重载函数吗?
int func (int a,const char* s)
) v  b5 h: j& U4 x2 F7 S( |{/ p  B) y# P& [. G2 K
   return a;
1 j! B4 T, O: c7 @}
7 D3 Y. N! h( n7 c2 \2 I2 t6 c+ ~6 l
int func(const char*s,int a)
; y# Z8 [/ L' l8 T7 k2 _( m* k{
4 G6 g) [* w) l( X- H/ \# a    return strlen(s)$ q% V' i, F+ L2 i0 x: b
}

1 V( o7 C" l- B6 g# k0 z* z
答案肯定是可以构造重载函数的,读者可以自己试试(这个比较好理解)。
3、当函数默认参数遇上函数重载会发生什么?
例如下面的两个函数:
int func(int a, int b, int c =0)
3 ~. @8 p3 J) u, C/ L: c" b& b# S{
; X; T7 V/ ~) x: ~9 Y/ W* s( R    return a*b*c;( I9 [# G; T6 S9 c) B
}. ^! a+ X, L9 i6 |0 E4 o1 m0 w0 h
int func(int a, int b)  `2 p  }- X! o8 c& j
{
4 b+ p$ ^( \" _; s; L3 i3 ?! t7 I   return a+b;- U0 b0 \# K& q8 n. d
}
; ]' t) t( C: o; d) M, z% t( y( M

  |, j0 O$ u% K
到底会发生啥,我们还是看下面这个实验:
#include <stdio.h>1 W  Q& [. _! `4 z' V, s5 a

; P7 M8 h4 [0 k. a+ v: i: ^& K- p% H2 ~int func(int a, int b, int c = 0)
  t% H( C' _. ~. U& [{
& ~- N( E" M2 P" g9 P    return a * b * c;% `$ d+ \( s- I
}
8 d+ v  l1 V3 o) h) J, j7 a
4 D" W/ K  Z- a, @) T. xint func(int a, int b): f# U8 s% L4 T3 t, R7 @
{
( {. {0 E' ?( m2 D, J    return a + b;- C" N+ Q  i9 V. _. d( B
}( a! K( |: c2 p, f: ]6 e

- h2 f' [0 W, g$ E6 }1 V4 ^
# L6 Q8 ]) }" u- Zint main(int argc, char *argv[])6 @  |; X/ u: M' X0 y, L& L9 Y
{: T, L! J% Z; M3 a) {
    int c = func(1, 2);- h) Z, f, n, B1 j# ~
    $ H, y8 T9 P. z( ?4 D- m+ u  ~
    return 0;
3 D5 `% q: O, y}1 K3 a, [4 x6 L" \8 p4 U
" A7 ~# H0 z4 ^$ i4 ]
运行结果:
root@txp-virtual-machine:/home/txp# g++ test5.cpp
7 k; h/ v, a/ c% f, B% {* Rtest5.cpp: In function ‘int main(int, char**)’:
! V; i" Z! I8 _5 N4 K/ T/ E. `test5.cpp:16:22: error: call of overloaded ‘func(int, int)’ is ambiguous
" `, p) D, i4 n2 }* R0 P1 _$ m9 S' ~     int c = func(1, 2);
8 r0 x# J. P/ a                      ^
' `1 U9 s! \! ^6 `- Etest5.cpp:16:22: note: candidates are:
3 x' ?, \$ V4 T  t$ h9 T* R! e2 ftest5.cpp:3:5: note: int func(int, int, int)
% q: y) Q4 V0 j: _; ]6 }  l2 d8 N int func(int a, int b, int c = 0)% ~5 h+ k4 a3 o) _3 {" H. j1 s
     ^
! @2 z2 @3 m1 w* ftest5.cpp:8:5: note: int func(int, int)
# v$ b/ o; x7 B" _' I' ^& O3 {$ [ int func(int a, int b)  @' x! F7 U6 b8 d+ x5 P

# \# D; p; D2 J5 Z1 {) t2 j
从上面报错的结果里面有一个单词ambiguous(意思是梦棱两可的),也就是说默认参数这种使用时不允许的。
4、C++编译器调用重载函数的准则:
  • 将所有同名函数作为候选者
  • 尝试寻找可行的候选函数:
  • 精确匹配实参
    * I( G0 L( [+ ?$ i6 m6 B* a1 _1 n
       通过默认参数能够匹配实参
      通过默认类型转换匹配实参
  • 匹配失败:
    9 W' E$ E, v$ D4 q. ?, T5 h
      最终寻找到的候选函数不唯一,则出现二义性,编译失败
      无法匹配所有候选者,函数未定义编译失败
5、函数重载的注意事项:
  • 重载函数在本质上是相互独立的不同函数
  • 重载函数的函数类型不同
  • 函数返回值不能作为函数重载的依据
  • 函数重载是由函数名和参数列表决定的
    / I/ g2 C3 r+ A* u
代码测试:
#include <stdio.h>% X/ J0 |6 \7 d0 v$ ?. e
  ~5 y+ Q3 H0 \( _  K. t/ d
int add(int a, int b)  // int(int, int)- K$ @* d7 }2 f3 \" N( M
{
! _: b0 k. S( G# {" K' d8 C+ K    return a + b;
; h) c  L( T% Q9 E' s* L! E}
4 D- S5 `7 f) a  o, m6 l6 q$ P% j. J
int add(int a, int b, int c) // int(int, int, int)0 E% G8 W' K5 o5 P* U
{
$ U) w: }0 u, z" D# o! G" y    return a + b + c;* j; ?! K+ p" M6 C  K4 S
}
% l8 {" G: x" R- ^/ C+ {
! B9 V6 L$ c- R5 sint main()
1 V5 {+ m  }' S4 k8 ^{/ W4 q+ e( w6 \
    printf("%p\n", (int(*)(int, int))add);$ h# E5 ]6 N+ ^7 M2 X. c2 |/ a7 i
    printf("%p\n", (int(*)(int, int, int))add);
7 Y* y6 m( D% q9 e" v2 I9 {1 b$ ?% W6 Z3 J" T& X/ M
    return 0;1 o# `# m& p" e
}

& i) z" z0 \$ T0 I5 P
运行结果:
root@txp-virtual-machine:/home/txp# ./a.out
( |! F; b, y6 L: T0x40052d, J5 G' q5 s' E! S: J& w( O
0x400541& {7 J3 l* ~7 ?# c, V

) O! q+ a' G9 Y( A% i$ b$ l; M
从输出结果我们可以看出这两个函数的入口地址不一样,这表明这两个函数是不同的函数。
6、小结:
  • 函数重载是c++中引入的概念
  • 函数重载的本质是相互独立的不同函数
  • c++中通过函数名和函数参数确定函数调用
    : t/ h% k7 O) m# A% l! T) A
二、重载函数进阶学习
1、重载与指针:
下面的函数指针将保存哪个函数的地址?
int func(int x)
9 j, i  d/ w7 W6 A" p, z- W0 J{, a# C% q" G- u% q5 l
    return x;$ w7 c1 ]5 t' ~8 Z6 M( T6 K' c" b1 L3 ?
}! _; {; r: m: I8 j$ X/ M0 |
int func(int a, int b)9 f% _' Q; b( E& N( h: i
{
2 v3 j" _+ o- x2 \* S    return a+b;
- [+ `. j- J7 `) x4 B9 E: [}
4 P9 L. D+ T# T8 F; ^% Iint func(const char* s)
4 L: j8 ]/ W& ^, z4 e6 f* i{
) R  G5 S  ^$ p  return strlen(s);. g  |  V, O) }- u8 A. d
}
1 P: o% x2 ^/ s0 a0 D- |+ J- b3 m) f) F: g: B  ]9 v
typedef int (*PFUNC) (int a);
1 F8 t& B8 f+ i# G! J2 }
7 U! T% }. c5 w4 x, _int c =0;% }8 d9 k8 s3 l

" L5 O- Z; R, D  pPFUNC p = func;1 z( X2 S7 l, B$ [- K  w, s/ a+ ]. c5 d
, H8 x- k% \. b6 A8 c. g
c = p(2)//到底选择哪个func函数
% T" K1 }- \! k" ~) W% @+ `3 B8 l
% q4 Z' z7 z. t3 f) X& k$ E$ k
函数重载遇上函数指针:
  • 将函数名赋值给函数指针时
  • 根据重载规则跳线与函数指针参数列表一致的候选者
  • 严格匹配候选者的函数类型与函数指针的函数类型
    ' }" J! a+ ?' r$ X% |1 ]
代码试验:
#include <stdio.h>
) }: m( U9 ?2 c# b- C  L#include <string.h>
2 H: B3 }- X! A8 e+ n2 O7 i7 y2 Z8 F3 f* q- R& @
int func(int x)
9 A% X* y+ d3 k  A# v: @5 r' h{5 X8 P: p, Z, D& D
   return x;
8 q% m7 O1 J$ o. i}/ V( C) a# a7 W1 Q
7 w+ {* |% E  c$ u
int func(int a, int b)
4 @- E. W. g* X! \# s% b' i{
8 r# i1 M0 @4 ^6 z     return a+b;5 m+ R3 g( u) I" a% D
}
2 o8 i9 B4 W1 m+ n+ d7 M
& u& O. d8 S( {, b. vint func(const char* s)8 j/ W& h4 l0 d* N8 Q0 V
{
  w( h& G5 s) {7 V! H9 x# r, _    return strlen(s);/ X8 H0 _+ d% Y1 J$ v' {3 W% w
}7 R4 A. K5 D' ~  P5 j
typedef int(*PFUNC)(int a);( x" b9 p1 L& b0 M. b' e
+ r) z4 F# E: V
int main(int argc,char *argv[])) \$ j) U+ Z8 g; Q8 j
{+ n3 e0 _3 i+ b/ k
     int c =0;  B& P' D1 h" V
     PFUNC p =func;4 r' @) P  q' t# E4 U5 y
* h+ a1 m$ b% o- D0 R2 j  Z3 Y
     c = p(2);+ R, J- X& R) v  j, L* }
     printf("c=%d\n",c);5 ~( {  k3 L* }; @" n
     return 0;# O4 t9 F0 M  o
}
/ B  V# E0 F+ ~  W7 |' w: S, p7 x7 L
. a! e9 J; p$ g/ k* l( ]3 y0 Z6 Z
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out' x1 K7 `; k" i3 ^2 Z, V0 [
c=2
4 i7 Y, I9 S, g1 N4 n
% K) s% C; E. G8 f+ |
从输出结果来看,很明显调用了第一个func函数。
2、注意:
  • 函数重载必然发生在同一个作用域中
  • 编译器需要用参数列表或者函数类型进行函数选择(也就是说碰到指针,要注意函数类型了)
    7 D& k, Z6 y, _$ E( N3 b  P
无法直接通过函数名得到重载函数的入口地址,这里还是通过上面的例子演示一下:
#include <stdio.h>
5 X! D3 g& z0 ?% C$ U. m7 g5 @. H3 N. {& Z- j5 \" o2 K+ P
int add(int a, int b)  // int(int, int)% R" N+ m8 z) ~
{; |( H+ ^4 g5 Y+ w9 W$ N
    return a + b;
4 G! `. ^+ ?5 u* E9 {$ J/ \2 F}
2 ]5 C4 h- j, L* _  h  E3 z
+ X# j# V" c' k4 E9 Uint add(int a, int b, int c) // int(int, int, int)1 H- n4 O' I# J: J8 `$ [  y* A
{
% G8 o! Y, R% A2 J    return a + b + c;
: C' R. m% }, ~- f( W7 n}1 @2 V4 U! ~2 t

% ~& H% @  l! yint main()
8 F  o2 Z& d3 ~{# h" h2 {1 y9 M" b4 D% |6 v
    printf("%p\n", add);
$ t7 B9 k5 r$ D' X. q! M$ I    printf("%p\n", add);4 {0 n; f2 l+ X$ w5 U  S0 s5 {
* t( o4 D6 o: E: e2 [
    return 0;
1 _4 I8 @: X- F}
6 W; I5 }: x: o) x5 M
输出结果:
root@txp-virtual-machine:/home/txp# g++ test5.cpp; ~6 W) _  T/ M, m9 F
test5.cpp: In function ‘int main()’:
6 |# E  ?# `* M6 ]test5.cpp:15:23: error: overloaded function with no contextual type information/ V/ _$ y; E7 a6 W) u
     printf("%p\n", add);
3 W! q4 q" n- K4 c# K& H                       ^
  J  C, c8 V9 T/ vtest5.cpp:16:23: error: overloaded function with no contextual type information: O. B2 p$ B0 U3 |& y
     printf("%p\n", add);' r# A  |+ c- T+ V
6 w6 J: M& G! R3 M
三、C++和C相互调用:
  • 实际工程中C++和c代码相互调用是不可避免的
  • c++编译器能够兼容c语言的编译方式
  • c++编译器会优先使用c++编译的方式

    5 L8 m0 \4 Y! K8 t
extern关键字能够强制让C++编译器进行c方式的编译:
extern "c"+ x) P* d3 K7 Q6 r2 Z
{- c! X9 H$ E3 B& p. V

+ n" h1 L3 [/ E8 Z6 F
+ a# f- R* z  O- b* G3 ]}# m9 t" r" U3 {

7 ]! Z; Q3 ?, |
1、下面进行一个c++中调用c函数,这里我在当前创建三个文件:add.c 、add.h 、main.cpp。内容分别如下:
add.c内容:
8 ^7 G6 ]+ h; h% Q
#include "add.h"
# O, V* k( h; Cint add(int a, int b)
( c0 k! I0 _0 `6 p' o5 R; F7 Q0 h& I* w, I+ y+ V# y
{# n1 J1 n/ i. S+ ^! _1 z! x

1 g  h6 X0 W+ g) l    return a + b;
/ b3 _& v" t5 `6 s5 S; U9 u  k1 ?$ }5 W( N9 \0 S
}
0 P/ j5 ]% o1 N
1 Y; [3 {* y7 d' P  ]+ b$ X  t
add.h内容:
int add(int a, int b);
5 @- Y* J; b0 M- @, d- h0 e, H
然后我用gcc编译编译生成add.o文件:
root@txp-virtual-machine:/home/txp/add# vim add.c
" s7 O! |* M, h) K: T3 t, qroot@txp-virtual-machine:/home/txp/add# vim add.h
) @# V  v0 X; l# _. P& u; troot@txp-virtual-machine:/home/txp/add# gcc -c add.c -o add.o$ u7 `; ]! Q/ h$ p. u0 a4 t
root@txp-virtual-machine:/home/txp/add# ls
  I7 r4 ^# p6 F+ v/ }; e& jadd.c  add.h  add.o& p  S- D( c0 E* _5 c0 ^

9 e8 [& _( V  M0 \1 d4 `
然后main.cpp里面调用add.c
#include <stdio.h>
! R5 ]; S# u9 |: ^: G/ o+ B* Uint main()% G7 X% L  v$ t$ O: k7 s; L
{
) x2 `0 {9 l2 x0 l: ]* e) [# ]    int c = add(1, 2);
1 A# P) h. I: i   
6 a, K7 v. S" H7 K: {# M" V    printf("c = %d\n", c);
5 C. |! m+ f1 i   
; v7 ^/ s4 s) W0 ^" V    return 0;- P( }7 B  ^- l3 F  Y
}
- E8 U1 ?  r' D1 B2 A
输出结果:
root@txp-virtual-machine:/home/txp/add# g++ main.cpp add.o
3 c9 T7 X  ?7 s7 Z/tmp/ccqz3abQ.o: In function `main':4 I- V# _/ J, a: _( H) N4 d
main.cpp.text+0x13): undefined reference to `add(int, int)'
# g/ W. p8 P/ r  C3 tcollect2: error: ld returned 1 exit status. Z3 w) M' y6 m7 o( e
4 n; s$ \3 b: F( R: q
6 l6 |) p- F5 w  v5 d4 A/ B5 I! l
结果显示找不到这个函数,为了能够在c++里面调用c语言里面的函数,我们就要使用刚才上面讲的第四点了;这里我们先用nm命令来查看一下add.o文件里面是否生成符号表(有生成):
root@txp-virtual-machine:/home/txp/add# nm add.o3 o, I1 l& f1 V
0000000000000000 T add) J1 l1 k4 l+ `3 G

6 _6 M2 T# G) B0 y4 |/ [
解决方法,main.cpp改成:
#include <stdio.h>
) j2 \( O5 f. Y. {8 {' `
" S' i7 A, V" X& M; Uextern "c"
0 l2 o$ H: O5 E6 p; |: L% F4 x{# J3 b0 d+ G# Z% c( }* v" `
    #include "add.h"
! N$ y8 p, j  I% k0 l* k
* E9 [8 N5 D6 D8 [0 u}
; D$ w& g4 o# \/ N+ |' l9 c; @
2 y, k& P* J& l: O$ U$ X
% K+ g9 `  f4 pint main()
, J  {* ^2 {( M& a& b7 U3 l7 u; y5 z{
5 m! u  D5 E6 u8 ]1 w: L0 R' i    int c = add(1, 2);5 ]5 M  O( C' g, c; j
    & n1 z' Y0 M9 s  ^  P
    printf("c = %d\n", c);2 H7 u8 A1 U* X

+ l  t9 r# G) \; j& V5 ]    return 0;
1 c3 _% b3 r6 N$ X" v3 K}& F, y' o- L4 e1 v

7 k0 V) j! ^/ _2 z: @9 m
输出结果:
root@txp-virtual-machine:/home/txp/add# ./a.out
1 h* R! x* l% {2 S( Jc = 3
) v% d/ d' w- `8 Q, L
6 x4 K, E5 l8 R! \( x& n/ v
2、c中如何调用c++函数:
这里我把main.cpp的内容改成:
extern "C"
. Z& Y2 x8 t/ |; w: r1 j8 U# I{, v9 v6 A% F, ?! r
   int add(int a, int b);: z9 m' f) a) d: [. @8 E

- D) p1 P" N5 X: H: N4 k}
, p) c- e3 v! |5 ?0 Y! h" d8 d" d% }$ |& [/ L+ L' e; F, S
int add(int a, int b)  V- T( r3 B* A
{. l" `8 R3 b! d# M
    return a+b;    : M8 o, k( j+ w
}
% A5 r: B" T+ v( i" X" o$ V3 ^. o
" B! v! n# p% o* T+ w4 r' B# V+ f. x6 V
编译输出:
root@txp-virtual-machine:/home/txp/add# g++ -c main.cpp -o test.o! S  ?5 n( U" L3 ]
root@txp-virtual-machine:/home/txp/add# nm -s test.o' k3 m( {* w5 l9 L+ n+ ], U
0000000000000000 T add
1 @* o1 q1 T+ }1 d; Z  Q$ `" a9 o2 j1 g
4 j) G! X8 U- k% M, B; I
add.c文件内容改成:
#include <stdio.h>
; I  p1 `2 W  }& I$ z& C: C9 T: Hint main()
" m+ G0 z/ |1 `{
- S' Q1 l) m/ d0 K     int c =0;7 k' C7 r/ o# _( p
     c = add(2,3);
3 m" @) B6 z6 C( a0 u+ B2 F1 r6 I     printf("c=%d\n",c);8 M0 X4 L. `5 X! Z' h( [
     return 0;
7 j8 C4 O4 Q7 k) [: m* {) }$ h}
) @! W' J  s4 J/ C" t
输出结果:
root@txp-virtual-machine:/home/txp/add# gcc add.c test.o
; S; _& }: r3 D! croot@txp-virtual-machine:/home/txp/add# ./a.out. ]3 D2 I0 S$ Y/ J0 ?9 [7 G# r
c=5* M! j# Z1 x$ l' ?$ x; |' m

- B7 U) I0 V1 i2 }6 G: f
3、如何保证一段c代码只会以c的方式被编译?
解决方法如下:
  • __cplusplus是c++编译器内置的标准宏定义
  • __cplusplus的意义,确保c代码以统一的c方式被编译成目标文件

    9 U; M/ n5 k7 e# j
#ifdef __cplusplus
' g3 H( \6 U) }6 O! |2 A7 ~1 iextern "C"; Y# ?$ @9 v* q$ Z3 d
{5 p) Q& X) }- D2 G
  #endif) s) _3 O3 u0 L7 E" C" @

. |8 P8 i4 y9 }( h3 \" I  #ifdef __cplusplus7 ^9 |- o" x6 }# H: T! W
}& g  H( R! T" h7 I4 e2 v, G1 y7 f, I+ {
#endif
4 ?. Y: h" s" y4 T5 o$ W% h& ^
这里把main.cpp改成:
#include <stdio.h>
& W8 `/ q+ U' ~5 ]& r% g, L
& h: s5 j8 ~1 o6 t' y#ifdef __cplusplus
  L8 L5 z4 n& ^, P. fextern "C" {
. m/ J! o& ^" e* b# z#endif
- R+ R" l( r: i7 M8 H" Y4 C& A
2 z& h, j# P7 M! @! g4 j  |7 {: v6 |#include "add.h"
$ w% U. v/ D8 y
1 G7 ~1 ^6 |* q+ `#ifdef __cplusplus# ~  B2 v( F$ x9 h
}
. g+ j9 ?* X* j$ w( k0 d#endif" H0 g/ M6 K1 ^: o/ ]2 \! v

, u: f2 i; _4 Oint main()
3 }% |  ^% I+ s! o{
; C  l* U2 X( S& i1 M2 h5 A    int c = add(1, 2);
1 X% s& b3 S) w. f# n! l   
2 Q6 @( B; k2 Q0 U    printf("c = %d\n", c);
- @) w7 `9 l# ^. s1 U    0 _- I8 K3 w# A2 i
    return 0;
, w$ _% G  A( q/ `1 u}

; v; K6 I: }% X  v) g
输出结果:
root@txp-virtual-machine:/home/txp/add# g++ main.cpp add.o
( T; F  l0 j; a5 D3 froot@txp-virtual-machine:/home/txp/add# ./a.out
* r% Z# a- P" @# Y" s, \6 d! Nc = 37 \5 r1 c3 H# V. Z- Z, a# m

7 n2 G# G3 V' j7 u/ d5 ]! e
4、注意事项
  • C++编译器不能以c的方式编译重载函数
  • 编译方式决定函数名被编译后的目标名
  • c++编译方式将函数名和参数列表编译成目标名,这里举个例子main.cpp:
    ' N8 J. ^. f# h& J4 Q% H- j
int add(int a, int b)
! l$ y, y" P1 E/ R: A! _{
9 c. y2 |+ v, M" ?- |  i0 y  return a+b;
7 E4 h  K# m% @3 ]) ^, u}
8 U* K  A% i, r$ M$ J4 K& }- r( f1 r/ g
int add(int a, int b , int c)/ C9 Q. a# c9 X$ K7 K
{6 ^1 x% S0 A4 _3 G2 ?3 M
   return a+b+c;* H8 X/ X* \, a
}

+ {3 X, P' Q) F: S/ R
编译输出:
root@txp-virtual-machine:/home/txp/add# g++ -c main.cpp -o test.oo
' {+ x0 M# K$ i3 ^. }; y9 p. ~9 Mroot@txp-virtual-machine:/home/txp/add# nm test.oo" {$ M+ L" U7 u: O' v1 k; ]
0000000000000000 T _Z3addii0 w3 M) {+ q, R5 Z
0000000000000014 T _Z3addiii
% G! E/ G& j+ s; p
0 q8 x& F4 V) Q* _; H+ p9 l
说明ii表示两个参数,iii表示三个参数
  • c编译方式只将函数名作为目标名进行编译,这里还是以main.cpp为例:
    0 R7 f) {( Z3 j& D. c1 E
extern "C"* @: Z, u& Y- k* V% a
{
) @  `; t8 F. R# j& T- ^) p% |   int add(int a, int b)
% |/ g6 H5 ~  y+ v1 E3 S6 y  {
0 n; y$ I" l' N       return a+b;" W, ]0 N' B: W0 W2 {" @& ~
  }& o7 o; v+ l) R% H
* j. p9 S" Z& G4 {( X
  int add(int a, int b , int c)
) _, G4 I8 a2 e! v+ x   {
" z: b- P4 d( }      return a+b+c;
0 U, ~% O( r6 Z9 F9 e1 b   }
& H$ n$ c  o% j3 q* \}
" E, V! s; R5 {

5 o" y, S4 M$ r3 N+ n: a3 B
输出结果:
root@txp-virtual-machine:/home/txp/add# g++ -c main.cpp -o test.oo: M" B& y8 T: l% X% K' t
main.cpp: In function ‘int add(int, int, int)’:  `$ [' N: t8 E9 p
main.cpp:8:29: error: declaration of C function ‘int add(int, int, int)’ conflicts with
. O7 N% {  {. T int add(int a, int b , int c)+ j# K$ ^4 k. h3 q
                             ^
. m' M$ A) w% Smain.cpp:3:5: error: previous declaration ‘int add(int, int)’ here/ s/ T5 Y+ w1 b! A
int add(int a, int b)
" V) Q4 H0 B- m3 j: n2 y

4 h7 p$ d1 W/ a. J. ~; @% z, S# X
目标名起冲突所以报错。
5、小结:
  • 函数重载是c++对c的一个重要升级
  • 函数重载通过参数列表区分不同的同名函数
  • extern关键字能够实现c和c++的相互调用
  • 编译方式决定符号表中的函数名的最终目标名
    2 k6 \+ T* q+ C+ r( M
四、总结:. d! R3 q, j# D' Z6 Z; T

& ]# B9 {( w4 e4 @5 o
好了,今天的分享就到这里,如果文章中有错误或者不理解的地方,可以交流互动,一起进步。
& @! w& O7 F: H0 e
赞 收藏 评论0 发布时间:2020-8-10 22:17

举报

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