C++核心编程之类和对象（二）

最新推荐文章于 2022-04-20 13:07:29 发布

Gigi Princess

最新推荐文章于 2022-04-20 13:07:29 发布

阅读量300

点赞数

分类专栏： C++入门到大神的见证专栏文章标签： c++ c#

本文链接：https://blog.csdn.net/GiGi_Princess/article/details/120129627

版权

C++入门到大神的见证专栏专栏收录该内容

14 篇文章 1 订阅

订阅专栏

1.2 对象的初始化和清理

1.2.1 构造函数和析构函数

这个工作我们也可以不写，我们不写编译器会提供空实现。

了解一下什么是构造函数和析构函数

构造函数：创建对象时为对象的成员属性赋值
析构函数：执行清理工作

构造函数语法

类名（）{}

构造函数，没有返回值也不写void
函数名称与类名相同
构造函数可以有参数，所以可以发生重载
程序在调用对象的时候会自动调用构造，无须手动调用，只调用一次

析构函数语法

~类名（）{}

析构函数，没有返回值也不写void

函数名称与类名相同，在前面加~

析构函数不可以有参数，所以不可以发生重载

程序在对象销毁前会自动调用析构，无须手动调用，只调用一次

程序实现：

#include <iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "构造函数到此一游" << endl;
	}
	~Person()
	{
		cout << "析构函数到此一游" << endl;
	}
};

void test01()
{
	Person p;
}

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

注意注意！！！

我把Person p写在了主函数内，就只调用了构造函数，这是为什么呢？

原因是如果在test01()里，用掉之后就会把p释放了，但是p在主函数里就不会释放掉，直到摁完任意键的时候也就是我们要把小黑板关掉的时候，会瞬间出现析构调用的语句，但是闪现太快了我手速不够截不到图，理解就行。

1.2.2 构造函数的分类和调用

两种分类方式：

按参数分类：有参构造和无参构造

按类型分为：普通构造和拷贝构造

三种调用方式：

括号法

显示法

隐式转换法

#include <iostream>
using namespace std;
class Person
{
public:
	Person()
	{
		cout << "无参构造函数到此一游" << endl;
	}
	Person(int a)
	{
		age = a;
		cout << "有参构造函数到此一游" << endl;
	}
	Person(const Person &p)
	{
		age = p.age;
		cout << "拷贝构造函数到此一游" << endl;
	}
	~Person()
	{
		cout << "析构函数到此一游" << endl;
	}
	int age;
};
//括号法调用
void test01()
{
	Person p;
	Person p1(10);
	Person p2(p1);
	cout << "p1的年龄为:" << p1.age << endl;
	cout << "p2的年龄为:" << p2.age << endl;
}
//显示法调用
void test02()
{
	Person p;
	Person p1 = Person(10);
	Person p2 = Person(p1);
	//Person(10);  匿名对象 特点：当前执行结束后，系统会立即回收掉匿名对象
}
//隐式转换法调用
void test03()
{
	Person p3 = 10;
	Person p4 = p3;
}
int main()
{
	test01();
	//test02();
	//test03();
    system("pause");
	return 0;
}

注意点1：在用括号法调用默认构造函数的时候，不要加（）

例如Person p()

因为这样的代码，编译器会认为是一个函数的声明，不会认为在创建对象

注意点2：在用显示法调用的时候，不要利用拷贝构造函数初始化匿名对象

例如 Person(p2)

因为这样的代码，编译器会认为Person(p2)===Person p2，前面已经定义了 Person p2，重定义了

1.2.3 拷贝构造函数调用时机

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

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

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(20);
	Person p2(p1);

	cout << "p2的年龄为：" << p2.m_Age << endl;
}
//2、值传递的方式给函数参数传值

void doWork(Person p)
{

}
void test02()
{
	Person p;
	doWork(p);
}
//3、以值方式返回局部对象
Person doWork2()
{
	Person p1;
	return p1;
}
void test03()
{
	Person p = doWork2();
}
int main()
{
	test01();
	test02();
	test03();
    system("pause");
	return 0;
}

1.2.4 构造函数调用规则

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

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

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

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;
};
void test01()
{
	Person p;
	p.m_Age = 18;
	Person p2(p);

	cout << "p2的年龄为：" << p2.m_Age << endl;
}
void test02()
{
	Person p;
	/*Person p(28);
	Person p2(p);
	cout << "p2的年龄为：" << p2.m_Age << endl;*/
}
int main()
{
	//test01();
	test02();
    system("pause");
	return 0;
}

1.2.5 深拷贝与浅拷贝

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

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

浅拷贝带来的问题就是堆区的内存重复释放
浅拷贝问题要利用深拷贝进行解决

class Person
{
public:

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

	Person(int age,int height)
	{
		cout << "Person 有参构造函数调用" << endl;
		m_Age = age;
		m_Height = new int(height);
	}
	//自己实现拷贝构造函数 解决拷贝带来的问题
	Person(const Person &p)
	{
		cout << "Person 拷贝构造函数调用" << endl;
		m_Age = p.m_Age;
		//m_Height=p.m_Height; 编译器默认实现就是这行代码
		//深拷贝操作
		m_Height = new int(*p.m_Height);
	}
	~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;
}

1.2.6 初始化列表

作用：用来初始化属性
语法：构造函数（）：属性1（值1），属性2（值2），…{}

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);
	Person p(30,20,10);
	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;
}

1.2.7 类对象作为类成员

//手机类
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)//Phone 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;
}

1.2.8 静态成员

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

class Person
{
public:
	//静态成员函数
	static void func()
	{
		m_A = 100;//静态成员函数可以访问 静态成员变量
		//m_B = 200;//静态成员函数 不可以访问 非静态成员变量,无法区分到底是哪个对象的
		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;
}

Gigi Princess

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++核心编程之类和对象（二）

1.2 对象的初始化和清理1.2.1 构造函数和析构函数这个工作我们也可以不写，我们不写编译器会提供空实现。了解一下什么是构造函数和析构函数构造函数：创建对象时为对象的成员属性赋值析构函数：执行清理工作构造函数语法类名（）{}构造函数，没有返回值也不写void 函数名称与类名相同构造函数可以有参数，所以可以发生重载程序在调用对象的时候会自动调用构造，无须手动调用，只调用一次析构函数语法~类名（）{}析构函数，没有返回值也不写void函数名称与类名相同，在
复制链接

扫一扫