Question

在SO成员的帮助下，以下程序通过考虑以下标准成功地将静态1D阵列转换为2D矢量：

每次遇到值为0的元素时，都会创建一个新行。基本上，当遇到0时，行值增加，列值重置为0.如果遇到非零值，则保持行值并增加列值。

// declarations
int givenArray[9] = {1, 2, 3, 0, 4, 0, 1, 2, 1};
std::vector<int>::size_type j;
std::vector<int>::size_type i;

vector<vector<int>> my2dArray;
vector<int> dArray;

void calc(vector<int>&, int);
int task;
int sum = 0;

int main() {    
    for (int i = 0; i < 9;
         i++) // iterate through all elements of the given array
    {
        if (i == 0) // adding the first element
        {
            my2dArray.resize(my2dArray.size() + 1);
            my2dArray.back().push_back(givenArray[i]);
            continue;
        }
        if (givenArray[i] == 0) // re-size if 0 is encountered
        {
            my2dArray.resize(my2dArray.size() + 1);
        }
        my2dArray.back().push_back(givenArray[i]);
    }

    for (std::vector<std::vector<int>>::size_type i = 0; i < my2dArray.size();
         i++) {
        for (std::vector<int>::size_type j = 0; j < my2dArray[i].size(); j++) {
            std::cout << my2dArray[i][j] << ' ';

            if (my2dArray[i].size() > 2) {
                task = my2dArray[i].size();
                calc(my2dArray[i], task);
            }
        }

        std::cout << std::endl;
    }
}

void calc(vector<int>& dArray, int task) {
    int max = 0;
    for (unsigned int j = 0; j < task; j++) {
        if (dArray[i] > max)
            dArray[i] = max;
    }
    cout << "\nMax is" << max;
}

但是，如果每行的列数超过2，我想将单行2D向量2dArray传递给函数calc。函数calc旨在找到所有元素的最大值。通过了行。上述程序无法产生所需的输出。

Answer 1

你有一些问题：

您不需要在主要功能中循环j - 您的calc功能已经执行此操作。
您的calc函数循环遍历j，但在访问数组时使用全局变量i。
您的calc函数会将当前max值分配给数组，而不是将数组值分配给max

Answer 2

函数calc旨在查找传递行中所有元素的最大值。上述程序无法产生所需的输出。

您可以使用std::max_element。

，而不是编写函数

#include <algorithm>
//...
int maxVal = *std::max_element(my2dArray[i].begin(), my2dArray[i].begin() + task);
cout << "\Max is " << maxVal;

Answer 3

一些改进：

i and j个全局变量，您在循环初始化中声明循环的变量（例如：for（ int i = 0 ; i＆lt; 9; i ++），对于其他循环也一样。）
最好不要使用全局变量，只有在严格必要时（仔细分析原因）。在这种情况下，没有必要。
typedef可以更轻松地访问该类型的内部typedef（例如：size_type）。
你在内循环的每次迭代中都在调用calc方法，并且多次遍历同一行，这个调用应该每行执行一次。
不建议在代码中使用数组givenArray的大小作为常量，稍后您可以向数组中添加一些元素并忘记更新该常量，最好声明一个变量并进行一般计算（使用sizeof ）。
如果传递矢量，则无需将矢量的大小传递给方法calc。
如前所述，最好使用std::max_element标头algorithm。

如果你可以使用C ++ 11，givenArray可以转换为std::vector<int>并保持简单的初始化。

代码（在GCC 4.9.0中测试）

#include <vector>
#include <iostream>

using namespace std;

typedef std::vector<int> list_t;
typedef std::vector<list_t> list2d_t;

void calc(list_t& dArray, long& actual_max) {
    for (unsigned int j = 0; j < dArray.size(); j++) {
        if (dArray[j] > actual_max) {
            actual_max = dArray[j];
        }
    }
    cout << "Max is " << actual_max << "\n";
}

void calc(list_t& dArray) {
    long actual_max = 0;
    for (unsigned int j = 0; j < dArray.size(); j++) {
        if (dArray[j] > actual_max) {
            actual_max = dArray[j];
        }
    }
    cout << "Max is " << actual_max << "\n";
}

int main() {
    int givenArray[9] = {1, 2, 3, 0, 4, 0, 1, 2, 1};
    int givenArraySize = sizeof(givenArray) / sizeof(givenArray[0]);

    list2d_t my2dArray(1);
    list_t dArray;
    for (int i = 0; i < givenArraySize; i++) {
        if (givenArray[i] == 0) {
            my2dArray.push_back(list_t());
        } else {
            my2dArray.back().push_back(givenArray[i]);
        }
    }

    long max = 0;
    for (list2d_t::size_type i = 0; i < my2dArray.size(); i++) {
        for (list_t::size_type j = 0; j < my2dArray[i].size(); j++) {
            std::cout << my2dArray[i][j] << ' ';
        }

        std::cout << "\n";
        if (my2dArray[i].size() > 2) {
            // if you need the max of all the elements in rows with size > 2 uncoment bellow and comment other call
            // calc(my2dArray[i], max); 

            calc(my2dArray[i]);
        }
    }
}

获得输出：

1 2 3 
Max is 3
4 
1 2 1 
Max is 2

从2d向量传递一行到函数

3 个答案: