如何加快上课的循环？使用begin（）或循环

Question

如何加快char*/类迭代速度？ 我有一些演示代码测试迭代速度。

但是，我不明白为什么使用begin（）进行迭代char阵列如此慢，并且在使用for（int = 0; i＆lt; n; n; ++ i）{ ...}。

我正在使用g ++ gnu ++ 2a＆amp; MacOS。

base :: String是我的自定义类。

代码：

class Iterator {
public:
    const unsigned char *values;
    int n;
    int index = 0;
    Iterator(int n__, const unsigned char *v) {
        n = n__;
        values = v;
    }
    auto& ref() { return *this; }
    auto& ref() const { return *this; }
    auto& begin() { return ref(); }
    auto& cbegin() const { return ref(); }
    auto& end() { return ref(); }
    auto& cend() const { return ref(); }
    bool operator !=(const Iterator& x) { return index < n; }
    bool operator !=(const Iterator & x) const { return index < n; }
    auto& operator ++() { ++index; return ref(); }
};

int main() {
    using namespace cinc;
    using namespace cinc::utils;
    long mark;

    // Itrings.
    print("Speed test:");
    print("   - initialize:");
    mark = timestamp();
    for (int i = 0; i < 10000000; ++i) {
        std::string x;
        x = "";
    }
    print("     - std::string:",timestamp() - mark,"ms");
    mark = timestamp();
    for (int i = 0; i < 10000000; ++i) {
        base::string x;
        x = "";
    }
    print("     - base::string:",timestamp() - mark,"ms");

    // Append.
    print("   - append:");
    mark = timestamp();
    std::string std_string;
    std::string std_string_air;
    for (int i = 0; i < 10000000; ++i) {
        std_string += "0";
    }
    print("     - std::string:",timestamp() - mark,"ms");
    mark = timestamp();
    base::string base_string;
    base_string.allocate();
    base::string base_string_air;
    base_string_air.allocate();
    for (int i = 0; i < 10000000; ++i) {
        base_string.append('0');
    }
    print("     - base::string:",timestamp() - mark,"ms");
    base_string.del();

    // Iterate.
    print("   - iterate:");

    // Iterate std::string with begin.
    mark = timestamp();
    for (auto& i: std_string) {
        std_string_air += i;
    }
    print("     - base::string::begin:",timestamp() - mark,"ms");

    // Iterate base::string with a simlpe for index loop.
    mark = timestamp();
    const unsigned char* us = (unsigned char*)  base_string.values;
    int n = base_string.size__;
    for (int index = 0; index < n; ++index) {
        base_string_air.append(us[index]);
    }
    print("     - base::string::for:",timestamp() - mark,"ms");

    // Iterate base::string with the begin.
    mark = timestamp();
    Iterator iterator = Iterator(base_string.size__, (unsigned char*) base_string.values);
    for (auto& i = iterator.begin(); i != iterator.end(); ++iterator) {
        base_string_air.append(iterator.values[i.index]);
    }
    print("     - base::string::begin:",timestamp() - mark,"ms");
    return 0;

}

输出速度测试：

initialize:
 * std::string: 214 ms
 * base::string: 83 ms
append:
 * std::string: 120 ms
 * base::string: 46 ms
iterate:
 * std::string::begin: 83 ms
 * base::string::for: 22 ms
 * base::string::begin: 94 ms

使用G ++选项'-O2'速度日志：

Speed test:
Speed test:
   - initialize:
     - std::string: 58 ms
     - base::string: 0 ms
   - append:
     - std::string: 96 ms
     - base::string: 10 ms
   - iterate:
     - base::string::begin: 34 ms
     - base::string::for: 0 ms
     - base::string::begin: 0 ms

Answer 1

您正在附加到base_string_air。因此，字符串越来越长，将不得不重新分配越来越多的存储空间。

I是带有索引的第一个循环，字符串很小，将其复制到新存储空间很快。在第二个循环中，带有迭代器的字符串更长，并且复制需要更多的时间。

除此之外，您还必须查看编译的代码，以查看是否优化了迭代器抽象。