c++ - 重载 [] 但其结果在与其他运算符交互之前未解析 (c++)

Question

我有一个数据对象，我正试图让所有运算符(operator)使用它。它是一大块数据，其中包含可变指针，并且具有任意数量的不同类型和大小等等。类型由枚举、模板和 switch 语句处理。所以对于每个 x，d[x] 是一种类型，可以有任意数量，它们可以是 vector 。所以 d[x][y] 和 d[x][y][z]。我做了一个内部帮助对象来帮助解决这个问题。所以我有 [] 重载来做这样的事情，它会返回正确的类型:(gcc 4.6.1)

[编辑:我对 d(x,y,z) 也有同样的问题——问题不在于 [] 运算符]

int i = d[0][3][5];

我正在这个辅助对象中重载 T()。

template <class T> 
data::helper::operator T ();            // switch(x)...return different types
data::helper data::operator [] (int i); // recurse, return helper(t, d, x, i, j);

所以我只返回这个对象，它在那个时候解析它的类型(切换与 t->get (d, x, i, j) 相关的案例，等等)。所以问题是，如果我想做这样的事情

int i = d[0][1] + d[4][2];
if (d[5][1] != d[3][0]) ...

然后我最终不得不重载每个运算符以接受这个临时数组助手对象。现在，我有时不得不为某些运算符(operator)创建一个临时值，这很痛苦。

基本上，我觉得我需要先解析运算符 T()，然后编译器才会尝试获取其中两个并添加它们。

无论如何，我必须为 = 和 += 等运算符执行此操作，但我想删除这些帮助我定义所有这些其他运算符的大量宏。

另外，我觉得如果我能以某种方式重载左值运算符，我就不用担心 = 运算符了。也许是 &() (现在只返回一个模板化的 ptr)。 ……？或者实际上，这更像是我的意思，至少对于 d[] = something，但我还没有让它工作。我不确定如何将任何类型的 ptr 转换为该返回值。

data::helper & data::operator [] (int i);

我已经完成了其中的大部分工作，但它有很多代码，而且我认为我将不得不为每次访问添加一个额外的 if 语句来执行临时操作，我不想这样做。那么我错过了什么？

编辑:使用 d(x,i,j) 与 d[x][i][j] 相同。我很确定我至少正在做链接 n.m. 中使用的内容的开始部分。发布。问题是在语句中使用最后一个帮助对象之前将其解析为它的数据。不知何故，编译器想要一个接受帮助对象的运算符，即使它知道如何在单独时解决它......我想。已经让每个运算符(operator)重载了几天，所以我忘记了所有细节。 :)

但现在的主要问题是这样的:

helper operator + (helper & l, helper & r)

我想定义以下但它没有被使用——那么我想我的问题可能会得到解决。一元操作 ~、- 和后缀++、-- 的类似情况。

template <class T> T operator + (helper & l, helper & r)

但我认为所有这一切都只是因为我的 T() 有问题。其中大部分对我来说都是新的，所以我敢打赌我错过了一些东西。

Answer 1

做这种事情的实用方法是使用表达式模板。

我会将您的返回值从 operator[] 更改为表达式模板。

这将使用 C++11 特性，因为它使它更短。

enum class ExpressionType { Index, Addition };
template< ExpressionType Op, typename LHS, typename RHS >
struct Expression {
  LHS lhs;
  RHS rhs;
  template<typename T>
  operator T();
};
// to separate out the evaluation code:
template< typename T, ExpressionType Op, typename LHS, typename RHS >
struct Evaluate {
  T operator()( Expression<Op, LHS, RHS> exp ) const;
};
template< ExpressionType Op, typename LHS, typename RHS >
template<typename T>
Expression<Op,LHS,RHS>::operator T() {
  return Evaluate<T,Op,LHS,RHS>()( std::move(*this) );
}
// further specializations needed:
template< typename T, typename RHS >
struct Evaluate< T, ExpressionType::Index, data, RHS > {
  T operator()( Expression<Op, ExpressionType::Index, data, RHS> exp ) const {
    // we just assume RHS can be treated like an integer.  If it cannot,
    // we fail to compile.  We can improve this with SFINAE elsewhere...
    return exp.lhs.get_nth(exp.rhs);
  }
};
template< typename T, typename LHS, typename RHS >
struct Evaluate< T, ExpressionType::Addition, LHS, RHS > {
  T operator()( Expression<Op, ExpressionType::Index, data, RHS> exp ) const {
    // code with all of LHS, RHS and T visible!
  }
};
template<typename E>
struct is_expression : std::false_type {};
template<ExpressionType Op, typename LHS, typename RHS>
struct is_expression<Expression<Op,LHS,RHS> : std::true_type {};
template<ExpressionType Op, typename LHS, typename RHS>
Expression<Op, LHS, RHS> make_expression( LHS&& lhs, RHS&& rhs ) {
  return { std::forward<LHS>(lhs), std::forward<RHS>(rhs) };
}
// here is why I want to start out with returning an expression.  This SFINAE test
// is extremely easy because of that -- we overload operator+ on any two types, so long
// as one of them is an Expression!
template<typename LHS, typename RHS, typename=typename std::enable_if<is_expression<LHS>::value || is_expression<RHS>::value >::type>
ExpressionType<ExpressionType::Addition, LHS, RHS> operator+( LHS&& lhs, RHS&& rhs )
{
  return make_expression<ExpressionType::Addition>(std::forward<LHS>(lhs), std::forward<RHS>(rhs) );
}

所以我们的想法是，我们在编译时构建一个模板树，表示编译器评估各种表达式的顺序。

当我们最终将其转换为具体类型 T 时，我们才开始评估工作。

这避免了必须创建任何临时文件，但确实意味着我们必须做很多模板 mojo 才能启动和运行。以上就是这样一个模板表达式树生成器的示意图。

要查看一个简单案例的完整实现，这里有一个链接 wikipedia关于该主题的文章，其中构建了一个完整的表达式树系统来执行 std::vector vector 处理而无需临时对象。