1

我有一个数据对象，我试图让所有操作员都使用它。它是一大块数据，其中包含变量 ptrs，并且有任意数量的不同类型和大小等等。类型由枚举和模板以及 switch 语句处理。所以对于每个 x，d[x] 是一种类型，可以是任意数量的类型，并且它们可以是向量。所以 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< char>(d, x, i, j) 等相关的案例）。所以问题是，如果我想做这样的事情

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

然后我最终不得不重载每个运算符来接收这个临时数组辅助对象。现在我不得不在其中为一些操作员设置一个临时值，这很痛苦。

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

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

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

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

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

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

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

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

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

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

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

4

1 回答 1

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向量处理而无需临时性。

于 2013-07-06T01:44:33.847 回答