用C++编写迷宫求解可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的 路径，并将路径输出。

好的，这是一个比较典型的迷宫求解问题。我来为您讲解一下具体思路，然后给出一份 C++ 代码。

1.问题分析

首先，我们需要了解迷宫的数据结构。假设迷宫是一个 N 行 M 列的矩阵，其中 0 表示可以通过的路，1 表示障碍物不可通过。我们需要从起点 (start_x, start_y) 出发，走到终点 (end_x, end_y)。我们可以用一个二维数组 maze 存储迷宫，用一个二维数组 path 存储路径，用一个栈 stack 存储路径上的点。初始时，将起点 push 进栈中。

接下来，我们需要使用非递归的方法来求解迷宫。我们可以采用深度优先搜索的思路，在每个可达的点上继续深度搜索，直到搜索到终点或者所有的可达点都已经被搜索过。

具体的步骤如下：

1.初始化 maze、path、stack，将起点 push 进栈中。

2.当栈不为空时，取出栈顶元素，并将该点标记为已访问。

3.如果该点是终点，则输出路径，结束程序。

4.否则，将该点的可达点 push 进栈中，继续搜索。

5.如果栈为空，说明没有找到路径，结束程序。

需要注意的是，使用非递归的方法进行深度优先搜索时，需要手动维护栈。而且，为了避免重复访问已经访问过的点，我们需要在 maze 中将已经访问过的点标记为障碍物。

2.C++代码

下面是一份使用 C++ 实现的迷宫求解代码，供您参考：

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

const int MAXN = 100;

int n, m;
int maze[MAXN][MAXN];
int path[MAXN][MAXN];

struct Point {
    int x, y;
    Point(int _x, int _y) : x(_x), y(_y) {}
};

vector<Point> dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

void printPath() {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cout << path[i][j] << " ";
        }
        cout << endl;
    }
}

void solve() {
    stack<Point> s;
    s.push(Point(0, 0));
    while (!s.empty()) {
        Point cur = s.top();
        s.pop();
        if (cur.x == n - 1 && cur.y == m - 1) {
            // find the path
            printPath();
            return;
        }
        for (int i = 0; i < dirs.size(); i++) {
            Point next(cur.x + dirs[i].x, cur.y + dirs[i].y);
            if (next.x < 0 || next.x >= n || next.y < 0 || next.y >= m) {
                continue;
            }
            if (maze[next.x][next.y] == 0) {
                // not visited
                s.push(next);
                maze[next.x][next.y] = 1; // mark visited
                path[next.x][next.y] = path[cur.x][cur.y] + 1;
            }
        }
    }
}

int main() {
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> maze[i][j];
            path[i][j] = -1;
        }
    }
    path[0][0] = 0;
    solve();
    return 0;
}

上述代码的时间复杂度为 $O(nm)$，其中 n 和 m 分别表示迷宫的行数和列数。