在 C++ 中编码 structarray 映射函子的最清晰方法

Question

这是一项关于最易读的方法的意见调查——是否使用 C++ 成员指针、字节偏移量或模板化函子来定义“从结构 foo 中选择成员 X”。

我有一个包含大型结构向量的类型，并且我正在编写一个实用函数，该函数基本上作为 在某些范围内减少。每个结构将一组因变量与独立维度上的某个点相关联——为了发明一个简化的示例，想象一下它记录了房间随时间变化的一系列环境条件：

// all examples are psuedocode for brevity
struct TricorderReadings
{
  float time;  // independent variable

  float tempurature;
  float lightlevel;
  float windspeed; 
  // etc for about twenty other kinds of data...
}

我的函数只是执行 三次插值来猜测可用样本之间某个给定时间点的条件。

// performs Hermite interpolation between the four samples closest to given time
float TempuratureAtTime( float time, sorted_vector<TricorderReadings> &data)
{
    // assume all the proper bounds checking, etc. is in place
    int idx = FindClosestSampleBefore( time, data );
    return CubicInterp( time, 
                        data[idx-1].time, data[idx-1].tempurature,
                        data[idx+0].time, data[idx+0].tempurature,
                        data[idx+1].time, data[idx+1].tempurature,
                        data[idx+2].time, data[idx+2].tempurature );
}

我想概括这个函数，以便它可以普遍应用于任何成员，而不仅仅是温度。我可以想到三种方法来做到这一点，虽然它们都很容易编码，但我不确定对于一年后必须使用它的人来说什么是最易读的。这就是我正在考虑的：

---

指向成员的指针语法

typedef int TricorderReadings::* selector;
float ReadingAtTime( time, svec<TricorderReadings> &data, selector whichmember )
{
   int idx = FindClosestSampleBefore( time, data );
   return CubicInterp( time, data[idx-1].time, data[idx-1].*whichmember, 
                       /* ...etc */  );
}
// called like:
ReadingAtTime( 12.6f, data, &TricorderReadings::windspeed );

这感觉像是最“C++y”的方式，但它看起来很奇怪，并且整个指向成员的语法很少使用，因此很难理解我团队中的大多数人。这是技术上“正确”的方式，但也是我收到的电子邮件中最困惑的方式。

结构偏移量

float ReadingAtTime( time, svec<TricorderReadings> &data, int memberoffset )
{
   int idx = FindClosestSampleBefore( time, data );
   return CubicInterp( time, 
                       data[idx-1].time, 
                       *(float *) ( ((char *)(&data[idx-1]))+memberoffset ), 
                       /* ...etc */  );
}
// called like:
ReadingAtTime( 12.6f, data, offsetof(TricorderReadings, windspeed) );

这在功能上与上面相同，但显式地进行指针数学运算。这种方法对于我团队中的每个人（他们在 C++ 之前都学过 C）会立即熟悉和理解，而且它很健壮，但看起来很恶心。

模板化函子

template <class F>
float ReadingAtTime( time, svec<TricorderReadings> &data )
{
   int idx = FindClosestSampleBefore( time, data );
   return CubicInterp( time, 
                       data[idx-1].time, 
                       F::Get(data[idx-1]) ), 
                       /* ...etc */  );
}

// called with:
class WindSelector
{ 
   inline static float Get(const TricorderReadings &d) { return d.windspeed; }
}
ReadingAtTime<WindSelector>( 12.6f, data );

这是最直接、最类似 STL 的做事方式，但它看起来像是一大堆额外的类型和语法以及临时的类定义。它编译成与上面两个几乎完全相同的东西，但它还在可执行文件中转储了一堆冗余函数定义。 （我已使用 /FAcs 验证了这一点，但也许链接器会再次将它们取出。）

---

以上三个都可以工作，并且编译器会为所有这些发出几乎相同的代码；所以，我必须做出的最重要的选择就是最易读的。你怎么认为？

Answer 1

我发现在这种情况下模板化函子非常清楚。

ReadingAtTime<WindSelector>( 12.6f, data );

Answer 2

更接近 STL 的方式是使用通用仿函数，它使通过指向成员的指针进行的访问看起来像函数调用。它可能看起来像这样：

#include <functional>

template <class T, class Result>
class member_pointer_t: public std::unary_function<T, Result>
{
    Result T::*member;
public:
    member_pointer_t(Result T::*m): member(m) {}
    Result operator()(const T& o) const { return o.*member; }
};

template <class T, class Result>
member_pointer_t<T, Result> member_pointer(Result T::*member)
{
    return member_pointer_t<T, Result>(member);
}

float ReadingAtTime( float time, const std::vector<TricorderReadings> &data, member_pointer_t<TricorderReadings, float> f )
{
   int idx = FindClosestSampleBefore( time, data );
   return CubicInterp( time, data[idx-1].time, f(data[idx-1]));
}

ReadingAtTime( 12.6f, data, &TricorderReadings::windspeed);

该示例还包括一个辅助函数，用于帮助推断仿函数的模板参数（本示例中未使用）。

函数 ReadingAtTime 也可能接受模板化函子：

template <class Func>
float ReadingAtTime( float time, const std::vector<TricorderReadings>& data, Func f);

ReadingAtTime( 12.6f, data, member_pointer(&TricorderReadings::windspeed));

这样您就可以使用各种函数/函子从 data[idx - 1] 获取值，而不仅仅是指向成员的指针。

member_pointer 的更通用等价物可能是 std::tr1::bind 或 std::tr1::mem_fn。

Answer 3

如果您的团队由相当聪明的人组成，我想说要相信他们和他们的能力，并使用指向成员语法提供的技术上首选的解决方案。这就是它的用途。

如果您确实担心，可以采取一些步骤来缓解未来的麻烦，方法是

• 在 typedef 附近的注释中注明，并使用称为“指向成员的指针”语法，以便其他团队成员知道要查找的
• 内容。它在代码审查中明确指出，其中许多应该存在。如果认为它难以理解或过于晦涩而无法维护，请提出更改。

其他两种方法都有问题，正如您所描述的那样：

• 两者都需要更多的代码，有更多的打字错误空间等。

• offsetof原语在它可以应用的类型方面受到限制至：

  由于 C++ 中结构体的扩展功能，在这种语言中，offsetof 的使用仅限于“POD 类型”，对于类来说，或多或少对应于 C 结构体的概念（尽管非派生类具有只有公共非虚拟成员函数并且没有构造函数和/或析构函数也符合 POD 的资格）。

来自此处。

Answer 4

对于简单的事情，我更喜欢“指向成员的指针”解决方案。然而，函子方法有两个可能的优点：

1. 将算法与
   数据允许您使用算法
   对于未来更多的事情，正弦
   它可以与任何你提供的东西一起使用
   可以构造一个合适的函子。

2. 与#1相关，这可能会使
   测试算法更容易，因为您
   有办法提供测试数据
   不涉及的功能
   创建您的完整数据对象
   打算使用。你可以使用更简单的
   模拟对象。

然而，我认为只有当您正在制作的函数非常复杂和/或在许多不同的地方使用时，函子方法才值得。