C++类与对象深入之静态成员与友元及内部类详解

第C++类与对象深入之静态成员与友元及内部类详解目录一：静态成员1.1：静态成员分类1.2：静态成员变量1.3：静态成员函数1.4：总结特性1.5：试题示例1.6：C++11成员初始化新玩法二：友元2.1：全局函数做友元2.2：类做友元2.3：成员函数做友元三：内部类3.1：概念3.2：特性

一：静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。C++里面尽量用静态成员变量代替全局变量。

1.1：静态成员分类

1️静态成员变量:

所有对象共享同一份数据在编译阶段分配内存类内声明，类外初始化

静态成员函数

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

1.2：静态成员变量

classPerson

public:

staticintm_A;//静态成员变量

private:

staticintm_B;//静态成员变量也是有访问权限的

intPerson::m_A=10;

intPerson::m_B=10;

voidtest01()

//静态成员变量两种访问方式

//1、通过对象

Personp1;

p1.m_A=100;

cout"p1.m_A="p1.m_Aendl;

Personp2;

p2.m_A=200;

cout"p1.m_A="p1.m_Aendl;//共享同一份数据

cout"p2.m_A="p2.m_Aendl;

//2、通过类名

cout"m_A="Person::m_Aendl;

//cout"m_B="Person::m_Bendl;//私有权限访问不到

intmain(){

test01();

system("pause");

return0;

代码解释：上述代码我们主要验证了利用两种方式来访问静态成员变量，以及静态成员变量属于整个类，属于类的所有对象

1.3：静态成员函数

classPerson

public:

staticvoidfunc()

cout"func调用"endl;

m_A=100;

//m_B=100;//错误，不可以访问非静态成员变量

staticintm_A;//静态成员变量

intm_B;//

private:

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

staticvoidfunc2()

cout"func2调用"endl;

intPerson::m_A=10;

voidtest01()

//静态成员变量两种访问方式

//1、通过对象

Personp1;

p1.func();

//2、通过类名

Person::func();

//Person::func2();//私有权限访问不到

intmain(){

test01();

system("pause");

return0;

}

代码解释：上述代码我们主要验证了利用两种方式来访问静态成员函数，利用对象访问和利用类名访问，以及静态成员函数只可以访问静态成员变量

⚠️⚠️⚠️:为什么不可以访问非静态成员？

⭐️因为没有this指针

1.4：总结特性

静态成员为所有类对象所共享，不属于某个具体的类实例静态成员变量必须在类外定义，定义时不加static关键字类静态成员类名：：静态成员或者对象.静态成员来访问静态成员函数没有隐含的this指针，不可以访问任何非静态成员静态成员和类的普通成员也一样，也有三种访问权限，也可以有返回值。

1.5：试题示例

❓实现一个类，计算程序中创建了多少个类对象

classA

public:

A(){

++_count1;

A(constAaa){

++_count2;

//成员函数也可以是静态，static成员函数没有this指针

staticintGetCount1(){

return_count1;

staticintGetCount2(){

return_count2;

//private:

//静态成员变量属于整个类，所以类的所有对象

staticint_count1;

staticint_count2;//声明

//定义

intA::_count1=0;

intA::_count2=0;

AFunc(Aa)

Acopy(a);

returncopy;

intmain()

Aa1;

Aa2=Func(a1);

couta1._count1endl;

couta2._count1endl;

couta1._count2endl;

couta2._count2endl;

coutA::_count1endl;

coutA::_count2endl;

couta1.GetCount1()endl;

couta2.GetCount2()endl;

coutA::GetCount1()endl;

coutA::GetCount2()endl;

system("pause");

return0;

1

1

3

3

1

3

1

3

1

3

请按任意键继续...

1.6：C++11成员初始化新玩法

classB

public:

B(intb=0)

:_b(b)

int_b;

classA

public:

//A()//其实是编译器自己生产的默认构造函数用缺省值初始化

//:a(10)

//,b(20)

//,p((int*)malloc(4))

//{}

voidPrint()

coutaendl;

coutb._bendl;

coutpendl;

coutnendl;

private:

//非静态成员变量，可以在成员声明时给缺省值。

inta=10;

Bb=20;//单参数的构造函数，支持隐式类型的转换

int*p=(int*)malloc(4);

staticintn;

//非静态成员变量定义在构造函数

//静态在类外

intA::n=0;

intmain()

Aa;

a.Print();

system("pause");

return0;

}

二：友元

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

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

友元的关键字为friend

友元分为：

友元函数友元类

友元的三种实现：

全局函数做友元

类做友元

成员函数做友元

2.1：全局函数做友元

⭐️说明：友元函数可以直接访问类的私有成员，它是定义在类外部的普通成员函数，不属于任何类，但需要在类的内部声明，声明的时候需要加friend关键字。

classBuilding

//告诉编译器goodGay全局函数是Building类的好朋友，可以访问类中的私有内容

friendvoidgoodGay(Building*building);

public:

Building(){

this-m_SittingRoom="客厅";

this-m_BedRoom="卧室";

public:

stringm_SittingRoom;//客厅

private:

stringm_BedRoom;//卧室

voidgoodGay(Building*building){

cout"好基友正在访问："building-m_SittingRoomendl;

cout"好基友正在访问："building-m_BedRoomendl;

voidtest01(){

Buildingb;

goodGay(

intmain(){

test01();

system("pause");

return0;

}

代码解释：如上述代码中，我们需要告诉编译器goodGay全局函数是Building类的好朋友，可以访问类中的私有内容

2.2：类做友元

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类的非公有成员。

友元关系是单向的，不具有交换性。友元关系不可以传递。如果B是A的友元，C是B的友元，但是不可以说C是A的友元。

代码示例：

classBuilding;

classgoodGay

public:

goodGay();

voidvisit();

private:

Building*building;

classBuilding

//告诉编译器goodGay类是Building类的好朋友，可以访问到Building类中私有内容

friendclassgoodGay;

public:

Building();

public:

stringm_SittingRoom;//客厅

private:

stringm_BedRoom;//卧室

Building::Building(){

this-m_SittingRoom="客厅";

this-m_BedRoom="卧室";

goodGay::goodGay(){

building=newBuilding;

voidgoodGay::visit(){

cout"好基友正在访问"building-m_SittingRoomendl;

cout"好基友正在访问"building-m_BedRoomendl;

voidtest01(){

goodGaygg;

gg.visit();

intmain(){

test01();

system("pause");

return0;

}

代码解释：如上述代码中，我们需要告诉编译器告诉编译器goodGay类是Building类的好朋友，可以访问到Building类中私有内容

2.3：成员函数做友元

一个类的成员函数做另一个类的友元。

代码示例：

classBuilding;//提前声明

classgoodGay

public:

goodGay();

voidvisit();//只让visit函数作为Building的好朋友，可以发访问Building中私有内容

voidvisit2();

private:

Building*building;

classBuilding

//告诉编译器goodGay类中的visit成员函数是Building好朋友，可以访问私有内容

friendvoidgoodGay::visit();

public:

Building();

public:

stringm_SittingRoom;//客厅

private:

stringm_BedRoom;//卧室

Building::Building(){

this-m_SittingRoom="客厅";

this-m_BedRoom="卧室";

goodGay::goodGay(){

building=newBuilding;

voidgoodGay::visit(){

cout"好基友正在访问"building-m_SittingRoomendl;

cout"好基友正在访问"building-m_BedRoomendl;

voidgoodGay::visit2(){

cout"好基友正在访问"building-m_SittingRoomendl;

//cout"好基友正在访问"building-m_BedRoomendl;

voidtest01(){

goodGaygg;

gg.visit();

intmain(){

test01();

system("pause");

return0;

}

代码解释：如上述代码中，我们需要告诉编译器goodGay类中的visit成员函数是Building好朋友，可以访问私有内容

三：内部类

3.1：概念

概念：如果一个类定义在另一个类的内部，这个类就叫内部类。注意此时的内部类是一