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

Overloading [] but its result isn't resolving before interacting with other operators (c++)

本文关键字：交互 C++ 运算符 其他 结果 重载      更新时间：2023-10-16

我有一个数据对象，我正试图让所有的操作符都能使用它。它是一个包含可变ptr的数据块，有任意数量的不同类型和大小等等。类型是用枚举、模板和switch语句处理的。因此，对于每个x，d[x]是一种类型，有任意数量的它们，它们可以是向量。所以d[x][y]和d[x][y][z]。我制作了一个内部助手对象来帮助处理此问题。所以我重载了[]来做这样的事情，它会返回正确的类型fine：（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<char>（d，x，I，j）等相关的大小写）

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

然后我不得不重载每个操作符来接收这个临时数组辅助对象。现在，我不得不在那里为一些运营商创造临时价值，这是一种痛苦。

基本上，我觉得在编译器尝试获取其中两个并添加它们之前，我需要首先解析运算符T（）。

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

此外，我觉得如果我能以某种方式重载左值运算符，我就不用担心=运算符了。也许那和&（）（现在只返回一个模板化的ptr）。。。？或者实际上，这更像我的意思，至少对于d[]=什么，但我还没有做到这一点。我不知道如何将任何类型的ptr转换为这个返回值。

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

我已经完成了大部分工作，但这需要大量的代码，我想我必须在每次访问中添加一个额外的if语句来做临时工作，这是我不想做的。那么我错过了什么呢？

编辑：使用d（x，i，j）与d[x][i][j]相同。我确信我至少在做n.m.发布的链接中使用的开头部分。问题是在语句中使用最后一个辅助对象之前将其解析为数据。不知怎的，编译器想要一个接受辅助对象的运算符，即使它知道如何在单独的情况下解析它。。。我想。每个操作员都超载了几天，所以我忘记了所有的细节。：）

但现在的主要问题是这样的东西：

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

我想定义以下内容，但它还没有被使用——然后我想我的问题可能会得到解决。一元运算~、-和后缀++、-的情况类似。

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

但我想，所有这些都只是因为我的T（）有点不对劲。这大部分对我来说都是新的，所以我打赌我错过了一些东西。

实现这类操作的实用方法是使用表达式模板。

我甚至会将您的返回值从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时，我们才开始评估工作。

这避免了必须创建任何临时性的，但确实意味着我们必须做大量的模板魔力才能使事情正常运行。上面是这样一个模板表达式树生成器的草图。

为了查看一个简单案例的完整实现，这里有一个链接到维基百科关于这个主题的文章，其中建立了一个完整的表达树系统，可以在没有临时性的情况下进行std::vector向量处理。

相关文章：