Question

我正在寻找最好的方法来实现最初来自Ruby中的PHP类的方法。该方法使用PHP的“static”关键字创建一个计数器，该计数器可以记住上次调用函数时的值。

template<typename T> class SillyClass {
  T data;
public:
  SillyClass(const T val) : data(val) {}
  SillyClass(const SillyClass& other) : data(other.data) {}

  template<typename T1, typename T2>
  friend SillyClass<typename std::common_type<T1, T2>::type> 
  operator+(SillyClass<T1> const &lsh, SillyClass<T2>& rhs);

  template<typename T1, typename T2>
  friend SillyClass<typename std::common_type<T1, T2>::type> 
  operator+(SillyClass<T1> const &lsh, T2 const &rhs);

  template<typename T1, typename T2>
  friend SillyClass<typename std::common_type<T1, T2>::type> 
  operator+(T1 const &rhs, SillyClass<T2> const &rsh);
};

template<typename T1, typename T2>
SillyClass<typename std::common_type<T1, T2>::type> 
operator+(SillyClass<T1> const &lhs, SillyClass<T2>& rhs) {
  return SillyClass<typename std::common_type<T1, T2>::type>(lhs.data + rhs.data);
}

template<typename T1, typename T2>
SillyClass<typename std::common_type<T1, T2>::type> 
operator+(SillyClass<T1> const &lhs, T2 const &rhs) {
  return SillyClass<typename std::common_type<T1, T2>::type>(lhs.data + rhs);
}

template<typename T1, typename T2>
SillyClass<typename std::common_type<T1, T2>::type> 
operator+(T1 const &lhs, SillyClass<T2> const &rhs) {
  return SillyClass<typename std::common_type<T1, T2>::type>(rhs.data + lhs);
}

如您所见，规则是对象的数组成员。每次调用该函数时，它都会获得下一个规则，然后在结尾处返回null。我需要把它移植到ruby。可能有十几种方法可以做到，但我希望保持简单。

Answer 1

这里是纯Ruby中的方法。

def fetch_rule
  @rule_index ||= 0   # An instance variable of the object which will be set only if @rule_index is nil
  ret = @rules[@rule_index]   # A local variable

  # Increases the index or resets it to 0 if `ret` is nil.
  @rule_index = (ret.nil? ? 0 : @rule_index++)

  ret    # Returns the value implicitly. WARNING! Returns nil if the method reaches the end of the Array!
end

我认为您上面的代码中有一个小错误，因为您在每次调用$index时都会重置0。

您还应该查看TryRuby。从Ruby开始，这是一个很酷的教程。

移植使用“静态”到Ruby的PHP迭代函数

1 个答案: