对象的初始化
先上一段代码：
#include <stdio.h>
class Test
{
private:
int i;
int j;
public:
int getI() { return i; }
int getJ() { return j; }
};
Test gt;
int main()
{
printf("gt.i = %d\n", gt.getI());
printf("gt.j = %d\n", gt.getJ());
Test t1;
printf("t1.i = %d\n", t1.getI());
printf("t1.j = %d\n", t1.getJ());
return 0;
}
在上述代码中会打印什么呢？ 我这里直接放上运行结果；
gt.i = 0
gt.j = 0
t1.i = 1404627760
t1.j = 32767
- 从程序设计的角度，对象只是变量，因为：
- 在栈上创建对象时，成员变量初始为随机值
- 在堆上创建对象时，成员变量初始为随机值
- 在静态存储区创建对象时，成员变量初始为0值
一般而言，对象都需要一个确定的初始状态
解决方案：
（1）在类中提供一个public的initialize函数
（2）对象创建后立即调用initialize函数进行初始化
class Test
{
private:
int i;
int j;
public:
void initialize(){i = 0; j = 0;}
int getI() {return i;}
int getJ() {return j;}
}
存在的问题：
（1）initialize只是一个普通函数，必须显示调用
（2）如果未调用initialize函数，运行结果是不确定的
构造函数
-
C++中可以定义与类名相同的特殊成员函数
- 这种特殊的成员函数叫做构造函数
- 构造函数没有任何返回类型的声明
- 构造函数在对象定义时自动被调用
-
带有参数的构造函数
- 构造函数可以根据需要定义参数
- 一个类中可以存在多个重载的构造函数
- 构造函数的重载遵循C++重载的规则
例如：
class Test
{
public:
Test(int v)
{
//use V to initialize member
}
}
- 对象定义和对象声明不同
- 对象定义 --- 申请对象的空间并调用构造函数
- 对象声明 --- 告诉编译器存在这样一个对象
Test t; //定义对象并调用构造函数
int main（）
{
//告诉编译器存在名为 t 的 Test 对象
extern Test t;
return 0;
}
- 构造函数的自动调用
class Test
{
public:
Test() { }
Test(int v) { }
};
int main()
{
Test t; //调用Test()
Test t1(1); //调用Test(int v)
Test t2 = 1; //调用Test(int v)
return 0;
}
- 构造函数的调用
- 一般情况下，构造函数在对象定义时被自动调用
- 一些特殊情况下，需要手工调用构造函数
#include <stdio.h>
class Test
{
private:
int m_value;
public:
Test()
{
printf("Test()\n");
m_value = 0;
}
Test(int v)
{
printf("Test(int v), v = %d\n", v);
m_value = v;
}
int getValue()
{
return m_value;
}
};
int main()
{
//手工调用构造函数
Test ta[3] = {Test(), Test(1), Test(2)};
for(int i=0; i<3; i++)
{
printf("ta[%d].getValue() = %d\n", i , ta[i].getValue());
}
Test t = Test(100);
printf("t.getValue() = %d\n", t.getValue());
return 0;
}
特殊的构造函数
- 两个特殊的构造函数
- 无参构造函数 --- 没有参数的构造函数
- 拷贝构造函数 --- 参数为const class_name& 的构造函数
- 无参构造函数
- 当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空
- 拷贝构造函数
- 当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制
#include <stdio.h>
class Test
{
private:
int i;
int j;
public:
int getI()
{
return i;
}
int getJ()
{
return j;
}
//拷贝构造函数
/*Test(const Test& t)
{
i = t.i;
j = t.j;
}
//构造函数
Test()
{
}*/
};
int main()
{
Test t1;
Test t2 = t1;
printf("t1.i = %d, t1.j = %d\n", t1.getI(), t1.getJ());
printf("t2.i = %d, t2.j = %d\n", t2.getI(), t2.getJ());
return 0;
}
拷贝构造函数
- 拷贝构造函数的意义（一）
- 兼容C语言的初始化方式
- 初始化行为能够符合预期的逻辑
- 拷贝构造函数的意义（二）
- 浅拷贝 --- 拷贝后对象的物理状态相同
- 深拷贝 --- 拷贝后对象的逻辑状态相同
- 编译器提供的拷贝构造函数只进行 浅拷贝 ！
举个例子：
#include <stdio.h>
class Test
{
private:
int i;
int j;
int* p;
public:
int getI()
{
return i;
}
int getJ()
{
return j;
}
int* getP()
{
return p;
}
//重写拷贝构造函数，形成深拷贝
Test(const Test& t)
{
i = t.i;
j = t.j;
p = new int;
*p = *t.p;
}
Test(int v)
{
i = 1;
j = 2;
p = new int;
*p = v;
}
void free()
{
delete p;
}
};
int main()
{
Test t1(3);
Test t2(t1);
printf("t1.i = %d, t1.j = %d, *t1.p = %d\n", t1.getI(), t1.getJ(), *t1.getP());
printf("t2.i = %d, t2.j = %d, *t2.p = %d\n", t2.getI(), t2.getJ(), *t2.getP());
t1.free();
t2.free();
return 0;
}
- 什么时候需要进行深拷贝？
- 对象中有成员指代了系统中的资源
- 成员指向了动态内存空间
- 成员打开了外存中的文件
- 成员使用了系统中的网络端口
- .....
- 对象中有成员指代了系统中的资源
- 一般性原则
- 自定义拷贝构造函数，必然需要实现深拷贝！！！
网友评论