07学习笔记：C++类和对象（对象模型和this指针、友元、运算符重载）

已于 2024-10-11 23:47:33 修改
阅读量906 收藏 19
点赞数 19
分类专栏： C++系统篇 文章标签： 学习 笔记 c++
于 2024-08-23 23:29:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74209413/article/details/141422637
版权

1、对象模型和this指针

1.1成员变量和成员函数分开存储

  • 在C++中，类内的成员变量和成员函数分开存储
  • 只有非静态成员变量才属于类的对象上，静态成员变量，非静态成员函数，静态成员函数都不属于类的对象上
#include <iostream>
#include <string>

using namespace std;

//成员变量和成员函数分开存储

//人类
class Person
{
	int m_A; //非静态成员变量 属于类的对象上
	static int m_B;//静态成员变量 不属于类的对象上
	
	void func() {} //非静态成员函数 不属于类的对象上
	static void func() {} //静态成员函数 不属于类的对象上
};
//静态成员变量类内声明 类外初始化 Person作用域下的成员变量
int Person::m_B = 100;

void test01()
{
	Person p;
	//空对象占用的内存空间为：
	//C++编译器会给每个对象也分配一个字节的内存空间，是为了区分空对象占内存的位置
	//每个空对象也应该有一个独一无二的内存地址
	cout << "size of p = " << sizeof(p) << endl;
}

void test02()
{
	Person p;
	cout << "size of p = " << sizeof(p) << endl;
}
int main()
{
	test02();
	system("pause");
	return 0;
}

1.2this指针概念

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

那么问题是：这一块代码是如何区分哪个对象调用自己的呢？

C++通过特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象

 

this指针是隐含每一个静态成员函数内的一种指针

this指针不需要定义，直接使用即可

 

this指针的用途：

  • 当形参和成员变量同名时，可用this指针来区分
  • 在类的非静态成员函数中返回对象本身，可使用return *this
#include <iostream>
#include <string>

using namespace std;



class Person
{
public:
	Person(int age)
	{
		//this指针指向被调用的成员函数 所属的对象
		this->age = age;
	}
	//返回引用和返回值的区别：
	//返回值：按照自身拷贝构造一个新的数据，然后做了一个返回值，相当于返回了另一个对象
	//引用方式返回，会一直返回this所指的对象
	Person& PersonAddAge(Person& p)
	{
		this->age += p.age;
		return *this;
	}
	int age;
};

//1、解决名称冲突
void test01()
{
	Person p1(18);

	cout << "p1的年龄为： " << p1.age << endl;
}
//2、返回对象本身用*this
void test02()
{
	Person p1(10);
	Person p2(10);
	//链式编程思想
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
	cout << "p2的年龄为：" << p2.age << endl;
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

要注意以值返回和以引用返回 类 类型的数据的区别

Person func()
{
    return *this;
}
//这是方式是通过拷贝构造函数返回一个新的同类对象

Person func()
{
    return *this;
}
//这种以引用方式进行返回，返回this指针所指向的对象

1.3空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到的this指针

如果用到this指针，需要加以判断保证代码的健壮性

示例：

#include <iostream>
#include <string>

using namespace std;

//空指针调用成员函数

class Person
{
public:
	void showClassName()
	{
		cout << "this is Person class" << endl; 
	}
	void showPersonAge()
	{
		if (this == NULL)
		{
			return;
		}
		cout << "age = " << this->m_Age << endl; 
	}
	int m_Age;
};

//1、解决名称冲突
void test01()
{
	Person *p = NULL;

	//p->showClassName();
	p->showPersonAge(); //运行这行代码会报错，原因是传入的指针是为NULL
	//cout << "p1的年龄为： " << p1.age << endl;
}

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

1.4const修饰成员函数

常函数：

  • 成员函数后加const后我们称为这个函数为常函数
  • 常函数内不可以修改成员属性
  • 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

  • 声明对象前加const称该对象为常对象
  • 常对象只能调用常函数

示例：

#include <iostream>
#include <string>

using namespace std;
//常函数


class Person
{
public:
	//隐含在每个成员函数中都有一个this指针
	//this指针的本质 是指针常量 指针的指向是不可以修改的
	//const Person *const this; //this指针的指向不可以修改，指向的变量的值也不能修改
	//在成员函数后面加const，修饰的是this指针，让指针指向的值也不可以修改
	void showPerson()const
	{
		m_B = 100;
		//this->m_A = 100; //成员函数后加const，this指向的值不能修改
		cout << "this is Person class" << endl;
		//this = NULL; //this指针的指向不可以修改
	}
	void func()
	{
		m_A = 100;
	}
	int m_A;
	mutable int m_B; //特殊变量，即使在常函数中，也可以修改这个值，加关键字mutable
};


void test01()
{
	Person p;
	p.showPerson();
}
//常对象
void test02()
{
	const Person p; //在对象前加const，变为常对象
	//p.m_A = 100;  //常对象不可以修改普通的成员属性
	p.m_B = 100; //m_B是特殊值，在常对象下也可以修改
	//常对象只能调用常函数
	p.showPerson();
	//p.func();  //常对象不可以调用普通的成员函数，因为普通成员函数可以修改属性
}
int main()
{
	test01();
	//test02();
	system("pause");
	return 0;
}

指针常量和常量指针

指针常量：int * const p //指针常量

用指针修饰的常量，该变量存放一个地址，该地址不可以修改，但地址里的内容可以修改

常量指针：const int *p = &a; //常量指针

指向常量的指针，指针的指向可以改变，但是指针指向的变量的值不可以修改

2、友元

生活中你的家有客厅（Public），有你的卧室（Private）

客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去

但是呢，你也可以允许你的好闺蜜好基友进去。

在程序里，有些私有属性，也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术

友元的目的就是让一个函数或者类 访问另一个类的私有成员

友元的关键字为friend

友元的三种实现

  • 全局函数做友元
  • 类做友元
  • 成员函数做友元

2.1全局函数做友元

#include <iostream>
#include <string>

using namespace std;
//全局函数做友元

//建筑物类
class Building
{
	//goodGay全局函数是Building好朋友，可以访问Building中私有成员
	friend void goodGay(Building* building);  //全局函数做友元 
public:
	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;
};
//全局函数
void goodGay(Building *building)
{
	cout << "好基友全局函数 正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友全局函数 正在访问：" << building->m_BedRoom << endl;
}

void test01()
{
	Building building;
	goodGay(&building);
}

void test02()
{

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

2.2类做友元

#include <iostream>
#include <string>

using namespace std;
//类做友元
class Building;
class GoodGay
{
public:
	GoodGay();
	void visit(); //参观函数 访问building中的属性
	Building* building;
};
//建筑物类
class Building
{
	//GoodGay是本类的好朋友，可以访问本类的私有成员
	friend class GoodGay;
public:
	Building();

	string m_SittingRoom; //客厅
private:
	string m_BedRoom; //卧室
};

//类外写成员函数
Building::Building()
{
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
	//创建建筑物对象
	building = new Building; //初始化这个指针，指向堆区的一块内存，相当于创建一个Building类对象
}
void GoodGay::visit()
{
	cout << "好基友类正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友类正在访问：" << building->m_BedRoom << endl;
}
void test01()
{
	GoodGay gg;  //调用GoodGay的构造函数，创建一个Building类的对象，之后调用Building的构造函数，对其属性进行赋值
	gg.visit();
}

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

2.3成员函数做友元

#include <iostream>
#include <string>

using namespace std;
//成员函数做友元
class Building;
class GoodGay
{
public:
	GoodGay();
	void visit(); //参观函数 访问building中的私有属性
	void visit2(); //让visit2不可以访问building中的私有属性
	Building* building;
};
//建筑物类
class Building
{
	//告诉编译器 GoodGay的成员函数void visit 是本类的好朋友，可以访问本类的私有成员
	friend void GoodGay::visit();
public:
	Building();

	string m_SittingRoom; //客厅
private:
	string m_BedRoom; //卧室
};

//类外写成员函数
Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
	//创建建筑物对象
	building = new Building; //初始化这个指针，指向堆区的一块内存，相当于创建一个Building类对象
}
void GoodGay::visit()
{
	cout << "好基友类正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友类正在访问：" << building->m_BedRoom << endl;
}

void GoodGay::visit2()
{
	cout << "好基友类正在访问：" << building->m_SittingRoom << endl;
	//cout << "好基友类正在访问：" << building->m_BedRoom << endl;
}
void test01()
{
	GoodGay gg;  //调用GoodGay的构造函数，创建一个Building类的对象，之后调用Building的构造函数，对其属性进行赋值
	gg.visit();
	gg.visit2();
}

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

3、运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

1.1加号运算符重载

作用：实现两个自定义数据类型相加的运算

#include <iostream>
#include <string>

using namespace std;
//加号运算符重载
class Person
{
public:
	//1、成员函数重载+号
	//Person operator+(Person& p) //编译器提供的成员函数
	//{
	//	Person temp;
	//	temp.m_A = this->m_A + p.m_A;
	//	temp.m_B = this->m_B + p.m_B;
	//	return temp;
	//}
	//函数重载的版本

	int m_A;
	int m_B;
};
//全局函数重载+号
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}

Person operator+(Person& p1, int num)
{
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}

void test01()
{
	Person p1,p2,p3,p4;
	p1.m_A = 10;
	p1.m_B = 10;
	p2.m_A = 10;
	p2.m_B = 10;
	//成员函数本质调用
	//p3 = p1.operator+(p2);
	//全局函数本质调用
	//p3 = operator+(p1,p2);
	//上面的代码可以简化为以下
	p3 = p1 + p2;
	//运算符重载 也可以发生函数重载
	p4 = p1 + 15;

	cout << "p3.m_A = " << p3.m_A << endl;
	cout << "p3.m_B = " << p3.m_B << endl;

	cout << "p4.m_A = " << p4.m_A << endl;
	cout << "p4.m_B = " << p4.m_B << endl;
}

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

总结1：对于内置的数据类型的表达式的运算符是不可能改变的

总结2：不要滥用运算符重载

1.2左移运算符重载

作用：可以输出自定义的数据类型

#include <iostream>
#include <string>

using namespace std;
//左移运算符重载
class Person
{
	//利用友元访问私有属性
	friend ostream& operator<<(ostream& cout, Person& p); 
	//friend void test01();
	
public:
	//有参构造函数赋初值
	Person(int a, int b)
	{
		m_A = a;
		m_B = b;
	}
private:
	//利用成员函数重载 左移运算符 p.operator<<(cout) 简化版本 p << cout
	//不会利用成员函数重载<<运算符 因为无法实现cout在左侧
	//void operator<<(cout)
	//{
	//	
	//}
	int m_A;
	int m_B;
};
//只能利用全局函数重载左移运算符
//cout是标准的输出流对象
ostream &operator<<(ostream &cout, Person &p) //cout可以取别名，因为用的是引用
{
	cout << "m_A = " << p.m_A << " m_B = " << p.m_B;
	return cout;
}

void test01()
{
	Person p(10,10);
	//链式编程思想
	cout << p << endl; //前面调用完之后还返回cout，而不是返回void
}

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

1.3递增运算符重载

作用：通过重载递增运算符，实现自己的整形数据

   

#include <iostream>
#include <string>

using namespace std;
//递增运算符重载
//自定义整形
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符 返回引用为的是一直对一个数据进行递增操作
	MyInteger &operator++()
	{
		//先进行++运算
		m_Num++;
		//再将自身进行返回
		return *this;
	}
	//重载后置++运算符
	//返回值不是区分函数重载的条件
	//void operator++(int) int代表占位参数，可以用于区分前置和后置递增
	MyInteger operator++(int) 
	{
		//先 记录当时的结果
		MyInteger temp = *this;
		//后 递增
		m_Num++;
		//最后将记录的结果做返回操作
		return temp;
	}
private:
	int m_Num;
};

ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;
	return cout;
}
//前置递增
void test01()
{
	MyInteger myint;

	cout << ++(++myint) << endl;
	cout << myint << endl;
}
//后置递增
void test02()
{
	MyInteger myint;
	cout << myint++ << endl;
	cout << myint << endl;
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

总结：前置递增返回的是引用，后置递增返回的是值。

1.4赋值运算符重载

C++编译器至少给一个类添加4个函数

1、默认构造函数（无参，函数体为空）

2、默认析构函数（无参，函数体为空）

3、默认拷贝构造函数。对属性进行值拷贝

4、赋值运算符operator=，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深拷贝问题

示例：

#include <iostream>

using namespace std;
//赋值运算符重载
class Person
{
public:
	Person(int age)
	{
		m_Age = new int(age);
	}
	~Person()
	{
		//堆区内存重复释放导致程序崩溃
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}
	//重载赋值运算符
	Person &operator=(Person& p)
	{
		//编译器是提供浅拷贝
		//m_Age = p.m_Age;
		//应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//深拷贝
		m_Age = new int(*p.m_Age);
		return *this;
	}
	int *m_Age;
};

void test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(22);
	p3 = p2 = p1;  //赋值操作 p2调用赋值运算符重载函数之后要返回自身，
	//此时this指针指向p2，利用引用操作返回p2，return *this，this指针是一个指针常量
	cout << "p1的年龄为：" << *p1.m_Age << endl;
	cout << "p2的年龄为：" << *p2.m_Age << endl;
	cout << "p3的年龄为：" << *p3.m_Age << endl;
}

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

1.5关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

#include <iostream>
#include <string>
using namespace std;
//关系运算符重载
class Person
{
public:
	Person(string name,int age)
	{
		m_Name = name;
		m_Age = age;
	}

	//重载关系运算符
	bool operator==(Person& p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		} 
		return false;
	}
	bool operator!=(Person& p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return false;
		}
		return true;
	}
	string m_Name;
	int m_Age;
};

void test01()
{
	Person p1("Tom", 8);
	Person p2("Tom", 18);

	if (p1 == p2)
	{
		cout << "p1和p2是相等的！" << endl;
	}
	else
	{
		cout << "p1和p2是不相等的！" << endl;
	}
	if (p1 != p2)
	{
		cout << "p1和p2不是相等的！" << endl;
	}
	else
	{
		cout << "p1和p2是相等的！" << endl;
	}
}

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

1.6函数调用运算符重载

  • 函数调用运算符（）也可以重载
  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数
  • 仿函数没有固定写法，非常灵活
#include <iostream>
#include <string>
using namespace std;
//函数调用运算符重载

//打印输出类
class MyPrint
{
public:
	//重载函数调用运算符
	void operator()(string test)
	{
		cout << test << endl;
	}
};

void MyPrint02(string test)
{
	cout << test << endl;
}
void test01()
{
	MyPrint myPrint;
	myPrint("Hello World"); //由于使用起来非常类似于函数调用，因此称为仿函数

	MyPrint02("Hello World");
}

//仿函数非常灵活，没有固定的写法
//加法
class MyAdd
{
public:
	int operator()(int num1,int num2)
	{
		return num1 + num2;
	}
};

void test02()
{
	MyAdd myadd;
	int ret = myadd(2,2);
	cout << "sum = " << ret << endl;
	//匿名函数对象 
	cout << MyAdd()(100,100) << endl;
}
int main()
{  
	//test01();
	test02();
	system("pause");
	return 0;
}

 

 

 

御风_21
关注
专栏目录
C++学习笔记：类和对象
m0_64448698的博客
04-02 1028
class Point //点类private:int x;//x坐标int y;//y坐标public:Point()//默认构造函数，也是无参构造函数cout
c++学习笔记（7）友元 运算符重载
qq_42937719的博客
05-17 589
/ ()重载实现，使用非常像函数，所以又称仿函数。概念：对已有的运算符进行重新定义，赋予其另一种功能，以适应不同的数据类型。代码中包括类中构造函数以及成员函数的类外实现（加：：作用域）此处要返回值，不能返回引用，因为返回的是局部对象。由于重载后使用的方式非常像函数的调用，因此被称为仿函数。对于内置的数据类型的表达式的运算符是不可更改的。2）默认析构函数（无参，函数体为空）3）默认拷贝函数，对属性进行值拷贝。
C++学习笔记“类和对象”；运算符重载
qq_50259950的博客
06-05 301
C++学习笔记“类和对象”，运算符重载；加号运算符、左移运算符、递增运算符、赋值运算符、关系运算符、函数调用运算符重载。
C++学习笔记:类和对象
m0_70088853的博客
08-08 125
C++学习笔记:类和对象
C++学习笔记(三) 类(二) 友元和运算符重载
xi_xix_i的博客
07-26 164
在类中使用friend修饰全局函数、类、成员函数，即可令被修饰对象访问该类中private声明下的内容。
C++学习笔记之友元和运算符重载
weixin_46819249的博客
11-26 371
友元和运算符重载
C++入门：运算符重载及日期类的实现
2301_79501467的博客
04-18 1148
提问：拷贝构造中也有“=”的写法，赋值运算符中也有“=”的写法，是不是实现一个就可以了呢？欢迎留言评论区。
C++学习笔记（八）（C++对象模型和this指针 ，友元）
qq_40694605的博客
02-27 272
本笔记主要来源于教程https://www.bilibili.com/video/av41559729?p=1 4.3 C++对象模型和this指针 4.3.1 成员变量和成员函数分开储存 在C++中，类内的成员变量和成员函数分开存储 只有非静态成员变量才属于类的对象上 //成员变量和成员函数分开存储的 class Person { int m_A;//非静态成员变量 属于类的对象上 ...
【学习笔记】C++ 核心编程（七）类和对象——C++对象模型 + this指针
weixin_50499137的博客
05-03 1022
内容来自小破站《黑马程序员C++》复习自用
C++ 类数组，类作用域枚举，运算符重载，友元函数，类型自动转换
菜鸟进阶之路
07-02 3758
目录 一、类数组 二、类作用域枚举 三、运算符重载 1、通过类成员函数重载运算符 2、非类成员函数重载运算符 3、运算符重载的限制 四、友元函数 1、友元函数实现运算符重载 2、多个类的友元函数 3、类成员函数做友元函数 五、类类型转换函数 1、自动转换构造函数 2、类类型转换函数 一、类数组 《C++ Primer Plus》中提到初始化数组时都...
C++学习笔记- 面向对象 .md
11-13
内容是C++面对对象的，目录大致来源于菜鸟文档的C++面向对象，笔记是参考各种文章以及菜鸟文档改编的，内容包含C++类和对象（类定义和对象定义，类成员函数，类访问修饰符，友元函数，内联函数，this指针，静态成员...
C++运算符重载—使面向对象编程更加灵活
GeniusAng的博客
06-09 803
施磊C++语言基础提高课程笔记，包括了运算符重载CComplex复数类、实现C++标准库的string类、实现string类的迭代器、实现vector容器的选代器、迭代器失效问题、剖析new的delete的原理
C++学习笔记4：运算符重载、类型转换 ⚠ ⚠
qq_37299596的博客
04-13 495
运算符重载基本概念 成员函数重载运算符 单目运算符重载 双目运算符重载 重载++、–运算符 重载赋值运算符 重载下标运算符 重载函数调用运算符“()” 友元函数重载运算符 成员函数重载运算符和友元函数重载运算符比较 类型转换 运算符重载基本概念 面向对象程序涉及的重载有函数重载和运算符重载。 函数重载是指在相同作用域内，若干个参数特征不同的函数使用相同相同的函数名 运算符重载是另一种调用函数...
C++基础知识 —— 内存分区模型、引用、函数重载、类和继承、this指针、友元、多态、文件操作
不善挽留
03-27 633
1. 内存分区模型、2. 引用、3. 函数提高、4. 类和对象、5. 文件操作
嵌入式通信协议：MODBUS简明学习笔记
weixin_73867577的博客
11-02 361
学习Modbus的简明学习笔记
# SpringMVC学习
11-04 922
SpringMVC 是 Spring 框架的一部分，专门用于构建 Web 应用程序。它遵循 MVC（Model-View-Controller）设计模式，通过一系列组件和机制实现了请求的接收、处理和响应。
SPI通信详解-学习笔记
qq_45059758的博客
11-04 514
SPI通信
软件测试学习笔记丨Vue常用指令-条件渲染（v-if）
最新发布
ceshiren_com的博客
11-05 508
v-show只是简单控制dom元素的display属性。v-if通过操纵dom元素来进行切换显示。
SAP ABAP开发学习——接口中间件（PI）
m0_64077397的博客
11-04 206
左侧的红圈表示没有被生成。
C++初学者教程：类、对象与构造函数解析
类的声明涉及成员访问限定符、构造函数、析构函数、运算符重载、友元以及内存管理等多个方面，理解并熟练掌握这些知识点对于C++初学者至关重要。在实际编程中，应根据需求合理设计类和对象，充分利用C++的特性来提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值