使用迭代器时的性能问题？

Question

我有一个函数，它接收一个字符列表并生成下一个字典排列。为了好玩，我尝试泛化代码以使用迭代器，以及能够生成更多不同类型的排列。

template<typename ITER>
bool nextPermutation(ITER start, ITER end, std::random_access_iterator_tag)
{
    for(ITER i = end-1; i != start; --i)
    {
        if(*(i-1) < *i)
        {
            // found where can be swapped
            for(ITER j = end-1; j != (i-1); --j)
            {
                if(*(i-1) < *j)
                {
                    // found what to swap with
                    auto temp = *j;
                    *j = *(i-1);
                    *(i-1) = temp;
                    // put everything from i on into "sorted" order by reversing
                    for(ITER k = end-1; k > i; --k,++i)
                    {
                        temp = *k;
                        *k = *i;
                        *i = temp;
                    }
                    return true;
                }
            }
        }
    }
    return false;
}

但是，我遇到了一些问题，即当我不使用原始指针时，代码的性能会明显变慢。这是我的测试台：

template<typename ITER>
bool nextPermutation(ITER start, ITER end, std::random_access_iterator_tag);

template<typename ITER>
bool nextPermutation(ITER start, ITER end)
{
    return nextPermutation(start, end, std::iterator_traits<ITER>::iterator_category());
}

#define USE_VECTOR

int main(void)
{
    bool hasNext = true;
#ifdef USE_VECTOR
    std::vector<char> c;
    for(char i = '0'; i <= '9'; ++i)
    {
        c.push_back(i);
    }
    for(size_t i = 0; i < 999999 && hasNext; ++i)
    {
        hasNext = nextPermutation(c.begin(), c.end());
    }
#else
    char c[] = "0123456789";
    size_t LENGTH = 10;
    for(size_t i = 0; i < 999999 && hasNext; ++i)
    {
        hasNext = nextPermutation(c, c+LENGTH);
    }
#endif
    std::cout << "done" << std::endl;
    std::cin.ignore();
    return 0;
}

定义 USE_VECTOR 后，运行此测试台大约需要 20 秒。当我取消定义它时，代码在不到一秒的时间内运行（我没有写任何计时代码，但足以说明性能上有非常显着的差异）。

现在我的问题是，我在哪里会受到如此巨大的性能影响，这会影响使用迭代器（std::string 迭代器、std::vector 迭代器等）与原始指针的对比？

Answer 1

在我的盒子上，这些是时间，从采用上述时间，删除cin.ignore()，并使用以下方法进行基准测试：

$ g++-4.6 -O4 -DUSE_VECTOR -std=gnu++0x t.cpp -o t
$ time for a in $(seq 1 1000); do ./t; done > /dev/null

真正的 0m10.145s 用户 0m7.204s 系统 0m1.088s

$ g++-4.6 -O4 -std=gnu++0x t.cpp -o t
$ time for a in $(seq 1 1000); do ./t; done > /dev/null

真正的 0m7.693s 用户 0m3.280s 系统 0m0.984s

** 如果你问我，那没有令人震惊的区别 **

现在是一拳：

$ g++-4.6 -O0 -std=gnu++0x t.cpp -o t
$ time for a in $(seq 1 1000); do ./t; done > /dev/null

真正的 0m29.540s 用户 0m27.294s 系统 0m0.976s

Answer 2

没有优化，由于迭代器调试繁重（_ITERATOR_DEBUG_LEVEL 在调试模式下默认为 2，也就是完全调试），代码在我的机器上也很慢。
但是，使用/02，迭代器调试被完全禁用，代码在控制台窗口出现之前就完全执行了。
在这里，您有一个很好的调试示例，它使事情变得更慢但更安全。 :)