2021-8-2 C++进阶学习 -＞ 4.2类和对象--对象的初始化和清理

最新推荐文章于 2024-07-15 13:32:43 发布
最新推荐文章于 2024-07-15 13:32:43 发布
阅读量90 收藏
点赞数
分类专栏： C++实践 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ice_cream_moon/article/details/119303892
版权

目录

4.2.1 构造函数和析构函数

4.2.3拷贝构造函数调用时机

4.2.4构造函数调用规则

4.2.5深拷贝与浅拷贝

4.2.6初始化列表

4.2.7类对象作为类成员

4.2.8静态成员以及函数

4.2.1 构造函数和析构函数

构造函数
    没有返回值，不用写void
    函数名 与类名相同
    构造函数可以有参数，可以发生重载
    创建对象的时候，构造函数会自动调用，而且只调用一次

析构函数 进行清理的操作
    没有返回值 不写void
    函数名和类名相同 在名称前面加~
    析构函数不可以有参数 不可以发生重载
    对象在销毁前 会自动调用析构函数 而且只会调用一次

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

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

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

4.2.2构造函数的分类以及调用

1、构造函数的分类以及调用
分类
按照参数来分类     无参构造（默认构造）  有参构造
按照类型分类        普通构造函数                 拷贝构造函数

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

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

    void func();

    2、显示法

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

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

    3、隐式转化法

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

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

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

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

	//void func();
	//cout << "p2的年龄为："<< p2.age << endl;
	//cout << "p3的年龄为：" << p3.age << endl;

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

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

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

	//3、隐式转化法
	person p4 = 10;// 相当于 person p4= person(10)
	person p5 = p4;
}



int main() {

	text01();
	system("pause");
}

4.2.3拷贝构造函数调用时机

拷贝构造函数调用时机

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

2、值传递二点方式给函数参数传值

3、值方式返回局部对象

#include <iostream>
#include <string>
using namespace std;
class person
{
public:
	person()
	{
		cout << "person的构造函数调用" << endl;
	}

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

	person(const person &p)
	{
		Age = p.Age;
		cout << "person的拷贝函数调用" << endl;
	}

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

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

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

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

//2、值传递二点方式给函数参数传值
void dowork(person p)
{
}
void text02()
{
	person p;
	dowork(p);
}
//3、值方式返回局部对象
person dowork2()
{
	person p1;
	return p1;
}
void text03()
{
	person p = dowork2();
}
int main() {
	text01();
	text02();
	text03();
	system("pause");
}

4.2.4构造函数调用规则

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

2、  如果我们写了有参构造，编译器不再提供默认构造，依然提供拷贝构造
        如果我们写了拷贝构造函数，编译器就不再提供其他的普通构造函数

#include <iostream>
#include <string>
using namespace std;
//构造函数的调用规则
//1、创建一个类，c++编译器会给每个类都添加至少三个函数
//默认函数 （空实现）
//析构函数 （空实现）
//拷贝构造 （值拷贝）

//2、如果我们写了有参构造，编译器不再提供默认构造，依然提供拷贝构造
//如果我们写了拷贝构造函数，编译器就不再提供其他的普通构造函数
class person
{
public:
	person()
	{
		cout << "person的默认构造函数调用" << endl;
	}

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

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

void text01()
{
	person p;
	p.Age = 18;

	person p2(p);

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

void text02()
{
	person p(28);
	person p2(p);
}
int main() {

	text01();
	text02();
	system("pause");
}

4.2.5深拷贝与浅拷贝

深拷贝与浅拷贝
浅拷贝带来的问题：
堆区的内存重复释放 这个问题要用深拷贝来解决

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

#include <iostream>
#include <string>
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 text01()
{
	person p1(18,160);
	cout << "p1的年龄：" <<p1.Age<< "身高为:" << *p1.Height << endl;

	person p2(p1);
	cout << "p2的年龄：" << p2.Age <<"身高为:"<<*p2.Height<< endl;
}
int main() {

	text01();
	system("pause");
}

4.2.6初始化列表

初始化列表初始化属性
    person(int a,int b,int c) :A(a), B(b), C(c)
    {

    }

person(10,20,30);

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

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

	//person(int a, int b, int c)
	//{
	//	A = a;
	//	B = b;
	//	C = c;
	//
	//}

	//初始化列表初始化属性
	person(int a,int b,int c) :A(a), B(b), C(c)
	{

	}
	int A;
	int B;
	int C;

};

void text01()
{
	person p(10, 20, 30);
	//person p;
	cout << "A = " << p.A << endl;
	cout << "B = " << p.B << endl;
	cout << "C = " << p.C << endl;

}
int main() {

	text01();
	system("pause");
}

4.2.7类对象作为类成员

当其他类的对象作为本类的成员，构造时候先构造类对象，再构造自身，析构函数运行则相反

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

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

	Phone(string pname)
	{
		pName = pname;
		cout << " phone的构造函数调用" << endl;
	}
	~Phone()
	{
		cout << "phone的析构函数调用" << endl;
	}
	//手机品牌名称
	string pName;
};
class person
{
public:

	person(string name, string pname):Name(name),Phone(pname)
	{
		cout << "person的构造函数调用" << endl;
	}
	~person()
	{
		cout << "person的析构函数调用" << endl;
	}
	//姓名
	string Name;
	//手机
	Phone Phone;
};
//当其他类的对象作为本类的成员，构造时候先构造类对象，再构造自身，析构
void text01()
{
	person p("张三", "苹果max");
	cout << p.Name << "拿着：" << p.Phone.pName << endl;
}

int main() {

	text01();
	system("pause");
}

4.2.8静态成员以及函数

1、静态成员

   1、所有成员都共享同一数据
    2、编译阶段就分配内存
    3、类内声明，类外初始化操作

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

//静态成员变量
class person 
{
public:
	//1、所有成员都共享同一数据
	//2、编译阶段就分配内存
	//3、类内声明，类外初始化操作
	static int A;

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

int person::A = 100;

void text01()
{
	person p;
	cout << p.A << endl;

	person p2;
	p2.A = 200;

	cout << p.A << endl;
}

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

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

	//2、通过类名进行访问
	cout << person::A << endl;

	//cout << person::B << endl; 不可访问 类外访问不到私有的静态成员
}
int main() {

	text01();
	text02();
	system("pause");
}

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

静态成员函数   可以访问    静态成员变量

静态成员函数  不可以访问  非静态成员变量 无法区分到底是哪个对象的成员

静态成员函数也是有访问权限的，类外访问不到私有静态成员函数

访问方式有两种：1、通过对象进行访问

                             2、通过类名来进行访问

#include <iostream>
#include <string>
using namespace std;
//静态成员函数
//所有对象共享同一个函数
//静态成员函数只能访问静态成员变量

class person
{
public:

	//静态成员函数
	static void func()
	{
		A = 100;//静态成员函数   可以访问    静态成员变量
		//B = 100; 静态成员函数  不可以访问  非静态成员变量 无法区分到底是哪个对象的成员
		cout << "静态成员函数调用" << endl;
	}

	static int A;//静态成员变量
	int B;

	//静态成员函数也是有访问权限的

private:
	static void func2() {
		cout << "静态成员函数调用" << endl;
	}
 };

//有两种访问方式
void text01()
{
	//1、通过对象进行访问
	person p;
	p.func();
	//2、通过类名来进行访问
	person::func();
	
	//p.func2();类外访问不到私有静态成员函数

}
int main() {

	text01();
	system("pause");
}

ice_cream_moon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++程序设计基础课件第-讲类和对象完美版资料.ppt
11-14
本资源摘要信息涵盖了C++程序设计基础课件第-讲类和对象的主要内容，包括类的定义、对象的定义、对象的初始化、成员函数的特性、静态成员、友元、局部类和嵌套类等知识点，为C++程序设计学习者提供了系统的知识架构...
c++语言程序设计课件_C语言教程_C++程序设计--类与对象_
09-30
构造函数是类的一个特殊成员函数，它的主要任务是在创建对象时初始化对象的状态。构造函数的名字与类名相同，并且没有返回类型。例如，对于"Car"类，构造函数可能接受初始颜色和速度作为参数，以便在创建新对象时...
cotecsz#Linux-Cpp-Development-Advanced-Learning#C++进阶(6) 对象的构造顺序
07-25
6.1 局部对象 6.2 堆对象 6.3 全局变量
C++类和对象期末重点.doc
01-13
C++类和对象期末复习 C++ 中的类和对象是面向对象编程的基础概念。类是一种用户定义的数据类型，封装了数据和操作这些数据的函数。对象是类的实例，拥有类所定义的所有特征。 类和对象的定义 ---------------- 类...
K-mean聚类算法C++实现源码+文档.zip
03-10
- 主循环：包含上述的初始化、分配、更新和判断过程。 文档`k-means.docx`可能包含以下内容： - 算法原理的详细解释，包括数学公式和可视化示例。 - C++源码的注释和解析，帮助理解代码逻辑。 - 使用说明：如何编译...
函数模板与类模板
程序员_小兵
07-12 1571
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
Linux C | 管道open打开方式
I_feige的博客
07-12 333
1.
Reversing Numbers C++
FGGFFoj的博客
07-11 385
在默认情况下，C++的输入输出流（比如 cin, cout）与C标准库的输入输出流是同步的，这意味着在使用C++的输入输出流时，可能会因为需要与C标准库的同步而导致性能略有损失。在 C++ 中，默认情况下，cin 和 cout 是绑定在一起的，意味着在输入时，输出可能需要等待输入完成才会进行，这样可能会造成一些性能上的损失，特别是在需要频繁输入输出的场景下。需要注意的是，在取消同步后，应确保不要混合使用C++的输入输出和C标准库的输入输出，因为这可能会导致未定义的行为。
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1052
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++ 生成随机字符串
最新发布
m0_56306892的博客
07-15 199
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
05day--C++日期类的实现与取地址运算符的重载
weixin_73863912的博客
07-13 462
• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this。• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动。⽣成的就可以够我们⽤了，不需要去显⽰实现。
C++：哈希表
m0_61088872的博客
07-12 719
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【密钥删除(C/C++)】
m0_70748845的博客
07-12 363
为保证数据安全性，当不需要使用该密钥时，应该删除密钥。
C++中的多态：虚函数与纯虚函数详解
TheJustice_的博客
07-14 424
在C++中，虚函数是在基类中使用virtual关键字声明的函数。当基类指针或引用指向派生类对象时，调用虚函数将执行派生类中的版本。public:public:void display() override { // 使用 override 确保函数被正确重写纯虚函数在基类中使用virtual关键字和= 0来声明。public:// 纯虚函数。
[C/C++入门][变量和运算]7、交换变量（空杯思想）
qq_14840819的专栏
07-14 542
如图，一杯牛奶，一杯咖啡，如何进行交换呢？相信懂的都懂，不懂的看完这个图也就懂了。生活中非常简单的例子，放到我们计算机中也同样适用。
C++ Primer：2.5 处理类型
Linkon的博客
07-13 222
C++ 处理类型
C语言——函数、形参与实参、局部变量
weixin_45720999的博客
07-11 718
printf("欢迎来到我的代码\n");int fuctWithData(int x) //形式参数，需要包含变量类型、变量名int y;y = x-1;return y;int y;printf("请输入一个数：");return 0;
C++静态成员
2402_84626835的博客
07-14 177
对于类中的非静态数据成员，每一个类对象都拥有一个副本，即每个对象的同名数据成员可以分别存储不同的数值，这是保证每个对象拥有区别于其他对象的特征的需要。（1）由于在类的声明中仅仅是对静态数据成员进行了引用声明，因此必须在文件作用域的某个地方对静态数据成员进行定义并进行初始化，即应在类体外对静态数据成员进行初始化（静态数据成员的初始化与它的访问控制权限无关）。静态数据成员的值对每个对象都是一样的，它的值可以被任何一个对象更新，从而实现了同一类的不同对象之间的数据共享。9.1 静态数据成员。
【C++】模版与泛型编程
m0_52602233的博客
07-12 375
C++模板 函数模板 类模板

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值