在C++中传递和返回向量到函数

我有一个功能：

void computeC(array3D fp, double& C) {
C = 0.0;
for (int x = 0; x < M; ++x) {
    for (int y = 0; y < N; ++y) {
        for (int i = 0; i < 5; ++i) {
            C += fp[x][y][i];
        }
    }
}
}

执行主代码时，出现以下错误：

vect.cpp:9:22: error: invalid initialization of reference of type 'double&' 
from expression of type 'array2D {aka std::vector<std::vector<double> >}'

---

如何解决这个问题？

编译器的信息非常清楚。尝试传递给函数的第二个参数的类型与该参数声明的类型不匹配。参数的类型是double&但是您尝试传递一个array2D。array2D不是双精度的，因此不能将其传递给函数

要解决这个问题，请将C定义为双精度

---

但是array2D是一个双精度向量的向量。我怎样才能再次将C定义为double

可以通过删除定义array2D CM、array1DN、0；并将其替换为双C=0.0

用向量作为输入和输出参数的函数定义还有其他想法吗

---

是的，这是另一种可能的方法。您不需要定义一个以double&作为参数的函数，而可以实现一个以array2D&参数为参数的函数。然后您可以将C传递给该函数。

编辑：在OP的注释后更新答案

这就是你想要的吗：

typedef std::vector<double> array1D;
typedef std::vector<array1D> array2D;
typedef std::vector<array2D> array3D;

void computeC(array3D& fp, array2D& C) {
    double tmp = 0.0;

    // Calculate sum of element in 3D array
    for (int x = 0; x < M; ++x) {
        for (int y = 0; y < N; ++y) {
            for (int i = 0; i < 5; ++i) {
                tmp += fp[x][y][i];
            }
        }
    }

    // Update the 2D array
    for (int x = 0; x < M; ++x) {
        for (int y = 0; y < N; ++y) {
            C[x][y] = tmp;
        }
    }
}

int main()
{
    array2D C(M, array1D(N, 0));
    array3D fp(M, array2D(N, array1D(5, 0.0)));
    computeC(fp, C);
    return 0;
}

或

---

最后，我得到的结果和功能是完美的工作预期。谢谢你的帮助。工作职能是：

void computeC(array3D& fp, array2D& C) {
    for (int x = 0; x < M; ++x) {
        for (int y = 0; y < N; ++y) {
         C[x][y] = 0.0
            for (int i = 0; i < 5; ++i) {
                C[x][y] += fp[x][y][i];
            }
        }
    }
}

---

我认为StillLearning的答案最适合你的问题

也许您可以去掉全局变量，将该函数分为两个更基本的功能，如sumofements和setElements：

#include <iostream>
#include <vector>

typedef std::vector<double> array1D;
typedef std::vector<array1D> array2D;
typedef std::vector<array2D> array3D;

template< typename T>
double sumOfElements (T & a) {
    double sum = 0.0;
    for ( auto i : a) sum += sumOfElements(i);
    return sum;
}

template<>
double sumOfElements<array1D> (array1D & a) {
    double sum = 0.0;
    for ( auto i : a) sum += i;
    return sum;
}

template< typename T >
void setElements ( double val, T & a) {
    for ( auto & i : a) setElements(val,i);
}

template<>
void setElements<array1D> ( double val, array1D & a) {
    for ( auto & i : a) i = val;
}

int main() {
    double d;
    array2D b(4,array1D(5,0.1));
    array3D c(3,array2D(4,array1D(5,2.0)));


    d = sumOfElements(c);
    std::cout << "Sum of elements: " << d << std::endl;
    setElements(d,b);
    std::cout << "Now all the elements of the array2D are: " << b[2][3] << std::endl;;

    return 0;
}

---

令人惊讶的是，double&与array2D的类型不同。您是否阅读了错误消息？它确切地说明了问题所在。void computeCarray3D fp，double&C即使第二个参数有效，也应该通过引用而不是通过值传递第一个参数。PaulMckenzie..尝试您的建议仍然会出现相同的错误。我的建议与不必要的3d向量复制有关。如果您通过引用传递它，则不会进行复制。但是array2D是一个双精度向量的向量。如何再次将C定义为double？C是2D数组，其值将在代码执行期间更改。我已经定义了array2D CM，array1DN，0；在全局范围内，我的代码也在其他地方使用。还有其他关于以向量作为输入和输出参数的函数定义的想法吗？@代码C是2D数组，这正是问题所在。“如果C是一个2D数组，那么你就不能把它传递给一个不使用2D数组的函数。你完全不清楚你希望代码做什么，所以你必须解释它，”代码员说。你的函数需要一个double，但是你给了它一些其他的东西。你期待什么？当你向我们寻求帮助时，你希望我们做什么？@LightnessRacesinOrbit:代码必须采用我定义的向量向量的3D数组向量和定义的向量向量的2D数组向量。2D数组将在代码执行期间更新，但是，3D数组用于计算2D数组。我写了一个函数，它给出了上述错误。我想删除这个错误，并希望定义一个我不需要更改数组定义而需要修改函数的函数。我需要你们的帮助来完成修改或更改现有函数的某些部分，以使代码正常工作。假设M和N是在别处定义的非常量双值。没关系，但我仍然不明白OP想要对array2D C做什么，为什么他不直接返回一个Double，谁说了关于全局变量的事？@LightnessRacesinOrbit-OP在对另一个答案的评论中写道。直到它成为问题的一部分或问题的一部分，我才发现它的相关性。你已经正确地将参数类型更改为array2D&正如我所说的建议。但是您的函数似乎对参数没有任何作用。@user2079303:我的函数将fp作为输入3D数组，对其所有元素求和，并将其分配给C，即2D数组。@Bob\uu：您能突出显示或建议修改吗？因为我不是高级用户，所以，如果您可以这样做，我需要帮助。@代码器：您正在通过引用传递名为C的array2D。好的然后声明一个与double同名的变量，double是一个标量，1个数字，将其设置为0.0并使用它来累加和。您没有更改所传递参数的任何元素，而是在使用其他内容。看看Stillearnig写了什么。

typedef std::vector<double> array1D;
typedef std::vector<array1D> array2D;
typedef std::vector<array2D> array3D;

void computeC(array3D& fp, array2D& C) {
    double tmp = 0.0;

    // Calculate sum of element in 3D array
    for (int x = 0; x < M; ++x) {
        for (int y = 0; y < N; ++y) {
            for (int i = 0; i < 5; ++i) {
                tmp += fp[x][y][i];
            }
        }
    }

    // Update the 2D array
    for (int x = 0; x < M; ++x) {
        for (int y = 0; y < N; ++y) {
            C[x][y] = tmp;
        }
    }
}

int main()
{
    array2D C(M, array1D(N, 0));
    array3D fp(M, array2D(N, array1D(5, 0.0)));
    computeC(fp, C);
    return 0;
}

typedef std::vector<double> array1D;
typedef std::vector<array1D> array2D;
typedef std::vector<array2D> array3D;

void computeC(array3D& fp, array2D& C) {
    for (int x = 0; x < M; ++x) {
        for (int y = 0; y < N; ++y) {
            for (int i = 0; i < 5; ++i) {
                C[x][y] += fp[x][y][i];
            }
        }
    }
}

int main()
{
    array2D C(M, array1D(N, 0));
    array3D fp(M, array2D(N, array1D(5, 0.0)));
    computeC(fp, C);
    return 0;
}

void computeC(array3D& fp, array2D& C) {
    for (int x = 0; x < M; ++x) {
        for (int y = 0; y < N; ++y) {
         C[x][y] = 0.0
            for (int i = 0; i < 5; ++i) {
                C[x][y] += fp[x][y][i];
            }
        }
    }
}

#include <iostream>
#include <vector>

typedef std::vector<double> array1D;
typedef std::vector<array1D> array2D;
typedef std::vector<array2D> array3D;

template< typename T>
double sumOfElements (T & a) {
    double sum = 0.0;
    for ( auto i : a) sum += sumOfElements(i);
    return sum;
}

template<>
double sumOfElements<array1D> (array1D & a) {
    double sum = 0.0;
    for ( auto i : a) sum += i;
    return sum;
}

template< typename T >
void setElements ( double val, T & a) {
    for ( auto & i : a) setElements(val,i);
}

template<>
void setElements<array1D> ( double val, array1D & a) {
    for ( auto & i : a) i = val;
}

int main() {
    double d;
    array2D b(4,array1D(5,0.1));
    array3D c(3,array2D(4,array1D(5,2.0)));


    d = sumOfElements(c);
    std::cout << "Sum of elements: " << d << std::endl;
    setElements(d,b);
    std::cout << "Now all the elements of the array2D are: " << b[2][3] << std::endl;;

    return 0;
}