Stl算法作为功能模板

Question

I am trying to do a benchmark of stl algorithm on some structures :

using namespace std;

template<typename A, typename T>
void test(){
    T c(1000);
    A(c.begin(), c.end(), true);

}
int main(){
    test<find,vector<bool>>();
}

but I get a template argument deduction/substitution failed

Answer 1

The compilation error itself was well discussed in other answers. I present a solution with C++14 generic lambdas:

template<typename Container, typename Algorithm>
void test(Algorithm algo = Algorithm()){
    Container c(1000);
    algo(c.begin(), c.end(), true);
}

int main(){
    auto find_proxy = [](auto ... args){ return std::find(args...); };
    test<std::vector<bool>>(find_proxy);
}

Answer 2

Everyone's answer are good, but let me just add another note.

To make your code just work without changing much.. This is what has to happen.

#include <vector>
#include <algorithm>

template< typename SearchFunctionType, typename ContainerType >
void test( SearchFunctionType fSearch, const ContainerType& container){
    fSearch(container.begin(), container.end(), true);
}

int main(){
    std::vector<bool> v(1000);
    test(std::find<std::vector<bool>::const_iterator, bool>, v);
}

std::find is not type as pointed out by everyone. std::find is a function. You may pass it as a function pointer. Then look, std::find is again template function, and compiler has no clue what template argument that std::find will have. That's why you don't just pass std::find. instead ,

std::find<std::vector<bool>::const_iterator, bool>.

Edit:

#include <algorithm>
#include <vector>


template < typename ContainerType
         , typename ContainerType::const_iterator (*fpSearchFunction) (typename ContainerType::const_iterator, typename ContainerType::const_iterator, const typename ContainerType::value_type&) >
void test(const ContainerType& c, const typename ContainerType::value_type& value)
{
    fpSearchFunction(c.begin(), c.end(), value);
}


int main()
{
    std::vector<bool> v(1000);
    test< std::vector<bool>, std::find<std::vector<bool>::const_iterator, bool> >(v, true);
}

This works on VisualC. Yes. integer type or function pointer can be template argument too. I bet there is better way than this.

Edit 2:

Although I don't see why having it templetized is preferable than just hard coding, This is what I would do if I do make some complication.

#include <vector>
#include <algorithm>
#include <chrono>
#include <iostream>
#include <cstdlib>
#include <functional>

template <typename ContainerType>
class Benchmark
{
public:
    typedef typename ContainerType::const_iterator  ConstIteratorType;
    typedef typename ContainerType::value_type      ValueType;
    typedef std::function < ConstIteratorType(ConstIteratorType, ConstIteratorType, const ValueType&) >
        SearchFunctionType;
    typedef std::chrono::high_resolution_clock      ClockType;

    void TestAll(const ContainerType& container, const ValueType& serachVal)
    {
        for (std::size_t i = 0; i < m_functions.size(); ++i)
        {




            ClockType::time_point begin = ClockType::now();
            m_functions[i](container.begin(), container.end(), serachVal);
            ClockType::duration duration = ClockType::now() - begin;
            std::cout << i << " : " << duration.count() << std::endl;
        }
    }

    void PushBack(SearchFunctionType fSearch)
    {
        m_functions.push_back(fSearch);
    }
private:
    std::vector<SearchFunctionType> m_functions;
};

int main(){

    typedef Benchmark<std::vector<bool>> BenchmarkType;
    BenchmarkType benchmark;
    benchmark.PushBack(std::find<BenchmarkType::ConstIteratorType, BenchmarkType::ValueType>);
    benchmark.PushBack([](BenchmarkType::ConstIteratorType begin, BenchmarkType::ConstIteratorType end, const BenchmarkType::ValueType& v)
    {
        BenchmarkType::ConstIteratorType iter;
        do
        {
            iter = begin + std::rand() % (end - begin);
            if (*iter == v)
                return iter;
        } while (iter != end);
        return end;
    });
    struct BinarySearch
    {
        BenchmarkType::ConstIteratorType operator()(BenchmarkType::ConstIteratorType begin, BenchmarkType::ConstIteratorType end, const BenchmarkType::ValueType& v)
        {


            return std::lower_bound(begin, end, v);
        }
    };
    benchmark.PushBack(BinarySearch());

    std::vector<bool> c;
    c.assign(10000, false);
    c.back() = true;

    benchmark.TestAll(c, true);

}

output:

0 : 100005
1 : 300017
2 : 0

Answer 3

问题是您尝试将模板作为模板参数传递，并希望将其推论-这将不起作用，因为编译器必须在某个时候开始填充类型： std::find不是typename ，但您需要成为一个！

Answer 4

Quite correctly so. typename A requires a type name. std::find is not a type. You probably want to pass A a as a regular argument, and then pass an instantiation of std::find .

Answer 5

Seems like you want to pass in a function to be executed on the instance of T ? But you cannot use a function template to substitute for the preprocessor.

find is the name of an algorithm, not a typename. You need to define a real type to be used as A , maybe a functor whose operator() executes std::find on its arguments.

Suggest you get the logic working without A first and then extract A as a template parameter. An incremental approach is often helpful in building complex class or function templates, and in general, but the compiler errors for broken template code can be especially confounding.

Answer 6

You should check how it is already done in C++ library:

template< class InputIt, class UnaryPredicate >
typename iterator_traits<InputIt>::difference_type
    count_if( InputIt first, InputIt last, UnaryPredicate p );

As you can see you have to provide functor type as a template parameter and functor instance as a function parameter.