【P106 23】C++ 构造函数和析构函数

已于 2022-08-13 16:28:44 修改
阅读量831 收藏 54
点赞数 7
分类专栏： C++ 文章标签： c++ 构造函数 析构函数
于 2021-04-23 20:00:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51233386/article/details/116034499
版权

P106 23

类和对象—对象特征—构造函数和析构函数

生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全。

C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。

一、构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

一个对象或者变量没有初始状态，对其使用后果是未知

同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现。

·构造函数:主要作用在于创建对象时为对象的成员属性赋值，
构造函数由编译器自动调用，无须手动调用。

·析构函数:主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数（初始化）

构造函数语法:类名(){}
1.构造函数，没有返回值也不写void
2函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

析构函数（清理）

析构函数语法:~类名(){}
1.稽构函数，没有返回值也不写void
⒉函数名称与类名相同,在名称前加上符号~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

#include <iostream>
using namespace std;

//对象的初始化和清理

class Person
{
public:
	//1.构造函数
	//没有返回值不用写void
	//函数名与类名相同
	//构造函数可以有参数，可以发生重载
	//创建对象的时候，构造函数会自动调用，而且只调用一次
	Person()
	{
		cout << " Person 构造函数的调用" << endl;
	}

	//2.析构函数 进行清理的操作
	//没有返回值 不写void
	//函数名和类名相同 在名称的前面加~
	//析构函数不可以有参数，不可以发生重载
	//对象在销毁前 会自动调用析构函数，只会调用一次
	~Person()
	{
		cout << "~Person 析构函数的调用" << endl;
	}
};

//构造函数和析构函数都是必须有的实现，如果自己不提供，编译器会提供一个空实现的构造和析构
void test1()
{
	Person p;//在战上的数据，test1执行完毕后，释放这个对象
}
int main() 
{
	test1();
	return 0;
}

在这里插入图片描述

二、构造函数的分类及调用

在这里插入图片描述

1 两种分类

//两种分类
//按参数分为 : 有参构造 无参构造(默认构造)
//按类型分为 : 普通构造 拷贝构造

#include <iostream>
using namespace std;
class Person
{
public:
	//构造函数 (按参数分类)

	//无参构造(默认构造)
	Person()
	{
		cout << " Person无参 构造函数的调用" << endl;
	}
	//有参构造
	Person(int a)
	{
		age = a;
		cout << " Person有参 构造函数的调用" << endl;
	}

	//拷贝构造
	Person(const Person &p)//const引用拷贝
	{
		//将传入的人身上的所有属性，拷贝到当前人身上
		age = p.age;
	}

	//析构函数
	~Person()
	{
		cout << "~Person 析构函数的调用" << endl;
	}
private:
	int age;
};

2 三中调用

//三种调用方式 :
//括号法
//显示法
//隐式转换法理

1 括号法

//调用
void test1()
{

//1.括号法
	Person p1;//默认构造调用 无参
	

//2.显示法

//3.隐式转换法理

}

int main() 
{
	test1();
	return 0;
}

默认构造调用 无参
在这里插入图片描述
有参构造调用

//调用
void test1()
{

//1.括号法
//	Person p1;//默认构造调用 无参
	Person p2(10);

//2.显示法

//3.隐式转换法理

}

在这里插入图片描述
拷贝构造 调用

//调用
void test1()
{

//1.括号法
	Person p1;        //默认构造 调用 无参
	Person p2(10);  //有参构造 调用
	Person p3(p2); //拷贝构造 调用

	cout << "p2的年龄为：" << p2.age << endl;
	cout << "p3的年龄为：" << p3.age << endl;

//2.显示法

//3.隐式转换法理

}

创建对象的时候，构造函数会自动调用，而且只调用一次
对象在销毁前 会自动调用析构函数，只会调用一次

这里对象指test()这个函数
可以看到当test()函数执行完毕，才执行析构

在这里插入图片描述
调用默认构造函数时，不要加()

//调用
void test1()
{
	//注意：
	//调用默认构造函数时，不要加();//Person p1; //默认构造 调用 无参
	//因为下面这行代码，编译器会认为是一个函数声明
	 Person p1();     //默认构造 调用 无参
}

运行没有输出
在这里插入图片描述
编译器会认为是
Person p1();
一个函数声明

因为他和void func();很像
在这里插入图片描述

2 显示法

//调用
void test1()
{

	//1.括号法

	//2.显示法
	Person p1;//无参构造
	Person p2 = Person(10);//有参构造
	Person p3 = Person(p2);//拷贝构造

	//Person(10);//匿名对象 特点：当前执行结束后，系统会立即回收掉匿名对象

	//3.隐式转换法理

}

在这里插入图片描述注意事项1：
Person(10);//匿名对象
特点：当前执行结束后，系统会立即回收掉匿名对象

//调用
void test1()
{

	//1.括号法

	//2.显示法
	
	//注意事项1
	Person(10);//匿名对象 特点：当前执行结束后，系统会立即回收掉匿名对象
	cout << "aaaaaaaa" << endl;
	
	//3.隐式转换法理
}

在这里插入图片描述
可以看到，test()对象没执行完，仅调用了构造函数，而没有执行cout匿语句，匿名对象就销毁了（销毁前执行析构）

注意事项2
//不要利用拷贝构造函数 初始化匿名对象
Person(p3);//编译器会认为person(p3)等价于Person p3;编译器认为是对象声明
在这里插入图片描述

3 隐式转换法

//调用
void test1()
{

	//1.括号法

	//2.显示法
	
	//3.隐式转换法
	Person p4 = 10;//相当于Person p4=Person(10);

}

在这里插入图片描述

4 三种调用方法对比

三种一起是没法运行的，只是便于观察

习惯使用第一种括号法，简单方便

void test1()
{
	//1.括号法
	Person p1;        //默认构造 调用 无参
	Person p2(10);  //有参构造 调用
	Person p3(p2); //拷贝构造 调用

	cout << "p2的年龄为：" << p2.age << endl;
	cout << "p3的年龄为：" << p3.age << endl;

	//注意：
	//调用默认构造函数时，不要加();//Person p1; //默认构造 调用 无参
	//因为下面这行代码，编译器会认为是一个函数声明
	//Person p1();     //默认构造 调用 无参


	//2.显示法
	Person p1;//无参构造
	Person p2 = Person(10);//有参构造
	Person p3 = Person(p2);//拷贝构造

	//注意事项1
	//Person(10);//匿名对象 特点：当前执行结束后，系统会立即回收掉匿名对象
	//注意事项2
	//不要利用拷贝构造函数 初始化匿名对象
	//	Person(p3);//编译器会认为person(p3)等价于Person p3;编译器认为是对象声明


	//3.隐式转换法
	Person p4 = 10;//相当于Person p4=Person(10);

}

3 构造函数初始化列表

构造函数初始化列表的基本形式
构造函数初始化列表以一个冒号开始，接着是以逗号分隔的数据成员列表，
每个数据成员后面跟一个放在括号中的初始化式。

struct ListNode {
 int val;
 ListNode *next;
 ListNode() : val(0), next(nullptr) {}  //无参构造，初始化列表，，，，注意后面没有‘；’
 ListNode(int x) : val(x), next(nullptr) {} //有参构造，初始化列表
 ListNode(int x, ListNode *next) : val(x), next(next) {} //有参构造，初始化列表
};

class CExample {
public:
    int a;
    float b;
    //构造函数初始化列表
    CExample(): a(0),b(8.8)
    {}
    //构造函数内部赋值
    CExample()
    {
        a=0;
        b=8.8;
    }
};

C++ 初始化类成员时，是按照声明的顺序初始化的，而不是按照出现在初始化列表中的顺序。

class CMyClass {
    CMyClass(int x, int y);
    int m_x;
    int m_y;
};

CMyClass::CMyClass(int x, int y) : m_y(y), m_x(m_y)
{
};

三、拷贝构造函数调用时机

在这里插入图片描述

1.使用一个已经创建完毕的对象来初始化一个新对象

#include <iostream>
using namespace std;

//拷贝构造函数调用时机
//·使用一个已经创建完毕的对象来初始化一个新对象
//·值传递的方式给函数参数传值
//·值方式返回局部对象

class Person
{
public:
	//无参构造(默认构造)
	Person()
	{
		cout << " Person无参 构造函数的调用" << endl;
	}
	//有参构造
	Person(int age)
	{
		Age = age;
		cout << " Person有参 构造函数的调用" << endl;
	}

	//拷贝构造
	Person(const Person& p)//const引用拷贝
	{
		cout << " Person拷贝 函数的调用" << endl;
		//将传入的人身上的所有属性，拷贝到当前人身上
		Age = p.Age;
	}

	//析构函数
	~Person()
	{
		cout << "~Person 析构函数的调用" << endl;
	}

	int Age;
};

//1.使用一个已经创建完毕的对象来初始化一个新对象
void test1()
{
	Person p1(20);//有参
	Person p2(p1);//拷贝
	cout << " p2的年龄为："<<p2.Age << endl;
}

//2.值传递的方式给函数参数传值

//3.值方式返回局部对象

int main() 
{
	test1();
	return 0;
}

在这里插入图片描述

2.值传递的方式给函数参数传值

void doWork(Person p)
{

}
void test2()
{
	Person p;
	doWork(p);
}

在这里插入图片描述
两个p不是同一个p
在这里插入图片描述

3.值方式返回局部对象

Person  doWork2()
{
	Person p1;
	return p1;//拷贝出p1的值，返回，传给test03的p 
}
void test03()
{
	Person p=doWork2();
}

在这里插入图片描述
这里的p1 和p，也不是同一个内容；

在这里插入图片描述

4.三种拷贝构造函数调用对比

#include <iostream>
using namespace std;

//拷贝构造函数调用时机
//·使用一个已经创建完毕的对象来初始化一个新对象
//·值传递的方式给函数参数传值
//·值方式返回局部对象

class Person
{
public:
	//无参构造(默认构造)
	Person()
	{
		cout << " Person无参 构造函数的调用" << endl;
	}
	//有参构造
	Person(int age)
	{
		Age = age;
		cout << " Person有参 构造函数的调用" << endl;
	}

	//拷贝构造
	Person(const Person& p)//const引用拷贝
	{
		cout << " Person拷贝 函数的调用" << endl;
		//将传入的人身上的所有属性，拷贝到当前人身上
		Age = p.Age;
	}

	//析构函数
	~Person()
	{
		cout << "~Person 析构函数的调用" << endl;
	}

	int Age;
};

1.使用一个已经创建完毕的对象来初始化一个新对象
//void test1()
//{
//	Person p1(20);//有参
//	Person p2(p1);//拷贝
//	cout << " p2的年龄为："<<p2.Age << endl;
//}
//
2.值传递的方式给函数参数传值
//void doWork(Person p)
//{
//
//}
//void test2()
//{
//	Person p;
//	doWork(p);
//}
//3.值方式返回局部对象
Person  doWork2()
{
	Person p1;
	cout << (int)&p1 << endl;
	return p1;//拷贝出p1的值，返回，传给test03的p 
}
void test03()
{
	Person p=doWork2();
	cout << (int)&p << endl;
}
int main() 
{
	//test1();
	//test2();
	test03();
	return 0;
}

四、构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数

1．默认构造函数(无参，函数体为空)
2．默认析构函数(无参，函数体为空)
3．默认拷贝构造函数，对属性进行拷贝

构造函教调用规则如下:

如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造

如果用户定义拷贝构造函数，C++不会再提供其他构造函数

1.创建一个类，C++编译器会给每个类都添加至少3个函数

#include <iostream>
using namespace std;

//构造函数的调用规则
//1、创建一个类，C++编译器会给每个类都添加至少3个函数
//默认构造	 (空实现)
//析构函数	（空实现)
//拷贝构造	 (值拷贝）

class Person
{
public:
	//无参构造(默认构造)
	Person()
	{
		cout << " Person默认 构造函数的调用" << endl;
	}
	//有参构造
	Person(int age)
	{
		Age = age;
		cout << " Person有参 构造函数的调用" << endl;
	}

	//拷贝构造
	Person(const Person& p)//const引用拷贝
	{
		cout << " Person拷贝 函数的调用" << endl;
		//将传入的人身上的所有属性，拷贝到当前人身上
		Age = p.Age;
	}

	//析构函数
	~Person()
	{
		cout << "~Person 析构函数的调用" << endl;
	}

	int Age;
};


void test01()
{
	Person p;
	p.Age = 18;
	Person p2(p); //拷贝构造
	cout <<"p2的年龄为："<<p2.Age<< endl;
}
int main() 
{
	test01();
	return 0;
}

在这里插入图片描述
在这里插入图片描述

我们将拷贝函数注释掉

拷贝构造
	//Person(const Person& p)//const引用拷贝
	//{
	//	cout << " Person拷贝 函数的调用" << endl;
	//	//将传入的人身上的所有属性，拷贝到当前人身上
	//	Age = p.Age;
	//}

void test01()
{
	Person p;
	p.Age = 18;
	Person p2(p); //拷贝构造
	cout <<"p2的年龄为："<<p2.Age<< endl;
}

此时，p2应该是未知的，但是结果p2年龄任为18
与上面运行结果对比，输出少了拷贝构造函数的调用
在这里插入图片描述
原因分析：
只要创建一个类，C++编译器默认会给每个类都添加至少3个函数
默认构造 (空实现)
析构函数 （空实现)
拷贝构造 (值拷贝）

相当于编译器默认执行了Age = p.Age;

2.定义了有参构造函数，c++不在提供默认构造，但会提供默认拷贝构造

我们写了有参构造函数，然后注释点默认构造，再调用默认构造函数

进行验证
在这里插入图片描述
我们写了有参构造函数，此时编译器不在提供默认构造，报错

在这里插入图片描述
在上面条件下注释掉拷贝函数，再调用拷贝函数
在这里插入图片描述

void test02()
{
	Person p(18);
	Person p2(p);
	cout << "p2的年龄为：" << p2.Age << endl;
}

结果发现拷贝函数功能正常

再次验证了
写了有参构造函数，编译器不在提供默认构造，依然提供拷贝构造在这里插入图片描述

3.定义拷贝构造函数，C++不再提供其他构造函数

现在注释掉其他构造函数，仅保留拷贝构造
再调用默认构造、有参构造

class Person
{
public:
	无参构造(默认构造)
	//Person()
	//{
	//	cout << " Person默认 构造函数的调用" << endl;
	//}
	有参构造
	//Person(int age)
	//{
	//	Age = age;
	//	cout << " Person有参 构造函数的调用" << endl;
	//}

	//拷贝构造
	Person(const Person& p)//const引用拷贝
	{
		cout << " Person拷贝 函数的调用" << endl;
		//将传入的人身上的所有属性，拷贝到当前人身上
		Age = p.Age;
	}

	析构函数
	//~Person()
	//{
	//	cout << "~Person 析构函数的调用" << endl;
	//}

	int Age;
};

void test02()
{
	Person p;
	Person p2(18);
}

结果
默认构造和有参构造调用出错

验证了
如果我们写了拷贝构造函数，编译器就不在提供其他的普通构造函数了
在这里插入图片描述

五、深拷贝与浅拷贝

在这里插入图片描述

1.浅拷贝存在的问题

没有拷贝构造函数，也可以调用，因为编译器默认提供了拷贝，即
浅拷贝

#include <iostream>
using namespace std;

//深拷贝与浅拷贝

class Person
{
public:
	//无参构造(默认构造)
	Person()
	{
		cout << " Person默认 构造函数的调用" << endl;
	}
	//有参构造
	Person(int age)
	{
		Age = age;
		cout << " Person有参 构造函数的调用" << endl;
	}

	//析构函数
	~Person()
	{
		cout << "~Person 析构函数的调用" << endl;
	}

	int Age;
};


void test01()
{
	Person p1(18);//有参构造
	cout << "p1的年龄为：" << p1.Age << endl;

	Person p2(p1);//没有拷贝构造函数，也可以调用，因为编译器默认提供了拷贝，即
浅拷贝
	cout <<"p2的年龄为："<<p2.Age<< endl;
}

int main() 
{
	test01();
	return 0;
}

在这里插入图片描述
我们在Person类中增加指针成员变量 int *Height;

将有参构造，增加身高信息Person(int age, int height)

	//有参构造
	Person(int age, int height)
	{
		Age = age;
		Height = new int(height);//堆去开辟数据
		cout << " Person有参 构造函数的调用" << endl;
	}
	
	int Age;
    int *Height;

测试输出

void test01()
{
	Person p1(18,160);//有参构造
	cout << "p1的年龄为：" << p1.Age <<"   身高为：" <<*p1.Height<<endl;
	Person p2(p1);//没有拷贝构造函数，也可以调用，因为编译器默认提供
	cout <<"p2的年龄为："<<p2.Age << "   身高为：" << *p2.Height << endl;
}

此时，输出正常，但是程序有些问题
在这里插入图片描述

之前提到
在这里插入图片描述

堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete

对象在销毁前把堆区数据释放掉

那么对象何时销毁？

test01()执行完了，p1,p2 就销毁了

p1,p2 销毁前会调用析构函数，析构函数将堆区开辟数据释放干净

//析构函数
~Person()
{
	//析构代码，将堆区开辟数据做释放操作
	if (Height != NULL)
	{
		delete Height;
		Height = NULL;
	}
	cout << "~Person 析构函数的调用" << endl;
}

再运行
运行结果一闪而过
跳出错误
在这里插入图片描述

在这里插入图片描述

2.引入深拷贝

分析问题上述问题
在这里插入图片描述
解决方案
自己写一个拷贝函数
重新在堆区申请一块地址，存放160，这时地址不在是0xx0011

在这里插入图片描述

//自己实现一个拷贝构造函数，解决浅拷贝带来的问题
	Person(const Person& p)
	{
		cout << " Person拷贝 函数的调用" << endl;
		Age = p.Age;
		Height = p.Height;//编译器实现的浅拷贝就是这行代码
		
		//深拷贝
		Height = new int(*p.Height);

	}

在这里插入图片描述

深拷贝完整程序

#include <iostream>
using namespace std;

//深拷贝与浅拷贝

class Person
{
public:
	//无参构造(默认构造)
	Person()
	{
		cout << " Person默认 构造函数的调用" << endl;
	}
	//有参构造
	Person(int age, int height)
	{
		Age = age;
		Height = new int(height);
		cout << " Person有参 构造函数的调用" << endl;
	}

	//自己实现一个拷贝构造函数，解决浅拷贝带来的问题
	Person(const Person& p)
	{
		cout << " Person拷贝 函数的调用" << endl;
		Age = p.Age;
		Height = p.Height;//编译器实现的浅拷贝就是这行代码
		
		//深拷贝
		Height = new int(*p.Height);

	}
	//析构函数
	~Person()
	{
		//析构代码，将堆区开辟数据做释放操作
		if (Height != NULL)
		{
			delete Height;
			Height = NULL;
		}
		cout << "~Person 析构函数的调用" << endl;
	}

	int Age;
	int *Height;
};


void test01()
{
	Person p1(18,160);//有参构造
	cout << "p1的年龄为：" << p1.Age <<"   身高为：" <<*p1.Height<<endl;
	Person p2(p1);//没有拷贝构造函数，也可以调用，因为编译器默认提供
	cout <<"p2的年龄为："<<p2.Age << "   身高为：" << *p2.Height << endl;
}

int main() 
{
	test01();
	return 0;
}

参考：黑马程序员
哔哩哔哩 黑马程序员

R-G-B
关注
  • 7
    点赞
  • 踩
  • 54
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
【C++初阶】简析构造函数、析构函数
Captain_ldx的博客
10-04 1700
讲讲构造函数、析构函数的知识
c++之类和对象——构造函数，析构函数
kosokahonoka的博客
10-04 550
析构函数和构造函数详解
【C++入门】(拷贝)构造函数和析构函数
weixin_42031299的博客
10-06 1668
(1)：字面意思就是构造对象的函数，当我们定义类的对象时调用，可以帮我们完成对象的初始化；(2)：可以看做是构造函数的逆过程，当销毁类的时候调用，做一些收尾的工作；比如：定义类的对象时构造函数申请了动态内存，那在销毁对象时调研员的析构函数中就要释放申请的动态内存，否则就会造成内存泄漏；(3)。程序员可以在定义类时使用默认的构造/析构函数，或者自己定义构造/析构函数，但是构造/析构函数的调用却不是程序员主动去调用，而是C++语言自动帮我们调用。
C++ 构造函数与析构函数
2201_75772333的博客
05-03 1291
这可能会导致问题，例如，当一个对象被删除时，其析构函数可能会删除共享的内存，从而使另一个对象的指针变为悬挂指针。但是，如果类有指向动态分配内存的指针成员，或者包含需要特殊处理的资源（如文件句柄，网络连接等），那么通常需要提供自定义的拷贝构造函数以执行深拷贝。：当我们执行深拷贝时，不仅复制对象的所有非静态成员变量，还会为每个动态内存分配的指针成员创建新的内存复制，确保新对象获得的是原始对象数据的全新副本，而不是引用同一内存。在 C++ 中，构造函数是一种特殊的成员函数，它会在创建类的新对象时自动被调用。
【C++】构造函数与析构函数
翼同学
04-04 2612
什么是构造函数？ 构造函数是一种特殊的方法。 用于创建对象时初始化对象成员。 什么是析构函数？ 析构函数与构造函数相反。 当对象结束其生命周期，系统自动执行析构函数。 即释放内存，撤销类对象。...
C++构造函数和析构函数顺序
12-22
构造函数 　先看看构造函数的调用顺序规则，只要我们在平时编程的时候遵守这种约定，任何关于构造函数的调用问题都能解决；构造函数的调用顺序总是如下： 　1.基类构造函数。如果有多个基类，则构造函数的调用顺序...
深入解析C++中的构造函数和析构函数
12-31
调用构造函数和析构函数的顺序：先构造的后析构，后构造的先折构。它相当于一个栈，先进后出。 代码如下:#include<iostream>#include<string>using namespace std;class Student{ public: Student(string,string,...
C++构造函数和析构函数的使用与讲解
01-20
构造函数(constructor) 1.构造函数是种特殊的类成员函数，遵循如下规则： a.函数名与类名必须相同。...3.构造函数和普通成员函数不一样，一般不显示调用。在创建一个对象时，构造函数自动调用(编译器来完成
C++构造函数和析构函数的调用顺序1
08-08
C++构造函数和析构函数的调用顺序举例一．调用方法和区别1、构造函数的调用顺序： 基类构造函数、对象成员构造函数、派生类本身的构造函数 2、析构函数的调用顺序：
C++构造函数和析构函数
qq_63976098的博客
12-24 866
C++构造函数，析构函数；复制构造函数；拷贝构造函数；构造，析构的先后顺序
c++类和对象三部曲——（2）
m0_73904148的博客
04-09 704
默认成员函数(拷贝构造，编译器实现的拷贝构造，默认拷贝构造)(析构，默认析构)，(拷贝构造，默认拷贝构造，初识深拷贝浅拷贝问题)
构造函数与析构函数
m0_67711803的博客
10-01 3445
由于c语言常常会忘记初始化与销毁，造成许多麻烦。所以c++就引入了构造函数与析构函数，分别用来完成初始化与清理工作，且由编译器自动调用，这就避免了许多麻烦。
C++基础：构造函数与析构函数
weixin_58368590的博客
05-26 2622
数据成员多为私有的，要对他们进行初始化，必须用一个公有函数来进行。同时这个函数应该在定义对象时自动执行一次。称为构造函数。 构造函数的用途：1）创建对象；2）初始化对象中的属性；3）类型转换 构造函数的定义与使用： 构造函数是特殊的公有成员函数（在特殊用途中构造函数的访问限定可以定义成私有或者保护）。其特征如下： 1.函数名与类型名相同。 2.构造函数无函数返回类型说明。注意是没有而不是void,即什么也不写，也不可以写成void。实际上构造函数有返回值，返回的就是构造函数所创建的对象...
C语言构造函数和释构函数,c++基础语法:构造函数与析构函数
weixin_42656416的博客
05-21 1292
一.构造函数类似于java,C++中也有构造函数的概念，相关用法如下：1.1 构造函数的定义#include using namespace std;class Student{private:char *m_name;int m_age;float m_score;public://声明构造函数Student(char *name, int age, float score);//声明普通成员函...
C++类构造函数和析构函数
Jasmine-Lily的博客
11-16 1563
C++类构造函数和析构函数
c++中的构造函数和析构函数
m0_61973596的博客
03-13 1973
c++中的构造函数和析构函数
C++构造函数与析构函数
fairy_little的博客
04-18 945
构造函数语法：类名（）{} 1.构造函数，没有返回值也不写void 2.函数名与类名相同 3.构造函数可以有参数，因此可以发生重载 4.程序在调用对象时会自动调用构造函数，无需手动 析构函数语法：~类名（）{} 1.析构函数，没有返回值也不写void 2.函数名称与类名相同，在名称前加~ 3.析构函数不可以有参数，因此不能发生重载 4.程序在对象销毁前会自动调用析构函数，无需手动 构造函数的分类和调用 分类：有参构造函数 、无参构造函数 普通构造函数...
c++基础 面向对象：第五篇（构造，析构，拷贝函数）
呋喃吖的博客
06-21 614
一 构造函数 在c++中，类内的成员变量是通过构造函数去初始化的。 构造函数： 在实例化一个对象时，给对象的成员属性初始化。 语法： 类名（）{} 1.与类名同名，没有返回值。 2.创建对象时候自动调用构造函数 3.假如自己不写构造函数，编译器会给你写，并且时自动调用的。 4.构造函数可以有参数，所以也可以函数重载。 1. 构造函数的分类及其调用 分类： 默认（无参）构造：没有形参的构造函数。假如自己不编写，编译器自动调用的函数。无参不代表没有成员变量参数啊，只是代表没有形参。 有参构造：有
构造函数和析构函数
Denkensk的专栏
03-04 610
要想搞明白该问题，需要理解基类构造析构函数、子类构造析构函数和子类成员变量构造析构函数的调用顺序。 对于构造函数：基类构造函数 > 子类成员变量构造函数 > 子类构造函数 对于析构函数：子类析构函数 > 子类成员变量析构函数 > 基类析构函数 可以看出构造函数的调用过程和析构函数的调用过程正好相反。 main函数中首先构造变量a，然后是b。在构造b时首先调用b的基类A的构造函数
c++构造函数和析构函数
最新发布
06-07
C++中的构造函数和析构函数是用来初始化和清理类对象的特殊成员函数。构造函数在对象被创建时自动调用，而析构函数则在对象被销毁时自动调用。 构造函数的名称与类名称相同，没有返回类型，可以有参数，分为默认构造函数和带参数构造函数。默认构造函数无需参数，用于创建对象时的默认初始化操作；带参数构造函数可以通过参数列表对对象进行初始化。 析构函数的名称与类名称相同，前面加上~符号，没有返回类型和参数。析构函数通常用来释放对象占用的资源，如动态分配的内存、打开的文件等。 例如： ```c++ class MyClass { public: // 默认构造函数 MyClass() { // 对象初始化操作 } // 带参数构造函数 MyClass(int value) { // 对象初始化操作 } // 析构函数 ~MyClass() { // 对象清理操作 } }; ``` 当创建MyClass对象时，会自动调用相应的构造函数；当销毁MyClass对象时，会自动调用析构函数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

R-G-B

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值