C++ 类与类之间的关系_c++类之间的关系-CSDN博客

本文链接：https://blog.csdn.net/cxyhjl/article/details/146208249

在 C++ 中，类与类之间可以通过不同的方式建立关系，这些关系反映了面向对象设计中的核心概念。以下是 C++ 中常见的几种关系，并结合代码示例进行详细讲解。这些关系主要包括继承（Inheritance）、组合（Composition）、聚合（Aggregation）、关联（Association）和依赖（Dependency）。

1. 继承关系（Inheritance）

定义：一个类（子类/派生类）从另一个类（基类/父类）继承其属性和方法，表示“是一个”（is-a）关系。
特点：
- 子类继承基类的成员（数据和函数），可以重用代码或实现接口。
- C++ 支持单继承和多继承。
- 分为实现继承和接口继承（见前文）。
实现方式：使用 : 关键字，后接访问修饰符（如 public）。

示例：

#include <iostream>
class Animal {
public:
    void eat() { std::cout << "Eating..." << std::endl; }
};

class Dog : public Animal {  // Dog 是一个 Animal
public:
    void bark() { std::cout << "Woof!" << std::endl; }
};

int main() {
    Dog dog;
    dog.eat();  // 继承自 Animal
    dog.bark();
    return 0;
}

输出：
```
Eating...
Woof!
```

2. 组合关系（Composition）

定义：一个类包含另一个类的对象作为其成员，表示“有一个”（has-a）关系，且被包含对象与容器对象的生命周期紧密相关。
特点：
- 被包含对象（部分）在容器对象（整体）创建时初始化，销毁时一起销毁。
- 表示强拥有关系，整体负责部分的生命周期。
实现方式：在类中定义成员变量，通常通过构造函数初始化。

示例：

#include <iostream>
class Engine {
public:
    void start() { std::cout << "Engine started" << std::endl; }
};

class Car {
private:
    Engine engine;  // 组合：Car 包含 Engine
public:
    Car() {}  // Engine 在 Car 创建时自动构造
    void start() { engine.start(); }
};

int main() {
    Car car;
    car.start();
    return 0;
}

输出：
```
Engine started
```
说明：Engine 是 Car 的一部分，当 Car 对象销毁时，Engine 也会被销毁。

3. 聚合关系（Aggregation）

定义：一个类包含另一个类的对象，但被包含对象的生命周期独立于容器对象，表示“有一个”（has-a）关系，但较弱。
特点：
- 被包含对象可以在容器对象之外独立存在。
- 表示松散的拥有关系，通常通过指针或引用实现。
实现方式：使用指针或引用作为成员变量，对象在外部创建并传递给容器。

示例：

#include <iostream>
class Department {
public:
    void info() { std::cout << "Department info" << std::endl; }
};

class University {
private:
    Department* dept;  // 聚合：University 包含 Department
public:
    University(Department* d) : dept(d) {}  // 外部传入 Department
    void show() { dept->info(); }
};

int main() {
    Department dept;
    University uni(&dept);  // dept 独立存在
    uni.show();
    return 0;
}

输出：
```
Department info
```
说明：Department 的生命周期不依赖 University，可以在外部独立创建和销毁。

4. 关联关系（Association）

定义：类之间存在某种联系，但没有强依赖或拥有关系，表示一种松散的“使用”或“知道”关系。
特点：
- 通常是双向或单向的联系，可以通过成员变量、函数参数或返回值实现。
- 不涉及生命周期管理。
实现方式：通过指针、引用或临时对象表示联系。

示例：

#include <iostream>
class Teacher {
public:
    void teach() { std::cout << "Teaching..." << std::endl; }
};

class Student {
private:
    Teacher* teacher;  // 关联：Student 知道 Teacher
public:
    Student(Teacher* t) : teacher(t) {}
    void learn() { teacher->teach(); }
};

int main() {
    Teacher t;
    Student s(&t);
    s.learn();
    return 0;
}

输出：
```
Teaching...
```
说明：Student 和 Teacher 之间有关联，但彼此独立，Student 只是使用 Teacher。

5. 依赖关系（Dependency）

定义：一个类在某些操作中临时使用另一个类的对象，表示“依赖于”（uses-a）关系。
特点：
- 关系是临时的，通常通过函数参数或局部变量实现。
- 不涉及成员变量，依赖只在特定场景下发生。
实现方式：函数参数或局部变量。

示例：

#include <iostream>
class Tool {
public:
    void use() { std::cout << "Tool is used" << std::endl; }
};

class Worker {
public:
    void work(Tool& tool) {  // 依赖：Worker 使用 Tool
        tool.use();
    }
};

int main() {
    Tool tool;
    Worker worker;
    worker.work(tool);
    return 0;
}

输出：
```
Tool is used
```
说明：Worker 在 work 函数中依赖 Tool，但不拥有它，关系是临时的。

总结：C++ 中的关系对比

关系类型	表示	特点	实现方式	示例场景
继承	is-a	子类继承基类，强关系	`class A : public B`	Dog 是 Animal
组合	has-a	强拥有，生命周期同步	成员变量	Car 有 Engine
聚合	has-a	松散拥有，生命周期独立	指针/引用成员	University 有 Dept
关联	knows-a	松散联系，无生命周期依赖	指针/引用成员	Student 知道 Teacher
依赖	uses-a	临时使用，无成员关系	函数参数/局部变量	Worker 用 Tool