【C++】C++核心编程（五）---类与对象（对象的初始化与清理）

已于 2023-03-10 21:09:40 修改
阅读量365 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-03-10 16:23:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43723025/article/details/129402828
版权

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

1.构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题。一个对象或者变量没有初始状态，对其使用后果是未知的。同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题。
C++利用构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情，因此，如果我们不提供构造和析构，编译器会提供，只不过编译器提供的构造函数和析构函数是空实现。

构造函数：
主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用
语法：类名() {函数体语句}
特点：

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

析构函数：
主要作用在于对象销毁前系统自动调用，执行一些清理工作
语法：~类名() {函数体语句}
特点：

  1. 析构函数没有返回值，也不写void；
  2. 函数名称与类名相同，在名称前加上符号~；
  3. 析构函数不可以有参数，因此不能发生重载；
  4. 程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次。
  • 代码演示：
#include <iostream>
using namespace std;

class Person
{
public:
	// 创建一个构造函数，完成对对象的初始化（在调用对象时会被调用）
	Person()
	{
		cout << "Person 构造函数的调用！" << endl;
	}

	// 创建一个析构函数，完成对对象的清理（在对象销毁前会被调用）
	~Person()
	{
		cout << "Person 析构函数的调用！" << endl;
	}
};

// 构造函数与析构函数都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造与析构
void test()
{
	Person p; //创建一个对象 在栈上的数据，test执行完毕后，释放这个对象
}

int main() {

	test();
	Person p1;

	system("pause");
	return 0;
}
  • 输出结果：
Person 构造函数的调用！
Person 析构函数的调用！
Person 构造函数的调用！
请按任意键继续. . .
Person 析构函数的调用！

2.构造函数的分类与调用

构造函数的分类方式：

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

构造函数的调用方式：

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

构造函数调用的注意事项：

  1. 调用默认构造函数的时候，不要加()。因为，编译器会认为是一个函数的申明，不会认为在创建对象。比如：Person p0(); 不会有任何输出。
  2. 不要利用拷贝构造函数初始化匿名对象。编译器会认为Person (p12) == Person p12; 编译器会认为这是一个对象的申明。Person(p12); 报错，Person p12 重定义
  • 代码演示：
#include <iostream>
using namespace std;

class Person
{
public:
	// 普通构造函数
	// 1、无参构造函数
	Person()
	{
		//age = 0;
		cout << "Person 无参构造函数的调用！" << endl;
	}
	// 2、有参构造函数
	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 test()
{
	// 1、括号法调用构造函数
	Person p00;
	Person p01(10);
	Person p02(p01);

	cout << "p1的年龄 = " << p01.age << endl;
	cout << "p2的年龄 = " << p02.age << endl;

	// 注意事项一：调用默认构造函数的时候，不要加()
	// 因为，编译器会认为是一个函数的申明，不会认为在创建对象
	// Person p0(); //不会有任何输出
	

	// 2、显示法调用构造函数
	Person p10;
	Person p11 = Person(10);
	Person p12 = Person(p11);

	// Person(20); //匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象
	// cout << "匿名对象在执行完以后，系统会立马回收匿名对象！" << endl;

	// 注意事项二：不要利用拷贝构造函数 初始化匿名对象
	// 编译器会认为Person (p12) == Person p12; 编译器会认为这是一个对象的申明
	// Person(p12); //报错，Person p12 重定义

	// 3、隐式转换法调用构造函数
	Person p21 = 10; // 相当于 Person p21 = Person(10); 有参构造函数
	Person p22 = p21; // 相当于 Person p22 = Person(p21); 拷贝构造函数
}

int main() {

	test();

	system("pause");
	return 0;
}
  • 输出结果：
Person 无参构造函数的调用！
Person 有参构造函数的调用！
Person 拷贝构造函数的调用！
p1的年龄 = 10
p2的年龄 = 10
Person 无参构造函数的调用！
Person 有参构造函数的调用！
Person 拷贝构造函数的调用！
Person 有参构造函数的调用！
Person 拷贝构造函数的调用！
Person 析构函数的调用！
Person 析构函数的调用！
Person 析构函数的调用！
Person 析构函数的调用！
Person 析构函数的调用！
Person 析构函数的调用！
Person 析构函数的调用！
Person 析构函数的调用！
请按任意键继续. . .

3.拷贝构造函数调用时机

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

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

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

#include <iostream>
using namespace std;

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

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

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

	int p_Age;
};

void test01()
{
	Person p010(10);
	Person p011(p010);
	cout << "使用一个创建完毕的对象 p0 来初始化一个新对象 p1！" << endl;
}

int main() {

	test01();

	system("pause");
	return 0;
}
  • 输出结果：
有参构造函数的调用！
拷贝构造函数的调用！
使用一个创建完毕的对象 p0 来初始化一个新对象 p1！
析构函数的调用！
析构函数的调用！
请按任意键继续. . .

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

值传递的方式给函数参数传值是拷贝一个临时的副本，也是对数据进行一个克隆的过程，因此也会调用拷贝构造函数。

#include <iostream>
using namespace std;

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

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

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

	int p_Age;
};

void func1(Person p)
{
	cout << "值传递的方式给函数参数传值！" << endl;
}

void test02()
{
	Person p020;
	func1(p020);
}

int main() {

	test02();

	system("pause");
	return 0;
}
  • 输出结果：
默认构造函数的调用！
拷贝构造函数的调用！
值传递的方式给函数参数传值！
析构函数的调用！
析构函数的调用！
请按任意键继续. . .

3.以值的方式返回局部对象

以值方式返回局部对象，本身的对象已经被释放掉了，返回的是拷贝出来的一个新的对象已经返回的，因此也会调用拷贝构造函数。

#include <iostream>
using namespace std;

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

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

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

	int p_Age;
};

Person func2()
{
	Person p;
	cout << (int*)&p <<endl;
	return p;
}

void test03()
{
	Person p030 = func2();
	cout << (int*)&p030 << endl;
	cout << "以值方式返回局部对象！" << endl;
}

int main() {

	test03();

	system("pause");
	return 0;
}
  • 输出结果：
默认构造函数的调用！
010FF674
拷贝构造函数的调用！
析构函数的调用！
010FF76C
以值方式返回局部对象！
析构函数的调用！
请按任意键继续. . .

4.构造函数调用规则

默认情况下，C++编译器至少给一个类添加三个函数
1、默认构造函数（无参，函数体为空）
2、默认析构函数（无参，函数体为空）
3、默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

  1. 如果用户定义有参构造函数，C++不再提供默认无参构造函数，但是会提供默认拷贝构造函数
  2. 如果用户定义拷贝构造函数，C++不再提供其他构造函数
  • 代码演示：

1.验证C++编译器给我们提供了默认无参构造函数、拷贝构造函数和析构函数

#include <iostream>
using namespace std;

class Person
{
public:
	int p_Age;
};

// 1、验证C++编译器给我们提供了默认无参构造函数、拷贝构造函数和析构函数
void test01()
{
	Person p;
	p.p_Age = 2022;
	Person p1(p);
	cout << "p1的年龄 = " << p1.p_Age << endl; // 当拷贝构造函数自己未定义的时候，也可以输出，说明C++默认提供了拷贝构造函数
}

int main() {

	test01();
	
	system("pause");
	return 0;
}
  • 输出结果：
p1的年龄 = 2022
请按任意键继续. . .

2.验证当自定义了有参构造函数，C++就不会再提供默认构造函数，但是会提供拷贝构造函数

#include <iostream>
using namespace std;

class Person
{
public:

	Person(int a)
	{
		p_Age = a;
		cout << "有参构造函数的调用！" << endl;
	}
    ~Person()
	{
		cout << "析构函数的调用！" << endl;
	}
	int p_Age;
};
// 2、验证当自定义了有参构造函数，C++就不会再提供默认构造函数，但是会提供拷贝构造函数
void test02()
{
	//Person p02; // 报错，编译器未提供无参构造函数
    Person p020(10);
	Person p021(p020);
	cout << "p021的年龄 = " << p021.p_Age << endl;
}

int main() {

	test02();

	system("pause");
	return 0;
}
  • 输出结果：
有参构造函数的调用！
p021的年龄 = 10
析构函数的调用！
析构函数的调用！
请按任意键继续. . .

3.验证当自定义了拷贝构造函数，C++就不会再提供其他类型的构造函数了

#include <iostream>
using namespace std;

class Person
{
public:

	Person(int a)
	{
		p_Age = a;
		cout << "有参构造函数的调用！" << endl;
	}
	Person(const Person& p)
	{
		p_Age = p.p_Age;
		cout << "拷贝构造函数的调用！" << endl;
	}
    ~Person()
	{
		cout << "析构函数的调用！" << endl;
	}
	int p_Age;
};
// 3、验证当自定义了拷贝构造函数，C++就不会再提供其他类型的构造函数了
void test03()
{
	//Person p030; //报错，编译器不提供默认无参构造函数
	Person p030(10); 
	Person p031(p030);
}

int main() {

	test03();

	system("pause");
	return 0;
}
  • 输出结果：
有参构造函数的调用！
拷贝构造函数的调用！
析构函数的调用！
析构函数的调用！
请按任意键继续. . .

5.深拷贝与浅拷贝

深拷贝与浅拷贝是面试时的一个经典问题，也是常见的一个坑【需要好好理解***】
浅拷贝：简单的赋值操作。容易造成堆区的内存重复释放的问题。
深拷贝：在堆区中重新申请空间，进行拷贝操作。解决浅拷贝所带来的问题。
总结：
如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

  • 代码演示：
#include <iostream>
using namespace std;

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

	Person(int a,int height)
	{
		p_Age = a;
		cout << "有参构造函数的调用！" << endl;
		p_Height = new int(height); //开辟数据到堆区
	}

	// 自己实现拷贝构造函数 解决浅拷贝带来的问题
	Person(const Person& p)
	{
		p_Age = p.p_Age;
		//浅拷贝操作(简单地赋值操作)
		//p_Height = p.p_Height;
		 
		//深拷贝操作(重新在堆区开辟一块内存)
		p_Height = new int(*p_Height);
		cout << "拷贝构造函数的调用！" << endl;
	}

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

	int p_Age;
	int *p_Height; 
};

void test01()
{
	Person p010(18,180);
	cout << "p010的年龄 = " << p010.p_Age << "\t" << "p010的身高 = " << *p010.p_Height << endl;
	Person p011(p010);
	cout << "p011的年龄 = " << p011.p_Age << "\t" << "p010的身高 = " << *p011.p_Height << endl;

	// 如果利用编译器提供的拷贝构造函数，会做浅拷贝操作
	// 浅拷贝容易带来的问题就是：如果自己开辟了堆区数据，就会导致堆区的内存重复释放，从而出现错误【从内存释放的角度去解释？？？】
}

int main() {

	test01();

	system("pause");
	return 0;
}
  • 输出结果：
有参构造函数的调用！
p010的年龄 = 18 p010的身高 = 180
拷贝构造函数的调用！
p011的年龄 = 18 p010的身高 = 180
析构函数的调用！
析构函数的调用！
请按任意键继续. . .

6.初始化列表

作用：
C++提供了初始化列表语法，用来初始化属性
语法：
类名()：属性1(值1),属性2(值2)… {}

  • 代码实现

传统方式（有参构造函数）给属性赋初值

#include <iostream>
using namespace std;

class Person
{
public:
	Person(int a, int b, int c)
	{
		cout << "传统属性赋初值方法" << endl;
		p_A = a;
		p_B = b;
		p_C = c;
	}
	
	int p_A;
	int p_B;
	int p_C;
};

void test()
{
	Person p(30,55,88);
	cout << "p_A = " << p.p_A << endl;
	cout << "p_B = " << p.p_B << endl;
	cout << "p_C = " << p.p_C << endl;
}

int main() {

	test();

	system("pause");
	return 0;
}
  • 输出结果：
传统属性赋初值方法
p_A = 30
p_B = 55
p_C = 88
请按任意键继续. . .

类初始化列表方式给属性赋初值

#include <iostream>
using namespace std;

class Person
{
public:
	Person(int a, int b, int c) : p_A(a), p_B(b), p_C(c) 
	{
		cout << "类初始化列表给属性赋初值方法" << endl;
	}

	int p_A;
	int p_B;
	int p_C;
};

void test()
{
	Person p(30,55,88);
	cout << "p_A = " << p.p_A << endl;
	cout << "p_B = " << p.p_B << endl;
	cout << "p_C = " << p.p_C << endl;
}

int main() {

	test();

	system("pause");
	return 0;
}
  • 输出结果：
类初始化列表给属性赋初值方法
p_A = 30
p_B = 55
p_C = 88
请按任意键继续. . .

7.类对象作为类成员

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

例：
class A{};
class B
{
A a;
};
B类中有对象A作为成员，A为对象成员

当创建B对象时，A与B的构造和析构的顺序是谁先谁后？？？
构造的顺序是先A后B，析构的顺序恰好相反，先B后A。

  • 代码演示
#include<iostream>
using namespace std;

class Size
{
public:
	Size(int size)
	{
		cout << "A的有参构造函数调用！" << endl;
		s_Size = size;
	}

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

	int s_Size;
};

class Basketball
{
public:
	// 使用初始化列表来给类属性赋值
	Basketball(int level, int ssize):b_Level(level),s(ssize)
	{	
		cout << "B的有参构造函数调用！" << endl;
	}

	~Basketball()
	{
		cout << "B的析构函数调用！" << endl;
	}
	// 当类对象作为类成员时，编译时优先调用类对象成员构造函数，后调用类对象构造函数，析构则相反
	Size s;
	int b_Level;
};

void test()
{
	Basketball b(0,5);
	cout << b.b_Level << "性（0：女性；1：男性）篮球运动员比赛用球尺寸为（5：5号球；7：7号球）：" << b.s.s_Size << endl;
}

int main()
{
	test();

	system("pause");
	return 0;
}
  • 输出结果：
A的有参构造函数调用！
B的有参构造函数调用！
0性（0：女性；1：男性）篮球运动员比赛用球尺寸为（5：5号球；7：7号球）：5
B的析构函数调用！
A的析构函数调用！
请按任意键继续. . .

8.静态成员

定义：
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
分类：

  1. 静态成员变量
  2. 静态成员函数

1.静态成员变量：
特点：

  1. 所有对象共享同一份数据；
  2. 在编译阶段分配内存；
  3. 类内申明，类外初始化（若只是在类内进行了申明，没有在内外进行初始化操作，编译器就会报错）。

访问方式：

  1. 通过对象；
  2. 通过类名。

注意：静态成员变量也是有访问权限的，私有的保护的静态成员变量是类外访问不到的。

2.静态成员函数：
特点：

  1. 所有对象共享同一个函数；
  2. 静态成员函数只能访问静态成员变量（若静态成员函数访问了非静态成员变量，编译器将会报错）。

访问方式：

  1. 通过对象；
  2. 通过类名。

注意：静态成员函数也是具有访问权限的（与静态成员变量是一样的）。

  • 代码演示：
#include <iostream>
using namespace std;
#include <string>

class Person
{
public:
	static void p_Phone(double phone_number)
	{
		p_Number = phone_number;
		cout << p_Name << "的电话号码是：" << phone_number << endl;
	}

	void p_ID()
	{
		cout << p_Name << "的身份证号码是：" << p_Id << endl;
	}
	//静态成员变量，类内进行申明
	static string p_Name;
	static double p_Id;
	static int p_Number;
};
//静态成员变量，类外进行初始化
string Person::p_Name = "李四";
double Person::p_Id = 423020;
int Person::p_Number = 199;

void test()
{
	Person p;
	p.p_Name = "张三";
	p.p_Id = 423019;
	p.p_ID();
	cout << "\t" << endl;
	p.p_Phone(188);
	cout << "\t" << endl;
	cout << p.p_Name << "的身份证号码是：" << p.p_Id << endl;

	Person p1;
	p1.p_Name = "王二";
	p1.p_Phone(288);
	cout << "\n" << endl;
	cout << p.p_Name << "的身份证号码是：" << p.p_Id << endl;

	Person p2;
	cout << p2.p_Name << "的身份证号码是：" << p2.p_Id << endl;
	//通过类名访问
	cout << "\t" << Person::p_Name << endl;
	cout << "\t" << Person::p_Id << endl;
}

int main() {

	test();

	system("pause");
	return 0;
}
  • 输出结果：
张三的身份证号码是：423019

张三的电话号码是：188

张三的身份证号码是：423019
王二的电话号码是：288


王二的身份证号码是：423019
王二的身份证号码是：423019
        王二
        423019
请按任意键继续. . .
DU-KE
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象程序设计-C++-试卷分析(与“函数”相关共66张).pptx
11-13
3. **构造函数与析构函数**：构造函数是类的一个特殊成员函数，用于在对象创建时初始化成员变量。析构函数则在对象生命周期结束时执行，用于清理资源。类的指针成员初始化通常在构造函数中完成。 4. **const修饰符*...
C++编程思想--第4章 初始化与清除
12-16
C++通过引入构造函数和析构函数来解决这个问题，以确保对象在创建和销毁时能够正确地进行初始化和清理。 构造函数是C++中一种特殊的成员函数，它的主要任务是在对象创建时执行初始化操作。构造函数的名称与类名相同...
C++类与对象(中)
Adz1119的博客
08-04 137
C++类与对象(中)
函数的定义与声明
smartvxworks的博客
02-21 4649
函数的定义即函数的具体实现。int a；即对变量的定义，此变量为全局变量时，方可进行外部声明。
【学习笔记】C++ 核心编程（三）类和对象——构造函数和析构函数
weixin_50499137的博客
04-15 121
内容来自小破站《黑马程序员C++》复习自用
【C++】C++核心编程部分-内存分区模型-引用-函数提高-类与对象-文件操作
热门推荐
半生瓜のblog
07-09 7万+
相关视频——黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili(84-146) 我的小站——半生瓜のblog (doraemon2.xyz) 1-83笔记——如果你准备学习C++,并且有C语言的基础，我希望你能简单的过一遍知识点。_半生瓜のblog-CSDN博客 C++核心编程部分 内存分区模型 代码区：存放函数的二级制代码，由操作系统进行管理的 全局区：存放全局变量和静态变量以及常量 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等 堆区： 由程序员.
[C++核心编程-05]----C++类和对象之对象的初始化和清理
一伦明悦的博客
05-09 864
经过上述分析，在C++中，类和对象的初始化和清理是面向对象编程中非常重要的概念。以下是关于C++类和对象初始化和清理的总结：对象的初始化：默认构造函数：如果在类中没有定义任何构造函数，C++会提供一个默认构造函数。默认构造函数没有参数，用于创建对象时执行初始化操作。自定义构造函数：类可以定义一个或多个自定义构造函数，用于根据不同的参数进行对象的初始化。构造函数可以重载，允许根据参数的不同进行不同的初始化操作。成员初始化列表。
C++ 核心编程篇4.2：对象的初始化和清理
Conan_0728的博客
01-10 901
生活中我们买的电子产品基本有还原出厂设置，在某一天我们不用时候也会删除一些自己信息数据来保证安全C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置构造函数和析构函数的作用：对象的初始化和清零是非常重要的安全问题，一个对象或者变量没有初始状态，对其使用后果是未知，同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题C++利用构造函数和析构函数解决上述问题，这些函数将会被编译器自动调用，完成对象初始化和清理工作。
C++核心编程——类和对象的初始化和清理（二）
qq_43718691的博客
03-07 456
一、C++中拷贝构造函数调用时机通常有三种情况 1、使用一个已经创建完毕的对象来初始化一个新对象 2、值传递的方式给函数传值 3、以值方式返回局部对象 二、构造函数嗲用规则 默认情况下C++编译器至少给一个类添加3个函数 1、默认构造函数（无参，函数体为空） 2、默认析构函数（无参，函数体为空） 3、默认拷贝构造函数，对属性进行值拷贝 三、构造函数调用规则如下 1、如果用户蒂尼工艺有参数构造函数，C++不提供默认无参构造但是会提供默认拷贝函数 2、如果用户定义拷贝构造函数，C++不会再
C++核心编程（四）—— 类和对象(2) ：对象的初始化和清理
大彤小忆的博客
04-01 3610
3. 对象的初始化和清理3.1 构造函数和析构函数3.2 构造函数的分类及调用3.3 拷贝构造函数调用时机3.4 构造函数调用规则3.5 深拷贝与浅拷贝3.6 初始化列表3.7 类对象作为类成员4.2.8 静态成员 3. 对象的初始化和清理 生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用的时候也会删除一些自己信息数据保证安全； C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。 3.1 构造函数和析构函数   对象的初始化和清理也是两个非常重要的安全问题.
Python&C++相互混合调用编程全面实战-16c++调用python的类实例化对象访问成员函数和成员
编辑编辑器
06-19 5389
作者：虚坏叔叔 博客：https://xuhss.com在中添加一个类，用于被C++调用访问： 二、C++中调用类的成员函数 运行：可以看到输出了想要的字符串修改中的类中的函数test的参数和返回值： C++添加对单参数的Python类的调用 运行：添加中的类成员变量 C++添加对Python类成员变量的访问 运行： 六、总结 本文介绍了c++调用python的类实例化对象访问成员函数和成员。 如果觉得文章对你有用处，记得 一波哦，博主也支持为铁粉丝制作专属动态壁纸哦~ 💬 往期优质文章分享 .
C++核心编程：P5-＞类和对象----对象的初始化和清理
InnerPeaceHQ的博客
05-16 254
本系列文章为黑马程序员C++教程学习笔记，前面的系列文章链接如下 C++核心编程：P1-＞程序的内存模型 C++核心编程：P2-＞引用 C++核心编程：P3-＞函数提高 C++核心编程：P4-＞类和对象—封装 文章目录前言一、构造函数和析构函数二、构造函数的分类及调用2.1 构造函数的分类2.2 构造函数的调用三、拷贝构造函数调用时机四、构造函数调用规则五、深拷贝与浅拷贝六、初始化列表七、类对象作为类成员八、静态成员8.1 静态成员变量8.2 静态成员函数 前言 构造和析构的生活背景 ①生活中我们买的电
c++语言程序设计课件_C语言教程_C++程序设计--类与对象_
09-30
"C++语言程序设计课件_C语言教程_C++程序设计--类与对象_"这个标题揭示了我们将深入探讨C++中的核心概念，特别是面向对象编程的关键元素。 在C++中，类是数据和操作数据的方法的集合，它定义了一组属性和行为。类是...
面向对象的程序设计-个人复习笔记
10-26
在C++编程语言中，面向对象编程是一种核心概念，它基于类和对象的概念，使得代码更加模块化和易于管理。以下是一些关于C++面向对象编程的重要知识点： 1. **类与对象**：类是数据结构和操作这些数据的方法的集合，...
cpp代码-c++学习笔记——类与对象
07-14
在C++编程语言中，类（Class）与对象（Object）是核心概念，它们构成了面向对象编程的基础。本文将深入探讨这两个概念以及相关的知识点。 **类（Class）** 类是C++中的一个用户定义的数据类型，它允许我们将数据和...
C++二叉搜索树
最新发布
Jk_Mr的博客
07-20 711
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 200
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
学懂C语言系列（三）：C语言基本语法
martian665的专栏
07-17 551
学懂C语言系列,C语言基本语法
C++ std::thread 管理线程生命周期：join 和 detach
m0_59680769的博客
07-16 997
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
C++编程：面向对象编程基础-类与对象
"中国地质大学C++课程的第八章讲解了面向对象编程的关键概念，包括类、对象、构造函数、析构函数以及继承。课程强调了封装、数据隐藏、多态性和继承的重要性，并通过实例解释了这些概念。" 在面向对象编程（Object-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值