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

39次阅读

共计 3930 个字符,预计需要花费 10 分钟才能阅读完成。

构造函数的回顾

关于构造函数

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

问题

如何判断构造函数的执行结果?
在构造函数中执行 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 的重要来源
二阶构造人为的将初始化过程分为两部分
二阶构造能够确保创建的对象都是完整初始化的

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

正文完
 0