Question

我意识到std :: sort函数需要使用随机访问迭代器，而列表具有双向迭代器。关于这个问题有一个问题：

我正在努力回答加速C ++中出于家庭学习目的的问题5-4。

5-4。再看一下你在上一个练习中写的驱动函数。请注意，可以编写仅在保存输入文件的数据结构的类型声明中不同的驱动程序。如果您的向量和列表测试驱动程序以任何其他方式不同，请重写它们，使它们仅在此声明中有所不同。

除了这个教科书问题，如果我使用模板而不是typedef来定义容器类型，这将非常有用。

Answer 1

...使用相同的命令对列表或向量进行排序？

最简单的方法是使用重载：

template <typename T>
inline void sort(std::vector<T>& x) { std::sort(x.begin(), x.end()); }

template <typename T>
inline void sort(std::list<T>& x) { x.sort(); }

<强>更新

您暗示您的文字尚未引入模板，因此这里是一个无模板的替代方案。问题是＆＃34;仅在保存输入文件＆＃34; 的数据结构的类型声明中有所不同，我们正在谈论vector和{{ 1}}，所以必须有类似的东西：

list

也许类型不是std::vector<std::string> input; - 您可能拥有自己的数据类型 - 但无论如何，标准容器（包括std::string和vector）都有{{ 1}}以便包含的类型可以引用ala list。这意味着您可以编写更具限制性的模板版本，这些版本仅适用于具有该特定元素类型的typedef和input::element_type：

vector

当然，如果您只想硬编码list或当前的元素类型，那么也可以正常工作 - 从维护角度来看，问题是您需要更改此问题如果稍后更改元素类型，则为代码。

inline void sort(std::vector<input::element_type>& x) { std::sort(x.begin(), x.end()); }

inline void sort(std::list<input::element_type>& x) { x.sort(); }

Answer 2

由于简单的方法已经得到解答，让我指出一个艰难的方法：

#include <algorithm>
#include <iterator>
#include <list>
#include <vector>

template <typename IterType>
struct sort
{
    template<typename Cont, typename Comp>
    inline static void impl(Cont &container, Comp F) {
        container.sort(F);
    }
    template<typename Cont>
    inline static void impl(Cont &container) {
        container.sort();
    }
};

template <>
struct sort<std::random_access_iterator_tag>
{
    template<typename Cont, typename Comp>
    inline static void impl(Cont &container, Comp F) {
        std::sort(std::begin(container), std::end(container), F);
    }
    template<typename Cont>
    inline static void impl(Cont &container) {
        std::sort(std::begin(container), std::end(container));
    }
};

template<typename Cont>
void Sort(Cont &container) {
    sort<typename std::iterator_traits<typename Cont::iterator
        >::iterator_category>::impl(container);
}

template<typename Cont, typename Comp>
void Sort(Cont &container, Comp F) {
    sort<typename std::iterator_traits<typename Cont::iterator
        >::iterator_category>::impl(container, F);
}

int main ()
{
    std::list<int> ml;
    std::vector<int> mv;

    Sort(ml);
    Sort(mv);
    Sort(ml, [](int a, int b) { return a > b; });
    Sort(mv, [](int a, int b) { return a > b; });

    return 0;
}

现在，如果您只想区分list和vector，则上述情况会有些过分。仅当您需要按类型机制实现标记分派时才使用，该机制扩展到实现某些迭代器概念的任意容器。

这种方式，例如对std::array或std::deque进行排序不需要额外的重载，因为它们的迭代器可以指向正确的分派结构

Accelerated C ++：我可以使用相同的命令编写一个对列表或向量进行排序的程序吗？

2 个答案: