2021自学C++核心编程之对象初始化(构造函数)和清理(析构函数)以及静态成员(五)

最新推荐文章于 2022-10-18 22:38:31 发布
置顶 最新推荐文章于 2022-10-18 22:38:31 发布
阅读量358 收藏 1
点赞数
分类专栏： c/c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QZP51ZX/article/details/121616725
版权

4.2 对象的初始化和清理

生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全，同理，C++中创建每个对象也都会有初始设置以及对象使用完销毁前的清理数据的设置，以保证程序安全运行！

4.2.1 构造函数和析构函数

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

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

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

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供

注意:编译器提供的构造函数和析构函数是空实现。

  • 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
  • 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：

类名(){
    //空实现:指任何类中默认存在无参构造函数且函数体内不做任何操作，创建对象时，编译器自动调用提供的无参构造函数且不做任何其他操作
}

书写构造器的规则:

  1. 构造函数没有返回值也不写void
  2. 构造器的方法名称和类名相同（首字母一定要大写）

注意事项：

  • 默认在任意一个类中，如果不存在任何构造器，那么c++会填充一个无参的构造函数，且为空实现
  • 程序在类创建对象时会自动调用构造，无须手动调用,而且只会调用一次
#include<iostream>
using namespace std;
//创建一个Person类
class Person{
public:
	//注意:类中默认存在一个无参构造构造函数且为空实现，这个构造函数一般可以省略不写，可以直接调用
    //注意:当类中编写了无参构造函数，则可以进行其他操作，例如:进行打印输出
	Person(){
        cout << "无参构造函数!" << endl;
	}
};

int main() {
	//创建Person实例化对象p时，编译器会自动调用无参构造函数
	Person p;
	system("pause");
	return 0;
}
  • 对于带参数构造函数来说，如果一个类中存在带参构造器，那么默认存在无参构造函数如果在程序不编写，则不存在。如果编写，则仍然存在，我们可以在程序中看到
  • 构造函数可以有参数，可以发生重载
#include<iostream>
using namespace std;
//创建一个Person类
class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
};
int main() {
	//创建Person实例化对象p1时，编译器会自动调用无参构造函数
	Person p1;
    //创建Person实例化对象p2时，编译器会自动调用有参构造函数
    Person p1(10);
	system("pause");
	return 0;
}

析构函数语法：

~类名(){
    //空实现:指任何类中默认存在无参析构函数且函数体内不做任何操作，在销毁该类的对象时，编译器默认调用提供的无参析构函数且不做任何其他操作
}

注意事项:

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

代码示例:

#include<iostream>
using namespace std;
//创建一个Person类
class Person{
public:
	//构造函数
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};
//定义全局函数test01，测试创建对象时，构造函数和析构函数的调用情况
void test01()
{
	//创建Person实例化对象p时，编译器会自动调用无参构造函数
	Person p;
}
int main() {
	//调用全局函数test01
    //注意:当调用全局函数test01时，创建对象P是一个局部对象，在test01函数调用完后，局部对象p的生命周期就结束了，GC会主动销毁对象p，编译器会在对象销毁前自动调用析构函数来清理对象中的数据
	test01();
	system("pause");
	return 0;
}

效果如图:

在这里插入图片描述

4.2.2 构造函数的分类及调用

两种分类方式：

  1. 按参数分为： 有参构造和无参构造
  2. 按类型分为： 普通构造和拷贝构造

三种调用方式：

  1. 括号法
  2. 显示法
  3. 隐式转换法

示例：

#include<iostream>
using namespace std;

//创建一个Person类
class Person {
//成员变量
public:
	//年龄
	int age;
//成员方法
public:
	//无参构造函数
	Person() {
		cout << "Person类的无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "Person类的有参构造函数!" << endl;
	}
	//拷贝构造函数
	//注意:使用const修饰引用类型的形参，防止形参改变实参
	Person(const Person &p) {
		//进行属性值拷贝
		age = p.age;
		cout << "Person类的拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "Person类的析构函数!" << endl;
	}
};
//测试
void test01() {
	//1.括号法，常用
	//1.1 默认调用无参构造函数
	Person p1;
	//1.2 调用有参构造函数
	Person p2(10);
	//1.3 调用拷贝构造函数
	Person p3(p2);
	cout << "p2.age = " << p2.age << endl;
	cout << "p3.age = " << p3.age << endl;
	//注意：调用无参构造函数不能加()，否则编译器认为这是一个函数声明
	Person p4();

	//2.显式法
	//2.1 默认调用无参构造函数
	Person p5;
	//2.2 调用有参构造函数
	Person p6 = Person(10);
	//2.3 调用拷贝构造函数
	Person p7 = Person(p6);
	//注意1:单独写就是匿名对象,创建匿名对象时，调用有参构造函数，对象创建完毕后，调用析构函数
	Person(10);
	cout << "匿名对象创建完之后调用析构函数后打印输出" << endl;
	//注意2：不能利用拷贝构造函数初始化匿名对象 编译器会认为Person (p7) == Person p7；对象的声明
	//Person(p7);

	//3 隐式转换法
	//3.1 调用有参构造函数
	Person p8 = 10; // <==> Person p8 = Person(10); 
	//3.2 调用拷贝构造函数
	Person p9 = p8; // <==> Person p9 = Person(p8); 
}
int main() {
	test01();
	system("pause");
	return 0;
}
4.2.3 拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况:

  1. 使用一个已经创建完毕的对象来初始化一个新对象
  2. 值传递的方式给函数参数传值
  3. 以值方式返回局部对象

示例：

#include<iostream>
using namespace std;

class Person {
public:
	int m_Age;
public:
	Person() {
		cout << "Person类默认构造函数!" << endl;
		m_Age = 0;
	}
	Person(int age) {
		cout << "Person类有参构造函数!" << endl;
		m_Age = age;
	}
	Person(const Person &p) {
		cout << "Person类拷贝构造函数!" << endl;
		m_Age = p.m_Age;
	}
	//析构函数在释放内存之前调用
	~Person() {
		cout << "Person类析构函数!" << endl;
	}
};

//1.使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
	//创建对象p1，调用有参构造函数
	Person p1(100); 
	//创建对象p2，调用拷贝构造函数，将对象p1中属性值拷贝给对象p2中相应的属性
	Person p2(p1); 
	cout << "p1.m_Age =" << p1.m_Age << endl;
	cout << "p2.m_Age =" << p2.m_Age << endl;
	//Person newman2 = p1; //拷贝构造

	//Person newman3;
	//newman3 = man; //不是调用拷贝构造函数，赋值操作
}

//2.值传递的方式给函数参数传值
//注意:形参对象为值传递的时，无法改变类中属性值
void doWork1(Person p) {
	cout << "p.m_Age = " << p.m_Age << endl;
	p.m_Age = 1000;
	cout << "p.m_Age = " << p.m_Age << endl;
}
void test02() {
	//创建对象p3，自动调用无参构造函数
	Person p3; 
	//注意:当调用doWork1(Person p1)函数时，形参中传入对象p，编译器自动进行将 Person p = p3 转换成 Person p = Person(p3)，调用了拷贝构造函数
	doWork1(p3);
	cout << "p3.m_Age = " << p3.m_Age << endl;
}

//3.以值方式返回局部对象
Person doWork2(){
	//创建对象p4，自动调用无参构造函数
	Person p4;
	cout << "p4对象的地址为:" << (int*)&p4 << endl;
	//注意:返回对象p4不是返回对象p4的地址，而是对象p4中的数据
	cout << "p4.m_Age = " << p4.m_Age << endl;
	p4.m_Age = 2000;
	cout << "p4.m_Age = " << p4.m_Age << endl;
	return p4;
}
void test03(){
	//注意:当调用doWork2()函数时，编译器自动进行将 Person p5 = p4 转换成 Person p5 = Person(p4)，调用了拷贝构造函数
	Person p5 = doWork2();
	cout << "p5对象的地址为:" << (int*)&p5 << endl;
	cout << "p5.m_Age = " << p5.m_Age << endl;
}

int main() {
	test01();
	cout<< "-------------------------------" << endl;
	test02();
	cout << "------------------------------" << endl;
	test03();
	system("pause");
	return 0;
}

效果如图:

在这里插入图片描述

4.2.4 构造函数调用规则

默认情况下，c++编译器至少给一个类添加4个函数，目前先学习以下3个函数

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

构造函数调用规则如下：

  • 任何类中定义有参构造函数，c++不在提供默认无参构造函数，但是会提供默认拷贝构造函数

  • 任何类定义拷贝构造函数，c++也不在提供默认无参构造函数

示例：

#include<iostream>
using namespace std;

class Person {
public:
	int m_Age;
public:
	//无参（默认）构造函数
	Person() {
		cout << "Person类无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age) {
		m_Age = age;
		cout << "Person类有参构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "Person类析构函数!" << endl;
	}
};
void test01()
{
	Person p1(18);
	cout << "p1的年龄为： " << p1.m_Age << endl;
	//如果类中不编写拷贝构造函数，编译器会自动添加拷贝构造函数，并且做浅拷贝操作
	Person p2(p1);
	cout << "p2的年龄为： " << p2.m_Age << endl;
}

class People {
public:
	int m_Age;
public:
	//有参构造函数
	People(int age) {
		m_Age = age;
		cout << "People类有参构造函数!" << endl;
	}
	//析构函数
	~People() {
		cout << "People类析构函数!" << endl;
	}
};
void test02()
{
	//任何类中定义有参构造函数，c++不在提供默认无参构造函数，但是会提供默认拷贝构造函数
	//People p1;  编译器直接报错
	//创建对象p2，调用有参构造函数
	People p2(10); 
	cout << "p2的年龄为： " << p2.m_Age << endl;
	//如果类中不编写拷贝构造函数，编译器会自动添加拷贝构造函数，并且做浅拷贝操作
	People p3(p2);
	cout << "p3的年龄为： " << p3.m_Age << endl;
}

class Human {
public:
	int m_Age;
public:
	//拷贝构造函数
	Human(const Human &p) {
		m_Age = p.m_Age;
		cout << "Human拷贝构造函数!" << endl;
	}
	//析构函数
	~Human() {
		cout << "Human类析构函数!" << endl;
	}
};
void test03()
{
	//任何类定义拷贝构造函数，c++也不在提供默认无参构造函数,
	//Human p1; Human类中无默认构造函数，编译器直接报错
	//Human p2(10); Human类无有参默认构造函数，编译器直接报错
	//Human p6(p5); Human类有拷贝构造函数，但无法创建其他对象，导致拷贝构造函数也无法使用
	string str = "注意:任何类在使用拷贝构造函数时，都需要在类中编写一个无参构造函数或者有参构造函数";
	cout<< str << endl;
}

int main() {
	test01();
	cout << "-------------------------------" << endl;
	test02();
	cout << "-------------------------------" << endl;
	test03();
	system("pause");
	return 0;
}

效果如图:

在这里插入图片描述

4.2.5 深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

示例：

#include<iostream>
using namespace std;
class Person {
public:
	//年龄
	int m_Age;
	//身高 注意:对于指针变量存储地址，不存储数据
	int* m_Height;
public:
	//无参构造函数
	Person() {
		cout << "Person类无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age) {
		cout << "Person类有参构造函数!" << endl;
		m_Age = age;
	}
	//有参构造函数
	Person(int age, int height) {
		cout << "Person类有参构造函数!" << endl;
		m_Age = age;
		m_Height = new int(height);

	}
	//类中必须编写一个拷贝构造函数，c++中提供的拷贝构造函数是浅拷贝  
	Person(const Person &p) {
		cout << "Person类拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_Age = p.m_Age;
		//m_Height = p.m_Height; 编译器默认实现浅拷贝
		cout << "p.m_Height地址为:" << p.m_Height << endl;
		m_Height = new int(*p.m_Height);//深拷贝
		cout << "m_Height地址为:" << m_Height << endl;

	}
	//析构函数
	~Person() {
		//注意:析构函数将堆区开辟数据空间进行释放操作
		cout << "Person类析构函数!" << endl;
		if (m_Height != NULL)
		{
			delete m_Height;
			m_Height = NULL;
		}
	}
};
void test01(){
	//调用有参构造函数
	Person p1(25);
	cout << "p1的年龄： " << p1.m_Age << endl;
	//调用拷贝构造函数
	Person p2(p1);
	cout << "p2的年龄： " << p2.m_Age << endl;
}
void test02(){
	Person p1(18, 180);
	cout << "p1的年龄： " << p1.m_Age << " 身高： " << *(p1.m_Height) << endl;
	//调用拷贝构造函数
	//注意:一定要在类中编写一个拷贝构造函数，编译器提供的默认拷贝构造函数实现浅拷贝，会导致浅拷贝带来的重复释放堆区问题
	Person p2(p1);
	cout << "p2的年龄： " << p2.m_Age << " 身高： " << *(p2.m_Height) << endl;
}

int main() {
	//调用test01函数时，调用的是c++中默认提供的拷贝构造函数
	test01();
	//调用test01函数时，调用的是类中编写的拷贝构造函数
	test02();
	system("pause");
	return 0;
}

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

C++用类名创建对象和用new创建对象的区别

  1. 用类名创建对象，是使用的stack空间，而使用new创建对象则使用的heap的空间;
  2. 使用new创建对象，用完之后必须要delete。并且要把指针置为NULL;用类名创建的对象，使用完后，系统自动销毁，不会存在系统泄露的问题。
  3. new创建的对象是使用指针来接受，一处初始化，多处使用。
  4. 对于频繁使用的场合，不建议使用new来创建。

构造函数使用new注意事项：

  1. 如果在构造函数使用new来初始化指针，则在析构函数使用delete

  2. new和delete要对应。new对应delete,new [] 对应delete []

  3. 如果有多个构造函数，必须以相同的方式使用new，因为只有一个析构函数。默认构造函数将它设置为null或0

4.2.6 初始化列表

作用：

C++提供了初始化列表语法，用来给属性初始化

语法：构造函数():属性1(值1),属性2(值2)... {}

示例：

#include<iostream>
using namespace std;
class Person {
public:
	int m_A;
	int m_B;
	int m_C;
public:
	//第一种方式:有参构造函数进行属性初始化
	//Person(int a, int b, int c) {
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}
	//第二种方式:无参构造函数初始化列表方式进行属性初始化
	//注意:这种方式属性的值无法随意改动，只能是固定值
	Person() :m_A(10), m_B(20), m_C(30) {};
	//第三种方式:有参构造函数初始化列表方式进行属性初始化
	//注意:有参构造函数初始化列表方式本质就是第一种有参构造函数进行属性初始化，所以，两者不能同时存在
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
};
//测试
void test01() {
	Person p1(1, 2, 3);
	cout << "mA = " << p1.m_A << endl;
	cout << "mB = " << p1.m_B << endl;
	cout << "mC = " << p1.m_C << endl;
}
void test02() {
	Person p2;
	cout << "mA = " << p2.m_A << endl;
	cout << "mB = " << p2.m_B << endl;
	cout << "mC = " << p2.m_C << endl;
}
void test03() {
	Person p3(100,200,300);
	cout << "mA = " << p3.m_A << endl;
	cout << "mB = " << p3.m_B << endl;
	cout << "mC = " << p3.m_C << endl;
}
int main() {
	test01();
	test02();
	test03();
	system("pause");
	return 0;
}
4.2.7 类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员

例如：

class A {}
class B
{
    A a；
}

B类中有对象A作为成员，A为对象成员

那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

示例：

#include<iostream>
using namespace std;
//定义一个Phone类
class Phone{
public:
	//手机型号名称
	string m_PhoneName;
public:
	Phone(string name)
	{
		m_PhoneName = name;
		cout << "Phone类中有参构造函数" << endl;
	}
	~Phone()
	{
		cout << "Phone类中析构函数" << endl;
	}
};
//定义一个Person类
class Person{
public:
	//姓名
	string m_Name;
	//手机
	Phone m_Phone;
public:
	//有参构造函数通过初始化列表可以进行属性初始化
	//注意:Phone m_Phone = pName <==>Phone m_Phone = Phone(pName),利用了隐式转换法，编译器自动调用了Phone类中的有参构造函数
	Person(string name, string pName) :m_Name(name), m_Phone(pName){
		cout << "Person类有参构造函数" << endl;
	};

	~Person(){
		cout << "Person析构" << endl;
	};

	void playGame(){
		cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
	};
};
//测试
void test01()
{
	//当类中成员是其他类对象时，我们称该成员为 对象成员
	//构造的顺序是:先调用对象成员的构造函数，再调用本类构造函数
	//析构的顺序是:先调用本类析构函数，再调用对象成员的析构函数
	Person p("张三", "苹果X");
	p.playGame();
}

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

结论: 当A类中成员是B类对象时，A与B的构造和析构的顺序如下:

  1. 构造的顺序是:先调用B类对象中的构造函数，再调用A类中构造函数
  2. 析构的顺序是:先调用A类析构函数，再调用B类对象的析构函数
4.2.8 静态成员

静态成员分为：

  • 静态成员变量
    • 所有对象共享同一份数据
    • 在编译阶段分配内存
    • 类内声明，类外初始化
  • 静态成员函数
    • 所有对象共享同一个函数
    • 静态成员函数只能访问静态成员变量

静态成员指在成员变量和成员函数前加上关键字static进行修饰，称为静态成员

示例1: 静态成员变量

#include<iostream>
using namespace std;
class Person {
public:
	//1.定义静态成员变量，
	//注意:
	//①.静态成员变量在编译阶段分配内存
	//②.在类中声明，在类外必须初始化，否则无法进行链接而导致编译无法通过！
	static int m_A; 
private:
	//4.当静态变量在private权限下，在类外两种方式都无法访问！！！
	static int m_B; //静态成员变量也是有访问权限的
};
//2.静态变量类内声明，类外初始化
int Person::m_A = 10;
int Person::m_B = 10;

void test01()
{
	//静态成员变量两种访问方式
	//第一种方式:通过类创建对象，对象.静态变量名进行操作，写读可写
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;
	p1.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl;
	Person p2;
	//3.所有类创建的对象共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;
	//第二种方式:通过类名::静态变量名进行操作，可读可写
	cout << "Person::m_A = " << Person::m_A << endl;
	Person::m_A = 2000;
	cout << "Person::m_A = " << Person::m_A << endl;
	//私有权限访问下的静态变量类外无法访问
	//cout << "m_B = " << Person::m_B << endl; 编译直接报错
}

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

总结:

  • 静态成员变量在编译阶段分配内存
  • 静态成员变量在类中声明，在类外必须初始化，否则无法进行链接而导致编译阶段无法通过！
  • 非private权限下的静态成员变量两种访问方式：
    • 通过类创建对象，对象.静态成员变量名进行操作，写读可写
    • 通过类名::静态成员变量名进行操作，可读可写
  • pirvate权限定义的静态成员变量类外上述两种方式都无法访问
  • 所有该类创建的对象或类名:::静态成员变量名共享同一份静态成员变量资源

示例2: 静态成员函数

#include<iostream>
using namespace std;
class Person{
public:
	//3.定义两个成员变量，静态成员变量注意需要在类外进行初始化
	static int m_A ; //静态成员变量
	int m_B; //成员变量
public:
	//1.在public权限下定义一个静态成员函数
	static void function1(){
		cout << "静态函数function1调用" << endl;
	}
	static void function2() {
		cout << "静态函数function2调用" << endl;
		//注意点如下:
		//①.静态成员函数中只可以访问静态成员，且对静态成员变量可以进行可读可写，对静态成员函数可以进行操作！
		//②.静态成员函数不可以访问非静态成员
		cout << "m_A 初始值为: " << m_A << endl;
		m_A = 100;
		cout << "m_A 修改值为: " << m_A << endl;
		//cout << "m_B 修改值为: " << m_B << endl;//编译器直接报错，无法访问成员函数
		function1();//调用静态成员函数function1
		//function3();//编译器直接报错，无法访问调用成员函数function3
	}
	//4.在public权限下定义一个非静态成员函数
	void function3() {
		cout << "静态函数function3调用" << endl;
	}
private:
	//6.private权限下定义静态成员函数
	static void function4(){
		cout << "function4调用" << endl;
	}
};
//静态成员变量m_A类外进行初始化
int Person::m_A = 10;

//测试
void test01(){
	//2.静态成员变量两种访问方式
	//注意:两种方式访问静态成员函数均为共享同一个函数
	//第一种方式:通过类创建对象后，以对象.静态成员函数名方式进行操作
	Person p1;
	p1.function1();
	//第二种方式:通过类名::静态成员函数名方式进行操作
	Person::function1();
	//5.调用静态成员函数function2
	//注意点如下:
	//①.静态成员函数中只可以访问静态成员，且对静态成员变量可以进行可读可写，对静态成员函数可以进行操作！
	//②.静态成员函数不可以访问非静态成员
	Person::function2();

	//注意:private权限下的静态成员函数,上述两种方式无法访问！！！
	//Person::function4(); //编译器直接报错，无法访问private权限下的静态成员函数
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结:

  • 在非private权限下的静态成员函数有两种方式进行操作：
    • 通过类创建对象，对象.静态函数名进行操作
    • 通过类名::静态函数名进行操作
  • pirvate权限定义的静态成员函数类外上述两种方式都无法访问
  • 所有该类创建的对象或类名:::静态成员函数名共享同一份静态成员函数
QZP51ZX
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
构造、析构函数
dfuw13072的博客
04-10 129
body, table{font-family: 微软雅黑; font-size: 10pt} table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;} th{border: 1px ...
C++ 对象的初始化和清理(构造函数和析构函数)
枕上青灯竹书香的博客
10-30 469
生活中我们买的电子产品否基本会出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全 c++ 中的面向对象来源于生活，每个对象也都会又初始设置以及对象销毁前的清理数据的设置 1、构造函数和析构函数 对象的初始化和清理也是两个非常重要的安全问题 一个对象或者变量没有初始化状态，对其使用后果是未知 同样的使用完一个对象或变量，没有及时的清理，也会造成一定的安全问题 C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象的初始化和清理...
c++类和对象之对象的初始化和清理（构造函数和析构函数）
weixin_44300779的博客
01-01 714
1、构造函数和析构函数 对象的初始化和清理是两个非常重要的安全问题，一个对象或者变量没有初始状态，对其使用后是未知的。 同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题 c++利用的构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象的初始化和清理工作。 对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现 //构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，
C++中 静态成员的应用及虚析构函数的使用
一木
06-21 336
#include &amp;lt;iostream&amp;gt; using namespace std; class Animal { public: static int number; Animal(){ number++; } virtual ~Animal()//注释1 : 如果不加virtual,删除c2...
【PTA】【C语言】复盘练习——函数题
yewanyuan的博客
05-25 9227
目录 R6-1 最大公约数-递归 R6-2 猴子吃桃-递归 R6-3 奇妙的定律-递归 R6-4 删除单链表的第i个结点。 R6-5 链表-查找链表最后节点 R6-6 链表逆序 R6-7 结构体-查找最低分学生记录 R6-8 结构体-查找同学信息 R6-9 逆序输出字符串 R6-10 求整数区间[a,b]中偶数之和 R6-11 阶乘计算 R6-12 求10×10方阵主副对角线元素之和 R6-13 输入多个单词，统计以指定字母开头的单词个数 R6-14 求等差数列前n项和 R
C++面向对象程序设计(甲)试卷B和参考答案.zip
最新发布
05-30
5. **构造函数与析构函数**：构造函数用于初始化新创建的对象，析构函数则在对象生命周期结束时执行，用于释放资源。C++还支持拷贝构造函数和移动构造函数。 6. **运算符重载**：C++允许用户为已有的运算符定义新的...
2021年全国月自学考试C程序设计试题.doc
12-18
6. 构造函数：C++中，构造函数是一种特殊的成员函数，用于初始化类的对象。 7. 函数参数传递：C++中的函数参数传递是按值传递，如果传递的是引用类型，则函数内部的操作会改变实参的值。例如，函数`void inc(int)`...
全国2010年1月自学考试C++程序设计试题以及答案
09-24
14. **对象数组与析构函数**：使用`delete[]`删除对象数组时，会自动调用每个元素的析构函数，确保资源的释放。 15. **条件编译指令**：`#elif`、`#error`、`#pragma`和`#include`都是预处理器指令，其中`#elif`...
C++编程思想.pdf
09-30
　全书共分十八章，内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流介绍、常量、内联函数、命名控制、引用和拷贝构造函数、运算符重载、动态对象创建、继承和组合、多态和虚...
C++编程思想
10-21
全书共分十八章，内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流介绍、常量、内联函数、命名控制、引用和拷贝构造函数、运算符重载、动态对象创建、继承和组合、多态和虚...
C++(11)：通过变长模板和完美转发实现函数的装饰器
风静如云的博客
05-24 482
结合变长模板，auto推导及完美转发的概念可以实现函数的装饰器功能： #include <iostream> using namespace std; template<class Fn, class ...Args> decltype(auto) func_wrap(Fn&& fn, Args&&... args) { printf("func call begin\n"); auto ret = forward<decltype(f
PTA 2022秋季C语言专题实验07
qq_46537100的博客
10-18 2748
6-1 指针应用-查找数组元素 6-2 请编写函数CHG(char *S) 7-1 秋天的第一杯奶茶 7-2 统计单词 7-3 找最大字符串 7-4 字符串排序 7-5 缩写期刊名 7-6 魔镜 7-7 书号判断与纠错 7-8 检查密码 7-9 六大门派身份识别
PTA:6-73 函数调用
Sy_Faker的博客
03-17 2449
编写三个函数：求两个整数的最大值、最小值、和。分别用这三个函数作为实参，再写一个计算函数compute，对两个整数进行各种计算。其中一个形参为指向具体算法函数的指针。 函数接口定义： int max(int a, int b); int min(int a, int b); int sum(int a, int b); int compute(int a, int b, int(*func)(in...
Java—计算题
qq_45885219的博客
10-08 604
Java—计算题 Description 一个简单的计算，你需要计算f(m,n)，其定义如下： 当m=1时，f(m,n)=n； 当n=1时，f(m,n)=m； 当m>1,n>1时，f(m,n)= f(m-1,n)+ f(m,n-1) Input 第一行包含一个整数T（1<=T<=100），表示下面的数据组数。 以下T行，其中每组数据有两个整数m，n（1<=m，n<=2000），中间用空格隔开。 Output 对每组输入数据，你需要计算出f(m,n)，并输出。每个结果占一行
【C++】构造函数 利用构造函数对类对象进行初始化
TPON的博客
01-25 1万+
有关构造函数与析构函数的知识点
C++PTA习题总结（二）
热门推荐
Lereno的博客
09-09 1万+
文章目录第五章 继承性：派生类 第五章 继承性：派生类
PTA.重载下标运算符[ ]
往事撩人醉的博客
05-10 893
4-1 重载下标运算符[ ]   (10分) 这段程序实现了安全数组。 请认真阅读程序并补全程序使之能正确执行。 裁判测试程序样例： 在这里给出函数被调用进行测试的例子。例如： #include #include using namespace std; const int SIZE = 3; class atype { int a[SIZE]; public:
c++构造与析构函数：初始化或清理一个对象
qq_41657077的博客
03-23 802
C++中使用构造函数和析构函数来进行这两项操作。这两个函数由编译器自动调用。 构造函数在创建对象时为成员属性赋值。析构函数在对象销毁时自动调用，如果对象不销毁则不调用。 这两个函数都是写在类里面。这两个函数必须存在，如果咱们不写，则编译器会自动写上，其中函数的内容为空。 默认构造函数和有参构造函数 构造函数写于类中。构造函数可以分为以下几类，即给一个对象的属性赋初值的方式有如下几类：有参和无参、普通和拷贝。 编译器自动提供的是无参构造函数。当我们没有给出其他构造函数时，编译器才会自动生成默认构
++i i++运算符重载简单理解
weixin_34321753的博客
10-11 1328
左右值的由来 左右值这两概念从c中传承而来，在c中左值是指能够出现在等号的左边的变量(表达式)，右值是指只能出现在等号右边的变量(表达式)。 左右值的区别 左值的变量或表达式由两部分组成，分别为数据值以及内存地址，而右值没有内存地址。 简单的小例子 #include <iostream> using namespace std; void main(){ i...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

QZP51ZX

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

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

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

打赏作者

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

抵扣说明：

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

余额充值