使用boost::bind(）填充std::min_element(）的自定义函数中的结构

fill structure in a custom function of std::min_element() using boost::bind()

本文关键字：element 结构 自定义函数 std boost bind 填充 使用 min      更新时间：2023-10-16

试图在我的向量上保存一次迭代。

我有一个vector<T>，我需要在向量中找到一个最小元素。

我正在使用std::min_element。现在需要创建一个自定义结构，该结构包含<T>元素和一些额外的元素，这些元素是动态计算的。

因此，我尝试使用boost::bind()的函数，如下所示：

std::vector<MyStruct> myStructObj;
typename std::vector< T >::iterator it = std::min_element(V.begin(), V.end(), boost::bind(BuildStructAndFindMin, myStructObj, _1, _2));

但是我应该如何定义BuildStructAndFindMin函数呢？到目前为止，我从未需要创建这样的自定义函数。

  1. _1和_2表示对V的内容的两个引用对象。但是哪一个是它们中最小的？我的意思是：std::min_element()'s的定义将在一个向量上迭代。对于拳头呼叫，它只需发送前两个元素。对于第二个调用，将发送vector中的第三个元素和last_found_min元素。这个last_found_min是_1还是_2？如何返回迭代器？我模糊的草图是这样的：

    std::vector< T >::iterator BuildStructAndFindMin (std::vector<MyStruct>& myStructObj, const T &a, const T &b)
{
    if(<a_min_condition>) // I am aware of this if statement. Just assume it to be a<b
    {
        // the point which is greater - create a struct object for that
        // and push_back in myStructObj
        return //what?;
    }
    else
    {
        // the point which is greater - create a struct object for that
        // and push_back in myStructObj
        return //what?
    }
}

调用此函数后，我将有一个min_element，但它不会出现在myStructObj中。因此，我将在开头插入它。

做这部戏剧的全部目的是节省一次迭代。

最简单的方法是：迭代一个向量并构建一个结构。然后调用std::min_element()。但不知何故，我在为几纳秒而战，在这种情况下，时间就是金钱。

std::min_element的第三个参数可以是这样的类：

struct myclass { 
    bool operator() (int i,int j) { return i<j; }
};

在comperator类中，您可以存储任何需要的信息，也可以实现任何需要的逻辑。如果有必要，您甚至可以将类似boost::bind的东西作为参数传递给它的构造函数。

template< typename T, typename TSTRUCT, typename TBIND >
struct MyCompare
{
    MyCompare( TSTRUCT &myStruct, T &ref1, T &ref2, TBIND bind )
        : _myStruct( myStruct )
        , _1( ref1 )
        , _2( ref2 )
        , _bind( bind )
    {}
    bool operator()( const T &a, const T &b )
    {
        // enter your code her
        return ...;
    }
    TSTRUCT &_myStruct;
    T &_1;
    T &_2;
    TBIND &_bind; 
};
template< typename T > 
struct MyStruct
{
    std::vector< T > V;
    T obj1;
    T obj2;
  typename std::vector< T >::iterator it = std::min_element(V.begin(), V.end(), MyCompare<T,MyStruct>( *this, obj1, obj2, boost::bind( ... what ever ... ) ) );
};

我发现一个简单而优雅的解决方案是重载<运算符。假设您的MyStruct结构定义如下。

struct MyStruct
{
    std::string str;
    int num;
    MyStruct(int initial_value)
        : num(initial_value)
    {
    }
    bool operator<(const MyStruct& other)
    {
        return num < other.num;
    }
};

所以你有几个成员，有一个构造函数，这都是标准的东西。但是，请注意operator<函数，如果thisMyStruct被认为"小于"otherMyStruct，它所做的就是返回true，否则返回false。现在可以在std::min_element中使用MyStruct，就像使用整数一样。看看：

int main()
{
    std::vector<MyStruct> objects = {10, 20, 15, 2, 25, 5, 30};
    std::vector<MyStruct>::iterator minval = std::min_element(objects.begin(), objects.end());
    std::cout << "Minimum value is " << minval->num << std::endl;
    return 0;
}

此代码打印出最小值的2。现在，您可能已经注意到了C++11初始化列表的使用。这种语法在这种情况下有效，因为在初始化列表中传递的值可以被馈送到MyStruct的构造函数中。我会让你初始化MyStructs的向量，但我必须为这个例子给出一个完整的定义，但这里的重点是，通过重载<运算符，你可以很容易地在std::min_element中使用MyStructs。

编辑：

我忘了提一下，当然，只有当您能够更改类的公共接口以支持<运算符重载时，这个解决方案才有效。我想你可能有理由不能那样做。

相关文章：