C++自学笔记

最新推荐文章于 2024-07-24 08:30:00 发布
最新推荐文章于 2024-07-24 08:30:00 发布
阅读量108 收藏 1
点赞数 1
分类专栏： C++自学笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuandenixin/article/details/107923590
版权

C++自学笔记（14 类和对象_对象的初始化和清理）

14 类和对象_对象的初始化和清理

本次记录对象的初始化和清理，还请各位大佬批评指正！

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

构造函数和析构函数

对象的初始化和清理是两个非常重要的安全问题。
（1）一个对象或者变量没有初始状态，对其使用后果是未知；
（2）同样的，使用完一个对象或者变量，没有及时清理，也会造成某些安全问题。
C++利用构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供。编译器提供的构造函数和析构函数是空实现。
1、构造函数：
主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用。
语法：
类名（）{ }
1、构造函数没有返回值，也不写void。
2、函数名于类名称相同。
3、构造函数可以有参数，因此可以重载。
4、程序在调用对象的时候会自动调用构造，无需手动调用，且只会调用一次

2、析构函数：
主要作用在于对象销毁前系统自动调用，执行一些清理工作。
语法：
~类名（）{ }
1、析构函数没有返回值，也不写void。
2、函数名于类名称相同，在名称前加上符号 ~ 。
3、析构函数不可以有参数，因此不可以重载。
4、程序在调用对象的时候会自动调用析构，无需手动调用，且只会调用一次。

#include<iostream>
#include <stdlib.h>
#include<string>
using namespace std;

//对象的初始化和清理
class person
{
public: //class 默认权限为私有

	//1、构造函数 进行初始化操作
	person()//构造函数没有返回值，也不写void ; 函数名于类名称相同
	{
		cout << "person 构造函数的调用" << endl;
	}

	//2、析构函数 进行清理的操作
	~person()//析构函数没有返回值，也不写void ; 函数名于类名称相同，在名称前加上符号 ~
	{
		cout << "person 析构函数的调用" << endl;
	}

};

//构造和析构都是必须有的实现，若自己不提供，编译器会提供一个空实现的构造和析构
void test01()
{
	person p; //局部变量 在栈上的数据，test01执行完毕后，释放这个对象
}

int main()
{
	test01();
	person p;//对象不会释放，程序结束的时候才会调用析构函数


	system("pause");

	return 0;
}

运行结果如下：
其中前两行是调用 test01( ) 的结果，test01( )运行结束后，p就被释放掉了，会有构造函数和析构函数的调用。
第三行是 person p; 代码运行的结果，执行完该行代码，对象不会释放，程序结束的时候对象释放，才会调用析构函数，也就是最下边一行的结果。
在这里插入图片描述

构造函数的分类及调用

两种分类方式：
按参数分为：有参构造和无参（默认）构造。
按类型分为：普通构造和拷贝构造。
三种调用方式：
括号法。
显示法。
隐式转换法。

#include<iostream>
#include <stdlib.h>
#include<string>
using namespace std;

//构造函数对的分类及调用
class person
{
public: //class 默认权限为私有

	//构造函数 
	//前俩为普通构造函数，第三个为拷贝构造函数；第一个为无参构造函数，后边俩为有参构造函数
	person()
	{
		cout << "person 的无参构造函数的调用" << endl;
	}
	person(int a)
	{
		age = a;
		cout << "person 的有参构造函数的调用" << endl;
	}

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

	//析构函数 进行清理的操作
	~person()//析构函数没有返回值，也不写void ; 函数名于类名称相同，在名称前加上符号 ~
	{
		cout << "person 析构函数的调用" << endl;
	}

	int age;
};

//调用
void test01()
{
	//1、括号法
	//person p1; //默认构造函数的调用
	//person p2(10);//有参构造函数的调用
	//person p3(p2);//拷贝构造函数

	//注意事项1
	//调用默认构造函数的时候不要加（）
	//person p1();//这行代码，编译器会认为是函数的声明，不会认为在创建对象

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


	//显示法
	//person p1;
	//person p2 = person(10);//有参构造
	//person p3 = person(p2);//拷贝构造

	//注意事项
	//不要利用拷贝构造函数 初始化匿名对象
	//person(p3); //person p3重定义 编译器会认为 person(p3) == person p3 对象声明

	//person(10);//匿名对象 特点：当前行执行结束后，系统立即回收匿名对象
	//cout << "aaaaa" << endl;


	//隐式转换法
	person p4 = 10;//相当于写了person p4 = person(10);   有参构造
	person p5 = p4;//拷贝构造
}

int main()
{
	test01();


	system("pause");

	return 0;
}

拷贝构造函数的调用时机

C++中拷贝构造函数调用时机通常有三种情况：
1、使用一个已经创建完毕的对象来初始化一个新对象；
2、值传递的方式给函数参数传值；
3、以值的方式返回局部对象。
注意：函数的返回值不可以作为函数重载的条件 。

#include<iostream>
#include <stdlib.h>
#include<string>
using namespace std;

//拷贝构造函数调用时机
class person
{
public: //class 默认权限为私有

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

	//拷贝构造函数
	person(const person &p)//引用是用来防止递归调用拷贝构造函数的
	{
		m_age = p.m_age;//将传入的人身上的所有属性，拷贝到我身上
		cout << "person 的拷贝构造函数的调用" << endl;
	}

	//析构函数 进行清理的操作
	~person()//析构函数没有返回值，也不写void ; 函数名于类名称相同，在名称前加上符号 ~
	{
		cout << "person 析构函数的调用" << endl;
	}

	int m_age;
};

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

	cout << "p2的年龄为： " << p2.m_age << endl;
}

//2、值传递的方式给函数参数传值
void dowork01(person p)
{

}
void test02()
{
	person p;
	dowork01(p);
}

//3、以值的方式返回局部对象
person dowork02()
{
	person p1;
	cout << (int*)&p1 << endl;
	return p1;
}
void test03()
{
	person p = dowork02();
	cout << (int*)&p << endl;
}

int main()
{
	test01();
	//test02();
	//test03();

	system("pause");

	return 0;
}

test01();调用结果如下：
代码person p1(20);调用有参构造函数。代码person p2(p1);调用拷贝构造函数。输出p2的年龄后，test01程序结束，p1和p2被释放，调用两次析构函数。
在这里插入图片描述
test02();调用结果如下：
代码person p;调用默认构造函数。代码dowork01( p );以值传递（拷贝副本）的方式给参数传值是调用拷贝构造函数。test02程序结束，对象被释放，调用两次析构函数。
在这里插入图片描述
test03();调用结果如下：
首先看dowork02()，代码person p1;调用默认构造函数。然后输出p1的地址。代码return p1;会根据p1返回一个新的对象，给到对象p，此时调用拷贝构造函数。dowork02()结束后p1被释放，调用析构函数。然后输出对象p的地址。test03()结束后p被释放，调用析构函数。
在这里插入图片描述

构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数：
1、默认构造函数（无参，函数体为空）。
2、默认析构函数（无参，函数体为空）。
3、默认拷贝构造函数，对属性进行值拷贝。
构造函数调用规则如下：
1、如果用户定义有参构造函数，C++不再提供默认无参构造函数，但是会提供默认拷贝构造函数。调用 test02 时注释掉 test01 以及定义的拷贝构造函数，程序正常运行。此时定义了有参构造函数，C++提供默认拷贝构造函数，p1 能拷贝到 p2。
2、如果用户定义拷贝构造函数，C++不会再提供其他构造函数。调用 test01 时，若注释掉默认构造函数和有参构造函数时出错。此时定义了拷贝构造函数，C++不会再提供其他构造函数。

#include<iostream>
#include <stdlib.h>
#include<string>
using namespace std;

//构造函数调用规则
class person
{
public: 

	//无参（默认）构造函数
	person()
	{
		cout << "person 的无参构造函数的调用" << endl;
	}

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

	拷贝构造函数
	//person(const person &p)//引用是用来防止递归调用拷贝构造函数的
	//{
	//	m_age = p.m_age;//将传入的人身上的所有属性，拷贝到我身上
	//	cout << "person 的拷贝构造函数的调用" << endl;
	//}

	//析构函数 进行清理的操作
	~person()
	{
		cout << "person 析构函数的调用" << endl;
	}

	int m_age;
};

//void test01()
//{
//  person p;
//	person p1;
//	p1.m_age = 18;
//
//	person p2(p1); //值拷贝
//	cout << "p2的年龄为：  " << p2.m_age << endl;
//}

void test02() 
{
	person p; //注释掉默认构造函数后出错，没有合适的默认构造函数可用
	
	person p1(20);
	person p2(p1);
	cout << "p2的年龄为：  " << p2.m_age << endl;

	person p3;//注释掉默认和有参构造函数后出错，没有合适的默认构造函数可用
}


int main()
{
	//test01();
	test02();


	system("pause");

	return 0;
}

深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑。
浅拷贝：简单的赋值拷贝操作。存在的问题是，会导致堆区的内存重复释放。
深拷贝：在堆区重新申请空间，进行拷贝操作。

运行如下代码时，如果注释掉自己定义的拷贝构造函数，会出错。执行person p2(p1); 时会使用编译器提供的拷贝构造函数，会做浅拷贝操作。调用析构函数时，先进后出，即p2先释放，p1后释放。p2 释放调用析构函数时已经将身高的内存释放掉了，p1 释放调用析构函数会重复释放同一内存，重复释放是非法操作。浅拷贝的问题，要利用深拷贝进行解决。

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

#include<iostream>
#include <stdlib.h>
#include<string>
using namespace std;

//深拷贝与浅拷贝
class person
{
public: 

	//无参（默认）构造函数
	person()
	{
		cout << "person 的无参构造函数的调用" << endl;
	}

	//有参构造函数
	person(int age, int h)
	{
		m_age = age;
		m_h = new int(h);//利用new把数据创建在堆区 返回的是 int* ，用 int*接收它
		cout << "person 的有参构造函数的调用" << endl;
	}

	//拷贝构造函数
	person(const person &p)//引用是用来防止递归调用拷贝构造函数的
	{
		m_age = p.m_age;
		//m_h = p.m_h;//编译器默认实现的就是这行代码
		//深拷贝操作
		m_h = new int(*p.m_h);

		cout << "person 的拷贝构造函数的调用" << endl;
	}

	//析构函数 进行清理的操作
	~person()
	{
		//将堆区开辟的数据进行释放操作
		if (m_h != NULL)
		{
			delete m_h;
			m_h = NULL;
		}
		cout << "person 析构函数的调用" << endl;
	}

	int m_age;//年龄
	int* m_h;//身高
};

void test01()
{
	person p1(18, 160);
	cout << "p1的年龄为：  " << p1.m_age << endl;
	cout << "p1的身高为：  " << *p1.m_h << endl;

	//如果利用编译器提供的拷贝构造函数，会做浅拷贝操作
	person p2(p1); 
	cout << "p2的年龄为：  " << p2.m_age << endl;
	cout << "p2的身高为：  " << *p2.m_h << endl;
}

int main()
{
	test01();
	

	system("pause");

	return 0;
}

初始化列表

作用：C++提供了初始化列表语法，用来初始化属性
语法：构造函数（）：属性1（值1），属性2（值2）…{ }

#include<iostream>
#include <stdlib.h>
#include<string>
using namespace std;

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

	传统初始化操作
	//person(int a, int b, int c)
	//{
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}

	//初始化列表初始化属性
	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 p(10, 20, 30);
	
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;
}


int main()
{
	test01();


	system("pause");

	return 0;
}

类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员。
例如：
class A { };
class B
{
A a;
};
B类中有对象A作为成员，A为对象成员。

#include<iostream>
#include <stdlib.h>
#include<string>
using namespace std;

//类对象作为类成员
class phone
{
public:

	phone(string name)
	{
		cout << "phone 的构造函数调用" << endl;
		m_pname = name;
	}

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

静态成员

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

1、静态成员变量

特点如下：
所有对象共享同一份数据；
在编译阶段分配内存；
类内声明，类外初始化。

#include<iostream>
#include <stdlib.h>
#include<string>
using namespace std;

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

	//所有对象共享同一份数据；类内声明，类外初始化
	static int m_A;

	//静态成员变量也是有访问权限的
private:
	static int m_B;
};

int person :: m_A = 100;//类外初始化
int person :: m_B = 200;

void test01()
{
	person p1;
	cout << p1.m_A << endl;//没有类外初始化时会报错，无法解析的外部命令

	person p2;
	p2.m_A = 200;
	cout << p1.m_A << endl;//200

}

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

	//1、通过对象进行访问
	/*person p1;
	cout << p1.m_A << endl;*/

	//2、通过类名进行访问
	cout << person::m_A << endl;
	//cout << person::m_B << endl;//类外访问不到私有静态成员变量
}


int main()
{
	test01();
	test02();


	system("pause");

	return 0;
}

2、静态成员函数

特点如下：
所有对象共享一个函数；
静态成员函数只能访问静态成员变量。

#include<iostream>
#include <stdlib.h>
#include<string>
using namespace std;

//静态成员函数
class person
{
public:
	//静态成员函数
	static void func()
	{
		m_A = 100;//静态成员函数能够访问静态成员变量，所有对象都共享一份数据
		//m_B = 100;//静态成员函数 不能访问 非静态成员变量，无法区分到底是哪个对象的m_B属性
		cout << "static void func 的调用" << endl;
	}

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

private:
	static void func2()
	{
		m_A = 100;//静态成员函数能够访问静态成员变量，所有对象都共享一份数据
		//m_B = 100;//静态成员函数不能访问 非静态成员变量，无法区分到底是哪个对象的m_B属性
		cout << "static void func2 的调用" << endl;
	}
};

int person::m_A = 0;

//两种访问方式
void test03()
{
	//通过对象访问
	person p;
	p.func();

	//通过类名访问
	person::func();
	//person::func2();//私有静态成员函数类外访问不到
}

int main()
{
	test03();


	system("pause");

	return 0;
}
大可爱家的小可爱
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习笔记
ftm_csdn的博客
04-16 1万+
C++是C语言的超集。
C++ 学习笔记
weixin_42098295的博客
04-29 1496
继承可以让新的类继承现有类的特性，多态通过接口的多种实现提供了函数行为的多样性，而封装则隐藏了数据的内部表示，只暴露必要的操作接口，这有助于减少系统的复杂性并提高其安全性。内存管理还涉及到堆和栈的使用，其中栈用于存储局部变量和函数调用的信息，而堆则用于动态内存分配，通常由程序员手动管理，这在处理大量数据或不确定数据大小时特别有用。在组织大型程序时，命名空间提供了避免名字冲突的方式，使得相同名字的变量或函数可以在不同的命名空间下共存，极大地增强了代码的模块化和可维护性。，用来存储数字、字符和布尔值。
c++学习笔记
weixin_54948102的博客
02-06 331
自用笔记。
C++自学笔记（day2)
S_mile_W的博客
07-21 117
二、类和对象 1.类基础 2.简单的学生类 3.构造函数 4.对象成员 5.拷贝构造 6.析构函数
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
C++学习笔记.pdf
08-12
C++学习笔记
C++自学笔记.pdf
11-16
C++自学笔记.pdf
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1131
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1127
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++笔试强训7
m0_74189279的博客
07-21 972
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 324
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 260
C++笔记3：基类指针delete子类对象的内存泄漏问题
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
热门推荐
面试高手的博客
07-21 4万+
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
C++中的模板函数和模板类
2302_81171591的博客
07-22 657
T1 ,classT2 ,... ,classTnclass类模板名//类内成员定义。
内网对抗-隧道技术篇&防火墙组策略&HTTP反向&SSH转发&出网穿透&CrossC2&解决方案
最新发布
siu~
07-24 714
1、C2/C2上线-CrossC2插件-多系统平台支持 2、隧道技术篇-应用层-SSH协议-判断&封装&建立&穿透 3、隧道技术篇-应用层-HTTP协议-判断&封装&建立&穿透
C语言 打印菱形的程序（Program to print the Diamond Shape）
csdn_aspnet的专栏
07-22 2185
O(n*n)，因为我们正在遍历网格的行和列来打印空格 ' '和星号 '*'。给定一个数字n ，编写一个程序来打印一个有2n行的菱形。O(1)，不使用额外空间。
C++学习笔记：面向过程与C++概述
"这篇文档是关于C++的学习笔记，主要关注面向过程的编程思想，并提到了C++的一些基本概念和历史。文档指出C++是由比雅尼·斯特劳斯特鲁普博士开发的一种通用编程语言，它在C语言的基础上增加了面向对象、数据抽象和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值