Question

有没有办法将std::max_element()或std::min_element()传递给模板类方法？例如：

#include <vector>
#include <algorithms>

template <typename T>
class A 
{
public: 
    int fooMax()
    {
        return foo(std::max_element());
    }

    int fooMin()
    {
        return foo(std::min_element());
    }

private:
    std::vector<T> data_;

private:
    int foo(??? func)
    {
        auto it = func(data_.begin(), data_.end());

        int i = do_something();
        return i;
    }
};

我尝试使用函数指针，但它没有编译。

Answer 1

std::max_element和std::min_element是模板函数，您需要实例化它们：

template <typename T>
class A
{
public:
    int fooMax()
    {
        return foo(&std::max_element<typename std::vector<T>::const_iterator>);
    }

    int fooMin()
    {
        return foo(&std::min_element<typename std::vector<T>::const_iterator>);
    }

private:
    std::vector<T> data_;

private:
    template<typename func_type>
    int foo(func_type func)
    {
        auto it=func(data_.begin(), data_.end());

        return 0;
    }
};

使用gcc 5.3.1和-std=c++14进行测试。

如果您愿意，也可以选择实例化std::vector<T>::iterator。

Answer 2

您可以使用lambda表达式：

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

template <typename T>
struct A {
   vector<T> v;
   A(vector<T> v): v(v) { }
   template <class Lambda>
   T element(Lambda &&lambda) {
      return *lambda(v.begin(), v.end());
   }
};

int main() {
   vector<int> vi {1, 2, 3, 4, 5, 6};
   A<int> a(vi);
   cout << a.element([](typename vector<int>::iterator begin,
                        typename vector<int>::iterator end){ 
                            return max_element(begin, end); 
                        }) << endl;
}

这样它应该内联并因此有效...

如果你可以使用c ++ 14代码，那就更简单了：

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

template <typename T>
struct A {
   vector<T> v;
   A(vector<T> v): v(v) { }
   T element(auto &&lambda) {
      return *lambda(v.begin(), v.end());
   }
};

int main() {
   vector<int> vi {1, 2, 3, 4, 5, 6};
   A<int> a(vi);
   cout << a.element([](auto begin, auto end) { 
                           return max_element(begin, end); 
                        }) << endl;

}

Answer 3

我知道，不是你想看到的。但是如果你想把它作为函数指针传递......

#include <vector>
#include <algorithm>

int do_something();

template <typename T>
class A 
{
public: 
    int fooMax()
    {
        return foo(std::max_element<const_iterator>);
    }

    int fooMin()
    {
        return foo(std::min_element<const_iterator>);
    }

private:
    std::vector<T> data_;

private:
    using const_iterator = typename std::vector<T>::const_iterator;
  using fp = const_iterator (*)(const_iterator, const_iterator);


    int foo(fp func)
    {
        auto it = func(data_.begin(), data_.end());

        int i = do_something();
        return i;
    }
};

传递std :: max_element（）或std :: min_element（）作为argiment

3 个答案: