从其他类实例访问类实例

发布于 2024-11-27 01:25:35 字数 541 浏览 1 评论 0原文

我有 4 个类：A、B、C 和 D。A

实际上是一个主类，并且具有 B、C 和 D 的实例：

class A() {

  var B_class : B = new B()
  var C_class : C = new C()
  var D_class : D = new D()

}

D 类具有使用 C 类方法的方法。但这些方法需要知道C类的状态。

所以我的理解是，在构造 D 类时，我需要将 C 类作为参数传递，如下所示：

class A() {

  var B_class : B = new B()
  var C_class : C = new C()
  var D_class : D = new D(C_class)

}

但另一个问题是 C_class 还需要使用 D_class 中的方法来更改 D_class 的状态。如果一切都在一个类中，那就很容易了。

当然，我可以只拥有接受特定类的方法，但必须有更好的方法。我确信我在设计中忽略了一些基本的东西。

原文

I have 4 classes: A, B, C and D.

A is really a main class, and has instances of B, C and D:

class A() {

  var B_class : B = new B()
  var C_class : C = new C()
  var D_class : D = new D()

}

The D class has methods that use methods from C class. But these methods need to know the state of C class.

So my understanding is I would need to pass C class in as a parameter when constructing D class like so:

class A() {

  var B_class : B = new B()
  var C_class : C = new C()
  var D_class : D = new D(C_class)

}

But the other issue is the fact that C_class also needs to use methods from D_class that change the state of D_class. If everything was in one class it'd be easy.

Sure, I could just have methods that take specific classes, but there must be a better way. I'm confident I've overlooked something basic in my design.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

指尖上的星空 2024-12-04 01:25:35

我不确定这是否适用于您的 OO 语言，但是您可以轻松地让 C_class 包含对 D 的引用和 D_class 的引用到C：

class C;
class D;

class C
{
  D & otherD;

public:
  C(D & d) : otherD(d) { }
};

class D
{
  C & otherC;

public:
  D(C & c) : otherC(c) { }
};

class A
{
  C myC;
  D myD;

public:
  A() : myC(myD), myD(myC) { }
};

关键是可以有不完整类型的指针和引用。由于您不需要实际的相互嵌套成员（无论如何这都没有意义），而只需要引用，因此您可以轻松地拥有这样的循环引用。

I'm not sure if this applies to your OO language, but in you can easily have C_class contain a reference to D and D_class a reference to C:

class C;
class D;

class C
{
  D & otherD;

public:
  C(D & d) : otherD(d) { }
};

class D
{
  C & otherC;

public:
  D(C & c) : otherC(c) { }
};

class A
{
  C myC;
  D myD;

public:
  A() : myC(myD), myD(myC) { }
};

The key is that it's possible to have pointers and references to incomplete types. Since you don't need actual mutually nested members (which wouldn't make sense anyway), but only references, you can easily have circular references like this.

回复收藏 0 原文