路由信息协议RIP（Routing Information Protocol）中，路由表更新的原则是找出到每个目的网络的最短距离，这种更新算法又称为距离向量算法。编程模拟这个路由算法，c++实现

以下是一个简单的 C++ 实现，模拟 RIP 路由算法：

#include <iostream>
#include <vector>
#include <map>
#include <limits>

using namespace std;

const int INF = numeric_limits<int>::max();

// 路由表项
struct RouteEntry {
    int dest;  // 目的网络
    int nextHop;  // 下一跳路由器
    int cost;  // 到目的网络的距离
};

// 路由器
class Router {
public:
    Router(int id) : id(id) {}

    // 添加一个邻居路由器
    void addNeighbor(int neighborId, int cost) {
        neighbors[neighborId] = cost;
    }

    // 更新路由表
    void updateRoutingTable(const vector<RouteEntry>& routes) {
        bool updated = false;
        for (const auto& entry : routes) {
            int dest = entry.dest;
            int cost = entry.cost + neighbors[entry.nextHop];  // 下一跳路由器到目的网络的距离
            if (cost < routingTable[dest].cost) {
                routingTable[dest] = { dest, entry.nextHop, cost };
                updated = true;
            }
        }
        if (updated) {
            cout << "Router " << id << " updated routing table:" << endl;
            printRoutingTable();
        }
    }

    // 打印路由表
    void printRoutingTable() const {
        cout << "Destination\tNext Hop\tCost" << endl;
        for (const auto& entry : routingTable) {
            cout << entry.second.dest << "\t\t"
                 << entry.second.nextHop << "\t\t"
                 << entry.second.cost << endl;
        }
    }

private:
    int id;  // 路由器 ID
    map<int, int> neighbors;  // 邻居路由器及其到该路由器的距离
    map<int, RouteEntry> routingTable;  // 路由表
};

int main() {
    // 构建拓扑
    Router r1(1);
    Router r2(2);
    Router r3(3);
    r1.addNeighbor(2, 1);
    r1.addNeighbor(3, 2);
    r2.addNeighbor(1, 1);
    r2.addNeighbor(3, 1);
    r3.addNeighbor(1, 2);
    r3.addNeighbor(2, 1);

    // 初始化路由表
    vector<RouteEntry> r1Routes = {
        { 1, 0, 0 },
        { 2, 2, INF },
        { 3, 3, INF }
    };
    vector<RouteEntry> r2Routes = {
        { 1, 1, INF },
        { 2, 0, 0 },
        { 3, 1, INF }
    };
    vector<RouteEntry> r3Routes = {
        { 1, 2, INF },
        { 2, 1, INF },
        { 3, 0, 0 }
    };
    r1.updateRoutingTable(r1Routes);
    r2.updateRoutingTable(r2Routes);
    r3.updateRoutingTable(r3Routes);

    // 模拟路由器之间的信息交换
    r1.updateRoutingTable(r2Routes);
    r1.updateRoutingTable(r3Routes);
    r2.updateRoutingTable(r1Routes);
    r2.updateRoutingTable(r3Routes);
    r3.updateRoutingTable(r1Routes);
    r3.updateRoutingTable(r2Routes);

    return 0;
}

该程序中，我们定义了一个 `Router` 类来表示一个路由器，其中包含了邻居路由器及其到该路由器的距离、路由表等信息。在 `updateRoutingTable` 方法中，我们遍历传入的路由表，根据距离向量算法更新路由表中的相应条目。当路由表发生变化时，我们打印出新的路由表。

在程序的开头，我们构建了一个小型的拓扑，并初始化了每个路由器的路由表。之后，我们模拟了路由器之间的信息交换，不断更新路由表，直到所有路由器的路由表不再发生变化。

该程序仅作为一个简单的示例，实际上 RIP 路由算法还有很多细节需要考虑，比如如何处理网络拓扑中的环路、如何处理链路状态发生变化等等。