C+中的参考数组/矩阵+； 我对C++是新的，这就是我目前陷入困境的原因。 现在问题来了：我有两个类似的浮点矩阵： static const float matr1[4][8] = {0.0, 0.0, ...}; static const float matr2[7][8] = {0.0, 0.5, ...};

等等。 我有一个类似于此的结构：

struct structy{
float matr[][];
int index;
float somevalue;
};

我有一个

结构的向量

，它是根据其他信息动态创建的。 如果struct（行）的第一个参数不同，我如何在struct变量中引用这些声明的矩阵？ 稍后我需要一行矩阵作为浮点数组

---

谢谢你的帮助

您还应该在structy中存储列数和行数，以便在稍后的时间点了解matr的维度。否则，无法检查二维阵列的长度

---

至于您的主要问题：在访问2D浮点数组（matr）中的单个矩阵条目时是否遇到问题？

我所见过的唯一方法是动态地：

struct structy{
    float ** matr;

    // Need to add these 2 variables
    int dimensionRow;
    int dimensionCol;

    int index;
    float somevalue;
};

---

当您将数据放入

matr

时，还需要设置

dimensionRow

和

dimensionCol

，并在填充前动态分配

matr

，如果您计划复制。如果没有，您可以简单地将

matr

设置为预定义矩阵之一的指针。无论哪种方式，您都需要设置

维度行

和

维度列

如果您需要不同大小的矩阵，我建议使用向量向量。这将避免手动分配2D阵列和管理其内存的麻烦。一种可能的实施方式：

struct structy {
    std::vector< std::vector<float> > matr;
    int index;
    float somevalue;
};

structy s;
...
s.matr[0][1] = 42.0f;
...

---

不能创建引用不同类型的引用（不是传统意义上的引用），不同长度的数组是不同的类型。但是，您可以利用数组是连续的这一事实（因此数组的数组是连续的数组），并使用指针创建一个充当引用的类

template<typename T>
class matrix_reference
{
public:
    template<size_t R, size_t C>
    void set_reference(T (&arr)[R][C])
    {
        m_start = &arr[0][0];
        m_rows = R;
        m_columns = C;
    }

    T& operator()(size_t r, size_t c)
    {
        return m_start[r * m_columns + c];
    }

    size_t rows() const { return m_rows; }
    size_t columns() const { return m_columns; }
private:
    T* m_start;
    size_t m_rows;
    size_t m_columns;    
};

int main()
{
    matrix_reference<const float> mref;

    mref.set_reference(matr1);
    for (size_t r=0; r<mref.rows(); ++r)
    {
        for (size_t c=0; c<mref.columns; ++c)
            std::cout << mref(r,c) << ' ';
        std::cout << '\n';
    }

    mref.set_reference(matr2);
    for (size_t r=0; r<mref.rows(); ++r)
    {
        for (size_t c=0; c<mref.columns; ++c)
            std::cout << mref(r,c) << ' ';
        std::cout << '\n';
    }    
}

模板
类矩阵
{
公众：
模板
无效集_参考（T&arr）[R][C]）
{
m_start=&arr[0][0]；
m_行=R；
m_列=C；
}
运算符（）（大小\u T r，大小\u T c）
{
返回m_start[r*m_列+c]；
}
size_t rows（）常量{返回m_rows；}
size_t columns（）常量{return m_columns；}
私人：
T*m_开始；
行的大小；
列的大小；
};
int main（）
{
矩阵参考mref；
mref.set_参考（matr1）；
对于（size_t r=0；r不确定您期望的
float matr[][]
是什么。
给定结构的第一个参数（行）变化？
不，不可能，因为它不能。我用不同数量的行初始化了不同的矩阵。我的结构中的
matr
变量应该包含对其中一个矩阵的引用。这可能吗？如果可能，怎么可能？关于这一点有很多问题。关于信息，我会记住维度。我有将
matr
分配给
matr1
或
matr2
时出现问题，如何才能做到这一点？我只是对参考感兴趣，因为我计划稍后阅读矩阵的某些行。但是，声明
matr
就像您在第二个版本中提到的，稍后调用例如
structy1.matr=matr1；
将出现
错误：无法在赋值中将'float const[4][8]转换为'float const**'。
明白了，正确的方法是在结构中声明我的引用：
const float（*textCoords）[8]
每行包含8个浮点数。Thx伙计们！我不是100%确定这一点，但我认为任何多维数组的内存布局都是相同的，所以我相信您也可以应用一个cast:structy1.matr=reinterpret_cast（matr1）；如果有人对此发表意见，将不胜感激！如何正确设置指向预定义矩阵之一的指针？
template<typename T>
class matrix_reference
{
public:
    template<size_t R, size_t C>
    void set_reference(T (&arr)[R][C])
    {
        m_start = &arr[0][0];
        m_rows = R;
        m_columns = C;
    }

    T& operator()(size_t r, size_t c)
    {
        return m_start[r * m_columns + c];
    }

    size_t rows() const { return m_rows; }
    size_t columns() const { return m_columns; }
private:
    T* m_start;
    size_t m_rows;
    size_t m_columns;    
};

int main()
{
    matrix_reference<const float> mref;

    mref.set_reference(matr1);
    for (size_t r=0; r<mref.rows(); ++r)
    {
        for (size_t c=0; c<mref.columns; ++c)
            std::cout << mref(r,c) << ' ';
        std::cout << '\n';
    }

    mref.set_reference(matr2);
    for (size_t r=0; r<mref.rows(); ++r)
    {
        for (size_t c=0; c<mref.columns; ++c)
            std::cout << mref(r,c) << ' ';
        std::cout << '\n';
    }    
}