4、静态成员、对象模型(C++核心语法)

于 2021-04-12 17:04:14 发布
阅读量169 收藏
点赞数
分类专栏： C++核心编程 文章标签： 指针 c++ 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30457077/article/details/115629782
版权
本文详细介绍了C++中的静态成员，包括静态成员变量和静态成员函数，强调它们的特性及访问方式。此外，文章还探讨了单例模式，通过主席类和打印机案例展示了如何实现确保类只有一个实例的单例设计模式，并讨论了单例模式的应用场景。最后，简要提及了C++对象模型、this指针、空指针、常对象和常函数、友元等相关概念。
摘要由CSDN通过智能技术生成

1 静态成员

1.1 静态成员变量
	1.1.1 所有对象都共享同一份数据
	1.1.2 编译阶段就分配内存
	1.1.3 类内声明、类外初始化
	1.1.4 访问方式有两种：通过对象访问、通过类名访问
	1.1.5 静态成员变量也是有访问权限
1.2 静态成员函数
	1.2.1 所有对象都共享同一份函数
	1.2.2 静态成员函数  只可以访问  静态成员变量，不可以访问非静态成员变量
	1.2.3 静态成员函数  也是有访问权限的
	1.2.4 静态成员函数 有两种访问方式：通过对象 、通过类名

#define _CRT_SECURE_NO_WARNINGS
		#include<iostream>
		using namespace std;


		class Person
		{
		public:
			//1、静态成员变量
			//静态成员变量 ：编译阶段就分配了内存
			//类内声明 、类外初始化
			//静态成员变量 所有对象都共享同一份数据
			static int m_A;


			//2、静态成员函数
			//所有对象都共享同一个func函数
			static void func()
			{
				//m_C = 100; //静态成员函数 不能访问非静态成员变量
				m_A = 100; //静态成员函数 能访问静态成员变量
				cout << "func调用" << endl;
			}

			int m_C;

		private:
			static int m_B; //私有静态成员变量 

			static void func2()
			{
			
			}
		};

		int Person::m_A = 0;
		int Person::m_B = 0;


		void test01()
		{
			//1、通过对象进行访问
			Person p1;
			cout << p1.m_A << endl;

			Person p2;
			p2.m_A = 100;

			cout << p1.m_A << endl;

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

			//静态成员变量 也是有访问权限的，私有权限类外访问不到
			//cout << Person::m_B << endl;

		}

		void test02()
		{
			//通过对象
			Person p1;
			p1.func();
			//通过类名
			Person::func();


			//Person::func2();  静态成员函数也是有访问权限的


		}

		int main(){

			//test01();
			test02();
			system("pause");
			return EXIT_SUCCESS;
		}

2 单例模式 – 主席类案例

2.1 通过一个类 只能实例化唯一的一个对象
2.2 私有化
	2.2.1 默认构造
	2.2.2 拷贝构造
	2.2.3 唯一实例指针
2.3 对外提供 getInstance 接口，将指针返回

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//主席类
class ChairMan
{
public:
	static ChairMan * getInstacne()
	{
		return singleMan;
	}
private:
	//将构造函数私有化，不可以创建多个对象
	ChairMan(){};

	ChairMan(const ChairMan &){};

//public:
private:
	//将主席指针 私有化，对外提供只读接口
	static  ChairMan * singleMan; //类内声明  类外初始化
};

ChairMan *  ChairMan::singleMan = new ChairMan;

void test01()
{
	/*ChairMan c1;
	ChairMan c2;
	ChairMan * c3 = new ChairMan;*/

	//ChairMan * c1 = ChairMan::singleMan;
	//ChairMan * c2 = ChairMan::singleMan;


	ChairMan * c1 = ChairMan::getInstacne();
	ChairMan * c2 = ChairMan::getInstacne();

	//ChairMan * c3 = new ChairMan(*c1);

	if (c1 == c2)
	{
		cout << "c1 = c2" << endl;
	}
	else
	{
		cout << "c1 != c2" << endl;
	}

	//if (c1 == c3)
	//{
	//	cout << "c1 = c3" << endl;
	//}
	//else
	//{
	//	cout << "c1 != c3" << endl;
	//}


}


int main(){
	test01();


	system("pause");
	return EXIT_SUCCESS;
}

3 单例模式 – 打印机案例

	3.1 和主席类案例一样设计单例模式
	3.2 提供打印功能并且统计打印次数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include <string>
class Printer
{
public:
	static Printer * getInstance()
	{
		return printer;
	}

	void printText(string text)
	{
		m_Count++;
		cout << text << endl;
	}

	int m_Count;

private:

	Printer()
	{ 
		m_Count = 0;
		//cout << "打印机构造调用" << endl; 
	};

	Printer(const Printer & p){};

	static Printer * printer;

	
};

Printer * Printer::printer = new Printer;


void test01()
{
	Printer * p1 = Printer::getInstance();
	p1->printText("入职证明");
	p1->printText("离职证明");
	p1->printText("加薪申请");
	p1->printText("旅游申请");

	cout << "打印机使用次数： " << p1->m_Count << endl;


	Printer * p2 = Printer::getInstance();
	p2->printText("调休申请");

	cout << "打印机使用次数： " << p1->m_Count << endl;

}

int main(){
//	cout << "mian函数调用" << endl;

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

4 C++对象模型初探

4.1 类中的成员变量 和 成员函数  是分开存储的
4.2 只有非静态成员变量  属于类对象上
4.3 空类的sizeof结果  1

#define _CRT_SECURE_NO_WARNINGS
	#include<iostream>
	using namespace std;

	//#pragma pack(1)

	class Person
	{
	public:

		int m_A; //只有非静态成员变量  属于类对象上

		void func( )  //成员函数  并不属于类对象上
		{
			
		}

		static int m_B; //静态成员变量  不属于类对象上

		static void func2()//静态成员函数  不属于类对象上
		{
			
		}

		double m_C;

	};
	int Person::m_B = 0;

	void test01()
	{
		//空类的sizeof结果是1  原因  每个对象都应该在内存上有独一无二的地址，因此给空对象分配1个字节空间
		// Person pArr[10]  pArr[0]  pArr[1]
		Person p1;
		//  空对象 大小 1  
		cout << "sizeof = " << sizeof(p1) << endl;//和结构体对齐规则一样 因此16的字节

	}


	int main(){
		test01();


		system("pause");
		return EXIT_SUCCESS;
	}

5 this指针

5.1 this指针 指向 被调用的成员函数 所属的对象
5.2 this指针可以解决名称冲突
5.3 this指针 隐式加在每个成员函数中
5.4 *this 就是本体
5.5	p1.personAddPerson(p2).personAddPerson(p2).personAddPerson(p2); //链式编程

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Person
{
public:
	Person(int age)
	{
		//用途1 ：解决名称冲突
		this->age = age;//this->age表示下面的int age;而age表示构造函数的int age
	}


	//this指针 隐式加在每个成员函数中
	bool compareAge(Person &p)
	{
		if (this->age == p.age)
		{
			return true;
		}
		return false;
	}

	//Person&  personAddPerson的&的存在原因是：将另外一个人的年龄叠加到一个人身上
	Person&  personAddPerson(Person &p)
	{
		this->age += p.age;
		return *this; //*this 就是Person&  personAddPerson中的Person本体
	}

	int age;
};

void test01()
{
	//this指针 指向 被调用的成员函数 所属的对象
	Person p1(10);

	cout << "p1的年龄为： " << p1.age << endl;


	Person p2(10);

	bool ret = p1.compareAge(p2);
	if (ret)
	{
		cout << "p1与p2年龄相等" << endl;
	}


	p1.personAddPerson(p2).personAddPerson(p2).personAddPerson(p2); //链式编程
	cout << "p1的年龄为： " << p1.age << endl;

}


int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

6 空指针访问成员函数

6.1 如果成员函数中没有用到this指针，可以用空指针调用成员函数
6.2 如果成员函数中用到了this，那么这个this需要加判断，防止代码down掉

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;


class Person
{
public:

	void showClass()
	{
		cout << "class Name is Person" << endl;
	}

	void showAge()
	{
		/*	if (this == NULL)
			{
			return;
			}*/
		//m_Age = 0;
		cout << "age = " << this->m_Age << endl;
	}

	int m_Age;
};


void test01()
{
	Person * p = NULL;

	//p->showClass();

	p->showAge();

}

int main(){
	test01();


	system("pause");
	return EXIT_SUCCESS;
}

7 常对象和常函数

7.1 常函数
	7.1.1 成员函数 声明后面加const
	7.1.2 void showPerson() const
	7.1.3 const目的是为了修饰成员函数中的this指针，让指针指向的值不可以修改
	7.1.4 有些属性比较特殊，依然在常函数或者常对象中可以修改，需要加入关键字 mutable
7.2 常对象
	7.2.1 const Person p
	7.2.2 常对象也不许修改成员属性
	7.2.3 常对象只能调用常函数
7.3 对于成员函数 ，可不可以 用static 和 const同时修饰 ，不可以

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Person
{
public:
	Person(int age)
	{
		this->m_Age = age;
	}

	//常函数 ： 修饰成员函数中的 this指针，让指针指向的值不可以修改
	void showPerson() const
	{
		//m_Age = 100;

		m_A = 100;

		//this指针的本质： const Person * const this 
		//this = NULL; 指针的指向不可以修改，而指针指向的值 可以改
		cout << "person age = " << this->m_Age << endl;
	}

	void func()
	{
		m_Age = 100;
		cout << "func调用" << endl;
	}

	int m_Age;

	mutable int m_A; //常函数中或常对象 有些特殊属性依然想修改，加入关键字 mutable
};

void test01()
{
	//常对象
	const Person p1(10);
	//p1.m_Age = 10;
	p1.m_A = 10;

	p1.showPerson();

	//p1.func(); //常对象 只能调用常函数
}

int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

8 友元

8.1 全局函数作为友元函数

	8.1.1 利用friend关键字让全局函数  goodGay作为本类好朋友，可以访问私有成员
	8.1.2 friend  void goodGay(Building * buliding);

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

class Building
{
	//利用friend关键字让全局函数  goodGay作为本类好朋友，可以访问私有成员
	friend void goodGay(Building * buliding);

public:
	Building()
	{
		this->m_SittingRoom = "客厅";
		this->m_BedRoom = "卧室";
	}

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

//好基友全局函数  可以访问Building的私有属性
void goodGay( Building * buliding)
{
	cout << "好基友正在访问：" << buliding->m_SittingRoom << endl;

	cout << "好基友正在访问：" << buliding->m_BedRoom << endl;
}

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

int main(){
	test01();
	

	system("pause");
	return EXIT_SUCCESS;
}

8.2 类作为友元类

	8.2.1 让goodGay类作为 Building的好朋友，可以访问私有成员
	8.2.2 friend class GoodGay;

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

class Building
{
	//利用friend关键字让全局函数  goodGay作为本类好朋友，可以访问私有成员
	friend void goodGay(Building * buliding);

public:
	Building()
	{
		this->m_SittingRoom = "客厅";
		this->m_BedRoom = "卧室";
	}

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

//好基友全局函数  可以访问Building的私有属性
void goodGay( Building * buliding)
{
	cout << "好基友正在访问：" << buliding->m_SittingRoom << endl;

	cout << "好基友正在访问：" << buliding->m_BedRoom << endl;
}

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

int main(){
	test01();
	

	system("pause");
	return EXIT_SUCCESS;
}

8.3 类中的成员函数作为友元函数

	8.3.1	//让GoodGay类中的 visit成员函数作为友元
	8.3.2   friend void GoodGay::visit();

#define _CRT_SECURE_NO_WARNINGS
	#include<iostream>
	using namespace std;
	#include <string>
	class Building;
	class GoodGay
	{
	public:

		GoodGay();

		void visit(); //可以访问building的私有

		void visit2(); // 不可以访问building的私有

		Building * m_building;
	};

	class Building
	{
		//让GoodGay类中的 visit成员函数作为友元
	   friend void GoodGay::visit();
	public:
		Building();

		string m_SittingRoom;

	private:
		string m_BedRoom;
	};

	Building::Building()
	{
		this->m_SittingRoom = "客厅";
		this->m_BedRoom = "卧室";
	}

	GoodGay::GoodGay()
	{
		this->m_building = new Building;
	}

	void GoodGay::visit()
	{
		cout << "好基友正在访问： " << this->m_building->m_SittingRoom << endl;
		cout << "好基友正在访问： " << this->m_building->m_BedRoom << endl;
	}

	void GoodGay::visit2()
	{
		cout << "好基友正在访问： " << this->m_building->m_SittingRoom << endl;
		//cout << "好基友正在访问： " << this->m_building->m_BedRoom << endl;
	}


	void test01()
	{
		GoodGay gg;
		gg.visit();
		gg.visit2();
	}

	int main(){

		test01();

		system("pause");
		return EXIT_SUCCESS;
	}
伍粟
关注
专栏目录
深度探索 C++ 对象模型 01：对象模型简介（附静态成员介绍）
InGeniX
10-18 250
C - 过程式（procedural）语言：数据和处理数据的操作（函数）分开声明，语言本身并不支持数据和操作之间的关联性 过程式语言由一组分布在函数中的算法所驱动，这些函数以功能为导向，这些算法则处理共同的外部数据 typedef struct point3d { float x; float y; float z; } Point3d; void print_point3...
面向对象静态语言的模型
weixin_30438813的博客
01-27 195
基本模型：（Java，C#，Scala） 接口，类 接口可以继承多个接口 类可以实现多个接口 类只能继承一个父类 扩展模型一：静态扩展（C#，Swift） 静态扩展通常属于项目后期的一种行为。 静态扩展针对特定的类型，可重用性不佳。 Extension可以扩展一个类，为类添加新的方法。 扩展模型二：动态组合（Scala） Trait类似于一个带全部或部分实现...
静态建模（类图和对象图）
mozhan的专栏
09-07 4712
<br />构成面向对象模型的基本元素有类，对象，类与类之间的关系等。<br /> <br />类图是用类和他们之间的关系描述系统的一种图示，是从静态角度表示系统的，因此类图属于一种静态模型。类图是构建其它图的基础。<br />当类图中存在多个类时，类与类之间的关系可以用表示某种关系的连线，把他们连接起来。<br /> <br />二，定义类<br />定义类，也就是将系统要处理的数据抽象成类的属性，将处理数据的方法抽象为操作，对于建模者所定义的类通常要有这样二个特点：1，使用来自问题域的概念；2，类的名字
对象的静态类型与动态类型
CNV_2305
04-12 787
由于继承导致对象的指针和引用具有两种不同的类型： 静态类型 和 动态类型 。 静态类型 ：指针或者是引用声明时的类型。 动态类型 ：由他实际指向的类型确定。 例如：GameObject *pgo = new SpaceShip; //pgo静态类型是 GameObject动态类型是 SpaceShip* Asterioid *pa = new Asterioid; //pa的静态类型是 Ast
第4章 静态建模: 类图和对象图
night_cat的专栏
08-12 1992
第4章  静态建模:  类图和对象图      构成面向对象模型的基本元素有class(类),objects(对象),类与类之间的关系等.4.1 类和对象  对象就是可以控制和操作的实体,是类的实例化,所有操作都是针对对象进行的.4.2 类图    是用类和它们之间的关系描述系统的一种图示,属于静态图.    类的图示如下:    1.定义类的方法:      a>有没有一定要存储或分析的信息
深度探索C++对象模型
02-11
《深度探索C++对象模型》是一本专注于C++编程语言底层机制的专业书籍，它深入剖析了C++的对象模型，帮助读者理解C++是如何在内存中表示对象、类、继承、多态等核心概念的。这本书适合已经具备一定C++基础，并希望...
C++对象模型-322
08-03
在C++编程语言中，对象模型是理解和设计高效代码的关键概念。...这些章节深入讨论了C++对象模型的关键方面，涵盖了类的构造和数据管理，以及成员函数的使用。理解这些概念对于编写高效、健壮的C++代码至关重要。
深度探索C++对象模型 超清
05-15
C++作为一门静态类型、编译型的语言，其对象模型是理解其工作原理的关键。下面，我们将详细探讨C++对象模型的相关知识点。 1. **类与对象**：C++中的类是对象的蓝图，定义了对象的属性（数据成员）和行为（成员函数...
第三阶段程序员C++核心编程.pdf
07-24
本文从【第三阶段程序员C++核心编程.pdf】文件内容中提炼出的C++编程知识点包括内存管理、面向对象编程、new和delete操作符以及引用的使用等多个方面。 首先，C++程序在运行时的内存分配主要分为四个区域：代码区、...
C++核心编程.pdf
04-10
C++核心编程是面向对象编程技术的重要组成部分，本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1. 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域：代码区、全局区、栈区和堆...
UML模型中的图-静态图【类图、对象图】
梦蝶
01-22 3275
更好
UML建模——静态图（类图、对象图、包图）
shang_0122的博客
11-30 9161
在完成系统的用例图后就可以根据用例图的参与者以及用例来进行UML的静态设计了。从静态设计的图就包括类图、对象图、包图，下面咱们一一叙述   类图 类图是描述类、接口、协作以及他们之间的关系的图，用来显示系统中某个类的静态结构 包含元素 类 类是面向对象组织结构的核心，对一组具有相同属性、操作、关系和语义的对象的描述 接口 接口是在没有给出对象的实现和状态的情况下对对象的行为...
c++list容器简单实现排序
GetByteDance的博客
02-06 552
#include<iostream> #include<string> #include<list> using namespace std; class Person { public: Person(string name, int age, int height) { m_Name = name; m_Age = age; m_Height = height; } string m_Name; int m_Age; int m_Height;
UML——类图、对象图（静态图）
张伟光
10-03 1595
【什么是类图】 类图是类的模型，是利用图示和文字注释描述类以及类和类之间相互关系的方法。 【类图的组成】 类图=类+关系+约束 类 类是对一组具有相同属性、操作、关系和语义的对象的抽象。 1.1类名 类名可分为三类...
java 面试题三十三 子类父类方法执行顺序的问题
jianfpeng241241的专栏
06-29 1836
. 判断以下Teacher类的main方法的运行结果（B） public class Teacher extends Person { public Teacher () { super(); } public Teacher(int a) { System.out.println (a); } public void func() { System.out.print ("2, ");
C++学习之路（四）
weixin_43850162的博客
01-29 813
文章目录静态成员变量静态成员函数单例模式的简介单例模式案例——主席案例单例模式案例——打印机案例 静态成员变量 在类定义中，它的成员（包括成员变量和成员函数），这些成员可以用关键字static声明为静态的，称为静态成员。 不管这个类创建了多少个对象，静态成员只有一个拷贝，这个拷贝被所有属于这个类的对象共享。 在一个类中，若将一个成员变量声明为static，这种成员称为静态成员变量。与一般的数据成员...
静态模型、动态模型
热门推荐
skyecs的博客
03-04 1万+
静态模型-离线训练易于构建和测试-使用批量训练和测试，对其进行迭代，直到达到良好效果仍然需要对输入进行监控模型容易过时动态模型-在线训练随着时间的推移不断为训练数据注入新的数据，定期更新同步版本使用渐进式验证，而不是批量训练和测试需要监控、模型回滚和数据隔离会根据变化作出相应调整，避免了过时问题学习谷歌机器学习速成...
C++面向对象：静态成员函数详解
静态成员函数是C++面向对象编程中的一种特性，它属于类而非对象，可以在没有创建类的对象实例的情况下直接访问。在给定的代码示例中，`Application` 类展示了如何使用静态成员函数。 首先，让我们理解静态成员函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值