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

Question

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

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

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(这就是为什么我们需要在 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 类来重载运算符 <。请注意，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") );