Question

我正在寻找有利于实现决策矩阵的数据结构，一方面是非POD类型的参数，另一方面是回调函数。

特别是我想在参数的 set / tuple 和回调函数之间使用某种一对一的对应关系。在这种情况下，存在一组特定的参数值会导致回调的明确定义，类似于：

template<typename t1, typename t2, ...>
(t1 arg1 == _1_1, t2 arg2 == _2_1, t3 arg3 == _3_1) -> void callback_func_1()
(t1 arg1 == _1_2, t2 arg2 == _2_2, t3 arg3 == _3_2) -> void callback_func_2()
(t1 arg1 == _1_3, t2 arg2 == _2_3, t3 arg3 == _3_3) -> void callback_func_3()
...
(t1 arg1 == _1_n, t2 arg2 == _2_n, t3 arg3 == _3_n) -> void callback_func_n^3()

应该有一个搜索方法，它将选择与参数集相对应的回调函数，其值等于给定值（在C ++方面 - 类似伪代码）：

template<typename t1, typename t2, ...>
void CallbackMatrix::SelectCallback(t1& arg1, t2& arg2, t3& arg3, ...)
{
    BOOST_FOREACH(const auto& item, Matrix)
    {
        if( arg1 == item.arg1 && arg2 == item.arg2 && ... )
        {
             item.function();
             break;
        }
    }
}

从我的角度来看，这个数据结构可能对许多开发人员有用，所以我正在寻找一个的库实现（可能是，在Boost中的某个地方？）。虽然如果有人提供他自己的数据结构版本，我将不胜感激。

谢谢。

Answer 1

你要找的东西对我来说似乎很复杂。你确定你不能重新设计你的程序以避免这种情况吗？

无论如何，让我们将您的非POD类型视为类MyType

struct MyType
{
  int         i;
  double      d;
  std::string s;

  MyType(...) {...} //ctor
  bool operator<( const MyType& other) //define a 'lexicographical' order
  {
    if(      i < other.i 
        || ( i == other.i && d < other.d )
        || ( i == other.i && d == other.d && s.compare( other.s ) < 0 ) )
    {
      return true;
    }
    else
      return false;
  }
};

然后，让我们使用strategy pattern来代替回调。

class MyFunc
{
public:
  virtual void function( MyType& ) = 0;
  virtual ~MyFunc() = default;
};

class FirstImpl : public MyFunc
{
public:
  void function( MyType& t ) {...} // do something
};

class SecondImpl : public MyFunc
{
public:
  void function( MyType& t ) {...} // do something else
};

最后，使用一个映射，其中键是MyType（这就是为什么我们需要重载运算符＆lt;在MyType中），值是（指向）MyFunc派生对象。

std::map<MyType, MyFunc*> Matrix;
//feed you map
MyType t1( 42, 0., "hey" );
MyType t2( 7, 12.34, "cool" );
MyFunc *f1 = new FirstImpl;
MyFunc *f2 = new SecondImpl;
Matrix.insert( std::make_pair<MyType, MyFunc*>( t1, f1 ) ); // can also use the C++11 map::emplace
Matrix.insert( std::make_pair<MyType, MyFunc*>( t2, f2 ) );

然后，您可以调用您的选择功能

template<typename t1, typename t2, ...>
void CallbackMatrix::SelectCallback(t1& i, t2& d, t3& s, ...)
{
    for_each(const auto& item : Matrix)
    {
        if( i == item.first.i && d == item.first.d && ... )
        {
             item.second->function( item.first );
             break;
        }
    }
}

此解决方案适合您吗？

编辑 - 第二个解决方案

警告：以下是伪代码;我没有尝试编译它！但这个想法就在这里。

我们仍然需要一个MyType类来重载运算符＆lt;。请注意MyType成为POD。这是一个问题吗？

struct MyType
{
  std::vector< boost::any > myVec;

  bool operator<( const MyType& other)
  {
    if( myVec.size() != other.myVec.size() )
      return false;
    else
    {
      for( int i = 0; i < myVec.size(); ++i )
      {
        if( myVec[i] < other.myVec[i] ) // so types must be comparable
          return true;
        else if( myVec[i] > other.myVec[i] )
          return false;
      }

      return false; // meaning myVec and other.myVec are identical
    }
  }
};

然后，SelectCallback变为

void CallbackMatrix::SelectCallback( std::vector< boost::any > args )
{
  for_each(const auto& item : Matrix)
    if( args.size() == item.first.myVec.size() )
    {
      auto mismatch_pairs = std::mismatch( args.begin(), 
                                           args.end(), 
                                           item.first.myVec.begin() );

      if( mismatch_pairs.empty() ) // if no mismatch
      {
           item.second->function( item.first );
           break;
      }
    }
}

当然，用数据填充MyType对象会略有不同，比如

MyType t1;
t1.myVec.push_back( 42 );
t1.myVec.push_back( 0. );
t1.myVec.push_back( static_cast<char const *>("hey") );

C ++中回调矩阵实现的数据结构

1 个答案:

编辑 - 第二个解决方案