Question

我需要返回3个值。 X，Y，Z。我尝试过类似的东西，但它不起作用，任何人都可以帮我一点吗？我看过这里：Return a float array in C++我尝试做同样的事情，除了返回一维数组。

class Calculate
{
 float myArray[3][4], originalArray[3][4], tempNumbers[4];
 float result[3]; // Only works when result is 2 dimensional array, but I need 1 dimension.

public:
 Calculate(float x1, float y1, float z1, float r1,
  float x2, float y2, float z2, float r2,
  float x3, float y3, float z3, float r3)
 {
  myArray[0][0] = x1;
  myArray[0][1] = y1;
  myArray[0][2] = z1;
  myArray[0][3] = r1;

  myArray[1][0] = x2;
  myArray[1][1] = y2;
  myArray[1][2] = z2;
  myArray[1][3] = r2;

  myArray[2][0] = x3;
  myArray[2][1] = y3;
  myArray[2][2] = z3;
  myArray[2][3] = r3;

  result[0] = 1;
  result[1] = 2;
  result[2] = 3;
 }

 float* operator[](int i)
 {
  return result[i]; //Value type does not match the function type
 }

 const float* operator[](int i) const
 {
  return result[i]; //Value type does not match the function type
 }
};

Answer 1

通常更好的做法是接受指针并在那里写出结果，而不是返回指针。这样，有人可以在堆栈上分配一个常规数组，并通过Calculate初始化它。

类似的东西：

class Calculate
{
 float myArray[3][4], originalArray[3][4], tempNumbers[4];

public:
 Calculate(float x1, float y1, float z1, float r1,
  float x2, float y2, float z2, float r2,
  float x3, float y3, float z3, float r3, float *result)
 {
  myArray[0][0] = x1;
  myArray[0][1] = y1;
  myArray[0][2] = z1;
  myArray[0][3] = r1;

  myArray[1][0] = x2;
  myArray[1][1] = y2;
  myArray[1][2] = z2;
  myArray[1][3] = r2;

  myArray[2][0] = x3;
  myArray[2][1] = y3;
  myArray[2][2] = z3;
  myArray[2][3] = r3;

  result[0] = 1;
  result[1] = 2;
  result[2] = 3;
 }
};

你可以做的其他一些调整 - 将构造函数与计算分开，因为构造函数更多用于初始化;并传递数组以实现更安全的内存控制：

class Calculate
{
    float myArray[3][4], originalArray[3][4], tempNumbers[4];

public:
    Calculate(const float initArray[3][4])
    {
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 4; j++)
                myArray[i][j] = initArray[i][j];
    }

    void DoCalculation(float result[3]) const
    {
        result[0] = 1;
        result[1] = 2;
        result[2] = 3;
    }
};

int main()
{
    float myArray[3][4] =
    {
        { 0, 1, 2, 3 },
        { 4, 5, 6, 7 },
        { 8, 9, 0, 1 }
    };
    float result[3];
    Calculate calc(myArray);
    calc.DoCalculation(result);
    return 0;
}

Answer 2

result[i]是浮点数，而不是浮点数*，所以你可以做

const float operator[](int i) const
{
  return result[i]; 
}

但我认为你确实想要返回一个引用来获取正确的语义，所以你需要

const float& operator[](int i) const
{
  return result[i]; 
}

float& operator[](int i)
{
   return result[i];
}

右？（我认为这没关系 - 它编译但是我已经做了一段时间了......）

Answer 3

另一种方法是将result作为一个单独的结构，并将其作为值返回或通过引用传递：

struct Result_Type
{
  double values[3];
// Alternatively:
// double x;
// double y;
// double z;
};

// Returning a result
const Result_Type calculate_result_1(/* yada yada yada */)
{
  Result_type new_result;
  new_result.value[0] = 0;
  new_result.value[1] = 0;
  new_result.value[2] = 0;
  return result;  // Return the result as a object
}

// Or passing a result to be modified
void  clear_result(Result_Type & any_result) // <-- Note pass by reference
{
  any_result.value[0] = 0;
  any_result.value[1] = 0;
  any_result.value[2] = 0;
  return;
}

您可能会发现这是首选设计，因为您可以传递结果，修改Result_Type结构以使用其他结果向量（数学术语）执行操作。矩阵也可以被视为结果向量的组合。

这可能会使代码更容易阅读。

Answer 4

在您收到错误的代码中，您不会尝试返回指针。您试图在给定索引处返回单个浮点数。

Calculate c;
float first = c[0];
float second = c[1];
float third = c[2];

如果你想返回一个指向results数组的指针，那么你必须返回数组，例如

float* GetResult() { return result; }

你可能会保持多少并不重要，因为最终效果几乎相同。如果你重载operator[]，你将拥有更多的控制权，因为你可以检查越界访问。

Answer 5

一些回复表明使用了指针。问题是谁分配了指针并释放了它。还需要检查传入指针是否为NULL等等。相反，我会建议构造函数的以下声明。

 Calculate(float x1, float y1, float z1, float r1, 
  float x2, float y2, float z2, float r2, 
  float x3, float y3, float z3, float r3, float (&r)[3])

这更安全，因为引用不能为NULL。

从Class返回数组

5 个答案: