【C++】面向对象之宏观部分——类的层次结构与互相关系(has_a、use_a、is_a)

最新推荐文章于 2026-06-18 21:05:44 发布

原创

最新推荐文章于 2026-06-18 21:05:44 发布 · 2.2k 阅读

标签

#c++ #开发语言 #c语言 #经验分享 #继承

本文详细介绍了C++中面向对象的三大关系：包含关系(has_a)、友元关系(use_a)和继承关系(is_a)，并通过代码示例展示了它们的具体应用及注意事项。

文章目录

一、包含关系(has_a关系)
- 1.1 包含关系的定义
- 1.2 包含关系的内存布局
二、友元关系(use_a关系)
三、继承关系(is_a关系)
四、多继承、棱形继承、虚继承

一、包含关系(has_a关系)

1.1 包含关系的定义

包含关系：即一个对象由多个对象共同组成。也被称之为has_a关系，组合关系，复合关系。

代码示例：

#include <iostream>

using namespace std;
class Man
{
   
   
public:
    Man()
    {
   
   
        cout << "Man的构造" << endl;
    }
    ~Man()
    {
   
   
        cout << "Man的析构" << endl;
    }
};
class Desk
{
   
   
public:
    Desk()
    {
   
   
        cout << "Desk的构造" << endl;
    }
    ~Desk()
    {
   
   
        cout << "Desk的析构" << endl;
    }
};
class Chair
{
   
   
public:
    Chair()
    {
   
   
        cout << "Chair的构造" << endl;
    }
    ~Chair()
    {
   
   
        cout << "Chair的析构" << endl;
    }
};
class Room
{
   
   
private:
    Chair chair;
    Desk desk;
    Man man;
public:
    Room()
    {
   
   
        cout << "Room的构造" << endl;
    }
    ~Room()
    {
   
   
        cout << "Room的析构" << endl;
    }
};

int main()
{
   
   
    Room room;
    return 0;
}

结果展示：
在这里插入图片描述
总结：
通过结果我们可知
构造顺序：先构造类中的成员对象，最后再构造最外层的包含对象，构造顺序为类中成员对象的声明顺序相同。
析构顺序：则相反。

1.2 包含关系的内存布局

我们来打印他们的this指针看一看
在这里插入图片描述
通过上图我们可以发现最外层的包含对象Room和第一个声明的成员对象Chair的地址是一样的，其他因为是空类依次加一。
由此我们可以推断出包含关系的内存布局如下图所示：

二、友元关系(use_a关系)

友元关系：就是用来描述，类与函数之间，类与类之间的一种亲密关系。
功能：可以访问朋友类中的私有成员。
友元关系的两种形式：友元函数，友元类。

2.1 友元函数

声明一个函数是类的友元函数，那么在这个函数里就可以访问类的私有成员了。

代码举例：

#include <iostream>

using namespace std;
class Man
{
   
   
private:
    int money;
public:
    Man(int _money):money(_money){
   
   }
//友元函数的声明
friend void girlfriend(Man& man);
};
void girlfriend(Man& man)
{
   
   
    man.money=man.money-100;
    cout << man.money <<endl;
}

int main()
{
   
   
    Man man(1000);
    girlfriend(man);
    return 0;
}

结果展示：
在这里插入图片描述

总结：
由结果可知当友元函数中，有被use_a的类时，那么这个类的对象将不再受到访问权限的限制。

2.2 友元类

如果声明B类是A类的友元类，那么在B类中的所有成员函数，都可以访问A类的私有成员。

代码示例：

#include <iostream>

using namespace std;
class Man
{
   
   
private:
    string name;
public:
    Man(string _name):name(_name){
   
   }
    friend class girlfriend;
};
class girlfriend
{
   
   
private:
    string name;
public:
    girlfriend(string _name):name(_name){
   
   }
    void show(Man& man)
    {
   
   
        cout << man.name << "正在陪" << name << endl;
    }
};
int main()
{
   
   
    Man man("小明");
    girlfriend girl("小红");
    girl.show(man);
    return 0;
}

结果展示：
在这里插入图片描述
总结：
由结果可知：在A类中声明friend class B，那就是B是A的友元类。如果B类中有定义A的对象时，A类的对象将不受A类的访问权限的限制。
注意：

友元关系不具有交换性：B是A的友元，但A不一定是B的。
友元关系不具有传递性：A是B的友元，B是C的友元，A不一定是C的友元。
友元关系不能被继承：父类的朋友不一定是子类的朋友。
友元关系破坏了类的封装性，让访问控制权限没有意义了，在实际开发中，不要过分依赖友元。

2.3 C++中分文件编程的实现

分文件编程实现boy与girl的相互友元
boy.h

#ifndef BOY_H
#define BOY_H
#include <iostream>
using namespace std;
class Girl;
class Boy
{
   
   
private:
    string name;
    int age;
public:
    Boy(string name,int age);
    void show();
    void show(Girl& girl);
    friend class Girl;
};

#endif // BOY_H

girl.h

#ifndef GIRL_H
#define GIRL_H
#include <iostream>
using namespace std;
class Boy;
class Girl
{
   
   
private:
    string name;
    int age;
public:
    Girl