C++基于类设计一个随机二维环境的最短路规划程序，包括： 1） 随机产生二维障碍物环境，包括路径随机起点、终点，以及障碍物和边界信息 2） 设计算法，实现从起点到终点的最短路径的求解。

好的，下面是一个基于类设计的随机二维环境的最短路规划程序的示例代码，其中使用了BFS算法求解最短路径问题。

#include <iostream>
#include <queue>
#include <vector>
#include <ctime>
#include <cstdlib>

using namespace std;

class Point {
public:
    int x, y;
    Point(int x = 0, int y = 0) : x(x), y(y) {}
};

class Maze {
public:
    Maze(int n = 10, int m = 10, int p = 20) : n(n), m(m), p(p) {
        maze = new int*[n];
        for(int i = 0; i < n; i++) {
            maze[i] = new int[m];
            for(int j = 0; j < m; j++) {
                if(i == 0 || i == n-1 || j == 0 || j == m-1 || rand()%100 < p)
                    maze[i][j] = 1;
                else
                    maze[i][j] = 0;
            }
        }
        start = Point(rand()%(n-2)+1, rand()%(m-2)+1);
        end = Point(rand()%(n-2)+1, rand()%(m-2)+1);
        while(maze[start.x][start.y] || maze[end.x][end.y] || start.x == end.x || start.y == end.y) {
            start = Point(rand()%(n-2)+1, rand()%(m-2)+1);
            end = Point(rand()%(n-2)+1, rand()%(m-2)+1);
        }
    }
    ~Maze() {
        for(int i = 0; i < n; i++)
            delete[] maze[i];
        delete[] maze;
    }
    void print() {
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                if(i == start.x && j == start.y)
                    cout << "S ";
                else if(i == end.x && j == end.y)
                    cout << "E ";
                else if(maze[i][j])
                    cout << "# ";
                else
                    cout << ". ";
            }
            cout << endl;
        }
    }
    bool is_valid(Point p) {
        if(p.x < 0 || p.x >= n || p.y < 0 || p.y >= m || maze[p.x][p.y])
            return false;
        return true;
    }
    int bfs() {
        queue<Point> q;
        vector<vector<int> > dist(n, vector<int>(m, -1));
        q.push(start);
        dist[start.x][start.y] = 0;
        while(!q.empty()) {
            Point p = q.front();
            q.pop();
            if(p.x == end.x && p.y == end.y)
                return dist[p.x][p.y];
            int dx[] = {-1, 0, 1, 0};
            int dy[] = {0, 1, 0, -1};
            for(int i = 0; i < 4; i++) {
                Point np(p.x+dx[i], p.y+dy[i]);
                if(is_valid(np) && dist[np.x][np.y] == -1) {
                    q.push(np);
                    dist[np.x][np.y] = dist[p.x][p.y] + 1;
                }
            }
        }
        return -1;
    }
private:
    int n, m, p;
    int **maze;
    Point start, end;
};

int main() {
    srand(time(NULL));
    Maze maze;
    maze.print();
    int steps = maze.bfs();
    if(steps != -1)
        cout << "Shortest path: " << steps << endl;
    else
        cout << "No path found!" << endl;
    return 0;
}

在这个示例代码中，`Maze`类表示一个随机生成的二维环境，包括障碍物和起点、终点等信息。在构造函数中，使用随机数生成器生成障碍物和起点、终点等信息。在`print`函数中，输出当前环境的信息。在`is_valid`函数中，判断一个点是否是一个合法的位置。在`bfs`函数中，使用BFS算法遍历所有可能的路径，找到最短路径的长度。

在主函数中，首先使用随机数生成器生成一个随机的二维环境，并输出当前环境的信息。然后使用`bfs`函数求解最短路径问题，并输出最短路径的长度。

这是一个简单的随机二维环境的最短路规划程序的示例代码，可以作为你参考的思路。如果你有任何问题和困惑，也可以随时向我提问。