0%

C++ - 构造析构

最近在学习 C++,所以顺便将每日所学记录下来,一方面为了巩固学习的知识,另一方面也为同样在学习C++的童鞋们提供一份参考。

构造析构

构造

类的构造函数是类的一种特殊的成员函数,它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。构造函数可用于为某些成员变量设置初始值。

对于构造函数有以下几点需要注意:

  • 构造函数与类同名,并且没有返回值。
  • 构造函数和其他成员函数一样,都能够被重载
  • 构造函数不能够被声明成const,当我们创建一个const对象,直到构造函数初始化完成,对象才能获得真正的常量属性。因此构造函数可以创建对象过程中对其写值。

C++ 默认构造函数是对类中的参数提供默认值的构造函数,一般情况下,是一个没有参数值的空函数。当没有显示声明构造函数的时候,编译器会隐式生成一个默认构造函数,并且这个构造函数什么都不会做。如果在类中显示申明构造函数,编译器将不会隐式生成默认构造函数。默认构造函数初始化规则如下:

  • 如果类中有初始值,用它来初始化成员。
  • 否则默认初始化该成员。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <iostream>
using namespace std;


class Test01
{
public:
Test01();
~Test01();

private:
int a;
int b;
char *p;
protected:
};

class MyClass
{
public:
MyClass();
~MyClass();

private:

};

Test01::Test01()
{
p = (char *)malloc(100);
strcpy(p, "11111");
cout << "我是构造函数,自动被调用了" << endl;
}


Test01::~Test01()
{
cout << "我是析构函数,自动被调用了" << endl;
if (p != NULL)
{
free(p);
}
}


void ObjPlay()
{
Test01 T1;
cout << "展示t1的生命周期" << endl;
}


int main()
{
ObjPlay();
system("pause");
return 0;
}

有参构造函数调用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <iostream>
using namespace std;

class Test
{
public:
Test()
{
m_a = 0;
m_b = 0;
cout<<"无参构造函数"<<endl;
}
Test(int a)//3种方法
{
m_a = a;
m_b = 0;
cout<<"1个参数有参构造函数"<<endl;
}
Test(int a, int b )//3种方法
{
m_a = a;
m_b = b;
cout<<"有参构造函数"<<endl;
}
Test(const Test&obj)
{
cout<<"赋值构造函数"<<endl;
}
void print()
{
cout<<m_a<<endl;
cout<<"普通函数"<<endl;
}
protected:
private:
int m_a ;
int m_b;
};
void display()
{
//1.调用有参构造函数方法1
//Test t(1,2);
//t.print();

//1.调用有参构造函数方法2
//Test t = (1,2,3);//逗号表达式 取最后一个值
//t.print();

//1.调用有参构造函数方法3
Test t = Test(1,2);//编译器会产生一个匿名对象
//t.print();
}
int main()
{
display();
system("pause");
return 0;

}

析构

析构函数(destructor)是成员函数的一种,它的名字与类名相同,但前面要加~,没有参数和返回值。

一个类有且仅有一个析构函数。如果定义类时没写析构函数,则编译器生成默认析构函数。如果定义了析构函数,则编译器不生成默认析构函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<iostream>
using namespace std;
class CDemo
{
public:
~CDemo() { //析构函数
cout << "Destructor called"<<endl;
}
};
int main()
{
CDemo array[2]; //构造函数调用2次
CDemo* pTest = new CDemo; //构造函数调用
delete pTest; //析构函数调用
cout << "-----------------------" << endl;
pTest = new CDemo[2]; //构造函数调用2次
delete[] pTest; //析构函数调用2次
cout << "Main ends." << endl;
return 0;
}