二阶构造模式

 1 #include <stdio.h>
 2 class Test
 3 {
 4 private:
 5     int  mi;
 6     int  mj;
 7     bool mStatus;
 8 public:
 9     Test(int i,int j):mStatus(false)
10     {
11         mi = i;
12         return;
13         mj = j;
14         mStatus = true;
15     }
16     int getI()
17     {
18         return mi;
19     }
20     int getJ()
21     {
22         return mj;
23     }
24     int status()
25     {
26         return mStatus;
27     }
28 };
29 int main()
30 {
31     Test t(1,2);
32     if(t.status())
33     {
34         printf("t.mi=%d\n",t.getI());
35         printf("t.mj=%d\n",t.getJ());
36     }
37     return 0;
38 }

 1 #include <stdio.h>
 2 class TwoPhaseCons
 3 {
 4 private:
 5     //第一阶段构造函数
 6     TwoPhaseCons()
 7     {
 8     }
 9     //第二阶段构造函数
10     bool construct()
11     {
12         return true;
13     }
14 public:
15     //对象创建函数
16     static TwoPhaseCons*NewInstance();
17 };
18 //内部静态成员函数直接访问私有成员是合法的
19 TwoPhaseCons* TwoPhaseCons::NewInstance()
20 {
21     //通过动态内存分配创建一个对象,构造函数
22     //肯定会调用，执行第一阶段的构造函数
23     TwoPhaseCons*ret = new TwoPhaseCons();
24     //执行第二阶段构造函数
25     if(!(ret && ret->construct()))
26     {
27         delete ret;
28         ret = NULL;
29     }
30     return ret;
31 }
32 int main()
33 {
34     //因为构造函数是私有的，所以想用类名直接定义一个对象是不合法的
35     //在main函数中，无法访问类中的私有成员，所以可以在静态成员函数中
36     //访问类中的私有成员
37     //在堆空间中可以生成一个合法的，可以使用的对象
38     TwoPhaseCons*obj = TwoPhaseCons::NewInstance();
39     printf("obj = %p\n",obj);
40     return 0;
41 }