c++ - std::array 类的堆栈溢出

Question

我以前做过一些 C# 和 Java，但最近我想学习 c++，而且我发现很多大公司更喜欢 c++，因为它的效率。

为了适应 C++ 的语法和行为，我开始将我在 Java 中完成的测试翻译成 C++ 代码，以下是其中之一:

#include "stdafx.h"
#include <iostream>
#include <array>
#include <string>
#include <cstring>
#include <chrono>
using namespace std;
using namespace std::chrono;

typedef array<array<int, 1000>, 1000> aArray;

aArray hasLocality(aArray, aArray);
aArray noLocality(aArray, aArray);

static aArray a = aArray();
static aArray b = aArray();

int main() {

    for (size_t i = 0; i < 100; i++)
    {
        for (size_t j = 0; j < 100; j++)
        {
            a[i][j] = i + j;
            b[i][j] = i + j;
        }
    }
    hasLocality(a, b);
    noLocality(a, b);
    system("pause");
    return 0;
}

aArray hasLocality(aArray a, aArray b) {
    milliseconds startTime = duration_cast<milliseconds>(
        system_clock::now().time_since_epoch()
        );
    aArray ans = aArray();
    for (size_t i = 0; i < ans.size(); i++)
    {
        for (size_t k = 0; k < ans[0].size(); k++)
        {
            for (size_t j = 0; j < ans[0].size(); j++)
            {
                ans[i][j] = ans[i][j] + a[i][k] * b[k][j];
            }
        }
    }

    milliseconds endTime = duration_cast<milliseconds>(
        system_clock::now().time_since_epoch()
        );
    string time = std::to_string((endTime - startTime).count()) + "\n";
    cout.write(time.c_str(), (unsigned)strlen(time.c_str()));
    return ans;
}

aArray noLocality(aArray a, aArray b) {
    milliseconds startTime = duration_cast<milliseconds>(
        system_clock::now().time_since_epoch()
        );
    aArray ans = aArray();
    for (size_t i = 0; i < ans.size(); i++)
    {
        for (size_t j = 0; j < ans[0].size(); j++)
        {
            for (size_t k = 0; k < ans[0].size(); k++)
            {
                ans[i][j] = ans[i][j] + a[i][k] * b[k][j];
            }
        }
    }
    milliseconds endTime = duration_cast<milliseconds>(
        system_clock::now().time_since_epoch()
        );
    string time = std::to_string((endTime - startTime).count()) + "\n";
    cout.write(time.c_str(), (unsigned)strlen(time.c_str()));
    return ans;
}

这是我通过简单的矩阵乘法对局部性进行的测试之一，但是由于数组大小过大，我无法摆脱堆栈溢出异常，我认为这对测试来说是必不可少的。

我还认为数组会放在堆上而不是堆栈上，因为我把它作为静态的。

最后，我发现当给定较小的数组大小 (100, 100) 时，noLocality 比 hasLocality 更有效，是异常还是数量不足本地发生的数据？

提前致谢

Answer 1

在 Java 中，所有对象参数都是通过引用传递的。在 C++ 中，默认情况下它们是按值传递的(即在堆栈上放置一个拷贝)。所以当你打电话时:

aArray hasLocality(aArray a, aArray b)

您最终在堆栈上得到了 a 的拷贝，然后是 b 的拷贝，并且您还为返回值分配了空间，即 aArray 的另一个拷贝。您在堆栈上分配了 3 个大型数组。这与 Java 不同。

在 C++ 中，您可以通过使用引用或指针来避免按值传递。 Java 没有指针。 Java 引用与 C++ 引用不太一样，但也有相似之处。

如果你有:

aArray hasLocality(aArray &a, aArray &b)

然后你会得到类似于 Java 的东西，数组通过引用传递，与 Java 相同。对 hasLocality 的调用也不异常(exception)。所以只需将 hasLocality 和 noLocality 以这种方式更改即可。您仍然拥有返回值拷贝。为避免这种情况，您可以做的一件事是也传递返回值:

void hasLocality(aArray &a, aArray &b, aArray &ans)

然后移动

aArray ans = aArray();

在函数之外。

那时你不会像 Java 那样进行数组复制。但请记住 C++ 中的引用有点不同，一旦引用引用了一个对象，它就不能引用任何其他对象。由于您是 C++ 的新手，这可能会让您现在感到困惑，但您会学习的。请注意，C++ 总体上比 Java 更复杂。