我想用C++来写一个程序，要求如下：迷宫问题求解 给定一个M×N的迷宫图、入口与出口、行走规则。求一条从指定入口到出口的路径。所求路径必须是简单路径，即路径不重复。使用栈的结构完成。

好的，这是一个很经典的迷宫问题，需要使用深度优先搜索算法和栈的数据结构来解决。下面是一个基本的思路：

1.定义一个栈，用于存储走过的路径。
2.从入口开始，按照规则依次尝试向上、向右、向下、向左四个方向前进。
3.如果前进的方向可以走，就将该方向的位置入栈，并将当前位置更新为该方向的位置。
4.如果前进的方向已经走过，或者是墙，就回溯到上一个位置，继续尝试其他方向。
5.如果最终能够到达出口，就将栈中的路径输出即可。

下面是一个简单的 C++ 代码示例，请参考：

#include <iostream>
#include <stack>
using namespace std;

const int MAX_SIZE = 100;
int maze[MAX_SIZE][MAX_SIZE]; // 迷宫
int visited[MAX_SIZE][MAX_SIZE]; // 标记是否访问过
stack<pair<int, int>> path; // 存储路径

// M 行 N 列，入口为 (startX, startY)，出口为 (endX, endY)
void dfs(int startX, int startY, int endX, int endY, int M, int N) {
    path.push(make_pair(startX, startY));
    visited[startX][startY] = 1;

    if (startX == endX && startY == endY) { // 到达出口
        // 输出路径
        cout << "Path: ";
        stack<pair<int, int>> tmp; // 用于反转路径
        while (!path.empty()) {
            pair<int, int> p = path.top();
            path.pop();
            tmp.push(p);
        }
        while (!tmp.empty()) {
            pair<int, int> p = tmp.top();
            tmp.pop();
            cout << "(" << p.first << ", " << p.second << ") ";
        }
        cout << endl;
        return;
    }
    
    // 尝试向上走
    if (startX > 0 && maze[startX-1][startY] == 0 && visited[startX-1][startY] == 0) {
        dfs(startX-1, startY, endX, endY, M, N);
        visited[startX-1][startY] = 0; // 回溯
        path.pop();
    }
    // 尝试向右走
    if (startY < N-1 && maze[startX][startY+1] == 0 && visited[startX][startY+1] == 0) {
        dfs(startX, startY+1, endX, endY, M, N);
        visited[startX][startY+1] = 0; // 回溯
        path.pop();
    }
    // 尝试向下走
    if (startX < M-1 && maze[startX+1][startY] == 0 && visited[startX+1][startY] == 0) {
        dfs(startX+1, startY, endX, endY, M, N);
        visited[startX+1][startY] = 0; // 回溯
        path.pop();
    }
    // 尝试向左走
    if (startY > 0 && maze[startX][startY-1] == 0 && visited[startX][startY-1] == 0) {
        dfs(startX, startY-1, endX, endY, M, N);
        visited[startX][startY-1] = 0; // 回溯
        path.pop();
    }
}

int main() {
    int M, N;
    int startX, startY, endX, endY;

    cout << "请输入迷宫的行数和列数：";
    cin >> M >> N;
    cout << "请输入迷宫（0表示可以通过，1表示墙）：" << endl;
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++) {
            cin >> maze[i][j];
        }
    }
    cout << "请输入入口坐标：";
    cin >> startX >> startY;
    cout << "请输入出口坐标：";
    cin >> endX >> endY;

    dfs(startX, startY, endX, endY, M, N);
    
    return 0;
}

注意，这个代码示例只是一个基本的框架，还有很多细节需要考虑，比如边界检查、非法输入检查、路径是否存在等等。另外，如果迷宫比较大，使用递归的方式实现深度优先搜索可能会导致栈溢出，这时可以考虑使用迭代的方式来实现。