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

Question

我有一个函数：

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];
        }
    }
}
}

这里的变量 fp 和 C 定义为：

typedef std::vector<double> array1D;
typedef std::vector<array1D> array2D;
typedef std::vector<array2D> array3D;
array2D C(M, array1D(N, 0));
array3D fp(M, array2D(N, array1D(5, 0.0)));

函数被称为：

computeC(fp, C);

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

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

和

vect.hpp:130:6: error: in passing argument 2 of 'void computeRho(array3D, double&)'

我该如何解决这个问题？

Answer 1

编译器信息很清楚。您尝试传递给函数的第二个参数的类型与声明的参数类型匹配。参数的类型是double&，但您尝试传递array2D。 array2D 不是 double，所以你不能把它传递给函数。

要解决这个问题，请将C 定义为double。

但是 array2D 是双精度向量的向量。如何再次将 C 定义为双精度？

您可以通过删除定义 array2D C(M, array1D(N, 0)); 并将其替换为 double C = 0.0; 来做到这一点

关于以向量作为输入和输出参数的函数定义的任何其他想法？

是的，这是另一种可能的方法。您可以代替定义一个接受double& 作为参数的函数，而是实现一个接受array2D& 参数的函数。然后你可以将C 传递给这样的函数。

Answer 2

（编辑：在 OP 的 cmets 后更新答案）

这是你要找的东西吗：

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;
}

Answer 3

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

也许你可以去掉全局变量，把这个函数分成两个更基本的功能，比如 sumOfElements 和 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;
}

Answer 4

最后，我得到了结果，并且功能按预期完美运行。谢谢您的帮助。工作功能是：

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];
            }
        }
    }
}