Algorithm 建议如何保持；“计算的”；“很多”；相依；参数

我有几个指标需要“始终保持最新”。也就是说，当任何事情发生变化时，我需要重新计算“依赖”。我有几个级别，只有在计算上一个级别时，才能计算下一个级别。让我用这幅闪亮的图画来解释：

在某个时刻，我们假设法郎发生了变化。那么我们应该：

计算法郎/第纳尔

计算法郎/第纳尔/比索

或者，如果比索、法郎和第纳尔同时发生变化，那么我们应该：

计算法郎/第纳尔

计算法郎/第纳尔/比索

计算比索+欧元/（欧元+美元）

因此，无论何时更改

级别0

的任何内容，我们都应该重新计算所有其他级别。但是

• 我们应该只计算必需的项目。如果欧元发生变化，我们无需重新计算法郎/第纳尔
• 我们不应该只计算一次。如果欧元和美元同时发生变化，我们应该只计算一次欧元+美元（而不是两次）

最直接的解决方案是：

• 将每个级别存储在数组中
• 对于数组中的每个项目，从下一个级别跟踪“侦听器”（可能很困难，因为比索有来自不同级别的侦听器-第2级为法郎/第纳尔/比索，第3级为比索+欧元/（欧元+美元），因此需要两个双货币数组..）
• 如果项被重新计算，则将所有it侦听器也标记为重新计算
• 从0级转到最后一级，重新计算标记为要重新计算的项目（最初更新的项目是要重新计算的市场，例如比索）

---

我想我的问题是大家都知道的，也许你可以给我推荐一个大家都知道的解决方案。我不想重新发明轮子：）谢谢

我认为基于级别的方法是不错的，假设听众总是处于较低的级别

这个想法： 有一个包含实际数据的2D数组，第一个索引是级别，第二个是级别上的位置。让每个元素都有一个

willberecommediated

标志

每个级别都有一个

待计算的
列表（因此是一个列表数组）

对于每个元素，都有一个包含2个整数的元素列表（侦听器）——一个用于级别，一个用于索引

对于要修改的每个元素，将元素添加到相应级别的
toberecommuted
，并将
willberecommuted
设置为true

然后从第一级到最后一级进行
toberecommuted
，重新计算每个元素，将其
willberecommuted
设置为false，对于每个侦听器，查找适用的元素，如果
willberecommuted
为true，则不执行任何操作，否则，将
willberecomputed
设置为true，并将其添加到其（侦听器）级别的
toberecomputed

这种方法不会检查所有数据，以检查需要修改/已经修改的内容，它只检查适用的元素，并且没有重复计算

例子：
对此：

[[E, U, P, F, D],
 [E+U, F/D],
 [E/E+D, F/D/P],
 [P+E/E+U]
]

E:[(1,0), (2,0)] // E+U and E/E+U
U:[(1,0)] // E+U
P:[(2,1), (3,0)]
F:[(1,1)]
D:[(1,1)]
E+U:[(2,0)]
F/D:[(2,1)]
E/E+U:[(3,0)]


（对于我的缩写，我只取每个单词的第一个字母。我使用的是0索引数组）

实际数据：

[[E, U, P, F, D],
 [E+U, F/D],
 [E/E+D, F/D/P],
 [P+E/E+U]
]

E:[(1,0), (2,0)] // E+U and E/E+U
U:[(1,0)] // E+U
P:[(2,1), (3,0)]
F:[(1,1)]
D:[(1,1)]
E+U:[(2,0)]
F/D:[(2,1)]
E/E+U:[(3,0)]

听众：

[[E, U, P, F, D],
 [E+U, F/D],
 [E/E+D, F/D/P],
 [P+E/E+U]
]

E:[(1,0), (2,0)] // E+U and E/E+U
U:[(1,0)] // E+U
P:[(2,1), (3,0)]
F:[(1,1)]
D:[(1,1)]
E+U:[(2,0)]
F/D:[(2,1)]
E/E+U:[(3,0)]

修改
E
和
U
：

[[E, U, P, F, D],
 [E+U, F/D],
 [E/E+D, F/D/P],
 [P+E/E+U]
]

E:[(1,0), (2,0)] // E+U and E/E+U
U:[(1,0)] // E+U
P:[(2,1), (3,0)]
F:[(1,1)]
D:[(1,1)]
E+U:[(2,0)]
F/D:[(2,1)]
E/E+U:[(3,0)]

将
E
和
U
添加到
toberecommuted[0]
中，并将这两个值的
willberecommuted
设置为true

通过
进行计算[0]

修改
E
时，将
willberecomputed
设置为false，将
E+U
的
willberecomputed
设置为true，并将其添加到
toberecomputed[1]
中，将
E/E+U
的
willberecomputed
设置为true，并将其添加到
toberecomputed[2]

当修改
U
时，将它的
willberecomputed
设置为false，我们检查
E+U
的
willberecomputed
并查看它是否为true，因此不做任何操作

然后通过
进行计算[1]
。修改
E+U
时，将其
willberecomputed
设置为false，并检查
E/E+U
的
willberecomputed
是否为true，因此不要执行任何操作

注:
最好让侦听器成为指向元素的指针，而不是一个级别和一个索引变量。
好吧，当你说你在处理级别时，会想到某种树数据结构

但对于你的问题，我认为对某种有向无环图建模是可行的

您的图形可能看起来像这样（所有方向都是向下的）

如果您像遍历树数据结构一样遍历它，那么每次更新货币时，您将只更新一次转换率
 您所描述的内容可以很容易地在短时间内完成

Qt的QML还提供了一种属性绑定机制，可以为UI实现这一点

查看Qt属性绑定和其他反应式语言的实现可能会给您一些实现想法

页面标识了JavaScript、.NET、Python、java、C++以及许多其他语言中的反应式编程库。
 < P>我认为这里可以使用多态性。
有一个货币列表，每个货币都有一个向量，其中包含所有依赖元素的指针（指向基类）

基类强制它们包含一个函数
update（）
，该函数在当前货币每次更新时调用

dependant元素依次具有它们所依赖的每种货币的指针，并使用这些指针在其
update（）
实现中更新自己

#include<iostream>
#include <vector>
class c_node_combi_base;
class currency
{
  std::vector<c_node_combi_base*> m_dependant;
  double m_val;
public:
  double value (void) const { return m_val; }
  void reg (c_node_combi_base * p) { m_dependant.push_back(p); }
  void update (double val);
};
class c_node_combi_base
{
  std::vector<currency*> currencies;
public:
  virtual void update (void) = 0;
};

template<size_t N, typename OP> // templated to differentiate types of nodes
class currency_node : public c_node_combi_base 
{ 
};

struct divide_d 
{
  double operator() (const double x, const double y) const {return x/y;}
};

template<typename OPT> // node type 2
class currency_node<2u, OPT> 
  : public c_node_combi_base
{
  currency *A, *B;
  OPT _op;
  double m_val;
public:
  currency_node (currency * a, currency * b)
    : A(a), B(b), _op(), m_val(_op(A->value(), B->value())) 
  {
    A->reg(this);
    B->reg(this);
  }
  void update (void) 
  { 
    m_val = _op(A->value(), B->value());
  }

  double value (void) { return m_val; }

};

void currency::update (double value) 
{
  m_val = value; 
  for (size_t i=0; i<m_dependant.size(); ++i)
  {
    m_dependant[i]->update();
  }
}

#包括
#包括
c类节点组合基；
类别货币
{
std：：向量m_依赖；
双m_val；
公众：
双值（void）常量{return m_val；}
void reg（c_node_combi_base*p）{m_d