构造与析构（上）

对象的初始化：

生活中存在的对象都是被初始化后才上市的；

初始状态是对象普遍存在的一个状态的；

一般而言所有的对象都需要一个确定的初始状态

解决方案

为每个类都提供一个public的initialize函数；

对象创建后立即调用initialize函数进行初始化；

initialize只是一个普通的函数，必须显示的调用

一旦由于失误的原因，对象没有初始化，那么结果将是不确定的；

没有初始化的对象，其内部成员变量的值是不定的；

c++中的构造函数：

C++中的类可以定义与类名相同的特殊成员函数

这种与类名相同的成员函数叫做构造函数

构造函数在定义时可以有参数，但是没有任何返回类型的声明

构造函数的调用：

一般情况下c++编译器会自动调用构造函数，有时候也需要手工调用；

class Test
{
private:
    int i;
    int j;
    int k;
    
public:
    Test(int v)
    {
        i = v;
        j = v;
        k = v;
    }  
    void print()//构造函数
    {
        printf("i = %d, j = %d, k = %d\n", i, j, k);
    }
};
int main()
{
    Test t1(4);//自动调用构造函数
    Test t2 = 5;//自动调用构造函数
    Test t3 = Test(6);//主动调用构造函数    
    t1.print();
    t2.print();
    t3.print();    
    Test tA[3] = {Test(1), Test(2), Test(3)};//主动调用构造函数
    for(int i=0; i<3; i++)
    {
        tA[i].print();
    }

}

成员函数的重载

类的成员函数和普通函数一样可以进行重载，并遵守相同的重载规则；

class Test
{
private:
    int i;
    int j;
    int k;   
public:
    Test()
    {
        i = 0;
        j = 0;
        k = 0;
    }
    Test(int v)
    {
        i = v;
        j = v;
        k = v;
    }
    void print()
    {
        printf("i = %d, j = %d, k = %d\n", i, j, k);
    }  
    void print(int v)
    {
        printf("v = %d\n", v);
    }
};

两个特殊的构造函数：

/*
    注意：
    1. 当类中没有定义任何一个构造函数，C++编译器会为提供无参构造函数和拷贝构造函数
    2. 当类中定义了任意的非拷贝构造函数时，C++编译器不会为提供无参构造函数 
*/
class Test
{ 
public:
    Test()
    {
        printf("Test()\n");
    }
    
    Test(const Test& obj)
    {
        printf("Test(const Test& obj)\n");
    }
};
int main()
{
    Test t1;
    Test t2 = t1;
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}

两个特殊的构造函数

无参构造函数

当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空；

拷贝构造函数

当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制；

数组类的创建：

#ifndef _ARRAY_H_
#define _ARRAY_H_
class Array
{
private:
    int mLength;
    int* mSpace;


public:
    Array(int length);
    Array(const Array& obj);
    int length();
    void setData(int index, int value);
    int getData(int index);
    void destory();
};
#endif

#include "Array.h"
Array::Array(int length)
{
    if( length < 0 )
    {
        length = 0;
    }  
    mLength = length;
    mSpace = new int[mLength];
}
Array::Array(const Array& obj)
{
    mLength = obj.mLength;   
    mSpace = new int[mLength];    
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
}
int Array::length()
{
    return mLength;
}
void Array::setData(int index, int value)
{
    mSpace[index] = value;
}
int Array::getData(int index)
{
    return mSpace[index];
}
void Array::destory()
{
    mLength = -1;
    delete[] mSpace;
}

构造函数是C++中用于初始化对象状态的特殊函数

构造函数在对象创建时自动被调用

构造函数和普通成员函数都遵循重载规则

拷贝构造函数是对象正确初始化的重要保证