构造函数的回顾
关于构造函数
类的构造函数用于对象的初始化
构造函数与类同名并且没有返回值
构造函数在对象定义时自动被调用
问题
如何判断构造函数的执行结果？
在构造函数中执行 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 的重要来源
二阶构造人为的将初始化过程分为两部分
二阶构造能够确保创建的对象都是完整初始化的
以上内容参考狄泰软件学院系列课程，请大家保护原创！