二阶构造模式

一、构造函数的回顾

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

二、问题

1、如何判断构造函数的执行结果？

2、在构造函数中执行return语句会发生什么？

3、构造函数执行结束是否意味着对象构造成功？

三、编程实验

#include <stdio.h>
class Test
{
	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 t1(1,2);
	printf("t1.mi = %d\n",t1.getI());
	printf("t1.mj = %d\n",t1.getJ());
		
	return 0;
}

//编译，运行结果
$ g++ test.cpp 
$ ./a.out 
t1.mi = 1
t1.mj = 32766

回答：

1、没有办法

2、return可以存在，return时，直接返回，构造结束

3、否

四、一种方法（low）

//27-1.cpp
#include <stdio.h>
class Test
{
	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 t1(1,2);
	if(t1.status())
	{
		printf("t1.mi = %d\n",t1.getI());
		printf("t1.mj = %d\n",t1.getJ());

	}
		
	return 0;
}

五、真相

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

---

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

---

六、半成品对象

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

七、编程实验

//IntArray.cpp

IntArray::IntArray(int len)
{
	m_pointer = new int[len];

	for(int i = 0; i < len; i++)
	{
		m_pointer[i] = 0;
	}
	m_legth = len;
}

如果m_pointer = new int[len];申请内存失败，很难复现的bug。

---

引入二阶构造函数：

八、二阶构造

• 工程开发中的构造过程，一分为二：
  • 资源无关的初始化操作
    • 不可能出现异常情况的操作
  • 需要使用系统资源的操作
    • 可能出现异常情况，如：内存申请，访问文件
  • 

//二阶构造示例代码
class TwoPhaseCons
{
private:
	TwoPhaseCons()//第一阶段构造函数
	{

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

TwoPhaseCons* TwoPhaseCons::NewInstance()
{
	//第一阶段构造
	TwoPhaseCons* ret = new TwoPhaseCons();

	//若第二阶段构造失败，返回NULL
	if(!(ret && ret->construct()))
	{
		delete ret;
		ret = NULL;
	}

	return ret;
}

//27-2.cpp
#include <stdio.h>

class TwoPhaseCons
{
private:
	TwoPhaseCons()//第一阶段构造函数
	{

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

TwoPhaseCons* TwoPhaseCons::NewInstance()
{
	//第一阶段构造
	TwoPhaseCons* ret = new TwoPhaseCons();

	//若第二阶段构造失败，返回NULL
	if(!(ret && ret->construct()))
	{
		delete ret;
		ret = NULL;
	}

	return ret;
}

int main()
{
	//无法编译通过
	//TwoPhaseCons* obj = new TwoPhaseCons();
	
	TwoPhaseCons* obj = TwoPhaseCons::NewInstance();

	printf("obj = %p\n",obj);
	return 0;
}

---

九、继续优化数组类

//IntArray.h
#ifndef _INTARRAY_H_
#define _INTARRAY_H_

class IntArray
{
private:
	int m_legth;
	int* m_pointer;
	IntArray(int len);
	IntArray(const IntArray& obj);
	bool construct();
public:
	int length();
	bool get(int index, int& value);
	bool set(int index, int value);
	static IntArray* NewInstance(int length);
	//void free();
	~IntArray();
};


#endif// _INTARRAY_H_

//IntArray.cpp
#include "IntArray.h"


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

#if 0
//实现深拷贝
IntArray::IntArray(const IntArray& obj)
{
	m_legth = obj.m_legth;

	m_pointer = new int[obj.m_legth];

	for(int i = 0; i < obj.m_legth; i++)
	{
		m_pointer[i] = obj.m_pointer[i];
	}
}
#endif

bool IntArray::construct()
{
	bool ret = true;
	
	m_pointer = new int[m_legth];

	if(m_pointer)
	{
		for(int i = 0; i < m_legth; 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_legth;
}

bool IntArray::get(int index, int& value)
{
	bool ret = ((0 <= index) && (index < length()));

	if(ret)
	{
		value = m_pointer[index];
	}

	return ret;
}

bool IntArray::set(int index, int value)
{
	bool ret = ((0 <= index) && (index < length()));

	if(ret)
	{
		m_pointer[index] = value;
	}

	ret;

}

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

//main.cpp
#include <stdio.h>
#include "IntArray.h"

int main()
{
    IntArray* a = IntArray::NewInstance(5);    
    
    printf("a.length = %d\n", a->length());
    
    a->set(0, 1);
    
    for(int i=0; i<a->length(); i++)
    {
        int v = 0;
        
        a->get(i, v);
        
        printf("a[%d] = %d\n", i, v);
    }
    
    delete a;
    
    return 0;
}

十、小结

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