9.C++-对象的构造函数(详解)

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

大家都定义struct或class时,不能给成员直接赋值,那么对象中成员变量的初始值是多少?

对于局部对象变量而言,其成员是个随机值,因为该变量是被分配在栈上,对于其它局部变量也是这样.

对于全局对象变量而言,其成员都为0,因为该变量是被分配在静态存储区上,对于const修饰就是分配在只读静态存储区上.

对于使用malloc分配的对象变量而言,其成员是个随机值,因为用户分配的地址是存在堆上

对于使用new分配的对象变量而言,其成员也为随机,因为用户分配的地址是存在堆上

所以:

在栈上创建对象时,成员变量为随机值
在堆上创建对象时,成员变量初始为随机值
在静态存储区创建对象时,成员变量初始为0

构造函数

一般而言,对象创建时都会需要一个确定的初始状态

所以在C++中,引入了一个特殊函数-构造函数

构造函数的名字必须与类名相同
构造函数可以带参数,但是没有任何返回类型的声明,
构造函数在创建对象时,会被自动调用

参考下面示例:

class Test
{
private:
int i;
int j;
public:
int getI() { return i; }
int getJ() { return j; }
Test() //构造函数
{
i = ;
j = ;
}
};Test t; //创建全局对象t,并自动调用Test()来初始化 i=1 j=2

多个重载的构造函数

由于构造函数可以带参数,所以一个类可以存在多个重载的构造函数

例如:

class Test
{
public:
Test(){ }
Test(int i){ }
Test(int i,float t){ }
};

多个重载构造函数的调用

在之前小节,分析到构造函数是用来初始化对象的.如果有多个重载的构造函数,又如何来调用呢？

参考下面示例:

#include <stdio.h>
class Test
{
private:
int m_val;
public :
Test()
{
m_val=;
printf("Test() \n");
}
Test(int i)
{
m_val=i;
printf("Test(int i) i=%d \n",i);
}
Test(float t,int i)
{
m_val=i;
printf("Test(float t,int i) t=%f i=%d\n",t,i);
}
};int main()
{
Test t1; //调用Test()初始化
Test t2(); //调用Test(int i) 初始化
Test t4=; //调用Test(int i) 初始化
Test t3(1.5f,); //调用Test(float t,int i) 初始化 Test t4=Test(,); //调用Test(3,4)返回一个临时对象,然后通过拷贝构造函数来初始化t4 t1=t4; //赋值操作,所以不会调用Test()初始化
return ;
}

为什么使用Test t4=1 能调用Test (4)?

当构造函数的参数只有一个时,并且参数是其它类型,该构造函数便称为转换构造函数

所以编译Test t4=1时,编译器会通过1来查找哪个构造函数的参数满足它,若没找到则编译报错.

同样在C++中,也可以通过()来初始化变量,比如:

int i(); //转换为 int i=100;

对象数组之手工调用构造函数

还是以上个Test类为例:

Test Tarray[]={ Test(),Test(), Test()}; //初始化对象数组里的m_val值分别为0,1,2;

从上面可以看出,一个构造函数其实是有返回值的,返回的是一个临时对象,然后赋值给Tarray[]数组里。

这个临时对象仅仅在调用时有效,执行下个代码时,就会被注销。

临时对象在后面第11章会讲到:11.C++-临时对象分析

特殊的构造函数

-无参数构造函数

当类中没有定义构造函数时,编译器会默认提供一个函数体为空的无参构造函数,

-拷贝构造函数 (参数为: const class_name&)

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

1.接下来证明无参构造函数的存在,参考下面出错的示例

#include <stdio.h>class Test
{
private:
int m_val;
public :
int getm(void)
{
return m_val;
} Test(int val)
{
m_val=val;
}
};int main()
{
Test t1;
return ;
}

编译时, 报错:

test.cpp:: error: no matching function for call to ‘Test::Test()’

提示说, 定义Test t1时,没有没匹配到Test()无参构造函数.

这是因为我们提供了构造函数,所以编译器就不再提供无参构造函数了,从而编译报错。

也可以将上面的Test(int val)改为:

Test(int val=0)
{
m_val=val;
}

这样,就相当于提供了两个函数: Test(int val), Test().

当我们调用Test(1)时,则val=1.

当我们调用Test()时,则val=0.

这是C++新加的特性,在C里是没有该功能

2.接下来来证明拷贝构造函数的存在,参考下面示例

#include <stdio.h>
class Test
{
private:
int m_val;
public :
int getm(void)
{
return m_val;
}// Test()
// {
// }
// Test(const Test& t) //定义一个拷贝构造函数
// {
// printf("set m_val=%d\n",t.m_val);
// m_val= t.m_val;
// }};int main()
{
Test t1; //调用Test()初始化
Test t2=t1;
printf("t1.m_val=%d t2.m_val=%d \n",t1.getm(),t2.getm());
return ;
}

运行打印:

t1.m_val=- t2.m_val=-

可以发现打印的数据t1.m_val和t2.m_val的值是一摸一样的,这是因为执行Test t2=t1;时,由于Test类里没有提供拷贝构造函数,所以编译器提供了一个拷贝构造函数。

我们取消上面示例的屏蔽,使用自定义的拷贝构造函数:

运行打印:

set m_val=- t1.m_val=- t2.m_val=-

从打印的数据上看到,执行Test t2=t1; 时,明显调用了我们自定义的Test::Test(const Test& t)拷贝函数.

所以当类中没有定义拷贝构造函数时,编译器会默认提供一个拷贝构造函数,进行简单的成员变量拷贝.

深入理解拷贝构造函数

拷贝构造函数分为两种:

-浅拷贝(编译器提供的)

拷贝后对象的物理状态相同

-深拷贝(指自己定义的)

拷贝后对象的逻辑状态相同

接下来看浅拷贝和深拷贝的区别,参考下面示例:

#include <stdio.h>class Test
{
private:
int m_val;
int *p;
public :
int getm()
{
return m_val;
}int* getp()
{
return p;
} void free()
{
delete p;
} Test(int i)
{
delete p;
p= new int(i);
m_val=;
} // Test(const Test& obj)
// {
// p=new int;
//
// m_val=t.m_val;
// *p=*obj.p;
// }
};int main()
{
Test t1(); //调用Test(int i)初始化
Test t2=t1; //调用编译器提供的拷贝构造函数,进行浅拷贝 printf("t1.m_val=%d t1.p=%p *t1.p=%d\n",t1.getm(),t1.getp(),*t1.getp());
printf("t2.m_val=%d t2.p=%p *t2.p=%d\n",t2.getm(),t2.getp(),*t2.getp());
t1.free();
t2.free(); return ;
}