将char类型分配给char [9]的方式不兼容

Question

I can't for the life of me figure out why I'm getting this error message

incompatible types in assignment of `char' to `char[9]' 

The code:

class CabinAssignment {
    char room[3][4][9];

public:
    CabinAssignment();
    void display();
    bool available(int floor, int row, int col);
    void assignCabin(int floor, int row, int col);
};

CabinAssignment::CabinAssignment() {
    for(int i = 0;i<3;i++) {
        room[i][0] = 'A';
        room[i][1] = 'B';
        room[i][2] = 'C';
        room[i][3] = 'D';
        room[i][4] = 'E';
        room[i][5] = 'F';
        room[i][6] = 'G';
        room[i][7] = 'H';
        room[i][8] = 'I';
        room[i][9] = 'J';
    }
}

Answer 1

You declared room as 3D array of char elements. So, in order to access the actual char s, you have to apply three indices to room . Get it? Three -dimensional array needs three indices for individual element access. For example, room[i][j][k] will give you access to the corresponding character.

But if you apply only two indexes to room, as in room[i][4] , you get 1D array as the result. So in room[i][4] = 'E' you are attempting to assign 'E' to an 1D array of type char[9] . That just does not make sense. That's your problem.

Why are you using only two indices? What was the point of declaring room as a 3D array? What were you trying to do?

Also the second size of your array is only 4 , which means that the second index must lie between 0 and 3 . Yet you are attempting to access it out of bounds, as in room[i][9] .

Answer 2

char room[3][4][9];

says that room is an array of 3 x

char[4][9];

which is an array of 4 x

char[9];

which is an array of 9 chars.

room[i][0] = 'A';

Is trying to assign a single char to what is actually an array of char[9];

You can use typedef to make this easier on yourself.

typedef char COLUMN;
typedef COLUMN ROW [9]; // A row has 9 columns
typedef ROW FLOOR [4]; // A floor has 4 rows.

char FLOOR room[3];  // this object has 3 floors of 4 rows or 9 columns

Or better still, you could use inline-classing.

#include <array>  // this lets you do std::array<type, size> but requires c++11

class CabinAssignment {
public:
    class Column {
        char m_value;
    public:
        Column(char value_ = 0) : m_value(value_) {}
        char get() const { return m_value; }
        void set(char value_) { m_value = value_; }
    };

    class Row {
        std::array<Column, 9> m_columns;
    public:
        Row() : m_columns() {}
        const Column& col(size_t colNo_) const { return m_columns[colNo_]; }
        Column& col(size_t colNo_) { return m_columns[colNo_]; }
    };

    class Floor {
        std::array<Row, 4> m_rows;
    public:
        Floor() : m_rows() {}
        const Row& row(size_t rowNo_) const { return m_rows[rowNo_]; }
        Row& row(size_t rowNo_) { return m_rows[rowNo_]; }
    };

private:
    std::array<Floor, 3> m_floors;

public:
    CabinAssignment() : m_floors() {}
    const Floor& floor(size_t floorNo_) const { return m_floors[floorNo_]; }
    Floor& floor(size_t floorNo_) { return m_floors[floorNo_]; }
};

int main() {
    CabinAssignment cab;
    cab.floor(1).row(3).col(8) = 'A';
    char whoseOnFloor2Row5Col1 = cab.floor(2).row(5).col(1).get();
}

There are various ways you could eliminate the "get()" at the end, I was trying to go with a single theme. Charles Bailey points out you could make Column a simpler struct

    struct Column { char value; }

And then

    char whoseOnFloor2Row5Col1 = cab.floor(2).row(5).col(1).value;

I've gotten into the habbit of prefixing my member variables with "m_", though, which would make it

    struct Column { char m_value; }
    char whoseOnFloor2Row5Col1 = cab.floor(2).row(5).col(1).m_value;

and I balked at having an m_ exposed like that, but there's no real reason not to.

If you're not able to use std::array, simply change the definition of, eg m_columns to

Column m_columns[9];

and so on for m_rows and m_floors, but then you will probably want to do index checks on floor(), row() and column().