关于构造函数：用于对象的初始化，与类同名并且没有返回去，对象被定义时自动调用。
1、如何判断构造函数的执行结果？
没有办法，
2、构造函数中执行return语句会发生什么？
可以存在return语句，遇到return会立即返回，后边的语句不会执行。
3、构造函数执行结束是否意味着对象构造成功？
不完美的解决方法：
#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; // true 时可用
}
int getI()
{
return mi;
}
int getJ()
{
return mj;
}
int 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的重要来源。
工程开发中的初始化操作可分为：资源无关的初始化操作，不可能出现异常情况的操作。
需要使用系统资源的操作：可能出现异常情况，如：内存申请，访问文件。
将构造过程一分为2，资源无关第一阶段，资源有关第二阶段。
class Twphasecons{
private：
Twphasecons（）{} //第一阶段构造函数
}
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; }
完整程序：
#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 = TwoPhaseCons::NewInstance();
printf("obj = %p\n", obj);
delete obj;
return 0;
}
数组类的二阶构造：
#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
#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 = (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;
}
return ret;
}
IntArray::~IntArray()
{
delete[]m_pointer;
}
#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; }
总结：构造函数只能决定对象的初始化状态，构造函数中初始化操作的失败不影响对象的诞生，二阶构造初始化分为两部分，确保创建的对象都是完整初始化的。