C++核心入门-04类和对象（2）- 对象的清理和初始化

最新推荐文章于 2023-03-11 21:15:58 发布
最新推荐文章于 2023-03-11 21:15:58 发布
阅读量128 收藏
点赞数
分类专栏： C++学习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50615776/article/details/119038929
版权

C++核心入门-04类和对象（2）- 对象的清理和初始化

4.2 对象的初始化和清理

  • 生活中，我们买的电子产品都基本会有出场设置，在某一天，我们不用的时候也会删除一些自己的信息数据，保证安全。
  • C++中面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。

4.2.1 构造函数和析构函数

对象的初始化和清理是两个非常重要的安全问题。一个对象或者变量没有初始状态，对其使用的后果是未知的；同样的，使用完一个对象或变量，没有及时清理，也会造成一定的安全问题。

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

对象的初始化和清理工作是编译器强制要求我们做的事情，因此如果我们不提供构造函数和析构函数，编译器会自动提供。编译器提供的构造函数和析构函数是空实现。

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

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

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

我的理解就是：构造函数就是用来类的变量的初始化操作；析构函数就是用来对类的变量的清理操作。

例子：

#include<iostream>
using namespace std;

//对象的初始化和清理
class Person
{
public:
	//1、构造函数  进行初始化操作
	//1.1、构造函数
	//没有返回值 不用写void
	//函数名 与类名相同
	//构造函数可以有参数，可以发生重载
	//创建对象的时候，构造函数会自动调用，而且只调用一次
	Person()
	{
		cout << "Person 构造函数的调用" << endl;
	}
	//2.析构函数 进行清理的操作
	//没有返回值  不写void
	//函数名和类名相同 在名称前面加~
	//析构函数不可以有参数的，不能发生重载
	//对象在销毁之前 会自动调用析构函数，而且只会调用一次
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}
};

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

运行结果：
在这里插入图片描述
在这里，我们自己提供了构造函数和析构函数，并且每个函数都有cout的输出便于我们观察。从运行结果可以看到，当main()运行到test01()时，由于在子函数test01()中，通过Person p;语句创建了一个Person类的变量p，进而编译器自动调用了构造函数。当test01(）执行完毕之后，变量p进行了释放，编译器又自动调用了析构函数。

倘如main()中代码是这样子的：

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

并没有调用test01()这个子函数，运行结果如下：
在这里插入图片描述
当main()函数运行到语句 Person p;时，由于创建了一个Person类的变量p，所以编译器自动调用构造函数，之后就卡在了 system(“pause”);这个语句处，由于main()并没有执行完毕，所以变量p暂时没有被清除，所以还没有调用析构函数。当我们按下enter键后，main()接着执行，最后运行完毕。（执行完毕后其实应该也是调用了析构函数，屏幕的小黑框会有一瞬间显示析构函数调用了，我观看的教学视频里面确实有，我的电脑没有。。。。。）

4.2.2 构造函数的分类及调用

（1）分类方式有两种：

  • 按照参数分为：有参构造和无参构造；
  • 按照类型分为：普通构造和拷贝构造。

（2）调用方式有三种：

  • 括号法（最常用）；
  • 显示法；
  • 隐式转换法。

例子：

1）分类：

//分类
//	按照参数分类：无参构造（默认构造） 和 有参构造
//	按照类型分类：普通构造 和 拷贝构造
class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person 无参构造函数的调用" << endl;
	}

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

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

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

	int age;
};

2）调用：

  • 括号法
#include<iostream>
using namespace std;

class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person 无参构造函数的调用" << endl;
	}

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

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

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

	int age;
};

//调用
void test01()
{
	//1.括号法
	Person p;//默认构造函数调用
	Person p2(10);//有参构造函数调用
	Person p3(p2);//拷贝构造函数调用
	cout << "p2的年纪：" << p2.age << endl;
	cout << "p3的年纪：" << p3.age << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述
注意事项：
利用括号法，调用默认构造函数时，不要加（），因为编译器会认为这是一个函数声明，不会认为在创建对象。

例如：

//调用
void test01()
{
	//注意事项1：
	//调用默认构造函数时候，不要加（）
	//因为下面这行代码，编译器会认为是一个函数的声明，不会认为在创建对象
	Person p1();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述
没有任何输出，表示编译器将Person p1();当作函数声明了。

  • 显示法

例子：

//调用
void test01()
{
	//2.显示法
	Person p1;
	Person p2 = Person(10);//有参构造
	Person p3 = Person(p2);//拷贝构造
}

运行结果：
在这里插入图片描述
这里提一下，有一种叫匿名对象，其特点是：当前行执行结束后，系统会立即回收掉匿名对象。
例子：

//调用
void test01()
{
	Person(10);//匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象
	cout << "aaaa" << endl;
}

运行结果：
在这里插入图片描述

注意事项2：不要利用拷贝构造函数 初始化匿名对象 编译器会认为 Person(p3)==Person p3；这是对象声明;

//调用
void test01()
{
	//2.显示法
	Person p1;
	Person p2 = Person(10);//有参构造
	Person p3 = Person(p2);//拷贝构造
	
	//注意事项2：
	//不要利用拷贝构造函数，初始化匿名对象	编译器会认为 Person(p3)==Person p3;
	Person(p3);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述

  • 隐式转换法

例子：

//调用
void test01()
{
	//3、隐转换法
	Person p4 = 10;//相当于写了 Person p4=Person(10);	有参构造调用
	Person p5 = p4;//拷贝构造
}

运行结果：
在这里插入图片描述

4.2.3 拷贝构造函数调用时机

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

  • 使用一个已经创建完毕的对象来初始化一个新的对象；
  • 值传递的方式给函数参数传值；
  • 以值方式返回局部变量。

例子：
（1）使用一个已经创建完毕的对象来初始化一个新的对象

#include<iostream>
using namespace std;

//拷贝构造函数调用时机


class Person
{
public:
	Person()
	{
		cout << "Person的默认构造函数调用" << endl;
	}

	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;
	}

	int m_Age;
};

//1、使用一个已经创建完毕的对象来初始化一个新的对象
void test01()
{
	Person p1(10);
	Person p2(p1);

	cout << "p2的年纪为多少：" << p2.m_Age << endl;
}
int main()
{
	test01();
	//test02();
	//test03();
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述
（2）值传递的方式给函数参数传值

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

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

运行结果：
在这里插入图片描述
值传递的本身就是会拷贝出一个临时的副本出来，这里就调用了拷贝构造函数，类似于Person p( p );这两个p不是同一个，一个是形参，一个是实参。

（3） 以值方式返回局部变量

//3、值方式返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int)&p1 << endl;
	return p1;
}

void test03()
{
	Person p = doWork2();
	cout << (int)&p << endl;
}

运行结果：
在这里插入图片描述
这里return p1我理解的是先把内容给一个临时的变量，然后将临时变量拷贝给p。

4.2.4 构造函数调用规则

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

  • 默认构造函数（无参，函数体为空）
  • 默认析构函数（无参，函数体为空）
  • 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

  • 如果用户定义有参构造函数，C++编译器不再提供默认无参构造函数，但会提供默认拷贝构造函数；
  • 如果用户定义拷贝构造函数，C++编译器不会再提供其他构造函数。

例子：

(1)默认情况下，C++编译器至少给一个类添加3个函数
不设置拷贝构造函数，利用默认的拷贝构造函数

#include<iostream>
using namespace std;

//构造函数的调用规则
class Person
{
public:
	Person()
	{
		cout << "Person的默认构造函数调用" << endl;
	}

	Person(int age)
	{
		m_Age = age;
		cout << "Person的有参构造函数调用" << endl;
	}

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

	//Person(const Person &p)
	//{
	//	m_Age = p.m_Age;
	//	cout << "Person的拷贝构造函数调用" << endl;
	//}

	int m_Age;
};

void test01()
{
	Person p;
	p.m_Age = 18;

	Person p2(p);
	cout << "p2的年龄为：" << p2.m_Age << endl;
}

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

运行结果：
在这里插入图片描述
（2）如果我们写了有参构造函数，编译器就不再提供默认构造函数，但是依然提供拷贝构造函数

当我们创建了有参构造函数，编译器也不提供默认构造函数，又将自己创建的无参构造函数注释了，则：

#include<iostream>
using namespace std;

//构造函数的调用规则
//2.1 如果我们写了有参构造函数，编译器就不再提供默认构造函数，但是依然提供拷贝构造函数
class Person
{
public:
	//Person()
	//{
	//	cout << "Person的默认构造函数调用" << endl;
	//}

	Person(int age)
	{
		m_Age = age;
		cout << "Person的有参构造函数调用" << endl;
	}

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

	//Person(const Person &p)
	//{
	//	m_Age = p.m_Age;
	//	cout << "Person的拷贝构造函数调用" << endl;
	//}

	int m_Age;
};

void test02()
{
	Person p;

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

出现了报错：
在这里插入图片描述
但是会提供默认拷贝构造函数：
在这里插入图片描述
（3）如果用户定义拷贝构造函数，C++编译器不会再提供其他构造函数
将无参构造函数、和有参构造函数注释，则：
在这里插入图片描述

4.2.5 深拷贝与浅拷贝

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

浅拷贝：简单的赋值拷贝操作。
深拷贝：在堆区重新申请空间，进行拷贝操作。

例子：
当使用默认的拷贝构造函数时：

#include<iostream>
using namespace std;

//深拷贝和浅拷贝

class Person
{
public:
	Person()
	{
		cout << "Person的默认构造函数调用" << endl;
	}

	Person(int age)
	{
		m_Age = age;
		cout << "Person的有参构造函数调用" << endl;
	}

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

	int m_Age;//年龄
};

void test01()
{
	Person p1(18);
	cout << "p1的年龄为：" << p1.m_Age << endl;

	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << endl;

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

运行结果：
在这里插入图片描述
如果函数对堆区的数据进行处理，则会出现错误：

#include<iostream>
using namespace std;

//深拷贝和浅拷贝

class Person
{
public:
	Person()
	{
		cout << "Person的默认构造函数调用" << endl;
	}

	Person(int age, int height)
	{
		m_Age = age;
		m_Height = new int(height);
		cout << "Person的有参构造函数调用" << endl;
	}

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

	int m_Age;//年龄
	int *m_Height;//身高
};

void test01()
{
	Person p1(18, 160);
	cout << "p1的年龄为：" << p1.m_Age << "	身高为：" << *p1.m_Height << endl;

	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << "	身高为：" << *p2.m_Height << endl;

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

在这里插入图片描述
因为这里对堆区中的内存进行了重复的释放，所有报错了。

在这里插入图片描述
解决的办法就是：自己写深拷贝的拷贝构造函数。

	//自己实现拷贝构造函数 解决浅拷贝带来的问题
	Person(const Person &p)
	{
		cout << "Person拷贝构造函数的调用" << endl;
		m_Age = p.m_Age;
		//m_Height = p.m_Height;//编译器默认实现的就是这行代码

		//深拷贝操作
		m_Height = new int(*p.m_Height);
	}

运行结果：
在这里插入图片描述
我所理解的就是通过深拷贝，在堆区重新创建了另一个内存空间。
在这里插入图片描述
总结：如果有属性在堆区开辟的，一定要自己提供拷贝函数，防止浅拷贝带来的问题。

4.2.6 初始化列表

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

语法：构造函数（）：属性1（值1），属性2（值2）. . .{ }

（1）传统方式初始化

#include<iostream>
using namespace std;

//初始化列表
class Person
{
public:
	//传统初始化操作
	Person(int a, int b, int c)
	{
		m_A = a;
		m_B = b;
		m_C = c;
	}

	int m_A;
	int m_B;
	int m_C;
};

void test01()
{
	Person p1(30, 20, 10);
	cout << "m_A=" << p1.m_A << endl;
	cout << "m_B=" << p1.m_B << endl;
	cout << "m_C=" << p1.m_C << endl;

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

运行结果：
在这里插入图片描述
（2）初始化列表方式初始化

#include<iostream>
using namespace std;

//初始化列表
class Person
{
public:

	//初始化列表初始化属性
	Person() :m_A(10), m_B(20), m_C(30)
	{
	}

	int m_A;
	int m_B;
	int m_C;
};

void test01()
{
	Person p1;
	cout << "m_A=" << p1.m_A << endl;
	cout << "m_B=" << p1.m_B << endl;
	cout << "m_C=" << p1.m_C << endl;

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

运行结果：
在这里插入图片描述
或者：

#include<iostream>
using namespace std;

//初始化列表
class Person
{
public:

	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c)
	{

	}
	int m_A;
	int m_B;
	int m_C;
};

void test01()
{
	Person p1(30, 20, 10);
	cout << "m_A=" << p1.m_A << endl;
	cout << "m_B=" << p1.m_B << endl;
	cout << "m_C=" << p1.m_C << endl;

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

在这里插入图片描述

4.2.7 类对象作为类成员

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

例如：

class A {}
class B
{
	A a;
}

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

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

例子：

#include<iostream>
#include<string>
using namespace std;

//类对象作为类成员
//手机类
class Phone
{
public:
	Phone(string pName)
	{
		cout << "Phone的构造函数调用" << endl;
		m_PName = pName;
	}
	~Phone()
	{
		cout << "Phone的析构函数调用" << endl;
	}
	//手机品牌名称
	string m_PName;
};

//人类
class Person
{
public:
	//Phone m_Phone=pName  隐式转换法
	Person(string name, string pName) :m_Name(name), m_Phone(pName)
	{
		cout << "Person的构造函数调用" << endl;
	}

	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}
	//姓名
	string m_Name;
	//手机
	Phone m_Phone;
};

//当其他类对象作为本类成员，构造的时候先构造类对象，在构造自身，析构的顺序与构造相反
void test01()
{
	Person p("张三", "苹果MAX");
	cout << p.m_Name << "拿着：" << p.m_Phone.m_PName << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述
当其他类对象作为本类成员，构造的时候先构造类对象，在构造自身，析构的顺序与构造相反

4.2.8 静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。

静态成员分为：

（1）静态成员变量

  • 所有对象共享同一份数据
  • 在编译阶段分配内存
  • 类内声明，类外初始化

（2）静态成员函数

  • 所有对象共享一个函数
  • 静态成员函数只能访问静态成员变量

（1）静态成员变量

#include<iostream>
using namespace std;

//静态成员变量
class Person
{
public:

	//1、所以对象都共享一份数据
	//2、编译阶段就分配内存了
	//3、类内声明，类外初始化操作
	static int m_A;//类内声明
};

int Person::m_A = 100;//类外初始化操作

void test01()
{
	Person p;
	cout << p.m_A << endl;

	Person p2;
	p2.m_A = 200;
	//100？200
	cout << p.m_A << endl;
	cout << p2.m_A << endl;
}

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

运行结果：
在这里插入图片描述
可以看到p1和p2共同使用m_A这个数据。

静态成员变量有两种访问方式：通过对象和通过类名
例子：

void test02()
{
	//静态成员变量 不属于某个对象上，所有对象都共享同一份数据
	//因此静态成员变量有两种访问方式

	//1、通过对象进行访问
	Person p;
	cout << p.m_A << endl;

	//2、通过类名进行访问
	cout << Person::m_A << endl;
}

运行结果：
在这里插入图片描述
静态成员变量也是由访问权限的，例如声明了一个私有的静态成员变量m_B，在类外的子函数中不可以访问：
在这里插入图片描述

（2）静态成员函数

#include<iostream>
using namespace std;

//静态成员函数
//1、所有对象共享同一个函数
//2、静态成员函数只能访问静态成员变量
class Person
{
public:
	//静态成员函数
	static void func()
	{
		m_A = 100;//静态成员函数可以访问 静态成员变量
		m_B = 200;//静态成员函数 不可以访问非静态成员变量  无法区分到底是哪个对象的m_A
		cout << "static void func()的调用" << endl;
	}

	static int m_A;//静态成员变量
	int m_B;//非静态成员变量

	//静态成员函数也是又访问权限的
private:
	static void func2()
	{
		cout << "static void func2的调用" << endl;
	}
};

int Person::m_A = 0;
//有两种访问方式
void test01()
{
	//1、通过对象访问
	Person p;
	p.func();

	//2、通过类名进行访问
	Person::func();

	//Person::func2();//类外访问不到私有的静态成员函数
}
int main()
{
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述
静态成员函数只能访问静态成员变量，不能访问非静态成员变量。
静态成员函数同样也是有访问权限的。
静态成员函数也是有两种访问方式：通过对象和通过类名。

（这部分也太难了吧！！！！！！！！！！！！！！！！！！！！！！！！！！！！）

木头人的学习生活之旅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++资源——课件及其入门等---一本书
04-01
总的来说，理解和熟练运用构造函数和析构函数是掌握C++面向对象编程的基础，它们帮助开发者确保对象的正确初始化和清理，同时提高了代码的效率和可维护性。在实际编程中，合理利用这些特性能够有效地避免内存泄漏和...
四、类和对象——4.2对象特性、对象的初始化和清理
m0_51174762的博客
03-20 93
文章目录前言一、构造函数和折构函数二、构造函数的分类及调用三、拷贝构造函数调用时机四、构造函数调用规则五、深拷贝与浅拷贝六、初始化列表七、类对象作为类成员八、静态成员总结 前言 对象的初始化和清理 提示：以下是本篇文章正文内容，下面案例可供参考 一、构造函数和折构函数 二、构造函数的分类及调用 代码如下（示例）： 代码如下（示例）： 三、拷贝构造函数调用时机 四、构造函数调用规则 五、深拷贝与浅拷贝 六、初始化列表 七、类对象作为类成员 八、静态成员 总结 提示：这里对文章进行总结： 例如：以上就是.
c++访问私有（private)成员变量的常用方法
热门推荐
Hao_09的专栏
05-04 4万+
类的对象不能直接访问类声明的私有成员变量，否则破坏了信息隐藏的目的。 在C++中，为了防止某些数据成员或成员函数从外部被直接访问，可以将它们声明为private，这样编译器会阻止任何来自外部非友元的直接访问。 私有成员变量的常用访问方法如下： (1)通过公共函数为私有成员赋值 #include using namespace std; class Test {
C++对象的初始化和清理
m0_52095916的博客
08-17 466
C++对象的初始化和清理
c++ 尽量不要用memset去对类的实例清0
wulong710的专栏
08-08 2728
#include "iostream" #include "memory.h" using namespace std; class A { public: std::string tostring() { std::string buf; buf.append(std::to_string(major)) .appe...
C++之对象的销毁
程序手艺人 - 嵌入式音频技术之旅
03-26 5931
生活中对象都是被初始化后才上市的 生活中的对象被销毁前会做一些工作 问题1 : C++中如何清理需要销毁的对象? 一般而言,需要销毁的对象都应该做清理 解决方案 为每个类都提供一个public的free函数 对象不再需要时立即调用free函数进行清理　 class Test { int* p; public: Test() { p = new int ;};...
c++语言最详细入门0基础学习笔记.pdf
08-16
7. **构造函数和析构函数**：构造函数用于初始化新创建的对象，可以通过初始化列表指定初始值。析构函数在对象销毁前执行，用于清理资源。`const`修饰的引用可以防止通过引用修改对象的值。 8. **友元**：友元函数...
C++入门实用知识库分享
最新发布
11-08
2. 复制构造函数：复制构造函数是一种特殊的构造函数，它用于初始化对象时的复制操作。了解复制构造函数的使用场景和实现方法是C++程序员的必备知识。 3. 友元函数：友元函数是一种特殊的函数，它可以访问类的私有...
面向对象实验指导书
12-09
构造函数用于初始化对象，而析构函数则在对象生命周期结束时执行清理工作。静态成员属于类而非类的实例，常成员则保证了其值在对象生命周期内不可改变。 实验3涉及继承和多态性，这两者都是面向对象设计中的关键...
VS2010-MFC编程入门
10-16
2. WM_CREATE：窗口创建时触发，用于初始化窗口。 3. WM_DESTROY：窗口被销毁时触发，用于清理资源。 4. WM_MOVE：窗口位置改变时触发。 5. WM_SIZE：窗口大小改变时触发。 6. WM_ACTIVATE：窗口激活或失活状态改变...
C++对象创建与释放
奔放的菜鸟
04-03 2万+
创建对象有以下四种形式： #include using namespace std; class A{ private: int i; public: A(){ cout<<"调用没有参数的构造函数"<<endl; } A(int a):i(a){ cout<<"调用有一个参数的构造函数"<<endl; } ~A(){cout<<"成员变量为:"<<i<<"\t调用析构函数"<<en
c++对象的初始化和清理
qq_32328985的博客
03-09 712
文章目录构造函数和析构函数构造函数的分类和调用 构造函数和析构函数 对象的初始化和清理是两个非常重要的安全问题： 一个对象或者变量没有初始状态，对其使用后果是未知的； 使用完应该对象或变量，没有及时清理，也会造成一定的安全问题。 c++可以利用构造函数和析构函数解决上述问题。在两个函数会被编译器自动调用。对象的初始化和清理工作是编译器强制要做的，当我们不提供构造函数和析构函数时，编译器会提供空...
C++回顾（一）——从C到C++
qq_50615776的博客
02-23 6072
从C语言过度到C++，注意命名空间，struct结构体，bool类型，三目运算符的变化
C++回顾（二）——const和引用
qq_50615776的博客
02-25 944
C语言和C++中的const有何不同，C++中的引用
C++基础入门-05数组
qq_50615776的博客
06-28 784
C++基础入门-05数组5.1 概述5.2 一维数组5.2.1 一维数组的定义方式5.2.2 一维数组组名的用途 5.1 概述 数组：就是一个集合，里面存放了相同类型的数据元素。 特点： 1、数组中的每个数据元素都是相同类型； 2、数组中每个数据元素的位置在内存中是连续的。 5.2 一维数组 5.2.1 一维数组的定义方式 1、一维数组定义一共有三种方式： （1）、数据类型 数据名[ 数组长度 ]； 例如： int arr[4]; （2）、数据类型 数据名[ 数组长度 ]={ 值1，值2，… }；
C++回顾（四）—— 类的封装
qq_50615776的博客
03-01 780
struct和class的分别，类的对象，函数的权限
C++回顾（二十）—— vector容器 和 deque容器
qq_50615776的博客
03-11 699
介绍了一下vector容器和deque容器，一些构造，插入，删除，迭代器等等
C++回顾（二十五）—— map/multimap容器
qq_50615776的博客
03-11 698
简单介绍了一下map和multimap
c++面向对象-类和对象的创建和使用
08-12
C++是一种面向对象的编程语言，它支持类和对象的创建和使用。类是一种用户定义的数据类型，它封装了数据和方法，可以用来描述一个实体的属性和行为。对象是类的实例，它具有类定义的属性和行为。 在C++中，可以通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值