C++语言代码rip仿真器的实现

以下是一个简单的C++语言实现的RIP协议仿真器示例：

#include <iostream>
#include <vector>
#include <map>
#include <queue>
#include <climits>

using namespace std;

#define MAX_NODES 10
#define INFINITY INT_MAX

typedef struct {
    int dest;
    int distance;
} RoutingTableEntry;

class Router {
private:
    int id;
    map<int, int> neighbors; // neighbor id -> cost
    vector<RoutingTableEntry> routing_table;

public:
    Router(int id) {
        this->id = id;
        for (int i = 0; i < MAX_NODES; i++) {
            routing_table.push_back({i, INFINITY});
        }
        routing_table[id].distance = 0;
    }

    void add_neighbor(int neighbor_id, int cost) {
        neighbors[neighbor_id] = cost;
        routing_table[neighbor_id].distance = cost;
    }

    void send_routing_table(map<int, Router*>& routers) {
        for (auto& neighbor : neighbors) {
            int neighbor_id = neighbor.first;
            int cost = neighbor.second;
            vector<RoutingTableEntry> neighbor_routing_table = routers[neighbor_id]->get_routing_table();
            for (auto& entry : neighbor_routing_table) {
                int dest = entry.dest;
                int distance = entry.distance + cost;
                if (routing_table[dest].distance > distance) {
                    routing_table[dest].distance = distance;
                }
            }
        }
    }

    vector<RoutingTableEntry> get_routing_table() {
        return routing_table;
    }

    void print_routing_table() {
        cout << "Routing table for router " << id << ":" << endl;
        cout << "Destination\tDistance" << endl;
        for (auto& entry : routing_table) {
            if (entry.dest == id) {
                continue;
            }
            cout << entry.dest << "\t\t" << entry.distance << endl;
        }
    }
};

void simulate(map<int, Router*>& routers) {
    int num_iterations = 0;
    while (true) {
        num_iterations++;
        for (auto& router : routers) {
            router.second->send_routing_table(routers);
        }
        bool converged = true;
        for (auto& router : routers) {
            vector<RoutingTableEntry> old_routing_table = router.second->get_routing_table();
            router.second->send_routing_table(routers);
            vector<RoutingTableEntry> new_routing_table = router.second->get_routing_table();
            if (old_routing_table != new_routing_table) {
                converged = false;
            }
        }
        if (converged) {
            break;
        }
    }
    cout << "Converged in " << num_iterations << " iterations." << endl;
}

int main() {
    map<int, Router*> routers;
    for (int i = 0; i < MAX_NODES; i++) {
        routers[i] = new Router(i);
    }
    int num_edges;
    cout << "Enter the number of edges: ";
    cin >> num_edges;
    for (int i = 0; i < num_edges; i++) {
        int u, v, w;
        cout << "Enter edge #" << i + 1 << " (u v w): ";
        cin >> u >> v >> w;
        routers[u]->add_neighbor(v, w);
        routers[v]->add_neighbor(u, w);
    }
    simulate(routers);
    for (auto& router : routers) {
        router.second->print_routing_table();
    }
    return 0;
}

在该代码中，我们使用了一个 `Router` 类来表示每个节点，并使用邻接表来表示图。路由表使用了一个 `vector` 来存储每个目的地的距离。在仿真器中，我们通过 `map` 来存储每个节点，并使用 `simulate` 函数来模拟 RIP 协议的工作过程。在每个迭代中，我们首先让每个节点将自己的路由表发送给邻居节点，然后检查是否已经收敛。最后，我们打印出每个节点的路由表。