C：关联、聚合和组合

Question

我开始研究 OOAD，我很难找到一个 C 代码示例来说明如何以编程方式实现关联、聚合和组合。（到处都有几篇文章，但它们与 C# 或 Java 有关）。我确实找到了一两个例子，但它们都与我的导师的指示相冲突，我很困惑。

我的理解是，在:

< li >关联:Foo有一个指向Bar对象的指针作为数据成员 < li >聚合:Foo有一个指向Bar对象的指针，Bar的数据被深度复制到该指针中。 < li >组成:Foo有一个Bar对象作为数据成员。

这就是我如何实现它的：

class Bar
{
    Baz baz;
};

//ASSOCIATION (with Bar)
class Foo
{
    Bar* bar;
    void setBar(Bar* _bar)
    {
        bar = _bar;
    }
};

//AGGREGATION (with Bar)
class Foo
{
    Bar* bar;
    void setBar(Bar* _bar)
    {
        bar = new Bar;
        bar->baz = _bar->baz;
    }
};


//COMPOSTION (with Bar)
class Foo
{
    Bar bar;
    Foo(Baz baz)
    {
        bar.baz = baz;
    }
};

这是对的吗？如果没有，那么应该如何做呢？如果您还给我一本书中的代码参考，我将不胜感激（以便我可以与我的老师讨论）

Answer 1

我将忽略聚合。它不是一个非常明确定义的概念，在我看来，它造成的混乱超过了它的价值。组合和关联就足够了，克雷格·拉曼告诉我。这可能不是你的老师想要的答案，但无论如何，它不太可能在C中实现，与关联有任何不同。

没有一种方法可以实现组合和关联。如何实现它们将取决于您的需求，例如关系的多样性。

实现组合的最简单方法是使用一个简单的Bar成员变量，就像您建议的那样。我要做的唯一更改是初始化构造函数成员初始化器列表中的bar：

// COMPOSITION - with simple member variable
class Foo {
 private:
  Bar bar;
 public:   
  Foo(int baz) : bar(baz) {}
};

使用构造函数初始化列表来初始化成员变量通常是一个好主意，这样会更快，而且在某些情况下，像const成员变量，这是初始化它们的唯一方法。

使用指针实现复合可能也是有原因的。例如，＜code＞Bar＜/code＞可能是一个多态类型，而您在编译时不知道具体的类型。或者，您可能希望转发声明＜code＞Bar＜/code＞以最小化编译依赖性（请参见PIMPL习惯用法）。或者这个关系的多重性是1到0..1，你需要有一个空的＜code＞Bar＜/code＞。当然，因为这是CompositionFoo应该拥有Bar，而在现代C 11/C 14世界中，我们更喜欢使用智能指针，而不是拥有原始指针：

 // COMPOSITION - with unique_ptr
class Foo {
 private:
  std::unique_ptr<Bar> bar;
 public:   
  Foo(int baz) : bar(barFactory(baz)) {}
};

我在这里使用了std:：unique_ptr，因为Foo是Bar的唯一所有者，但如果其他对象需要std:：weak_ptr到Bar时，您可能需要使用td:：shared_ptr。

关联通常使用指针实现，就像您所做的那样：

// Association - with non-owning raw pointer
class Foo {
 private:
  Bar* bar;
 public:   
  void setBar(Bar* b) { bar = b; }
};

当然，您需要确信Bar在Foo使用时会活着，否则您就有一个悬空指针。如果Bar的生命周期不太清楚，那么std::weak_ptr可能更合适：

// Association - with weak pointer
class Foo {
 private:
  std::weak_ptr<Bar> bar;
 public:   
  void setBar(std::weak_ptr<Bar> b) { bar = std::move(b); }
  void useBar() {
    auto b = bar.lock();
    if (b)
      std::cout << b->baz << "\n";
  }
};

现在< code>Foo可以使用< code>Bar而不用担心会留下悬空指针:

 Foo foo;
 {
   auto bar = std::make_shared<Bar>(3);
   foo.setBar(bar);
   foo.useBar(); // ok
 }  
 foo.useBar(); // bar has gone but it is ok

在某些情况下，Bar的所有权确实不清楚，可以使用std:：shared_ptr实现关联，但我认为这应该是最后的手段。

关于您使用柱线指针的深层副本实现聚合。我不会说这是一个典型的实现，但正如我所说，这取决于您的要求。您确实需要确保在 Foo 析构函数中对酒吧成员指针调用 delete，否则会出现内存泄漏（或使用智能指针）。