【C++】 27_二阶构造模式

构造函数的回顾

• 关于构造函数

  • 类的构造函数用于对象的初始化
  • 构造函数与类同名并且没有返回值
  • 构造函数在对象定义时自动被调用

问题

• 如何判断构造函数的执行结果？
• 在构造函数中执行 return 语句会发生什么？
• 构造函数执行结束是否意味着对象构造成功？

答：

• 无法判断
• 构造函数立即返回结束
• 构造函数执行结束并不意味着对象构造成功

编程实验： 异常的构造函数

test_1.cpp

#include <stdio.h>

class Test
{
private:
    int mi;
    int mj;
public:
    Test(int i, int j)
    {
        mi = i;
        
        return;               // 注意这里！
        
        mj = j;
    }
    int getI()
    {
        return mi;
    }
    int getJ()
    {
        return mj;
    }
};

int main()
{
    Test t(1, 2);

    printf("t1.mi = %d\n", t.getI());
    printf("t1.mj = %d\n", t.getJ());

    return 0;
}

第一次输出输出：【无警告，无错误】
t1.mi = 1
t1.mj = 16068596   
第二次输出输出：【无警告，无错误】
t1.mi = 1
t1.mj = 4145140
第三次输出输出：【无警告，无错误】
t1.mi = 1
t1.mj = 16068596

分析：
t1.mj 为随机值

结论

对象的诞生与构造函数是否被执行没有任何关系。
t虽然执行了构造函数，但构造函数内部是有问题的，导致 t 的初始化状态不确定，但并没有影响 t 对象的诞生.

不优雅的解决方法： test_2.cpp

#include <stdio.h>

class Test
{
private:
    int mi;
    int mj;
    bool mStatus;
public:
    Test(int i, int j) : mStatus(false)
    {
        mi = i;
        
        return;
        
        mj = j;
        
        mStatus = true;        // 注意这里！
    }
    int getI()
    {
        return mi;
    }
    int getJ()
    {
        return mj;
    }
    bool status()
    {
        return mStatus;
    }
};

int main()
{
    Test t(1, 2);
    
    if( t.status() )
    {
        printf("t1.mi = %d\n", t.getI());
        printf("t1.mj = %d\n", t.getJ());
    }
    else
    {
        printf("Structural abnormality...\n");
    }

    return 0;
}

输出：
Structural abnormality...

本质：
强行让构造函数有一个返回值，并且手工调用 status() 判断返回状态

你该知道的真相

• 构造函数

  • 只提供自动初始化成员变量的机会
  • 不能保证初始化逻辑一定成功
  • 执行 return 语句后构造函数立即结束

真相的意义

• 构造函数能决定的只是对象的初始化状态，而不是对象的诞生！

半成品对象

• 半成品对象的概念

  • 初始化操作不能按照预期完成而得到的对象
  • 半成品对象是合法的 C++ 对象，也是 bug 的重要来源

编程实验： 半成品对象的危害

#include <stdio.h>

class IntArray
{
private:
    int m_length;
    int* m_pointer;
public:
    IntArray(int len)
    {
        // m_pointer = new int[len];
        m_pointer = NULL;           // 模拟内存申请失败 ！ 
        m_length = len;
    }
    void set(int index, int value)
    {
        m_pointer[index] = value;
    }
    void get(int index, int& value)
    {
        value = m_pointer[index];
    }
    int length()
    {
        return m_length;
    }
    ~IntArray()
    {
        delete[] m_pointer;
    }
};

int main()
{
    IntArray a(5);
    
    printf("a.length = %d\n", a.length());
    
    a.set(0, 10);

    return 0;
}

输出：
a.length = 5
段错误

问题：

对于类的使用者来说并不关心或者熟悉类的内部实现,同时未给出类状态的判断方法；
内存申请只在极少数情况下会出现申请失败的情况。
这会带来极大的困扰并十分难以调试！！！

二阶构造

• 工程开发中的构造可分为

  • 资源无关的初始化操作

    • 不可能出现异常情况的操作

  • 需要使用系统资源的操作

    • 可能出现异常情况， 如： 内存申请，访问文件

• 二阶构造示例 一

class TwoPhaseCons
{
private:
    TwoPhaseCons()   // 第一阶段构造函数
    {
    }
    
    bool constrcut() // 第二阶段构造函数
    {
        return true;
    }
public:
    static TwoPhaseCons* NewInstance();  // 对象创建函数
};

• 二阶构造示例 二

TwoPhaseCons* TwoPhaseCons::NewInstance()
{
    TwoPhaseCons* ret = new TwoPhaseCons();
    
    // 若第二阶段构造失败，返回 NULL
    if( !(ret && ret->constrcut()) )
    {
        delete ret;
        ret = NULL;
    }
    
    return ret;
}

编程实验： 二阶构造初探

#include <stdio.h>

class TwoPhaseCons
{
private:
    TwoPhaseCons()   // 第一阶段构造函数
    {
    }
    
    bool constrcut() // 第二阶段构造函数
    {
        return true;
    }
public:
    static TwoPhaseCons* NewInstance();  // 对象创建函数
};

TwoPhaseCons* TwoPhaseCons::NewInstance()
{
    TwoPhaseCons* ret = new TwoPhaseCons();
    
    if( !(ret && ret->constrcut()) )
    {
        delete ret;
        ret = NULL;
    }
    
    return ret;
}

int main()
{
    TwoPhaseCons* obj = TwoPhaseCons::NewInstance();
    
    printf("obj = %p\n", obj);
    
    delete obj;

    return 0;
}

输出：
obj = 0x8070008

编程实验： 数组类的加强

IntArray.h

#ifndef _INTARRAY_H_
#define _INTARRAY_H_

class IntArray
{
private:
    int m_length;
    int* m_pointer;
    
    IntArray(int len);
    IntArray(const IntArray& obj);
    bool construct();

public:
    static IntArray* NewInstance(int length);
    int length();
    bool get(int index, int& value);
    bool set(int index, int value);
    ~IntArray();
};

#endif

IntArray.cpp

#include "IntArray.h"

IntArray::IntArray(int len)
{
    m_length = len;
}

bool IntArray::construct()
{
    bool ret = true;
    
    m_pointer = new int[m_length];
    
    if( m_pointer )
    {
        for(int i=0; i<m_length; i++)
        {
            m_pointer[i] = 0;
        }
    }
    else
    {
        ret = false;
    }
    
    return ret;
}

IntArray* IntArray::NewInstance(int length)
{
    IntArray* ret = new IntArray(length);
    
    if( !(ret && (ret->construct())) )
    {
        delete ret;
        ret = 0;
    }
    
    return ret;
}

int IntArray::length()
{
    return m_length;
}

bool IntArray::get(int index, int& value)
{
    bool ret = (index >= 0) && (index < length());
    
    if( ret )
    {
        value = m_pointer[index];
    }
    
    return ret;
}

bool IntArray::set(int index, int value)
{
    bool ret = (index >= 0) && (index < length());
    
    if( ret )
    {
        m_pointer[index] = value;
    }
    
    return ret;
}

IntArray::~IntArray()
{
    delete[] m_pointer;
}

main.cpp

#include <stdio.h>
#include "IntArray.h"
    
int main()
{
    IntArray* a = IntArray::NewInstance(5); 
    
    if( a )
    {
        printf("a->length = %d\n", a->length());
    
        a->set(0, 1);
        
        for(int i=0; i<a->length(); i++)
        {
            int value = 0;
        
            if( a->get(i, value) )
            {
                printf("b->[%d] = %d\n", i, value);
            }
        }
    }

    delete a;    
    
    return 0;
}

输出：
a->length = 5
b->[0] = 1
b->[1] = 0
b->[2] = 0
b->[3] = 0
b->[4] = 0

工程上的决定： 对象往往是较大的，因此不应当放在栈空间中，而应当出现在堆空间中

小结

• 构造函数只能决定对象的初始化状态
• 构造函数中初始化操作的失败不影响对象的诞生
• 初始化不完全的半成品对象是 bug 的重要来源
• 二阶构造人为的将初始化过程分为两部分
• 二阶构造能够确保创建的对象都是完整初始化的

以上内容参考狄泰软件学院系列课程，请大家保护原创！