用C++代码实现：理解并实现无向图邻接矩阵的创建，理解并实现无向图邻接矩阵方式存储的广度优先遍历的算法，转换成程序并上机实现； //用两个数组分别存储顶点表和邻接矩阵 #define MaxInt 32767 //表示极大值，即∞ #define MVNum 100 //最大顶点数 typedef char VerTexType; //假设顶点的数据类型为字符型 typedef int ArcType; //假设边的权值类型为整型 typedef struct{ VerTexType vexs[MVNum]; //顶点表 ArcType arcs[MVNum][MVNum]; //邻接矩阵 int vexnum,arcnum; //图的当前点数和边数 }AMGraph;

以下是C++代码实现：

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

#define MaxInt 32767
#define MVNum 100

typedef char VerTexType;
typedef int ArcType;

typedef struct{
    VerTexType vexs[MVNum];
    ArcType arcs[MVNum][MVNum];
    int vexnum, arcnum;
}AMGraph;

void CreateUDN(AMGraph &G) {
    cout << "请输入顶点数和边数：" << endl;
    cin >> G.vexnum >> G.arcnum;
    cout << "请输入顶点信息：" << endl;
    for(int i = 0; i < G.vexnum; i++) {
        cin >> G.vexs[i];
    }
    for(int i = 0; i < G.vexnum; i++) {
        for(int j = 0; j < G.vexnum; j++) {
            G.arcs[i][j] = MaxInt;
        }
    }
    cout << "请输入边的信息：" << endl;
    for(int k = 0; k < G.arcnum; k++) {
        int i, j, w;
        cin >> i >> j >> w;
        G.arcs[i][j] = w;
        G.arcs[j][i] = w;
    }
}

void BFS(AMGraph G, int v, bool visited[]) {
    queue<int> q;
    cout << G.vexs[v] << " ";
    visited[v] = true;
    q.push(v);
    while(!q.empty()) {
        int w = q.front();
        q.pop();
        for(int i = 0; i < G.vexnum; i++) {
            if(G.arcs[w][i] != MaxInt && !visited[i]) {
                cout << G.vexs[i] << " ";
                visited[i] = true;
                q.push(i);
            }
        }
    }
}

void BFSTraverse(AMGraph G) {
    bool visited[MVNum] = {false};
    for(int i = 0; i < G.vexnum; i++) {
        if(!visited[i]) {
            BFS(G, i, visited);
        }
    }
}

int main() {
    AMGraph G;
    CreateUDN(G);
    cout << "广度优先遍历结果：" << endl;
    BFSTraverse(G);
    return 0;
}

在这段代码中，我们使用了一个邻接矩阵来存储无向图，包括顶点表和邻接矩阵两个数组。函数 `CreateUDN` 可以创建一个无向图，并且使用了一个二维数组 `arcs` 来存储边的权值。

函数 `BFS` 实现了广度优先遍历算法，使用了一个队列来存储需要遍历的顶点。函数 `BFSTraverse` 则是对整个图进行了广度优先遍历。

在 `main` 函数中，我们先创建了一个无向图，然后调用 `BFSTraverse` 函数进行广度优先遍历，并输出结果。