用于访问作为参数传递的对象的不同成员的模板

Question

我有一个函数来计算在相邻点集上定义的不同变量的梯度。算法总是相同的，但根据计算的内容，访问邻居的不同成员数据，例如，在计算速度梯度时，使用Node::velocity，计算应力梯度时，使用Node::stress。避免多次编写相同函数的最佳方法是什么？

我想到了几种可能性：

1. 传递 lambda 函数 (c++0x) 或返回相关特定成员数据的可调用对象，称为

   gradVelocity=computeGradient(listOfNeighbors,[](const Node& n){ return n.velocity; });
   

   减号是每次读取时的额外函数调用。

2. 根据整数来模板化函数，说明正在计算的内容：

   enum{VAL_VELOCITY=0,VAL_STRESS,VAL_SOMETHING};
   模板 computeGradient(const std::list<节点>& 邻居){
       /*循环邻居*/
            value=(what==VAL_VELOCITY?neighbor.velocity:((what==VAL_STRESS)?neighbor.stress:neighbor.something);
       /* 等等 */
   }
   
   /* 这样调用 */
   gradVelocity=computeGradient（邻居）；
   

   它也许应该是高效的（希望编译器能够在各个实例化中使用常量来优化条件），但可读性和可维护性相当低。

有更好的主意吗？

Answer 1

如果所有字段都具有相同的类型，则很容易使用指向成员的指针：

struct Node
{
  double stress;
  double velosity;
};

void foo(Node* pNode, double Node::*pValue)
{
  cout << pNode->*pValue << endl;
}

int main()
{
  Node n1 = { 1, 2 };

  foo(&n1, &Node::stress);
  foo(&n1, &Node::velosity);
}

更新：如果不是，则仍然很容易将指向成员的指针与模板结合起来：

struct Node
{
  double stress;
  double velosity;
  int dimension;
};

template<class T>
void foo(Node* pNode, T Node::*pValue)
{
  cout << pNode->*pValue << endl;
}

int main()
{
  Node n1 = { 1, 2 };

  foo(&n1, &Node::stress);
  foo(&n1, &Node::velosity);
  foo(&n1, &Node::dimension);
}

我认为这可能是最有效的方法方式。也是相当的形象生动。

Answer 2

指向成员的指针就是您所需要的。类型写为 TS::* T 是数据成员的类型，S 是结构或类。这是一个小例子：

#include <iostream>

struct Foo
{
  int a;
  double b;

  Foo(int a, double b)
    : a(a), b(b)
  { }
};

template<typename T, T Foo::* mem>
void print(const Foo& foo)
{
  std::cout << foo.*mem << std::endl;
}

int main()
{
  Foo f(5, 3.14);
  print<int, &Foo::a>(f);
  print<double, &Foo::b>(f);
}

Answer 3

我是 Boost.Fusion 的忠实粉丝，更具体地说，是 Boost.Fusion.Map，它可以让你构建一个类型 ->值类型的地图。

struct Velocity {};
struct Stress {};

typedef boost::fusion::map<
  std::pair<Velocity, double>,
  std::pair<Stress, int>
> Map;

Map map;

现在，您可以使用 types 访问地图：

boost::fusion::at_key<Velocity>(map)

返回对 boost::fusion::result_of::at_key::type 类型变量的引用

通过适当的包装，您将获得：

extern Velocity const velocity;
extern Stress const stress;

myItem.access(stress) = 3;

当然，由于我们正在谈论模板，因此根本没有运行时损失:)

Answer 4

从 Node 继承并使用虚拟访问怎么样？甚至可以使用 CRTP 来避免虚拟呼叫。

Answer 5

您可以将velocity、stress、something组合在一个数组中，并根据enum索引访问它们。

struct Node
{
  int attributes[3]; // contains 'velocity', 'stress', 'something';
  enum { VAL_VELOCITY=0, VAL_STRESS, VAL_SOMETHING };
};

用法：

Node n;
n.attributes[Node::VAL_VELOCITY] = <value>;  // writing 'Node::velocity'
<otherthing> = n.attributes[Node::VAL_SOMETHING]; // reading 'Node::something'

[注意：如果您想将属性保留在私有区域内，则在Node中提供getter和setter方法来访问它们。]