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

一、构造函数：

1、什么是构造函数？

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

#include <stdio.h>
1 p# X0 ]8 W# W5 R
class Test:
( k7 o  w+ {: E# a7 h{
( `( V% E% G& w3 e2 Y4 o; ~8 w8 O7 v   public:
        Test()
" V5 l8 L- E9 a0 @; S+ ]; g: w        {
. `. m) M3 L+ n          printf("Test()\n");
; y8 F6 @) g- Y; ?) G# o" x3 N# k6 [( l        }
" |9 W0 k3 u/ g2 V. P}
, ^  f: j) P1 u  {0 v  h- T

2、构造函数调用：

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

#include <stdio.h>
+ u: [* k2 ~" L7 k" _
class Test
/ F. }% H* i! M' M5 G1 b{
& f  d% _7 U+ v  {public:
    Test()
    {
        printf("Test()\n");
    }
9 \; J1 T7 c7 M, P' w   
};
3 |" z) t1 `) a
! n+ r$ [# d: y) x( hint main()
{
    Test t;      // 调用 Test()
    return 0;
' u" V/ @9 c% D9 n* h}
, N) `8 }1 M5 {5 x
+ G4 D# q; F/ r

演示结果如下：

root@txp-virtual-machine:/home/txp/c++# ./a.out
9 a2 x' W4 b( h# e( {, FTest()

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

二、带参数的构造函数：

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

class Test
; Z/ f, z* j. Y% e; H( \, R. C{
    public:
          Test(int v)
          {
         
8 C9 m6 q1 O, X  ]* `4 O( u+ a          }
};

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

#include <stdio.h>
8 B: r: q" s/ u4 {- t* \. p
8 T1 K% i5 x' p+ |class Test
; u3 b# v; M) x' I) r7 F1 U1 L! Q4 e{
private:
0 E9 X9 g9 ~4 ?5 P* h    int m_value;
public:
% Q" R0 u6 Y' ], E    Test()
2 b' Z" l" L' }: l  D    {
6 E6 t0 c2 i' h* p8 _5 U& h( W        printf("Test()\n");
        
        m_value = 0;
    }
    Test(int v)
    {
        printf("Test(int v), v = %d\n", v);
        
        m_value = v;
% S7 |5 [: X0 @( y    }
* g! E$ n# v2 _; `$ S! v# g4 o' ?    int getValue()
    {
        return m_value;
9 A% c  H% s# M- ~( p6 Z    }
7 \" P0 u! ]% `1 \( e};

, L, n  b. U. h3 x4 e9 }/ Pint main()
4 q5 D3 n, r( {- E5 G! U0 ~& ^; W{
% X2 I2 C3 ~3 A  N4 H    Test ta[3] = {Test(), Test(1), Test(2)};
   
6 D1 A# w$ T6 X3 Z    for(int i=0; i<3; i++)
9 G+ p" |9 ]" b7 c$ s0 w    {
        printf("ta[%d].getValue() = %d\n", i , ta.getValue());
2 S( {' B1 z  @    }
* I) B9 W8 ]: Z+ s2 u5 j   
    Test t = Test(100);
   
9 i; s% z; K. E, V    printf("t.getValue() = %d\n", t.getValue());
   
    return 0;
* B1 b0 y' O% e9 Z2 \; A/ z/ z}
$ _( M; W$ Z3 s) Q& p/ S+ q

演示结果如下：

root@txp-virtual-machine:/home/txp/c++# ./a.out
. T4 G5 w( D7 I# ~* @Test()
Test(int v), v = 1
' N: |! J; R* r$ X5 N/ \8 i- BTest(int v), v = 2
ta[0].getValue() = 0
, `* z+ t2 G, w8 R& Zta[1].getValue() = 1
% q* W# e& d6 L- N. R* Kta[2].getValue() = 2
" d& s3 Q; m! v' y# aTest(int v), v = 100
) h4 @$ k8 f3 bt.getValue() = 100
8 A: G: R; G" @+ P

三、实战案例：

需求：开发一个数组类解决原生数组的安全性问题：
& J+ `& Y7 y* [/ v  A) y# c
——提供函数获取数组长度
) @" P" l7 m7 \9 b* E4 T- o
; F/ @/ c; O# O* x——提供函数获取数组元素
. k6 z3 h8 ]% d: P' @4 I
& E: Y2 b- Z' T. Z) b# R, r——提供函数设置数组元素

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

#ifndef _INTARRAY_H_
#define _INTARRAY_H_
$ Z: [& r( j. _; f# M- R3 p& X4 l4 K
class IntArray
{
6 h( h# A! F, Z6 }6 w   private:
  l0 T; _; k2 Y# ^         int m_length;
         int* m_pointer;
, @0 s- O; V5 U. Z8 m   public:
         IntArray(int len);
         int length();
         bool get(int index, int& value);
         bool set(int index ,int value);
' B# D' p  T" w+ ?+ J% b         void free();
};
% ?& [* [9 @, A2 m+ F+ s
#endif
& @1 Q3 \5 t, ^) o! W
) _' ]/ Z, H. ^" v& A- m

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

#include "IntArray.h"
# k8 ~. V7 P( |  z" \
IntArray::IntArray(int len)
{
! T, L" b) b: E9 @8 _    m_pointer = new int[len];
   
    for(int i=0; i<len; i++)
    {
( y! `1 d9 R3 X0 c' ^' X        m_pointer = 0;
/ [2 l* z! T6 e- ]: @. P8 y    }
/ W* V8 W. a: J! W. T4 M" s6 W   
, C/ P- G# G  T+ J" c: Z    m_length = len;
}
6 U2 X* |) ~  U
  a: w3 F; P1 S% p$ }& kint IntArray::length()
, k5 r5 Z7 e' ~! ]+ X* C{
    return m_length;
}
3 w5 u  j6 I( v
bool IntArray::get(int index, int& value)
{
    bool ret = (0 <= index) && (index < length());
% B1 J  J/ V7 z2 c+ W5 V   
    if( ret )
7 D) r7 ?* T3 @1 x& B+ w    {
$ |9 T/ |3 j0 m% j& z+ t4 ?        value = m_pointer[index];
: V+ c4 t, c5 z! {    }
   
    return ret;
}

bool IntArray::set(int index, int value)
8 f% a* {; a( r4 A0 y5 L, J8 a{
    bool ret = (0 <= index) && (index < length());
; b* f) r& V3 `, H   
1 x& Q+ O# b+ q) e  X, Q    if( ret )
! V0 q8 Z4 s" }6 A7 P    {
        m_pointer[index] = value;
    }
   
1 S- D; g$ U/ T3 c    return ret;
1 \! ~% E) T& n. c+ h}

7 E7 u. X0 t$ |5 T7 c3 K3 m6 fvoid IntArray::free()
{
/ `- q' k2 A) m/ O    delete[]m_pointer;
7 z  B% O4 Y3 C& f" K}
" }4 I" U" ?/ C  x- ~

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

#include <stdio.h>
#include "IntArray.h"

; [& j6 _! h3 K* q+ w; [int main()
8 b8 q7 i; H4 R+ D{
/ H$ A- b) `7 _8 o    IntArray a(5);
8 H) q* K) b2 N9 k) I   
  o- s6 V" A& t- M  W8 F    for(int i=0; i<a.length(); i++)
1 y$ c1 v, _  d- A" A6 ]' X    {
        a.set(i, i + 1);
- N" [) N' V3 {' p    }
5 Y: B7 O% l% j7 R' r$ X   
. a+ q( u: t8 ]' V+ l& A2 \    for(int i=0; i<a.length(); i++)
4 |2 k7 p% M4 _5 @$ ?    {
        int value = 0;
% b5 j+ h$ {/ K% Z' Q+ ~. [        
3 d4 U- X" O# i- h- M        if( a.get(i, value) )
4 f2 O$ A' P' q3 C2 K  `( Z        {
            printf("a[%d] = %d\n", i, value);
        }
    }
, Q3 S1 [4 {$ ~: }* n  ]! }9 W3 X   
) a3 b6 ?7 q, T0 P6 x  {/ Q    a.free();
1 Q- h4 U8 x" @( y8 T   
: j, _2 m# F7 p" h. B' O    return 0;
. o" z& `4 `6 ^6 S# |$ o! k}

最终演示结果：

root@txp-virtual-machine:/home/txp/c++# ./a.out
a[0] = 1
5 {* r/ j  Z- G2 U# Y$ \3 h, Za[1] = 2
a[2] = 3
a[3] = 4
a[4] = 5
$ ^( Y. O9 L& P# g! E5 p6 A- Q

小结：

——构造函数可以根据需要定义参数

3 l8 [. C( a) y( B- l- @$ C$ K/ v' y——构造函数之间可以存在重载关系

9 L# C" F* O5 l" y0 M——构造函数遵循C++中重载函数的规则
; W; K$ g8 p. T; H; h/ m. u% F; q
——对象定义时会触发构造函数的调用
3 R( ]! U; B' Z9 ^
——在一些情况下可以手动调用构造函数
+ X2 }4 \0 G' q8 w/ i
& D; }6 X) D& u  ]& z& Z, [" A- Q

四、总结：

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

谢谢分享
7 W' Y7 G8 ?( Z+ c