oop - 使用 Fortran 设计相互交互的对象的建议

Question

我整个下午都在用头撞墙试图找出这个问题，所以我希望有人能帮助我。

我有一个抽象基类，叫做 base_model (比如说)，在 Fortran2003 中看起来像:

type, abstract :: base_model
contains
  procedure(initMe), pass(this), deferred :: init ! constructor
  procedure(delMe), pass(this), deferred :: delete ! destructor
  procedure(solveMe), pass(this), deferred :: solve
end type base_model

显然，抽象程序 initMe , delMe和 solveMe使用抽象接口(interface) block 定义。然后我有三个派生类，称为 model1 , model2和 model3 (说):

type, extends(base_model) :: model1
  double precision :: x,y
contains
  procedure :: init => init_model1
  procedure :: delete => delete_model1
  procedure :: solve => solve_model1
end type model1

type, extends(base_model) :: model2
contains
  procedure :: init => init_model2
  procedure :: delete => delete_model2
  procedure :: solve => solve_model2
end type model2

type, extends(base_model) :: model3
contains
  procedure :: init => init_model3
  procedure :: delete => delete_model3
  procedure :: solve => solve_model3
end type model3

然后我有一个“控制”对象，称为 control (比如说)，它扩展了一个摘要 base_control :

type, abstract :: base_control
  class(base_model), allocatable :: m1
  class(base_model), allocatable :: m2
  class(base_model), allocatable :: m3
contains
  procedure(initMe), pass(self), deferred :: init
  procedure(delMe), pass(self), deferred :: delete
  procedure(runMe), pass(self), deferred :: run
end type base_control

type, extends(base_control) :: control
contains
  procedure :: init => init_control
  procedure :: delete => delete_control
  procedure :: run => run_control
end type control

对象 m1 , m2和 m3可以分配到任何模型中: model1 , model2或 model3 ，并且根据用户请求的“控制”以任何特定顺序“解决”。

三个可分配对象( m1 、 m2 和 m3 )需要在它们之间传递数据。鉴于它们是“控制”对象的成员，我可以为每个模型定义一个“getter”，然后将所需的数据传递给每个模型。然而，具体的模型在编译时是未知的，因此，“控制”对象不知道要获取什么数据，实际上，模型也不知道要接收什么数据!

例如，如果我 allocate(model1::m1) (也就是说，将 m1 分配为 model1 类型)然后它将包含两位数据 double precision :: x,y .那么如果 m2分配为 model2 类型( allocate(model2::m2) )，它可能需要 x但如果它被分配为 model3 类型( allocate(model3::m2) ) 那么它可能需要 y来自 m1 .因此，假设“控制”对象不知道是什么类型 m2被分配为，如何从 m1获取必要的数据传递到 m2 ?

另一个复杂因素是模型之间的交互通常是循环的。也就是说， m1需要来自 m2 的数据, m2需要来自 m1 的数据等等。此外，所需的数据通常不仅特定于模型，而且在类型和数量上也是可变的。

不幸的是，数据 x和 y不是 base_model 的成员因此，通过 m1进入 m2作为论点也行不通。

所以我有以下问题:

有没有更好的方法来设计这些对象，以便我可以轻松地在它们之间传递数据？环顾四周，有人建议最好的办法是重新设计对象，使它们之间的交互不是循环的。但是，这在这里是必要的!

我是否必须为可能在对象之间共享的每条数据编写一个“getter”？这似乎需要大量编码(我有很多可能共享的数据)。然而，这似乎也相当复杂，因为“getter”(特定于一条数据)也必须满足抽象接口(interface)。

在 Python 等高级语言中，这很容易，因为我们可以简单地创建一个新的数据类型作为模型的组合，但据我所知，这在 Fortran 中是不可能的。

提前致谢。任何帮助是极大的赞赏。

编辑:在下面与 francescalus 的讨论之后， select type是一种选择。实际上，在上面给出的简单示例中， select type将是一个不错的选择。但是，在我的实际代码中，这将导致大型嵌套 select type s 等等，如果有办法不使用 select type我更喜欢它。感谢 francescalus 指出我关于 select type 的错误。 .

Answer 1

回答你的两个问题:

有没有更好的设计方法？

我不太清楚为什么你的设计中有这么多限制，但总之是的。您可以为模型使用上下文管理器。我建议你看看这个答案:Context class pattern

您是否必须在每个模型上编写一个 getter 方法？

不完全是，如果你在这个特定问题上使用上下文策略，你唯一需要在每个模型上实现的就是一个 setter 方法，它将在模型之间共享数据。

我在 Python 中为这个场景实现了一个可行的解决方案。代码胜于 Eloquent 。我避免使用 Python 的任何特殊功能来让您清楚地了解在这种情况下如何使用上下文。

from abc import ABC, abstractmethod
import random

class BaseModel(ABC):
    def __init__(self, ctx):
        super().__init__()
        self.ctx = ctx
        print("BaseModel initializing with context id:", ctx.getId())

    @abstractmethod
    def solveMe():
        pass

class BaseControl(object):
    # m1 - m3 could be replaced here with *args
    def __init__(self, m1, m2, m3):
        super().__init__()
        self.models = [m1, m2, m3]


class Control(BaseControl):
    def __init__(self, m1, m2, m3):
        super().__init__(m1, m2, m3)

    def run(self):
        print("Now Solving..")
        for m in self.models:
            print("Class: {} reports value: {}".format(type(m).__name__, m.solveMe()))


class Model1(BaseModel):
    def __init__(self, x, y, ctx):
        super().__init__(ctx)
        self.x = x
        self.y = y
        ctx.setVal("x", x)
        ctx.setVal("y", y)

    def solveMe(self):
        return self.x * self.y

class Model2(BaseModel):
    def __init__(self, z, ctx):
        super().__init__(ctx)
        self.z = z
        ctx.setVal("z", z)

    def solveMe(self):
        return self.z * self.ctx.getVal("x")

class Model3(BaseModel):
    def __init__(self, z, ctx):
        super().__init__(ctx)
        self.z = z
        ctx.setVal("z", z)

    def solveMe(self):
        return self.z * self.ctx.getVal("y")

class Context(object):
    def __init__(self):
        self.modelData = {}
        self.ctxId = random.getrandbits(32)

    def getVal(self, key):
        return self.modelData[key]

    def setVal(self, key, val):
        self.modelData[key] = val

    def getId(self):
        return self.ctxId


ctx = Context()

m1 = Model1(1,2, ctx)
m2 = Model2(4, ctx)
m3 = Model3(6, ctx)

# note that the order in the arguments to control defines behavior
control = Control(m1, m2, m3)
control.run()

输出

python context.py
BaseModel initializing with context id: 1236512420
BaseModel initializing with context id: 1236512420
BaseModel initializing with context id: 1236512420
Now Solving..
Class: Model1 reports value: 2
Class: Model2 reports value: 4
Class: Model3 reports value: 12

解释

简而言之，我们创建了一个上下文类，它有一个可以在不同模型之间共享的字典。此实现非常特定于您提供的原始数据类型(即 x、y、z)。如果您需要在模型之间共享数据之前计算数据，您仍然可以通过替换 solveMe() 的返回来使用此模式。有一个延期的 promise 。