c++之类中复杂关系！！

第一种：友元

友元函数

当我们有这么一种需求：一个函数参数为类时，这就需要访问类的内部成员,public成员可以访问，那当我们需要访问private成员的时候呢？这在c++中如何实现呢？就需要通过友元函数了！

举例:

class T
{
    friend void Hp_Add(T& t1); //友元函数声明，此函数就可以访问private成员了
private:
    int Hp;   //私有成员，无法从外部直接访问

public:
    void Set_Hp(int _Hp) {
        Hp = _Hp;
    }
    int Get_Hp() const{
        return Hp;
    }
    
};

void Hp_Add(T& t1)
{
    t1.Hp++;//对私有成员进行写操作
}

int main()
{
    T t1; t1.Set_Hp(10);
    Hp_Add(t1);
    cout << t1.Get_Hp();
}

来看一下结果:

总结： 这里就通过声明友元函数的方式来进行对类中private成员进行访问了！

友元类

当我们出现如下需求时：第二个类中的某些成员函数需要访问第一个类中的私有成员变量，这时候就可以通过友元类的方式进行实现！

举例如下：

class T1
{
    friend class T2; //声明一个友元类！
private:
    int Hp;

public:
    void Set_Hp(int _Hp) {
        Hp = _Hp;
    }
    int Get_Hp() const{
        return Hp;
    }
    
};

class T2
{
private:
    int Mp;
public:
    void T1Hp_Add(T1&t) {  //这个类想要修改T1类中private成员
        t.Hp++;
    }
};

int main()
{
    T1 t1; t1.Set_Hp(10);  //给Hp赋值10
    T2 t2; t2.T1Hp_Add(t1); //通过T2类来改变t1的Hp
    cout <<"t1的Hp为 " <<t1.Get_Hp() << endl;
}

来看一下结果：

这里注意： 友元类的朋友关系只是单方面的，就如同上面的例子，T1类说T2是我的朋友，这时候T2类中就可以访问T1类的私有成员。但是反之则不成立，T1就无法访问T2的私有成员!

友元之总结:

1、友元类不是对等关系

2、友元类会破坏类的封装性，除非迫不得已，否则不要用！

第二种：嵌套类

举个例子：我们人这个类有身高、体重，也有鞋子这个属性。鞋子又有大小、品牌、颜色属性。这时候是不是很符合类的嵌套呢？Yes，这时候就可以用类的嵌套来设计类了！

这里举个简单的小案例，代码如下：

enum class Shoe_Color  //自定义鞋子颜色类型
{
    red = 1,
    blue,
    green,
};
enum class Shoe_Brand //自定义鞋子品牌类型
{
    Nike = 1,
    Adidas,
    Anta,
};
class Person //外层类,人
{
public:
    short height;//身高
    short weight;//体重
    class Shoes;     //鞋子  嵌套类的声明，写成这样时为了类的整洁性
};
//嵌套类详细的声明
class Person::Shoes 
{
private:
    short Size;
    enum Shoe_Color Color;
    enum Shoe_Brand Brand;
public:
    void Show();
    void Init_Shoes(short _Size, enum Shoe_Color _Cor, enum Shoe_Brand _Bra);
};
//嵌套类成员函数的实现，分文件写也是一样的
void Person::Shoes::Init_Shoes(short _Size, enum Shoe_Color _Cor, enum Shoe_Brand _Bra)
{
    Size = _Size;
    Color = _Cor;
    Brand = _Bra;
}
//嵌套类成员函数的实现
void Person::Shoes::Show()
{
    string Brand{}, Cor{};
    switch ((int)this->Brand) {
	    case (int)Shoe_Brand::Nike:
	        Brand = "Nake";
	        break;
	    case (int)Shoe_Brand::Adidas:
	        Brand = "Adidas";
	        break;
	    case (int)Shoe_Brand::Anta:
	        Brand = "Anta";
	        break;
    }
    switch ((int)this->Color) {
	    case (int)Shoe_Color::red:
	        Cor = "红色";
	        break;
	    case (int)Shoe_Color::green:
	        Cor = "绿色";
	        break;
	    case (int)Shoe_Color::blue:
	        Cor = "蓝色";
	        break;
    }
    cout << "码数：" << Size << " 品牌: " << Brand << " 颜色：" << Cor << endl;
}
int main()
{
    Person::Shoes shoe; //定义一双鞋得通过人的类加：：限定符
    shoe.Init_Shoes(40,Shoe_Color::red,Shoe_Brand::Nike);
    shoe.Show();
}

来看一下结果：

最后来说一下嵌套类中嵌套类和外层类访问权限的关系：

1、嵌套类可调用外层类所有成员

2、外层类仅能访问嵌套类中的共有成员

第三种：局部类

什么叫局部类呢？定义在函数内的类称为局部类!

虽然比较少见，但是也为了自己留个印象还是简单的学习一下！

差不多总结有三条规定：
1、局部类中不允许使用静态成员变量

有图有真相:

2、局部类定义必须在类内

有图有真相:

3、局部类可以访问全局变量

int flag = 10; //定义一个全局变量
void Func()
{
    class T   //定义局部类
    {
    private:
        int hp;
        int mp;
    public:
        void Init()
        {
            ::flag++;  //令全局变量加1
            hp = 1000;
            mp = 500;
        }
    };
    T t1;   //实例化一个局部类
    t1.Init();  //令flag++，看看是不是加1了
}


int main()
{
    cout << "flag=" << ::flag << endl;
    Func();
    cout << "flag=" << ::flag << endl;

结果：

这里我们看到局部类时能够调用全局变量的！！！！

感谢自己努力拼搏的学习！！！老铁们觉得有点用的话，记得点点赞哦！！！我是航行的小土豆!!!