从c+中的对象获取数组+； 这个问题可能很简单，但是我从来没有在C++中使用原始指针或数组，所以…p>

我需要使用如下所示的库函数：

void f(double a[3][3], double b[3], double c[3]);

#include <iostream>

class X {
 public:
    void getA(double (&array)[3][3]) {
        for (int i = 0; i < 3; ++i)
            for (int j = 0; j < 3; ++j)
                array[i][j] = a[i][j];
    }
 private:
    double a[3][3] = {{1,2,3},
            {4,5,6},
            {7,8,9}};
};

int main(void) {
    X o = X();
    double a[3][3];
    o.getA(a);
    for(int i = 0; i < 3; ++i)
        for(int j = 0; j < 3; ++j)
            std::cout << a[i][j] << std::endl;
    return 0;
}

a

和

b

用于输入，结果存储在

c

中

a

的计算有点复杂，但不会改变，因此只计算一次并保存结果是有意义的。在我的程序中，我可以将它链接到

X

类型的对象

class X{
public:
X(){ 
    a = {{1,2,3},
         {4,5,6},
         {7,8,9}}; 
    }

private:
    double a[3][3];
}

如何为函数

f

中使用的

X:：a

编写getter

这是我调用函数f的方式：

#include "X.h"

int main(int argc, char *argv[]){

    X o = X(); //create object
    double a[3][3] = o.getA(); // I want to get a somehow
    double b[3] =  {1,2,3}; // create dummy b
    double c[3] = {}; // create empty c
    f(a,b,c); // call funktion to populate c
    for(int i=0; i<3; ++i){
        std::cout << c[i] << endl;
    }
}

#包括“X.h”
int main（int argc，char*argv[]）{
xo=X（）；//创建对象
double a[3][3]=o.getA（）；//我想得到一个
双b[3]={1,2,3}；//创建伪b
双c[3]={}；//创建空c
f（a，b，c）；//调用函数来填充c
对于（int i＝0；i ），你知道C++中的2D数组是怎么走的，但是如果你不能绕过你所面临的障碍，那么就有可能把矩阵作为参数传递给吸气函数，比如：

void f(double a[3][3], double b[3], double c[3]);

#include <iostream>

class X {
 public:
    void getA(double (&array)[3][3]) {
        for (int i = 0; i < 3; ++i)
            for (int j = 0; j < 3; ++j)
                array[i][j] = a[i][j];
    }
 private:
    double a[3][3] = {{1,2,3},
            {4,5,6},
            {7,8,9}};
};

int main(void) {
    X o = X();
    double a[3][3];
    o.getA(a);
    for(int i = 0; i < 3; ++i)
        for(int j = 0; j < 3; ++j)
            std::cout << a[i][j] << std::endl;
    return 0;
}

#包括
X类{
公众：
void getA（双精度（&数组）[3][3]）{
对于（int i=0；i<3；++i）
对于（int j=0；j<3；++j）
数组[i][j]=a[i][j]；
}
私人：
双a[3][3]={{1,2,3}，
{4,5,6},
{7,8,9}};
};
内部主（空）{
xo=X（）；
双a[3][3]；
o、 格塔（a）；
对于（int i=0；i<3；++i）
对于（int j=0；j<3；++j）
std:：cout这个片段应该可以满足您的需要

#include <iostream>
#include <string>

using namespace std;

class X {
public:
    X() {
    }

    typedef double (*ptr_matrix)[3];

    ptr_matrix getA(){
        return a;
    }

private:
    double a[3][3] = {{ 1,2,3},
        {4,5,6},
        {7,8,9}};
};

void f(double a[3][3], double b[3], double c[3])
{
    cout<<"Inside f function";
    for(auto i = 0; i < 3;i++) {
        cout<<endl;
        for(auto j = 0 ; j < 3;j++)
            cout<<a[i][j];
    }
}

int main()
{
    X o = X(); //create object
    double (*a)[3] = NULL;
    a = o.getA(); // I want to get a somehow

    double b[3] = {0};
    double c[3] = {0};

    f(a,b,c);

}

#包括
#包括
使用名称空间std；
X类{
公众：
X（）{
}
类型定义双（*ptr_矩阵）[3]；
ptr_矩阵getA（）{
返回a；
}
私人：
双a[3][3]={{1,2,3}，
{4,5,6},
{7,8,9}};
};
无效f（双a[3][3]，双b[3]，双c[3]）
{
coutI可能在这里遗漏了一些细节，但在您的代码片段中，您将
X
存储在堆栈上，以及
a
，并且两者都在同一范围内。为什么您不能省略
X
并提供一些函数
computeA（双a[3][3]）
？我对示例做了一点修改。希望现在更清楚一些。在C中，您不能从函数返回原始指针数组。您可以返回std:：vector并获取数据（）。在C中，int a[n]等于int*a=malloc（sizeof（int）*n）；free（a）@AndrewRomanov当然可以，
std:：strdup
可以。不，您显示的两个声明不相等。@Yksisarvinen实际上参数声明
double a[3][3]
相当于
double（*）[3]
，这使得它与
A:：A
兼容。与其复制
X:：A
，为什么不直接传递它呢？因为X:：A是在o内部分配的，并且将随o一起消亡。这是不安全的，因为o将消亡，那么当前作用域将完成。@AndrewRomanov
main:：A
与
main:：o
具有相同的生存期（和
main:：o.a
），它们将一起死亡。@gsamaras只需将
X:：a
公开，并将
o.a
传递给
f
@gsamaras当然，但在这种情况下，拥有私有数据成员毫无意义，而且是有害的。真正的代码显然应该做一些完全不同的事情。与另一个答案相同的注释：为什么复制数组？！removed Copying我不认为这段代码好得多：不要通过参数传递结果，使用返回值。我也不太满意
double[3][3]的别名
使用
double*
，您将无法将结果传递给OP的
f
函数，而不进行另一次强制转换。如果我没有弄错的话，
可能这是我能做的最干净的方式。