一、类中的函数重载：

1、函数重载的温习：

• 函数重载的本质为相互独立的不同函数
• C++中通过函数名和函数参数确定函数调用
• 无法直接通过函数名得到函数重载函数的入口地址
• 函数重载必然发生在同一个作用域中
  
  . m$ e/ x; V; H9 P+ g

2、类中的成员函数可以进行重载：

• 构造函数的重载
• 普通成员函数的重载
• 静态成员函数的重载
  
  # P1 n% j2 K) l* t

这里有一个问题：全局函数，普通成员函数以及静态成员函数之间是否可以构成重载？

从上面回顾重载函数的知识中，我们要注意到一点函数重载必须发生在同一作用域里面（其他两点问题不大），所以的构造函数和普通成员函数是可以构造重载的，而与全局函数是不可以构成重载的。

代码测试：

#include <stdio.h>
* D0 y8 R1 E- N* |( f9 v
# ?* b) l7 L3 C; zclass Test
9 U: M+ f2 q( U# ~{
0 Y. V6 e6 K' g/ Z% G7 }1 w    int i;
# ^; e4 g. d: y5 Rpublic:
& e8 l8 a1 ~3 I. a1 \    Test()
    {
        printf("Test::Test()\n");
        this->i = 0;
    }
   
    Test(int i)
9 V% B( m7 S& a' U5 p    {
        printf("Test::Test(int i)\n");
) J9 D7 v0 j! Q, E: H- Y3 n7 Q* u7 m& j        this->i = i;
    }
   
% m5 ^; g1 g# }! {" S    Test(const Test& obj)
3 q: y+ _; q5 J9 A1 J    {
6 G& V! M- ^$ u5 f0 u% l5 m        printf("Test(const Test& obj)\n");
        this->i = obj.i;
    }
7 o. g8 ~6 |; k   
! u% e( Q8 T. T$ {$ d% x+ f    static void func()
    {
8 u2 C- C( G# J9 i        printf("void Test::func()\n");
  Q8 z" H  N, ?  ^  H    }
   
. n+ v; Q8 R7 n, T9 L    void func(int i)
7 k$ Z2 t/ f$ E  f2 O; H; }    {
        printf("void Test::func(int i), i = %d\n", i);
    }
   
. u- n4 }+ W7 Y: q  ~    int getI()
: p  p/ e/ F& j4 o6 A    {
        return i;
& p0 p- }& a1 a: E    }
% Y* z' x' K, X2 Z0 Q};
4 e- Y  y( {! F) |: ~, z" t. B
! b+ y4 F# p( i, ?; w; M: }% Cvoid func()
{
    printf("void func()\n");
- e! C+ W0 ?: q# U}

void func(int i)
3 {$ V0 ?  {, {+ z6 A{
    printf("void func(int i), i = %d\n", i);
}

int main()
{
    func();
' d) _/ h; [4 ~, t; V+ Z: G    func(1);
   
    Test t;        // Test::Test()
2 u; w: |: S' e/ T( k3 |% F    Test t1(1);    // Test::Test(int i)
    Test t2(t1);   // Test(const Test& obj)
   
    func();        // void func()
    Test::func();  // void Test::func()
   
    func(2);       // void func(int i), i = 2;
! e$ v- [' d5 |9 U    t1.func(2);    // void Test::func(int i), i = 2
    t1.func();     // void Test::func()
$ V) e/ Y9 E" g( M1 v   
    return 0;
}
) @- `' [! s- {2 J, ?
+ q1 Y2 T. T/ F5 [7 L" E9 M8 c

输出结果：

root@txp-virtual-machine:/home/txp# ./a.out
void func()
void func(int i),i=1
Test::Test()
Test::Test(int i)
2 }5 W  d! g4 L# G3 ~* }. LTest::Test(const Test& obj
: e3 F8 f* W1 `* B/ R* b: Mvoid func()
0 p/ e5 H7 i/ @2 n+ v3 yvoid Test::func()
! n; F; x& X) f0 U! {void func(int i),i=2
void Test::func(int i), i =2
void Test::func()

3、重载的意义：

• 通过函数名对函数功能进行提提示
• 通过参数列表对函数用法进行提示
• 扩展系统中已经存在的函数功能
  
  , U3 W  p. ]& D

这里用c语言里面的拷贝字符串函数strcpy来进行扩展演示：

代码版本一：

#include <stdio.h>
2 u0 z& D2 v0 l# L& j  c. g& L#include <string.h>
; D$ J7 Y& h- B2 ^2 }2 Y% p
8 {7 M$ l! U# `8 v, A- X6 aint main()
& ~2 `" K; n3 A9 F9 r{
    const char* s = "linux is great !";
/ j3 ?) l0 h; j1 w' J- K8 j    char buf[8] = {0};
7 F. Q; U' m; e   
/ c  ]2 M5 `; v* {    strcpy(buf, s);
   
   
+ ~; j/ t! Y. h0 m    printf("%s\n", buf);
1 u. ~+ @- a4 w$ _; k) P   
    return 0;
}

5 l) J$ ~% i+ X6 o  y

输出结果：

root@txp-virtual-machine:/home/txp# ./a.out
0 n' Z" r3 O# J' o) i$ M6 blinux is great !
*** stack smashing detected ***: ./a.out terminated
7 \. Q1 Z" b4 L+ q0 K1 ~1 xAborted (core dumped)
; X, v( m2 @( F8 _9 p4 |6 q, _

这里虽然结果是输出多了，但是这个程序同时也报了段错误，因为buf所能存储的能力小于s；所以为了解决这个问题，你肯定第一时间想到strncpy函数：

代码版本二：

#include <stdio.h>
2 X* e0 S' ]; O8 w8 A' H4 [#include <string.h>
5 W  h% ^( Q3 ?; k
' Z$ ]8 e8 f& c+ x$ Wint main()
{
    const char* s = "linux is great !";
  s5 M  y  p" b# H    char buf[8] = {0};
' z5 M' U; m0 E4 F2 l( A8 C   
    strncpy(buf, s,sizeof(buf)-1);
8 }4 y0 @+ {* q, y( i   
) N" r3 ]( p1 r% M   
. H/ Y9 @3 s* {    printf("%s\n", buf);
   
    return 0;
}
# |* f2 a% \+ J

输出结果：

root@txp-virtual-machine:/home/txp# ./a.out
& v6 k3 A# \; \3 H( qlinux i
  V& B8 r+ K. m, p2 d" H( i3 R6 X
& J+ p! A- b6 L/ S2 h8 A/ o0 I

这个函数就保护程序的安全性；但是我在c++里面既然学习了函数重载，那么久可以在原有的函数基础上进行扩展：

代码版本三：

#include <stdio.h>
#include <string.h>

3 H9 l' s6 F: L  f$ hchar* strcpy(char* buf, const char* str, unsigned int n)
{
' l$ d! p6 G( @% x    return strncpy(buf, str, n);
9 A4 M3 F& J9 Y  i& A# u2 `}
& K1 q3 f! }' Q2 k0 V; c
6 O$ O+ l" E6 A  m& B; ?% pint main()
{
    const char* s = "linux is great !";
    char buf[8] = {0};
   
2 C. _7 L4 T+ \6 A    strcpy(buf, s, sizeof(buf)-1);
& A$ S. h" E8 ^3 }- U   
& ]: @# J4 ~" w7 {5 R    printf("%s\n", buf);
9 R& z. d( D* K4 s8 F1 m& B) O$ c   
    return 0;
}
( x( Y$ b7 W8 C6 H6 s, g+ z8 K
$ J: @: R; h3 @

输出结果：

root@txp-virtual-machine:/home/txp# ./a.out
: i( M( R7 M/ @$ T* s7 Xlinux i
% I# k: M- q; o8 y: O

二、总结：

• 类的成员函数之间可以进行重载
• 重载必须发生在同一个作用域中
• 全局函数和成员函数不能构成重载关系
• 重载的意义在于扩展已经存在的功能
  
  4 Y, m1 M( m- e

好了，今天的分享就到这里，如果文章中有错误或者不理解的地方，可以交流互动，一起进步。

4 p. p9 a5 d8 a/ j