在 Mac 中将一维数组转换为二维不起作用

我上了一堂C++课，不像我所有的学生一样，我买了一台Mac，用xcode来运行和编辑我的文件。但最近有一段代码，它可以在Ubuntu系统中很好地运行，但在我的mac上，它一直给我错误。

错误出现在这一行中：char（*maze）[width]=relpret_cast（m_maze）；并且有3行具有相同的上述内容。如果你在Ubuntu中使用该代码，它会成功运行，但在mac中，它会终止并报告3个相同的错误。

警告说：无法初始化右值为"char（）[width]'的类型"char（）[iwidth]"的类型

Plz帮助

代码是关于一个鼠标在迷宫中。这是代码：

#include <iostream>
#include <stdexcept>
#include <cstdlib>
#include <cstdio>
using namespace std;
const char MOUSE  = '*';
const char WAY    = ' ';
const char WALL   = '@';
const char PASS   = '.';
const char IMPASS = 'X';
typedef enum tag_Direction {
    EDIR_RIGHT,
    EDIR_DOWN,
    EDIR_LEFT,
    EDIR_UP
}   EDIR;
class Stack {
public:
    Stack (void) : m_top (NULL) {}
    ~Stack (void) {
        for (Node* next; m_top; m_top = next) {
            next = m_top -> m_next;
            delete m_top;
        }
    }
    void push (EDIR dir) {
        m_top = new Node (dir, m_top);
    }
    EDIR pop (void) {
        if (! m_top)
            throw underflow_error ("Underflow of Stack！");
        EDIR dir = m_top -> m_dir;
        Node* next = m_top -> m_next;
        delete m_top;
        m_top = next;
        return dir;
    }
private:
    class Node {
    public:
        Node (EDIR dir, Node* next) : m_dir (dir),
        m_next (next) {}
        EDIR m_dir;
        Node* m_next;
    };
    Node* m_top;
};
class Mouse {
public:
    Mouse (size_t x, size_t y) : m_x (x), m_y (y),
    m_total (0), m_valid (0) {}
    size_t getx (void) const {
        return m_x;
    }
    size_t gety (void) const {
        return m_y;
    }
    size_t gettotal (void) const {
        return m_total;
    }
    size_t getvalid (void) const {
        return m_valid;
    }
    void stepright (void) {
        m_x++;
        remember (EDIR_RIGHT);
    }
    void stepdown (void) {
        m_y++;
        remember (EDIR_DOWN);
    }
    void stepleft (void) {
        m_x--;
        remember (EDIR_LEFT);
    }
    void stepup (void) {
        m_y--;
        remember (EDIR_UP);
    }
    void stepback (void) {
        switch (recall ()) {
            case EDIR_RIGHT:
                m_x--;
                break;
            case EDIR_DOWN:
                m_y--;
                break;
            case EDIR_LEFT:
                m_x++;
                break;
            case EDIR_UP:
                m_y++;
                break;
        }
    }
private:
    void remember (EDIR dir) {
        m_brain.push (dir);
        m_total++;
        m_valid++;
    }
    EDIR recall (void) {
        EDIR dir = m_brain.pop ();
        m_total++;
        m_valid--;
        return dir;
    }
    size_t m_x;
    size_t m_y;
    size_t m_total;
    size_t m_valid;
    Stack m_brain;
};
class Game {
public:
    Game (size_t width, size_t height) :
    m_width (width), m_height (height),
    m_maze (new char[width * height]),
    m_mouse (0, 1) {
        if (height < 3)
            throw invalid_argument ("The maze is too small！");
        srand (time (NULL));
        char (*maze)[width] = reinterpret_cast<char (*)[width]> (m_maze);**
        for (size_t i = 0; i < height; i++)
            for (size_t j = 0; j < width; j++)
                if (i == m_mouse.gety () &&
                    j == m_mouse.getx ())
                    maze[i][j] = MOUSE;
                else
                    if ((i == 1 && j < 4) ||
                        (i == height - 2 && j >width-5))
                        maze[i][j] = WAY;
                    else
                        if (i == 0 || i == height - 1 ||
                            j == 0 || j == width - 1)
                            maze[i][j] = WALL;
                        else
                            maze[i][j] =
                            rand () % 4 ? WAY : WALL;
    }
    ~Game (void) {
        if (m_maze) {
            delete[] m_maze;
            m_maze = NULL;
        }
    }
    void run (void) {
        for (show (); ! quit () && step (););
    }
private:
    void show (void) {
        char (*maze)[m_width] = reinterpret_cast<char (*)[m_width]> (m_maze);
        for (size_t i = 0; i < m_height; i++) {
            for (size_t j = 0; j < m_width; j++)
                cout << maze[i][j];
            cout << endl;
        }
        cout << "Total steps：" << m_mouse.gettotal ()
        << "，Valid steps：" << m_mouse.getvalid ()
        << endl;
    }
    bool quit (void) {
        cout << "Press<Q>to exit，Other keys to continue..."<<flush;
        int ch = getchar ();
        cout << endl;
        return ch == 'Q' || ch == 'q';
    }
    bool step (void) {
        char (*maze)[m_width] = reinterpret_cast<char (*)[m_width]> (m_maze);
        size_t x = m_mouse.getx ();
        size_t y = m_mouse.gety ();
        if (x + 1 <= m_width - 1 && maze[y][x + 1] == WAY) {
            maze[y][x] = PASS;
            m_mouse.stepright ();
        }
        else
            if (y + 1 <= m_height - 1 &&
                maze[y + 1][x] == WAY) {
                maze[y][x] = PASS;
                m_mouse.stepdown ();
            }
            else
                if (x - 1 >= 0 &&
                    maze[y][x - 1] == WAY) {
                    maze[y][x] = PASS;
                    m_mouse.stepleft ();
                }
                else
                    if (y - 1 >= 0 &&
                        maze[y - 1][x] == WAY) {
                        maze[y][x] = PASS;
                        m_mouse.stepup ();
                    }
                    else {
                        maze[y][x] = IMPASS;
                        m_mouse.stepback ();
                    }
        x = m_mouse.getx ();
        y = m_mouse.gety ();
        maze[y][x] = MOUSE;
        show ();
        if (x == 0 && y == 1) {
            cout << "I can't get out！cry~~~~" << endl;
            return false;
        }
        if (x == m_width - 1 && y == m_height - 2) {
            cout << "I am OUT！！！" << endl;
            return false;
        }
        return true;
    }
    size_t m_width;
    size_t m_height;
    char* m_maze;
    Mouse m_mouse;
};
int main (int argc, char* argv[]) {
    if (argc < 3) {
        cerr << "Method：" << argv[0] << " <width> <height>"
        << endl;
        return -1;
    }
    try {
        Game game (atoi (argv[1]), atoi (argv[2]));
        game.run ();
    }
    catch (exception& ex) {
        cout << ex.what () << endl;
        return -1;
    }
    return 0;
}

char (*maze)[width] = reinterpret_cast<char (*)[width]> (m_maze);

m_maze[y * width + x]

maze[y][x]