27，二阶构造模式（构造函数二阶构造）------对象初始化

模式------------即方法

1. 构造函数的回顾

（1）关于构造函数

　　①类的构造函数用于对象的初始化

　　②构造函数与类同名并且没有返回值（思考：无返回值如何判断构造函数的执行结果？）

　　③构造函数在对象定义时自动被调用

问题：

 1，如何判断构造函数的执行结果？  ---普通函数可以返回值

2，构造函数中执行return会发生什么？------普通函数立即返回，后面的函数不执行

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

编程实验以上问题：

#include<stdio.h> 
/*   1，没有办法判断构造函数的执行结果
     2，构造函数中执行return会发生什么？构造函数执行之后，不意味着对象构造成功
*/
// 模式即方法
class Test
{
    int mi;
    int mj;

public:

    Test(int i, int j)    //1,构造函数中执行return会发生什么？ 
    {                     //答：直接返回，Test t1(1,2)有问题，初始状态有问题，没有影响构造函数的诞生，只是不能知道t1能不能用
                          //所以没有办法判断构造函数的执行结果
        mi = i;

        return;           

        mj = j;              //这行代码没有执行--------mj变为随机数，mj成员未完成初始化
    }

    int getI()
    {
        return mi;
    }

    int getJ()
    {
        return mj;
    }
};

int main()
{
    Test t1(1,2);

    printf("t1.mi=%d
",t1.getI());    //1
    printf("t1.mj=%d
", t1.getJ());   //5689365

    return 0;
}

回答：构造函数的真相

　　①构造函数只提供自动初始化成员变量的机会，但不能保证初始化逻辑一定成功。它只能决定对象的初始状态，而不是对象的诞生！

　　②构造函数中执行return语句后，构造函数执行结束,但是不意味着对象构造成功。

那么怎么解决？？？？？

#include<stdio.h> 
/*  
    判断对象构造是否成功------方案：类中增加成员-mStatus-----强行让构造函数有个返回值mStatus
    */
//           模式即方法
class Test
{
    int mi;
    int mj;

    bool mStatus;   //成员变量记录类的初始状态

public:
    Test(int i, int j)  : mStatus(false)   //类的成员变量mStatus的初始化
    {
        mi = i;

        return;                              //mj变为随机数，mj成员未完成初始化

        mj = j;

        mStatus = true;                 //对象构造成功，mStatus返回true
    }
    int getI()
    {
        return mi;
    }
    int getJ()
    {
        return mj;
    }

    int status()  //功能函数
    {
        return mStatus;
    }
};

int main()
{
    Test t1(1, 2);

    if (t1.status())//构造未完成，status为false
    {
        printf("t1.mi=%d
", t1.getI());//i被正确初始化
        printf("t1.mj=%d
", t1.getJ());//j为随机值
    }
    return 0;
}

2. 半成品对象

（1）初始化操作不能按照预期完成而得到的对象

（2）半成品对象是合法的C++对象，也是bug的重要来源

段错误：指访问的内存超出了系统给这个程序所设定的内存空间，例如访问了不存在的内存地址、访问了系统保护的内存地址（比如0地址）、访问了只读的内存地址等等情况。

内存申请不成功，产生段错误，但是有的错误只产生一次，该怎么解决这种问题？？？

人为的将构造分为两步

3. 二阶构造---（用于杜绝半成品对象）

（1）工程开发中的构造过程

　　①资源无关的初始化操作阶段：

　　　　　　----------不会出现异常情况的操作（比如将成员变量的值设置为初始值）

　　②需要使用系统资源的操作　　　　　　

　　　　　　-------可能出现异常，如内存申请（堆空间），访问文件等。

二阶构造，对象只在堆空间产生，不能在栈上产生，往往实际工程对象是非常大的，不适合放在栈空间（栈空间有限）

　　　　　

为什么要用对象创建函数？？？

 因为构造函数是Private外界不能调用，所以要通过对象创建函数（stati 静态成员函数内部可以访问类的私有成员）

 static TwoPhaseCons* NewInstance();      //对象创建函数 -----------返回对象指针

实例：

#include<stdio.h> 



class TwoPhaseCons
{
private:
    TwoPhaseCons()        //第一阶段构造函（简单的赋值操作）            c++构造函数可以担任二阶构造的一阶构造函数
    {
    }
    bool construct()      //第二阶段构造函数（系统资源申请，打开文件，网络）                普通成员函数
    {
        return true;
    }
public:
                                            //构造函数时Private外界不能调用，通过对象创建函数（静态成员函数内部可以访问类的私有成员函数）
   static TwoPhaseCons* NewInstance();      //对象创建函数 ----------- 返回对象指针
                                                                                                  
};

//对象创建函数实现
TwoPhaseCons* TwoPhaseCons::NewInstance()           
{
    TwoPhaseCons* ret = new TwoPhaseCons();     //堆空间创建对象，调用构造函数----执行第一阶段构造--（静态成员函数内部可以访问类的私有成员）
                                                                                               
     
    //r若第二阶段构造失败，返回NULL
    if (!(ret && ret->construct()))             //construct----进行资源申请-------执行二阶构造
    {
        delete ret;                              //删除半成品对象
        ret = NULL;
    }

    return ret;                                //返回对象，资源申请成功-----合法对象NewInstance()申请成功
}

int main() 
{
   // TwoPhaseCons obj;                           //error  

  //  TwoPhaseCons* obj =new NewInstance();       //error 触发构造函数自动调用，但是构造函数是私有的，不能在外部main()自动调用,只能调用创建函数

     TwoPhaseCons* obj= TwoPhaseCons::NewInstance();   //只能调用静态创建函数-----因为要调用私有的构造函数，所以必须定义静态创建函数，实现在类的外部（mian）调用

    printf("obj=%p
",obj);                            //可以得到合法可用的对象----位于堆空间

    return 0;
}

【编程实验】数组类的加强   IntArray

//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);               //设置对应位置的数组元素为参数value
    void free();
};

#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++)    //将数组所有值设置为0
        {
            m_pointer[i] = 0;
        }
    }
    else
    {
        ret = false;
    }
    return ret;
}

int IntArray :: length()
{
    return m_length;
}

bool IntArray :: get(int index, int& value)    //安全性体现----得到对应位置的数组元素值 ---index为指定位置
{
    bool ret = (0 <= index) && (index <= length());     

    if (ret)
    {
        value = m_pointer[index];              //通过引用返回值
    } 

    return ret;
}

IntArray* IntArray::NewInstance(int length)       ///对象创建函数
{
    IntArray* ret = new IntArray(length);
   
    //r若第二阶段构造失败，返回NULL
    if (!(ret && ret->construct()))
    {
        delete ret;
        ret = 0;
    }

    return ret;
}


bool IntArray :: set(int index, int value)             //设置对应位置的数组元素为参数value
{
    bool ret = (0 <= index) && (index <= length());
    if (ret)
    {
        m_pointer[index]=value;                      //数组成员重新赋值
    }
    return ret;
}

void IntArray::free()
{
    delete[] m_pointer;       //释放堆空间
}

//main.c

#include<stdio.h>
#include "IntArray.h"


int main() {
    
        
//调用创建函数
    IntArray* a = IntArray::NewInstance(5);
    printf("a.length=%d
",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
",i,v);
    }


    return 0;
}

4. 小结

（1）构造函数只能决定对象的初始化状态

（2）构造函数中初始化操作的失败不影响对象的诞生

（3）初始化不完全的半成品对象是bug的重要来源

（4）二阶构造人为的将初始化过程分为两个部分

（5）二阶构造能够确保创建的对象都是完整初始化的