C++ 如何在c++；

如何从函数返回数组？我的代码是

float ClassArray::arr_sub(float a[100][100], float b[100][100]) {
    int i,j;
    for(i = 1; i < 10; i++) {
        for(j = 1; j < 10; j++){
            f[i][j]=b[i][j]-a[i][j];
        }
    }
    return f;
}

但是在构建类的时候，它说float到float[100][100]的类型分配不兼容

我对另一个关于数组的问题的回答解释了为什么不想使用数组

正如我在该答案中所说的，您不能像正在尝试的那样分配数组：

float g[100];
g = foo(); // illegal, assigning to arrays is not allowed

数组的另一个奇怪限制是不允许从函数返回它们：

float foo()[100]; // illegal, returning an array from a function is not allowed

还请注意，当您声明一个类似于

float arr_sub（float a[100][100]）

的函数时，您可能会认为您是在按值传递数组，但事实上，这会调用另一个为数组创建的奇怪异常。在C和C++中，每当声明函数的形式参数为数组时，该类型从“数组”调整为“数组元素类型指针”。

---

由于数组的行为与它们应有的不同，因此您应该使用std:：array或std:：vector：

std::array<float,100> foo(); // works

std::array<float,100> g;
g = foo(); // works

这不适用于std:：vector，因为std:：vector可以利用移动语义来避免复制其所有元素。

如果坚持使用“普通C”2D数组，最好是将指向结果的指针与两个输入参数一起传递，而不是像以前那样按值传递数组

<>但是，C++中最好的方法是使用<代码> vector < /C> >，并通过引用传递它。< /P>

void ClassArray::arr_sub(
    const vector<vector<float> > &a
,   const vector<vector<float> > &b
,   vector<vector<float> > &res)
{
    for(int i=0 ; i != a.size() ; i++)
        for(int j=0 ; j != b.size() ; j++)
            res[i][j] = b[i][j] - a[i][j];
}

void main() {
    vector<vector<float> > a(100, vector<float>(100, 12.345));
    vector<vector<float> > b(100, vector<float>(100, 98.765));
    vector<vector<float> > res(100, vector<float>(100, 0));
    arr_sub(a, b, res);
}

void类数组：：arr\u sub(
常数向量&a
，康斯特向量酒店
，矢量和分辨率）
{
for（int i=0；i！=a.size（）；i++）
对于（int j=0；j！=b.size（）；j++）
res[i][j]=b[i][j]-a[i][j]；
}
void main（）{
向量a（100，向量（100，12.345））；
载体b（100，载体（100，98.765））；
向量res（100，向量（100，0））；
arr_sub（a、b、res）；
}

最好的方法是将所有内容包装到一个类中。从表面上看，这是一个矩阵

可能已经有上百个矩阵类了，所以再写一个是毫无意义的

但是，如果这是一个学习练习，它可能是值得的

要回答您提出的问题，请为函数提供第三个参数：

float result[100][100]

。在函数内部，将结果写入结果数组

---

这是因为在C和C++中，数组总是通过引用传递，而不是按值传递。这是因为C++只传递指向数组起始的指针。

如果你真的想返回一个数组，而有些则如何在主（）中使用它，最有效的方法就是声明返回数组是动态的。这样可以避免丢失指向此新数组的指针，因为它将在堆中而不是在堆栈中分配。

-1:静态大小的数组和动态大小的向量对于不同的作业是不同的工具，

vector

不一定是获得二维的最佳方法。@Potatoswatter它们是“不同的工具”，好的，但是，在几乎所有情况下，这些工具中的一个都可以代替另一个使用，而不会造成明显的性能损失，并且可读性也会显著提高。我总是先选择一个向量，然后在经过一轮大量分析之后才切换到一个固定的多维数组。我见过一些需要切换到固定2D阵列进行优化的情况，但OP中描述的情况与这些情况不同。堆栈溢出是为了推广最佳实践，选择向量而不是普通数组就是其中之一。在矩阵库中使用

std:：array

而不是C数组是一个好主意。对固定大小的矩阵使用

std:：vector

是个坏主意。你是说

std:：vector

比

std:：array

产生的可读代码更多吗？@Potatoswatter我怎么能声称

std:：array

的任何内容都不提一次呢？很明显，我在比较灵活性OP的

float g[100][100]

和

std:：vector

，仅此而已。正如我所说，两个不同的工具用于两个不同的作业。另一方面，

std:：array

是一种代用品，它在这种情况下提供了

std:：vector

的所有好处，而不需要相关成本。您说过“堆栈溢出是为了推广最佳实践，选择向量而不是普通数组是其中之一”，而

std:：array

是一个普通数组。显式传递数组引用

float（&result）[100][100]

比使用会退化为混乱的

float（*result）[100]

。我注意到阵列为100x100，但I和j的值仅为10。这意味着您只处理前十行和前十列中的元素。这与你的问题并不相关，但如果你的实际程序这样做了，而且这不仅仅是一个打字错误，那么你应该在你的程序中修复它。

std::array<std::array<float,100>,100> g;

typedef std::array<std::array<float,100>,100> Matrix;

Matrix ClassArray::arr_sub(Matrix a, Matrix b) {
    ...
}

Matrix g;
g = cm.arr_sub(T,W);

template<typename T,int Rows,int Columns>
using Matrix2d = std::array<std::array<T,Columns>,Rows>;

Matrix2d<float,100,100> g;

void arr_sub(Matrix a, Matrix b, Matrix &result);

Matrix g;
arr_sub(T,W,g);

void ClassArray::arr_sub(
    const vector<vector<float> > &a
,   const vector<vector<float> > &b
,   vector<vector<float> > &res)
{
    for(int i=0 ; i != a.size() ; i++)
        for(int j=0 ; j != b.size() ; j++)
            res[i][j] = b[i][j] - a[i][j];
}

void main() {
    vector<vector<float> > a(100, vector<float>(100, 12.345));
    vector<vector<float> > b(100, vector<float>(100, 98.765));
    vector<vector<float> > res(100, vector<float>(100, 0));
    arr_sub(a, b, res);
}