如何以Python风格实现跨类动态变量传递（替代C++指针方式）

针对你遇到的类间动态依赖问题，这里提供几种实用的Python实现方式，适配不同场景：

1. 保持现有传参方式（最简直接） #

你当前的实现完全可行，优点是耦合度极低，每个类职责清晰，主逻辑完全掌控依赖关系。如果只是简单的一对一依赖，这种方式足够简洁高效：

# ClassY 实现
class ClassY:
    y_pos = 0
    
    def calc_y(self, x_pos):
        # 这里写你的y位置计算逻辑
        self.y_pos = x_pos * 2  # 示例计算
    
    def simulate(self, x_pos):
        self.calc_y(x_pos)
    
    def get_ypos(self):
        return self.y_pos

# 主逻辑
from some_module import ClassX

x = ClassX()
y = ClassY()

while True:
    x.simulate()
    y.simulate(x.get_xpos())

2. 让ClassY持有ClassX实例（简化主循环） #

如果ClassY固定依赖ClassX的x_pos，可以在初始化时传入ClassX实例，无需每次调用simulate都传参数，主循环会更简洁：

# ClassY 实现（需导入ClassX）
class ClassY:
    def __init__(self, x_instance):
        self.x = x_instance
        self.y_pos = 0
    
    def calc_y(self, x_pos):
        self.y_pos = x_pos * 2  # 示例计算
    
    def simulate(self):
        x_pos = self.x.get_xpos()
        self.calc_y(x_pos)
    
    def get_ypos(self):
        return self.y_pos

# 主逻辑
from some_module import ClassX

x = ClassX()
y = ClassY(x)  # 初始化时传入x实例

while True:
    x.simulate()
    y.simulate()  # 无需再传参数

这种方式耦合度略高于传参，但逻辑更内聚，适合ClassY必须依赖ClassX的场景。

3. 观察者模式（适配多依赖场景） #

如果有多个类需要监听x_pos的变化，或者想彻底解耦主循环的依赖管理，可以使用观察者模式：让ClassX在x_pos更新时主动通知所有依赖它的对象：

# ClassX 实现
class ClassX:
    def __init__(self):
        self.x_pos = 0
        self.observers = []  # 存储依赖的观察者
    
    def add_observer(self, observer):
        self.observers.append(observer)
    
    def simulate(self):
        # 这里写x位置的更新逻辑
        self.x_pos += 1  # 示例更新
        # 通知所有观察者x_pos已更新
        for observer in self.observers:
            observer.on_x_updated(self.x_pos)

# ClassY 实现
class ClassY:
    def __init__(self):
        self.y_pos = 0
        self.current_x = 0
    
    def on_x_updated(self, x_pos):
        # 接收x_pos的更新
        self.current_x = x_pos
    
    def calc_y(self):
        self.y_pos = self.current_x * 2  # 示例计算
    
    def simulate(self):
        self.calc_y()
    
    def get_ypos(self):
        return self.y_pos

# 主逻辑
from some_module import ClassX

x = ClassX()
y = ClassY()
x.add_observer(y)  # 将y注册为x的观察者

while True:
    x.simulate()  # x更新后自动通知y
    y.simulate()

这种方式适合复杂的依赖场景，主循环无需手动管理参数传递，依赖关系由类自行维护。

内容的提问来源于stack exchange，提问作者Fab_ME