C++ 在 .size() 之后丢失 vector 元素

Question

我是 C++ 新手，我的问题是我只是通过调用 .size() 以某种方式(看似)丢失了 vector 元素。对于以下代码段(下面附有完整代码)，我得到以下输出:

A: number of elements: 560
B: number of elements: 560
B: number of elements: 0
B: number of elements: 0
B: number of elements: 0
C: number of elements: 0

//有问题的片段

cout << "A: number of elements: " << combinations.size() << endl;
float sum_vect[120][2];
for (int i = 0; i < combinations.size(); ++i) {
    for (int j = 0; j < 2; ++j) {
        sum_vect[i][j] = 0;
    }
}
cout << "B: number of elements: " << combinations.size() << endl;
cout << "B: number of elements: " << combinations.size() << endl;
cout << "B: number of elements: " << combinations.size() << endl;
cout << "B: number of elements: " << combinations.size() << endl;

for (int i = 0; i < combinations.size(); ++i) {
    combination = combinations.at(i);
    for (int j = 0; j < order; ++j) {
        sum_vect[i][0] += (float)virtual_pos[combination[j]][0];
        sum_vect[i][1] += (float)virtual_pos[combination[j]][1];
    }
}

vector<int> optimal_ind;
cout << "C: number of elements: " << combinations.size() << endl;

//辅助函数

   void nchoosek_helper(int offset, int n, int k, vector<vector<int>> &combinations, vector<int> combination) {
        if (k == 0) {
            combinations.push_back(combination);
            return;
        }
        for (int i = offset; i <= n - k; ++i) {
            combination.push_back(i);
            nchoosek_helper(i+1, n, k-1, combinations, combination);
                combination.pop_back();
        }
    }


double euclidean_norm(double dist1, double dist2){
    return sqrt(pow(dist1,2) + pow(dist2,2));
}

//有问题的函数从这里开始

//weirdest: look at A B C
vector<vector<char> > step37::CUDADriver::get_access_pattern(int order){
    vector<vector<char> > result;
    vector<vector<int> > combinations;
    vector<int> combination;

    nchoosek_helper(0, 16 ,order, combinations, combination);
    cout << "number of combinations: " << combination.size() << endl;


    //                    //mapping lexical index 1-16 to 2D array
    int virtual_pos [16][2];
    for (int i = 0; i < 16; ++i) {
        virtual_pos[i][0] = i%4 * order; //write x
        virtual_pos[i][1] = (int)ceil(i/4) * order; //write y
        cout << "mapping " << i << "to (" << i%4 * order << "'" << (int)ceil(i/4) * order<< ")" << endl;
    }

    cout << "A: number of elements: " << combinations.size() << endl;
    float sum_vect[120][2];
    for (int i = 0; i < combinations.size(); ++i) {
        for (int j = 0; j < 2; ++j) {
            sum_vect[i][j] = 0;
        }
    }
    cout << "B: number of elements: " << combinations.size() << endl;
    cout << "B: number of elements: " << combinations.size() << endl;
    cout << "B: number of elements: " << combinations.size() << endl;
    cout << "B: number of elements: " << combinations.size() << endl;

    for (int i = 0; i < combinations.size(); ++i) {
        combination = combinations.at(i);
        for (int j = 0; j < order; ++j) {
            sum_vect[i][0] += (float)virtual_pos[combination[j]][0];
            sum_vect[i][1] += (float)virtual_pos[combination[j]][1];
        }
    }

    vector<int> optimal_ind;
    cout << "C: number of elements: " << combinations.size() << endl;

    cout << "main loop"<< endl;
    for (int i = order; i < order*2; ++i) {
        for (int j = order; j < order*2; ++j) {
            int pos [2];
            //        pos[0] = i;
            //        pos[1] = j;
            pos[0] = j;
            pos[1] = i;

            cout << "current position: (" << j << "," << i << ")" << endl;

            float min_len = std::numeric_limits<float>::infinity(); //minimum length of combined vector
            float min_sum_ind = std::numeric_limits<float>::infinity(); //minimum sum of individual vectors
            int min_idx = -1;

            for (int k = 0; k < combinations.size(); ++k) {
                int curr_vect [2];
                curr_vect[0] = sum_vect[k][0] - pos[0] * order;
                curr_vect[1] = sum_vect[k][1] - pos[1] * order;

                float curr_len = euclidean_norm(curr_vect[0], curr_vect[1]);

                float min_sum_tmp = 0;
                combination = combinations[k];

                for (int l = 0; l < order; ++l) {
                    min_sum_tmp += euclidean_norm(virtual_pos[combination.at(l)][0] - pos[0],
                            virtual_pos[combination.at(l)][1]- pos[1]);
                }

                if (i==4&&j==4){
                    cout << "  ind sum: " << min_sum_tmp << "   len: " << curr_len <<  "    sv: (" << sum_vect[k][0] << "," << sum_vect[k][1] <<
                            ")  cv: (" << curr_vect[0] << ","  << curr_vect[1] << ")" <<endl;

                }

                if (min_len > curr_len ||
                        min_len == curr_len && min_sum_tmp < min_sum_ind){
                    min_len = curr_len;
                    min_idx = k;
                    min_sum_ind = min_sum_tmp;
                }
            }

            //        cout <<

            cout << "pushing minimal idx " << min_idx << endl;
            optimal_ind.push_back(min_idx);
        }
    }

    cout << "main loop done"<< endl;

    //unpack optimal combinations into relative movements
    vector<char> optimal_x((int)pow(order,3));
    vector<char> optimal_y((int)pow(order,3));

    cout << "number of elements: " << combinations.size() << endl;
    for (int i = 0; i <(int)pow(order,2); ++i) {
        cout << "optimal idx: " << optimal_ind.at(i) << endl;
        combination = combinations.at(optimal_ind.at(i));
        for (int j = 0; j < order; ++j) {
            int lex_idx = combination.at(j); //some index between 0 and 15 from 4x4 grid

            //mvt range in grid relative to thread position: -1 to +
            int relative_x = -1 + lex_idx % 4;
            int relative_y = -1 + (int) floor(lex_idx / 4);

            optimal_x[i * order + j] = relative_x;
            optimal_y[i * order + j] = relative_y;
        }
    }

    //DEBUG print
    for (int i = 0; i < (int)pow(order,2); ++i) {
        combination = combinations.at(optimal_ind.at(i));
        cout << "combination: " << i << "   ";
        for (int j = 0; j < order; ++j) {
            cout << combination.at(j) << " ";
        }
        cout <<  endl;
    }

    result.push_back(optimal_x);
    result.push_back(optimal_y);

    for (int i = 0; i < optimal_x.size(); ++i) {
        cout << (int)optimal_x.at(i) << " " << endl;
    }

    cout << "optimal sizes: " << optimal_x.size() << endl;
    cout << "optimal sizes: " << optimal_y.size() << endl;


     cout << "result size: " << result.size() << endl;

    return result;
}

我真的不明白像 .size() 这样的函数怎么可能改变 vector 对象(或者它可能只是巧合地同时发生)。该应用程序在单线程中运行，但我想这无关紧要，因为所有相关内容都应包含在该函数的范围内。显然，当我实际尝试访问某些组合元素 (std::out_of_range) 时，代码会在稍后停止工作。考虑到错误的严重性，我想我一定是错过了一些非常基本的东西。令人不安的是，如果我使用 2 作为 get_access_pattern() 的参数，一切正常。以上所有内容(使用 3 和 4 测试)都会导致此错误。

Answer 1

你有一个缓冲区溢出。你的输出:

A: number of elements: 560

您的代码:

cout << "A: number of elements: " << combinations.size() << endl;
float sum_vect[120][2];
for (int i = 0; i < combinations.size(); ++i) {
   for (int j = 0; j < 2; ++j) {
      sum_vect[i][j] = 0;
    }
}

在该循环中，当它达到 120 时查看“i”变量。您正在访问 sum_vect[120][j]，这是越界的。

当发生缓冲区溢出时，您的程序将表现出未定义的行为。