C++ 对象的构造

在类里面成员函数的初始值是多少了？（取决于创建对象的位置，是在堆、栈、还是在静态存储区中创建。）

　　例如：　　

#include <stdio.h>

class Test
{
    private:
    int i;
    int j;
    public :
    int get_i(void)    {return i;}
    int get_j(void)    {return j;}
};

Test Ta;//在静态存储区中定义 Test类

int main(int argc, char *argv[])
{
    printf("Ta.i = %d\n",Ta.get_i());//Ta.i = 0
    printf("Ta.j = %d\n",Ta.get_j());//Ta.j = 0

    Test Tb;//在栈上定义类
    printf("Tb.i = %d\n",Tb.get_i());//Tb.i = 随机数
    printf("Tb.j = %d\n",Tb.get_j());//Tb.j = 随机数
    
    Test *Tc = new Test;//在堆上定义类
    printf("Tc->i = %d\n",Tc->get_i());//Tc.i = 随机数
    printf("Tc->j = %d\n",Tc->get_j());//Tc.i = 随机数
    
    return 0;
}

　　运行结果：　　

Ta.i = 0
Ta.j = 0
Tb.i = 1808322352
Tb.j = 32766
Tc->i = 0
Tc->j = 0

　　可以看出，对象只是变量，所以在不同的地方定义变量，所的到的初始值也不同。

　　在堆上定义：为随机数

　　在栈上定义：为随机数

　　在静态存储区上定义：因为静态存储区中变量默认为0 ，所以为0

这样在不同地方定义初始值就会不同，这样是不允许的所以我们需要对变量进行初始化。这就引入了类的构造函数。

构造函数：

　　构造函数特点：

　　　　1、构造函数没有任何返回类型的声明。

　　　　2、构造函数在定义的时候被自动调用。

　　　　例如：　　　　

#include <stdio.h>

class Test
{
    private:
    int i;
    int j;
    public :
    int get_i(void)    {return i;}
    int get_j(void)    {return j;}
    Test()
    {
        printf("Test()\n");
        i = 5; j = 10;
    }
};

Test Ta;

int main(int argc, char *argv[])
{
    printf("Ta.i = %d\n",Ta.get_i());
    printf("Ta.j = %d\n",Ta.get_j());

    Test Tb;
    printf("Tb.i = %d\n",Tb.get_i());
    printf("Tb.j = %d\n",Tb.get_j());
    
    Test *Tc = new Test;
    printf("Tc->i = %d\n",Tc->get_i());
    printf("Tc->j = %d\n",Tc->get_j());
    
    return 0;
}

　　在类中加入构造函数。

　　运行结果：　　

Test()
Ta.i = 5
Ta.j = 10
Test()
Tb.i = 5
Tb.j = 10
Test()
Tc->i = 5
Tc->j = 10

　　可以看出每次定义都调用了一次构造函数。

一个类中可以有多个构造函数构成重载，重载的概念在类中同样适用。

　　例如：

　　

#include <stdio.h>

class Test
{
    private:
    int i;
    int j;
    public :
    int get_i(void)    {return i;}
    int get_j(void)    {return j;}
    Test()
    {
        printf("Test()\n");
        i = 5; j = 10;
    }
    Test(int v)
    {
        printf("Test(int v);v = %d\n",v);
        i = 20; j = 30;
    }
};



int main(int argc, char *argv[])
{
    Test Ta;
    printf("Ta.i = %d\n",Ta.get_i());
    printf("Ta.j = %d\n",Ta.get_j());

    Test Tb(10);
    printf("Tb.i = %d\n",Tb.get_i());
    printf("Tb.j = %d\n",Tb.get_j());
    
    Test *Tc = new Test(30);
    printf("Tc->i = %d\n",Tc->get_i());
    printf("Tc->j = %d\n",Tc->get_j());
    
    
    return 0;
}

　　运行结果：　　

Test()
Ta.i = 5
Ta.j = 10
Test(int v);v = 10
Tb.i = 20
Tb.j = 30
Test(int v);v = 30
Tc->i = 20
Tc->j = 30

从结果中可以看出：

 Test Ta;调用的是 Test() 这个构造函数。

Test Tb(10);和 Test *Tc = new Test(30);调用的是   Test(int v) 这个构造函数。

注意：对象的定义与对象的声明是不同的。例如变量的定义与变量的声明也是不同的。
　　对象定义：声明对象的空间并调用构造函数。
　　对象的声明：告诉编译器存在这样的一个变量。
构造函数的手动调用：
　　一般来说构造函数在定义对象的时候被自动调用，但是在一些特殊情况下需要手动调用。
　　例如构造对象数组。
实验：创建一个数组类解决数组的安全性问题。
　　1、创建Intarray.h
　　　　

#ifndef __INTARRAY_H
#define __INTARRAY_H
class intArray
{
    private:
    int arrayLenght;
    int *Parray;
    public:
    intArray (int lenght);//构造函数
    bool changeArray(int index,int val);//修改数组中的元素
    int getLenght(void);//获取数组长度
    bool getArrayData(int index,int& val);//获取数组中的元素
    void free();
};


#endif 

　　2、创建Intarray.cpp
　　

#include "intArray.h"

intArray::intArray (int lenght)//构造函数
{
    Parray = new int[lenght];//创建数组空间
    for(int i=0; i<lenght; i++)//初始化
    Parray[i] = 0;
    arrayLenght = lenght;
}
bool intArray::changeArray(int index,int val)//修改数组中的元素
{
    bool ret = (index>=0)&&(index < arrayLenght);//判断是否越界
    if(ret)
    {
        Parray[index] = val;
    }
    return ret;
}
int intArray::getLenght(void)//获取数组长度
{
    return arrayLenght;
}
bool intArray::getArrayData(int index, int& val)//获取数组中的元素
{
    bool ret = (index>=0)&&(index < arrayLenght);//判断是否越界
    if(ret)
    {
        val =  Parray[index] ;
    }
    return ret;
}

void intArray::free()//
{
    delete[] Parray;
}

　　 3、创建main.cpp

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


int main(int argc, char *argv[])
{
    int temp ;
    intArray TestArray(6);
    for(int i=0; i<TestArray.getLenght();i++)
        TestArray.changeArray(i,i);
    for(int i=0; i<TestArray.getLenght();i++)
    {
        TestArray.getArrayData(i,temp);
        printf("getArrayData(%d) = %d\n",i,temp);
    }
    
    TestArray.free();
    return 0;
}

运行结果：

getArrayData(0) = 0
getArrayData(1) = 1
getArrayData(2) = 2
getArrayData(3) = 3
getArrayData(4) = 4
getArrayData(5) = 5