C ++迭代器比索引慢得多吗？

Question

I have a O(N^2) program and I notice the huge difference between using iterator and index, I paste the code and data here:

code:

#include <string>
#include <cstdio>
#include <fstream>
#include <iostream> 
#include <sstream>
#include <vector>

using namespace std; 

int main(int argc, char* argv[]){
    ifstream ifile("csv.csv"); 
    string s; 

    vector<long> vec_frd;
    vector<long> vec_real_frd;

    while (getline(ifile, s)){
        string s2 = s.substr(0, s.find(','));
        vec_frd.push_back(stol(s.substr(0, s.find(',')))); 
    }    
    long real_frd;

    // using iterator 
    vector<long>::iterator it1, it2;
    for (it1=vec_frd.begin(); it1<vec_frd.end(); it1++){
        if (*it1 == -1){
            vec_real_frd.push_back(-1);
            continue; 
        }
        real_frd = *it1; 
        for (it2=it1; it2<it1+*it1 && it2<vec_frd.end(); it2++){
            if (*it2 == -1)
                real_frd --;
        }
        vec_real_frd.push_back(real_frd);
    }

    // using index 
    // for (unsigned int i=0; i<vec_frd.size(); i++){
    //     if (vec_frd[i] == -1){
    //         vec_real_frd.push_back(-1);
    //         continue; 
    //     }
    //     real_frd = vec_frd[i]; 
    //     for (unsigned int j=i; j<i+vec_frd[i] && j<vec_frd.size(); j++){
    //         if (vec_frd[j] == -1)
    //             real_frd --;
    //     }
    //     vec_real_frd.push_back(real_frd);
    // }        

    ifile.close();
    return 1; 
}

data: https://www.dropbox.com/s/c2c7txhu24xy06r/csv.csv?dl=0

if we use iterator, on my machine it takes almost 30s, if we use index instead, it takes 5s, I am new to C++, is that kind of performance difference normal? Or am I wrong somewhere?

Answer 1

To answer your question - no, this behavior is most definetly not normal for the optimized code.
I could not reproduce it with gcc or MSVC. Your best bet I think is to carefully check your compiler options.

On a side note, I believe you can speed this task up quite a bit with some algorithm tweaking. Even asymptotically I'm pretty sure you can go from O(N^2) to O(N) by precomputing a couple of counters.