大家晚上好，今天给大家分享的是c++中的构造函数，这段时间可能分享c++、Uboot、linux内核的文章会比较多一点，自己的拖延症太强了，得改掉这个坏习惯来。每天进步一点点，日积月累你也是专家。

一、构造函数：

1、什么是构造函数？

关于这个构造函数，简单理解就是在一个类中，有一个函数，它的函数名称和类名同名，而且这个构造函数没有返回值类型的说法（  Test()这个函数就是构造函数了。）：

#include <stdio.h>

class Test:
; |* S, `# o; G  d% Q# w7 y; W{
   public:
" w, _; f, s& J8 O" X! N        Test()
        {
          printf("Test()\n");
: e4 F. P; l3 S        }
}
+ P: `5 A6 x7 [+ r

2、构造函数调用：

（1）一般情况下，构造函数在定义时自动被调用（主要作用就是自动去初始化类中的属性，这个属性通俗一点来说，就是我们所说的变量。而且这里的自动的意思，就是说当你创建了一个对象后，它就会自动调用构造函数，不用你再去main函数里面写构造函数了。）：

#include <stdio.h>

class Test
{
9 y6 u. r7 D" `) Spublic:
% ?6 J" ?8 [  B; r1 K9 u    Test()
  N" c+ c4 }1 m( `# Q: l0 j    {
        printf("Test()\n");
% i/ g8 S5 Z; F) B/ P2 w7 E    }
   
! B9 a; B) X$ K  T4 g};

int main()
; M' ^  ^' B" q( @{
    Test t;      // 调用 Test()
! \) Q- E7 }* h    return 0;
}
5 n9 A5 w4 Q* d' O$ T/ Y

演示结果如下：

root@txp-virtual-machine:/home/txp/c++# ./a.out
Test()

（2）一些特殊情况下，需要手工来调用构造函数（这个在下面带参数的构造函数里面会有一个案例分析）

二、带参数的构造函数：

(1)构造函数可以根据需要定义参数。

class Test
{
    public:
          Test(int v)
& \& g$ t4 C1 L+ A          {
         
) X; }6 t& K/ A% t3 I          }
};

(2)一个类中可以存在多个重载的构造函数（什么重载函数，简单来说，可以同函数名，但是它的传参类型或者返回类型不同就是重载函数了。）下面来看一个具体带参构造函数案例：

#include <stdio.h>

class Test
) N$ K5 K1 k& I' ?7 Y{
* ]7 @) t: N% f% zprivate:
    int m_value;
: B" v+ p% m, [" R" P  H) o) spublic:
$ h2 m; p1 l* W0 `$ ]7 D    Test()
' |4 S/ }9 j. w    {
! h% g( @3 R, U7 h3 u# b1 V6 y        printf("Test()\n");
- N- \3 u; {; c0 v        
        m_value = 0;
5 w3 b5 Z' [) W- N+ @    }
1 {, z! E5 T$ \' I# r! F; O9 i    Test(int v)
    {
        printf("Test(int v), v = %d\n", v);
        
        m_value = v;
) a8 b1 z9 k, c+ m4 Z    }
/ i& _% o1 y( L3 o/ y9 r( X( A    int getValue()
    {
        return m_value;
, l/ `. a2 l. l0 G6 ~; K    }
. N3 k3 X2 C2 {3 R' U9 Y: [};
( d; k# g) R0 N9 P0 T) a7 ~6 h* E  Q
int main()
{
    Test ta[3] = {Test(), Test(1), Test(2)};
$ E8 d. U' ~7 p- J- ]0 P2 Q   
2 h8 L9 u$ X4 x! t, B2 X! i    for(int i=0; i<3; i++)
; [$ }; A  F0 \    {
" m+ v! Z& S8 T8 G( z/ V' P        printf("ta[%d].getValue() = %d\n", i , ta.getValue());
    }
; ^& ~1 n3 E' X0 G5 s+ I+ S) Z; I5 L   
; R, ~2 p4 D# L, M# D    Test t = Test(100);
! D" a1 n/ t/ v1 l   
9 F  Q) U0 r! S8 S3 T; V    printf("t.getValue() = %d\n", t.getValue());
   
    return 0;
) u7 y0 l5 ~2 S* g, {}
; g0 w7 O1 N! F+ A8 |& `
/ ^  b5 L/ _6 W2 }$ m

演示结果如下：

root@txp-virtual-machine:/home/txp/c++# ./a.out
+ \9 a$ a6 U& g) {7 OTest()
Test(int v), v = 1
: ~) i/ G9 m2 h* w/ D/ wTest(int v), v = 2
  _& n- j2 |/ }' P7 A6 s0 {ta[0].getValue() = 0
ta[1].getValue() = 1
( W  }3 f6 Y3 d# Z$ e) Mta[2].getValue() = 2
Test(int v), v = 100
; @$ {1 A5 M$ _7 F+ @' Gt.getValue() = 100
1 W* _& c* G! y$ ]* {+ q- D3 l

三、实战案例：

需求：开发一个数组类解决原生数组的安全性问题：
+ m! r4 u& l3 _
——提供函数获取数组长度

5 `# a5 F3 f. A$ I, e——提供函数获取数组元素

4 Z: r* p. R& b# j' \/ R% Z1 v——提供函数设置数组元素

接下来我们先来写头文件IntArray.h，数组类就包含在里面：

#ifndef _INTARRAY_H_
: w, p( {: q$ K#define _INTARRAY_H_

class IntArray
2 j; ~% X# S( n/ Q2 i{
   private:
$ K: i! K  Z5 g% I) V         int m_length;
7 T" v3 q) a0 c2 p9 k* v+ r         int* m_pointer;
   public:
         IntArray(int len);
7 E" @5 E4 m. N- m         int length();
         bool get(int index, int& value);
* z1 y7 _1 }5 }4 A6 ?( @0 K0 q         bool set(int index ,int value);
% \+ A0 Z4 i: m9 F, s         void free();
};

7 T* P& [8 ~2 H4 Q% O7 P: b#endif

) u, a7 l2 N4 z6 K

然后接下来写IntArray.cpp，也就是类的方法具体实现了：

#include "IntArray.h"
; F' `7 P  j, ~+ `3 L* M+ H
IntArray::IntArray(int len)
{
    m_pointer = new int[len];
# q3 i7 Y4 |- C# i   
" J" d" J# d8 s% w: I$ E    for(int i=0; i<len; i++)
    {
" a, m% d1 i  `, w: E        m_pointer = 0;
    }
4 \/ i! R5 w" |0 H   
( l* I7 K- I" s    m_length = len;
}

int IntArray::length()
  u6 Y0 A( n5 t0 j{
& e# C$ j' E7 t) \6 n    return m_length;
) ]: p4 A' ~; ~}
( g1 Y7 _1 h, ?9 O& M! X2 p
bool IntArray::get(int index, int& value)
{
    bool ret = (0 <= index) && (index < length());
   
    if( ret )
    {
" I% S4 H* b5 T, W+ Y/ h3 X        value = m_pointer[index];
4 s6 G# v& @2 C. a/ F6 X2 f% W    }
3 t* i, p. c) U/ U1 ?/ p1 J   
% @" a- u, r( p( A9 J( c  p4 }    return ret;
}

, \  Z1 C, t3 I5 _& m# z( u5 [6 j0 G9 gbool IntArray::set(int index, int value)
" M+ Q: I0 ]  G! m{
) T1 @2 C. I7 u    bool ret = (0 <= index) && (index < length());
   
1 ?, [9 k/ t) m8 T    if( ret )
    {
        m_pointer[index] = value;
    }
' b0 Z. r: U( ^   
$ T, C$ y0 R6 r8 C0 Z+ c    return ret;
}
. p9 F5 a, M( C( y
void IntArray::free()
{
; I1 l0 Q# L, u; v    delete[]m_pointer;
  o  y3 @3 g0 I2 \}

最后就在main中来创建对象，来实现所需功能：

#include <stdio.h>
#include "IntArray.h"
7 G8 B- a* B- ?7 G1 r. z3 {0 `, U
int main()
{
    IntArray a(5);
5 a4 [5 n2 Q( V/ d) |   
, [6 V3 H/ [& x0 Z    for(int i=0; i<a.length(); i++)
    {
: N$ f4 T7 s8 q3 \( j8 y        a.set(i, i + 1);
    }
4 W' {0 q& |) e2 u   
    for(int i=0; i<a.length(); i++)
    {
        int value = 0;
        
        if( a.get(i, value) )
9 f* K2 N1 k! u& c# P, G        {
            printf("a[%d] = %d\n", i, value);
/ t5 ~0 }% C& o& I2 }, w* r        }
) g# N' j/ ]! f% n2 G; |9 |    }
   
; f7 S  V, z. Q/ s4 {+ ]    a.free();
* o- w. u# ?* S7 q) |+ E/ u9 T1 q# I# z   
: b1 \/ L6 w7 m3 d+ h    return 0;
3 `, Z) c; t( X/ Z4 ~/ I  |}

最终演示结果：

root@txp-virtual-machine:/home/txp/c++# ./a.out
. r: l: n; V4 ~/ f1 v8 fa[0] = 1
' t" x! |* o+ u1 ua[1] = 2
a[2] = 3
; _" f4 M" l. s  o( Sa[3] = 4
1 m$ W6 Q' ~3 P+ O* Y1 b  |: u6 Va[4] = 5

  w- P* N" m  o* o9 r& |

小结：

——构造函数可以根据需要定义参数
8 {( j/ b) _% Q  d# Q. E
——构造函数之间可以存在重载关系
# X7 ~& U. n6 d6 W& P
2 ^1 B. d$ f  s) ]* O6 v1 X——构造函数遵循C++中重载函数的规则

+ c0 [# |# a) F9 i5 Y——对象定义时会触发构造函数的调用

$ e5 T8 a6 d; ~" ?0 A* x! Y" |——在一些情况下可以手动调用构造函数
7 n2 s+ o) ~3 }$ I

四、总结：

通过上面的学习，我们大概对构造函数的使用有了一个比较清楚的认识，不过要掌握的更加牢靠，还是通过更多的动手练习哦！。

. n9 L$ d: {1 H0 d

谢谢分享