08—C++类和对象—对象特性

最新推荐文章于 2022-07-25 22:16:09 发布

彤彤的小跟班

最新推荐文章于 2022-07-25 22:16:09 发布

阅读量132

点赞数

分类专栏： C++基础文章标签： c++

本文链接：https://blog.csdn.net/weixin_45583303/article/details/105144625

版权

C++基础专栏收录该内容

14 篇文章 0 订阅

订阅专栏

拷贝构造

拷贝也就是复制
我们常见的使用变量b给变量a赋值就只一种拷贝
int a=10;
int b=a;
把a的值拷贝到b身上

类对象的拷贝

而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量

#include <iostream> 
using namespace std;
//定义一个类
class Person
{

private:
	//定义私有成员变量
	int a;
public:
	//定义有参构造
	Person(int b){
		a = b;
		cout << "有参构造被调用" << endl;
	}
public :
	//定义方法访问a
	void setA(int b)
	{
		a = b;
	}
	//定义一个方法用来显示结果
	void show(){
		cout << a << endl;
	}

};
void main(void)
{
	Person a1(18);
	//a2拷贝了a1，对比普通类型：int a=10; int b=a;	则b的值为10
	Person a2 = a1;
	a2.show();//输出a2的值为18
	system("pause");
}

从运行结果可以看出，系统为对象a2分配了内存并完成了与对象A的复制过程。
就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。
注意：
1.如果我们没有自己定义拷贝构造函数，系统会默认给我们创建一个拷贝构造函数，然后通过这个函数来进行类对象的拷贝。
2.构造函数和析构函数也是一样的，如果我们不创建系统都会帮我们创建一个默认的构造函数(无参的)和析构函数（都是空的函数），如果我们自己创建了，就会用我们自己的。

在下面这个例子中我们自己定义一个拷贝构造函数
拷贝构造函数的定义：Person(const Person &p){}
拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。

#include <iostream> 
using namespace std;
//定义一个类
class Person
{

private:
	//定义私有成员变量
	int a;
public:
	//定义有参构造
	Person(int b){
		a = b;
		cout << "有参构造被调用" << endl;
	}
	//定义拷贝构造函数
	Person(const Person &P){
		a = P.a;
		cout << "拷贝构造被自动调用了" << endl;
	}
public :
	//定义方法访问a
	void setA(int b)
	{
		a = b;
	}
	//定义一个方法用来显示结果
	void show(){
		cout << a << endl;
	}

};
void main(void)
{
	Person a1(18);
	//a2拷贝了a1，对比普通类型：int a=10; int b=a;	则b的值为10
	Person a2 = a1;
	a2.show();//输出a2的值为18
	system("pause");
}

运行结果

有参构造被调用
拷贝构造被自动调用了
18
请按任意键继续. . .

从上面的程序可以看出，我们并没有显示的调用拷贝构造函数，当我们拷贝类对象时，拷贝构造函数会被自动调用

当用一个已初始化过了的自定义类类型对象去初始化另一个新对象的时候，拷贝构造函数就会被自动调用。也就是，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
1.一个对象以值传递的方式传入函数体
2.一个对象以值传递的方式从函数返回
3.一个对象需要通过另外一个对象进行初始化
后面还会继续探讨！！！！！！

#include<iostream>
using namespace std;
#include<string>
//拷贝构造函数的调用时机
/*
C++中拷贝构造函数调用时机通常有三种情况
1.使用一个已经创建完毕的对象来初始化一个新的对象
2.值传递的方式给函数参数传递
3.以值得方式返回局部对象
*/
class Person{
	//构造函数
public:
	Person()
	{
		cout << "函数的无参构造" << endl;
	}
	Person(int age){
		m_Age = age;
		cout << "函数的有参构造" << endl;
	}
	Person(const Person &p){
		m_Age = p.m_Age;
		cout << "函数的拷贝构造" << endl;
	}
	~Person()
	{
		cout << "析构函数" << endl;
	}
	//成员变量
private:
	int m_Age;
	//成员方法
public:
	void setAge(int age){
		m_Age = age;
	}
	int getAge(){
		return m_Age;
	}
};

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

}
//2.值传递的方式给函数参数传递
void doTest01(Person p){
	//函数的参数为类对象
}
void Test_02(){
	Person p3;//此处调用无参构造
	doTest01(p3);//此处调用拷贝构造
}
//3.以值得方式返回局部对象
Person doTest02(){
	//定义一个返回值类型为Person的函数
	Person p4;
	cout << (int *)&p4 << endl;
	//当执行完这句之后p4就被释放了，但是会被到p5当中
	return p4;
}
void Test03(){
	Person p5=doTest02();
	cout << (int *)&p5 << endl;
	//当执行完这句之后p5就被释放了
}
int main(){
	//注意注意注意：拷贝构造不会改变原对象的值，因为是拷贝
	//Test_01();
	//Test_02();
	Test03();
	system("pause");
	return 0;
}

浅拷贝和深拷贝

其实不用指针一点吊事都没有！！！！！但是我们要用呀！！！！！

有时候定义一个类，类内成员变量需要动态开辟堆内存，如果实行浅拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

注意注意注意：当使用指针在堆区开辟内存的时候，析构函数就有用了，要通过析构函数把内存释放（手动释放）

下面代码就是因为浅拷贝出现的问题：

#include<iostream>
using namespace std;
#include<string>
//深拷贝和浅拷贝
/*
浅拷贝：简单的赋值拷贝
深拷贝：在堆区重新申请空间，进行拷贝操作
*/
/*
浅拷贝带来的问题：
Person p2(p1)，如果利用编译器提供的拷贝构造函数，会做浅拷贝，
p1和p2对象在堆区（n_Height）会指向同一个内存，这段内存会被两次析构（重复释放），报错
*/
/*
利用深拷贝解决浅拷贝带来的问题？
执行拷贝函数，复制的时候，把堆区的的进行资源重新分配（不指在一起）
*/
class Person{
	//构造函数
public:
	Person()
	{
		cout << "函数的无参构造" << endl;
	}
	Person(int age,int height){
		m_Age = age;
		m_Height=new int(height);//使用new把对象创建在堆区，返回的为int*
		cout << "函数的有参构造" << endl;
	}
	~Person()
	{
		//析构代码，将堆区开辟的数据做释放
		if (m_Height != NULL){
			delete m_Height;//释放堆区，需要手动释放
			m_Height = NULL;//避免出现野指针，让它指向空
		}
		cout << "析构函数" << 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)，如果利用编译器提供的拷贝构造函数，会做浅拷贝
	//p1和p2对象在堆区（n_Height）会指向同一个内存，这段内存会被两次析构（重复释放），报错
	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << "身高为：" << *p2.m_Height<<endl;
}
int main(){
	Test01();
	system("pause");
	return 0;
}

深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝

注意注意注意：当使用指针在堆区开辟内存的时候，析构函数就有用了，要通过析构函数把内存释放（手动释放）

深拷贝：只要修改拷贝构造函数即可

#include<iostream>
using namespace std;
#include<string>
//深拷贝和浅拷贝
class Person{
	//构造函数
public:
	Person()
	{
		cout << "函数的无参构造" << endl;
	}
	Person(int age,int height){
		m_Age = age;
		m_Height=new int(height);//使用new把对象创建在堆区(开辟一段内存)，返回的为int*
		cout << "函数的有参构造" << endl;
	}
	Person(const Person &p){
		m_Age = p.m_Age;
		//m_Height=p.m_Height;	//编译器默认的代码
		//下面进行深拷贝操作
		m_Height=new int(*p.m_Height);	//使用new把对象创建在堆区(开辟一段内存)
		cout << "函数的拷贝构造" << endl;
	}
	~Person()
	{
		//析构代码，将堆区开辟的数据做释放
		if (m_Height != NULL){
			delete m_Height;//释放堆区，需要手动释放
			m_Height = NULL;//避免出现野指针，让它指向空
		}
		cout << "析构函数" << 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)，如果利用编译器提供的拷贝构造函数，会做浅拷贝
	//p1和p2对象在堆区（n_Height）会指向同一个内存，这段内存会被两次析构（重复释放），报错
	//为了结觉这个问题，我们自定义拷贝构造函数，不让他报错
	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << "身高为：" << *p2.m_Height<<endl;
}
int main(){
	Test01();
	system("pause");
	return 0;
}

08类—对象特性（构造与析构函数）

#include<iostream>
using namespace std;
#include<string>
/*
对象的初始化和清理是两个非常重要的安全问题
一个对象或者变量没有初始状态，对其使用后果未知，同样不进行及时的清理也会造成安全为题

构造函数和析构函数会被编译器自动调用，完成对象的初始化和清理工作
对象的初始化和清理工作是编译器强制要求我们要做的事情，
因此我们不提供构造和析构函数（我们写了就用自己的），编译器会提供构造和析构函数的空实现

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

*/
/*
构造函数语法：类名(){}
1.构造函数，没有返回值也不写void
2.函数名和类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时会自动调用构造，无需手动调用，而且只会调用一次
*/
/*
析构函数语法：类名(){}
1.析构函数，没有返回值也不写void
2.函数名和类名相同，在名称前加一个符号~
3.构造函数不可以有参数，因此不会发生重载
4.程序在对象销毁时会自动调用析构，无需手动调用，而且只会调用一次
*/
class Person{
public:
	//1.创建构造函数
	Person(){
		cout << "构造函数被自动调用了" << endl;
	}
	//2.创建析构函数
	~Person(){
		cout << "析构函数被自动调用了" << endl;
	}
};
void Test(){
	//只创建一个对象，构造会被自动调用
	Person p;	//在栈上的数据，Test执行完之后就会释放这个对象
}
int main(){
	Test();
	system("pause");
	return 0;
}

09类—对象特性（构造函数分类）

#include<iostream>
using namespace std;
#include<string>
/*
构造函数的分类：两种分类方式
按参数分类：有参构造和无参构造
按类型分类：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法
*/

class Person{
private:
	int age;
public:
	//1.创建构造函数
	//无参构造
	Person(){
		cout << "无参构造函数被自动调用了" << endl;
	}
	//有参构造
	Person(int a){
		age = a;
		cout << "有参构造函数被调用了" << endl;
	}
	//拷贝构造（先记住）
	Person(const Person &p){
	//将传入的人身上的所有属性拷贝到我身上
		age = p.age;
		cout << "拷贝构造函数被调用了" << endl;
	}
	
	//2.创建析构函数
	~Person(){
		cout << "析构函数被自动调用了" << endl;
	}
};
void Test(){
	//调用
	//1.括号法
	Person p1;//默认调用无参构造
	Person p2(10);//调用有参构造
	Person p3(p2);//调用拷贝构造
	//注意事项：调用默认构造的时候不要加(),编译器会认为是一个函数的声明：void func();<——>Person p();
	//2.显示法
	Person p4;
	Person p5 = Person(10);
	Person p6 = Person(p5);

	Person(10);//匿名对象，特点：当前执行结束后，系统会立即回收掉匿名对象
	//注意事项：不要利用拷贝构造函数，初始化匿名对象，编译器会认为Person(p3)====Person p3;对象重定义
	//3.隐式转换法
	Person p7 = 10;//相当于写了Person p7=Person(10);	有参构造
	Person p8 = p7;//拷贝构造

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

10类—对象特性（拷贝构造函数的调用时机）

#include<iostream>
using namespace std;
#include<string>
//拷贝构造函数的调用时机
/*
C++中拷贝构造函数调用时机通常有三种情况
1.使用一个已经创建完毕的对象来初始化一个新的对象
2.值传递的方式给函数参数传递
3.以值得方式返回局部对象
*/
class Person{
	//构造函数
public:
	Person()
	{
		cout << "函数的无参构造" << endl;
	}
	Person(int age){
		m_Age = age;
		cout << "函数的有参构造" << endl;
	}
	Person(const Person &p){
		m_Age = p.m_Age;
		cout << "函数的拷贝构造" << endl;
	}
	~Person()
	{
		cout << "析构函数" << endl;
	}
	//成员变量
private:
	int m_Age;
	//成员方法
public:
	void setAge(int age){
		m_Age = age;
	}
	int getAge(){
		return m_Age;
	}
};

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

}
//2.值传递的方式给函数参数传递
void doTest01(Person p){
	//函数的参数为类对象
}
void Test_02(){
	Person p3;//此处调用无参构造
	doTest01(p3);//此处调用拷贝构造
}
//3.以值得方式返回局部对象
Person doTest02(){
	//定义一个返回值类型为Person的函数
	Person p4;
	cout << (int *)&p4 << endl;
	//当执行完这句之后p4就被释放了，但是会被拷贝到p5当中
	//对象作为返回值会调用拷贝构造
	return p4;
}
void Test03(){
	Person p5=doTest02();
	cout << (int *)&p5 << endl;
	//当执行完这句之后p5就被释放了
}
int main(){
	//注意注意注意：拷贝构造不会改变原对象的值，因为是拷贝
	//Test_01();
	//Test_02();
	Test03();
	system("pause");
	return 0;
}

11类—对象特性（构造函数调用规则）

#include<iostream>
using namespace std;
#include<string>
//构造函数调用规则
/*
默认情况下C++编译器至少会给类添加3个函数
1.默认无参构造（无参，函数体为空）
2.默认析构函数（无参，函数体为空）
3.默认拷贝构造（对属性进行拷贝）
*/
/*
构造函数调用规则：
如果用户自定义有参构造，C++不再提供默认无参构造，但会提供默认拷贝构造
如果提供自定义拷贝构造，C++不再提供其他构造函数
*/

//创建一个类，我们只提供一个默认的拷贝构造
class Person{
private:
	int age;
public:
	//创建拷贝构造
	Person(const Person &p){
		age = p.age;
		cout << "自定义拷贝构造" << endl;
	}
};

int main(){
	/*下面这句话本来会调用无参构造，因为我们自定义了拷贝构造，没有自定义无参构造
	系统也不提供无参构造，报错，
	注意：系统不会提供默认有参构造
	*/
	//Person p;
	system("pause");
	return 0;
}

12类—对象特性（深拷贝和浅拷贝）

#include<iostream>
using namespace std;
#include<string>
//深拷贝和浅拷贝
//只有使用指针在堆区开辟内存才会出现深拷贝和浅拷贝
/*
浅拷贝：简单的赋值拷贝
深拷贝：在堆区重新申请空间，进行拷贝操作
*/
/*
浅拷贝带来的问题：
Person p2(p1)，如果利用编译器提供的拷贝构造函数，会做浅拷贝，
p1和p2对象在堆区（n_Height）会指向同一个内存，这段内存会被两次析构（重复释放），报错
*/
/*
利用深拷贝解决浅拷贝带来的问题？
执行拷贝函数，复制的时候，把堆区的的进行资源重新分配（不指在一起）
*/
/*
注意注意注意：当使用指针在堆区开辟内存的时候，析构函数就有用了，要通过析构函数把内存释放（手动释放）
*/
class Person{
	//构造函数
public:
	Person()
	{
		cout << "函数的无参构造" << endl;
	}
	Person(int age,int height){
		m_Age = age;
		m_Height=new int(height);//使用new把对象创建在堆区(开辟一段内存)，返回的为int*
		cout << "函数的有参构造" << endl;
	}
	Person(const Person &p){
		m_Age = p.m_Age;
		//m_Height=p.m_Height;	//编译器默认的代码
		//下面进行深拷贝操作
		m_Height=new int(*p.m_Height);	//使用new把对象创建在堆区(开辟一段内存)
		cout << "函数的拷贝构造" << endl;
	}
	~Person()
	{
		//析构代码，将堆区开辟的数据做释放
		if (m_Height != NULL){
			delete m_Height;//释放堆区，需要手动释放
			m_Height = NULL;//避免出现野指针，让它指向空
		}
		cout << "析构函数" << 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)，如果利用编译器提供的拷贝构造函数，会做浅拷贝
	//p1和p2对象在堆区（n_Height）会指向同一个内存，这段内存会被两次析构（重复释放），报错
	//为了解决这个问题，我们自定义拷贝构造函数，不让他报错（想报错就删除自定义拷贝构造函数）
	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << "身高为：" << *p2.m_Height<<endl;
}
int main(){
	Test01();
	system("pause");
	return 0;
}

13类—对象特性（初始化列表）

#include<iostream>
using namespace std;
#include<string>
//初始化列表
/*
作用：C++提供了初始化列表的语法，用来初始化属性
语法：构造函数():属性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 p1(10, 20, 30);
	cout << "m_A=" << p1.m_A << endl;
	cout << "m_B=" << p1.m_B << endl;
	cout << "m_C=" << p1.m_C << endl;
}
*/
void Test02(){
	Person p2(10,20,30);
	cout << "m_A=" << p2.m_A << endl;
	cout << "m_B=" << p2.m_B << endl;
	cout << "m_C=" << p2.m_C << endl;
}
int main(){
	//Test01();
	Test02();
	system("pause");
	return 0;
}

14类—对象特性（类对象作为类成员）

#include<iostream>
using namespace std;
#include<string>
//类对象作为类成员
//C++类中的成员可以是另一个类的对象，我们称该成员为对象成员
//类对象作为成员的时候，会先调用成员类的构造（先有才能被调用）
//析构的调用是相反的
//手机类
class Phone{
public:
	Phone(string pName){
		m_PName = pName;
		cout << "手机构造调用了" << endl;
	}
	~Phone(){
		cout << "手机类的析构函数" << endl;
	}
	string m_PName;
};

//人类
class Person{
public:
	//初始化列表的方式写有参构造
	Person(string mMName, string pName) :m_MName(mMName), m_Phone(pName)
	{
		cout << "人类构造调用了" << endl;
	}
	//析构函数
	~Person(){
		cout << "人类的析构函数" << endl;
	}
	string m_MName;
	//手机类做成员变量
	Phone m_Phone;
};

void Test01(){
	Person p1("AISMALL", "HONER");
	cout << "p1.m_MName=" << p1.m_MName << " p1.m_Phone="<< p1.m_Phone.m_PName<< endl;
}
int main(){
	Test01();
	system("pause");
	return 0;
}

15类—对象特性（静态成员变量和函数）

#include<iostream>
using namespace std;
#include<string>
//静态成员
/*
静态成员：在成员变量和成员函数前面加上关键字static，成为静态成员
静态成员分为：静态成员变量和静态成员函数
静态成员变量：
1.所有对象共享一份数据（一改全改，所有子类中的这个变量都会改变）
2.在编译阶段分配内存
3.类内声明，类外初始化
静态成员函数：
1.所有对象共享同一个函数
2.静态成员函数只能访问静态成员变量

注意：静态成员变量是公共的（一改全改）不是一个对象特有的，静态成员函数也是，
所以静态成员函数可以访问静态成员变量。
但是不可以访问非静态的成员变量，因为非静态的成员变量是特有的（不能一改全改），访问会报错
*/
class Person{
public:
	//类内定义静态成员变量
	static int m_age;
	//静态成员变量也是有访问权限的(类内定义)
private:
	static int m_number;
public:
	//定义静态成员函数
	static void func(){
		m_age = 100;//静态的成员变量只能访问静态的成员函数

		cout << "修改静态的成员变量的值为:" <<m_age<< endl;
		cout << "静态成员函数" << endl;
	}
	//静态成员函数也是有访问权限的
private:
	static void func02(){
		//外部不可以访问
	}
};
//类外初始化静态变量（双冒号代表作用域）
int Person::m_age = 200;
int Person::m_number = 100;

void Test01(){
	//1.静态成员变量的访问方式一
	Person p1;
	p1.m_age = 200;
	cout << "静态变量m_age的值" << p1.m_age << endl;
	Person p2;
	p2.m_age = 300;
	cout << "通过p2修改静态变量m_age的值看看p1的会不会变" << p1.m_age << endl;
	
	//2.访问方式二
	//静态成员变量的另一个特点，可以直接通过类名进行访问
	cout << Person::m_age << endl;

	//私有的静态成员变量在类外可以初始化，但不能访问，会报错
	//Person::m_number;
}

void Test02(){
	//1.通过对象进行访问
	Person p2;
	p2.func();
	//2.通过类名进行访问
	Person::func();
}
int main(){
	Test01();
	Test02();
	system("pause");
	return 0;
}

16类—对象特性（C++对象模型）

#include<iostream>
using namespace std;
#include<string>
//C++对象模型和this指针
/*
成员变量和成员函数：分开存储：
在C++中，类的成员变量和成员函数是分开存储的
只有非静态的成员变量才属于类的对象上

注意：只有非静态成员变量属于类的对象上
*/

class Person01{

};
class Person02{
public:
	int m_A;//非静态的成员变量，分配内存，属于类的对象上
	static int m_B;//静态的成员变量，不分配内存，不属于类的对象上
	void func(){} //非静态成员函数，不分配内存，不属于类的对象上
	static void func(){}//静态成员函数，不分配内存，不属于类的对象上
};
void Test01(){
	Person01 p1;
	//空对象的sizeof是多少		1
	//C++编译器会给空对象分配一个字节的空间，为了区分对象占内存的位置
	//每个对象也因该有独一无二的内存地址
	cout << "sizeof p=" << sizeof(p1) << endl;
}
void Test02(){
	Person02 p2;
	//有一个非静态成员变量的对象的sizeof是多少		4（因为是int型）
	//在类中增加一个静态成员变量，占用内存大小不变
	//在类中增加一个非静态成员函数，占用内存大小还不变
	cout << "sizeof p=" << sizeof(p2) << endl;
}
int main(){
	Test01();
	Test02();
	system("pause");
	return 0;
}

17类—对象特性（this指针）

#include<iostream>
using namespace std;
#include<string>
//this指针的概念
/*
通过上节的学习我们知道在C++中成员变量和成员函数是分开存储的
每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

那么问题是：这一块代码是如何区分那个对象调用自己的呢？
c++通过提供特殊的对象指针，this指针，解决上述问题。

this指针指向被调用的成员函数所属的对象
this指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义，直接使用即可

例如我们定义一个成员函数：void setAge(int age){m_Age=age}
编译器会帮我们做如下处理：void setAge(Person *const this  int age){m_Age=age}
只不过我们自己看不见

this指针的用途：
1.当形参和成员变量同名时，可用this指针来区分
2.在类的非静态成员函数中返回对象本身，可使用return *this
*/

class Person{
public:
	//成员变量
	int age;

	//有参构造函数
	Person(int age){
		//其实我们定义成员变量应该为m_Age，这里为了演示故意定义成age
		//当调用这个有参构造的时候其实就是他自己给自己赋值，因为当形参和成员变量同名，
		//age = age;
		this->age = age; //this指针指向被调用的成员函数所属的对象(此对象专属的哟)
	}
	//定义拷贝构造函数（为了做验证：不使用引用接受会调用拷贝构造）
	Person(const Person &p){
		age = p.age;
		cout << "自定义拷贝构造被调用" << endl;
	}
	//使用引用的方式传入
	Person& PersonAddAge(Person &p){
		this->age += p.age;
		//this指向p2的指针，而*this指向的就是p2这个对象的本体
		//对象作为返回值会调用拷贝构造，而拷贝就是复制一份就不是原来的了，
		//为了返回对象本体，所以使用*this的方式（引用的方式），而接收也要用引用的方式
		//因为：引用就是给变量起别名，指的还是同一个东西
		//如果不使用引用方式接收，同样会调用拷贝构造函数（为了说明，我们定义一个拷贝构造函数）
		return *this;
	}

};
//1.解决对象冲突
void Test01(){
	Person p1(18);
	cout << "年龄：" << p1.age << endl;
}

//2.返回对象本身用*this（接收要使用引用的方式）
void Test02(){
	Person p1(10);
	Person p2(10);
	
	//链式编程思想
	p2.PersonAddAge(p1).PersonAddAge(p1);
	cout << "p2的年龄是：" << p2.age << endl;
}

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

18类—对象特性（空指针访问成员函数）

#include<iostream>
using namespace std;
#include<string>
///空指针访问成员函数
/*
C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针
如果用到this指针，需要加以判断保证代码的健壮性
*/
//空指针调用成员函数
class Person{
public:
	void showClassName(){
		cout << "this is Person class" << endl;
	}
	void showPersonAge(){
		//报错的原因是因为传入的指针为空（NUll）
		//避免报错，添加以下代码，提高代码的健壮性
		if (this == NULL){
			cout << "这是一个空指针" << endl;
			return;
		}
		cout << "this is Person age:" <<this->m_Age<< endl;
	}
	int m_Age;
};

void Test01(){
	//定义一个Person类型的指针，让他指向空
	Person *p = NULL;
	//我们没有创建对象，只创建了一个空指针，this指针也就没有具体的指向（报错）
	p->showClassName();
	p->showPersonAge();
}
int main(){
	Test01();
	system("pause");
	return 0;
}

19类—对象特性（const修饰成员函数）

#include<iostream>
using namespace std;
#include<string>
//const修饰成员函数
/*
常函数:
1.成员函数后加const后我们称为这个函数为:常函数
2.常函数内不可以修改成员属性
3.成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象:
1.声明对象前加const称该对象为常对象
2.常对象只能调用常函数

前面学过：静态成员函数只能调用静态成员函数（大家都是一改全改）
*/


class Person
{
public:
	//成员变量
	int m_Age;
	mutable int m_B;
	//成员函数：后面加上const称为常函数
	/*
	在我们创建类的时候，隐含在每一个成员函数内部都有一个this指针
	
	例如我们定义一个成员函数：void setAge(int age){m_Age=age}
	编译器会帮我们做如下处理：void setAge(Person *const this  int age){m_Age=age}
	只不过我们自己看不见
	
	this指针是一个指针常量：指向不可以修改但是值可以修改，
	所以我们可以在成员函数中使用：this->m_Age=100;来修改成员变量的值
	但是当我们在成员函数后面加上const修饰的时候，这个this指针就变成（值和指向都不可以更改的指针）

	有一种情况：就是在定义成员变量的时候前面加上mutable修饰，即使是常函数也可以更改成员变量的值
	*/
	//1.常函数
	void showPerson() const
	{
		cout << "showPerson被调用了" << endl;
		m_B = 100;
		//m_Age = 100;//报错
	}
	//2.普通函数
	void Test01(){
		m_Age = 100;
		cout << "Test01被调用了" << endl;
	}
};

//常对象
void Test02(){
	const Person p;//在对象前加const，变为常对象
	//p.m_Age=100;//报错，因为是常对象
	p.m_B = 100;//m_B特殊值在常对象下能修改
	//p.Test01();//报错，常对象只能调用常函数(因为普通成员函数可以从侧面修改成员变量的值)
	p.showPerson();
}

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

彤彤的小跟班

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
08—C++类和对象—对象特性

目录拷贝构造类对象的拷贝浅拷贝和深拷贝拷贝构造拷贝也就是复制我们常见的使用变量b给变量a赋值就只一种拷贝int a=10;int b=a;把a的值拷贝到b身上类对象的拷贝而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量#include <iostream> using namespace std;//定义一个类class Person{...
复制链接

扫一扫