C ++中的参考数组/矩阵

Question

I am new to C++ which is the reason why I'm currently kind of stuck. Now here's the Problem: I have a couple of float matrices like this:

static const float matr1[4][8] = {0.0, 0.0, ...};
static const float matr2[7][8] = {0.0, 0.5, ...};

etc. I have a struct like to this one:

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

I have a vector of this structy which is created dynamically dependent on other information. How can I reference a certain of these declared matrices in my struct variable, given that the first parameter of the struct (rows) varies? I need a row of the matrices as a float array later on.

Thanks for your help!

Answer 1

You should also store the number of columns and the number of rows in structy, so that you know the dimensions of matr at a later point in time. There is no way to check the length of the 2D array otherwise.

As for your main question: Are you having troubles accessing individual matrix entries in one of your 2D float arrays (matr)?

Answer 2

The only way I have ever seen this done is dynamically:

struct structy{
    float ** matr;

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

    int index;
    float somevalue;
};

When you place the data into matr , you need to also set dimensionRow , and dimensionCol , as well as dynamically allocate matr prior to filling it, IFF you plan to copy. If not you can simply set matr to the pointer of one of your pre-defined matrices. Either way you will need to also set dimensionRow and dimensionCol .

Answer 3

If you need varying sized matrices, I'd suggest using a vector of vectors. This will save you from the trouble of manually allocating a 2D array and managing its memory. One possible implementation:

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

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

And either grow the vectors on demand using push_back() or grow them beforehand with resize().

Now if you just want a reference to an external matrix (pointer to static memory) then you can just declare a pointer to pointer (double pointer):

struct structy {
    const float ** matr;
    int index;
    float somevalue;
};

Answer 4

You cannot create a reference (not in the traditional sense) that will refer to different types, and arrays with different lengths are different types. However, you can take advantage of the fact that arrays are contiguous, (and so arrays of arrays are contiguous arrays), and create a class that acts as a reference using pointers.

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