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定义为double？

您可以删除定义array2D C(M, array1D(N, 0));并将其替换为double C = 0.0;

来执行此操作

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

是的，这是另一种可行的方法。您可以改为实现一个带有double&参数的函数，而不是定义一个以array2D&作为参数的函数。然后，您可以将C传递给此类函数。

Answer 2

（编辑：在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;
}

或

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

最后，我得到了结果，并且功能正如所希望的那样完美。谢谢您的帮助。工作职能是：

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

Answer 4

我认为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;
}

将向量传递给C ++中的函数

4 个答案: