Question

我使用c ++ parallel quicksort程序进行了测试，如下所示，list作为容器然后我转移到通用容器类型，但它报告了标题错误。

可以帮忙吗？

#include <iostream>     // std::cout
#include <future>       // std::packaged_task, std::future
#include <chrono>       // std::chrono::seconds
#include <thread>       // std::thread, std::this_thread::sleep_for
#include <list>
#include <algorithm>
#include <type_traits>
#include <iterator>

template<typename F, typename A>
static std::future<typename std::result_of<F(A&&)>::type> spawn_task(F&& f, A&& a)
{
    typedef typename std::result_of<F(A&&)>::type result_type;

    std::packaged_task<result_type(A&&)> task(std::move(f));
    std::future<result_type> res(task.get_future());
    std::thread myThread(std::move(task), std::move(a));
    myThread.detach();
    return res;
}

template<class T, template<class T> class Container>

static Container<T> parallel_quick_sort(Container<T> input)
{
    if (input.empty())
    {
        return input;
    }

    Container<T> result;
    result.splice(result.begin(), input, input.begin());
    T const& partition_val = *result.begin();

    typename Container<T>::iterator divide_point = std::partition
    (input.begin(), input.end(), [&](T const& t)
        {
         return t<partition_val;
        }
    );

    Container<T> lower_part;
    lower_part.splice(lower_part.end(), input, input.begin(), divide_point);

    std::future<Container<T> > new_lower
    (
        spawn_task(&parallel_quick_sort<T>, std::move(lower_part))
    );
    Container<T> new_higher(parallel_quick_sort(std::move(input)));
    result.splice(result.end(), new_higher);
    result.splice(result.begin(), new_lower.get());

    return result;
}


static void testQuickSort()
{
    std::list<int> toSort={1, 4, 3, 6, 4, 89, 3};
    std::for_each
    (    
        std::begin(toSort), std::end(toSort), [](int n)
        {
            std::cout << n << std::endl;
        }
    );

    std::list<int> sorted;
    sorted = parallel_quick_sort(toSort);
    std::for_each
    (
        std::begin(sorted), std::end(sorted), [](int n)
        {
            std::cout << n << std::endl;
        }
    );
}

错误消息是：

../ src / TestGenericQuickSort.h：在静态成员函数中'static void TestGenericQuickSort :: testQuickSort（）'：

../ src / TestGenericQuickSort.h：67：41：错误：没有匹配函数来调用'TestGenericQuickSort :: parallel_quick_sort（std :: list＆amp;）'sorted = parallel_quick_sort（toSort）;

../ src / TestGenericQuickSort.h：67：41：注意：候选人是：

../ src / TestGenericQuickSort.h:33:22：注意：模板类容器＆gt; static Container TestGenericQuickSort :: parallel_quick_sort（Container）static Container parallel_quick_sort（Container input）

../ src / TestGenericQuickSort.h:33:22：注意：模板参数扣除/替换失败：

../ src / TestGenericQuickSort.h：67：41：错误：模板参数数量错误（2，应为1）sorted = parallel_quick_sort（toSort）;

../ src / TestGenericQuickSort.h:32:44：错误：为'模板类容器'模板类提供容器＆gt;

Answer 1

您传递std::list，其完整声明为

template <typename T, typename Alloc = std::allocator<T> >
class list;

所以，它有2个模板参数，虽然秒数有一个默认值（这就是你没有看到它的原因）。

更好的设计是将2个输入迭代器和输出迭代器传递给您的函数：

template <typename IteratorIn, typename IteratorOut>
static IteratorOut parallel_quick_sort(IteratorIn begin, IteratorIn end, IteratorOut out);

有关此签名的详细信息，请参阅std::sort。

Answer 2

首先，我要感谢lisyarus的回答，没有它，我无法解决问题，如下所示。

但是因为这是关于C ++内部工作的练习，所以我尝试修改自己的代码以使其工作，最后它的工作原理如下。

#include <iostream>     // std::cout
#include <future>       // std::packaged_task, std::future
#include <chrono>       // std::chrono::seconds
#include <thread>       // std::thread, std::this_thread::sleep_for
#include <list>
#include <algorithm>
#include <type_traits>
#include <iterator>

template<typename F, typename A>
static std::future<typename std::result_of<F(A&&)>::type> spawn_task(F&& f, A&& a)
{
    typedef typename std::result_of<F(A&&)>::type result_type;
    std::packaged_task<result_type(A&&)> task(std::move(f));
    std::future<result_type> res(task.get_future());
    std::thread myThread(std::move(task), std::move(a));
    myThread.detach();
    return res;
}
template<class T, class Alloc, template<class T, class Alloc> class Container>
static Container<T, Alloc> parallel_quick_sort(Container<T, Alloc> input)
{
    if (input.empty())
    {
        return input;
    }

    Container<T, Alloc> result;
    result.splice(result.begin(), input, input.begin());
    T const& partition_val = *result.begin();
    typename Container<T, Alloc>::iterator divide_point = std::partition(
            input.begin(), input.end(), [&](T const& t)
            {   return t<partition_val;});
    Container<T, Alloc> lower_part;
    lower_part.splice(lower_part.end(), input, input.begin(), divide_point);


    std::future<Container<T, Alloc> > new_lower(
            spawn_task(&parallel_quick_sort<T, Alloc, Container>, std::move(lower_part)));

    Container<T, Alloc> new_higher(parallel_quick_sort(std::move(input)));
    result.splice(result.end(), new_higher);
    result.splice(result.begin(), new_lower.get());
    return result;

}



static void testQuickSort()
{
    std::list<int> toSort={1,4,3,6,4,89,3};
    std::for_each(std::begin(toSort), std::end(toSort), [](int n){ std::cout << n << std::endl;});
    std::list<int> sorted;
    sorted=parallel_quick_sort(toSort);
    std::for_each(std::begin(sorted), std::end(sorted), [](int n){ std::cout << n << std::endl;});


}

感谢您的帮助!!!

C ++模板参数数量错误（2，应为1）

2 个答案: