RIP协议C语言实现.docx

RIP协议C语言实现.docx

《RIP协议C语言实现.docx》由会员分享，可在线阅读，更多相关《RIP协议C语言实现.docx（15页珍藏版）》请在冰豆网上搜索。

RIP协议C语言实现

RIP协议的C++实现

班级：

xxxxxxx

学号：

xxxxxxxxxx

姓名：

xxxx

xxxx.x.xx

一、RIP协议距离向量算法原理

RIP的距离向量算法如下，当收到相邻路由器（其地址为X）的一个RIP报文时

（1）先修改此RIP报文中的所有项目：

将下一跳字段中的地址都改为X，并将所有的距离字段值加1；

（2）对修改后的RIP报文中的每一个项目重复如下步骤：

若项目中的目的网络不在路由表中，则将该项目加到路由表中。

否则，若下一跳字段给出的路由器地址相同，则将收到的项目替换原路由表中的项目。

否则，若收到的项目中的距离小于路由表中的距离，则进行更新。

否则，什么都不做；

（3）若3分钟还没有收到相邻路由器的更新路由表，则将此相邻路由器记为不可达的路由器，即将距离置为16（距离为16表示不可达）；

（4）返回。

RIP让互联网中所有的路由器都和各自的相邻路由器不断交换并更新路由信息，最终可以使得每个路由器到到每个目的网络的距离最短。

总之，RIP的优点是算法简单，但是RIP不适应大网络，也不适应变化剧烈的网络环境。

从RIP算法的分析中可以发现其特点是“好消息传得快，坏消息传的慢”，这意味着当网络出现故障时，信息要经过较长时间才能通知到网内所有的路由器。

二、RIP协议基于C++的实现

2.1程序流程图

2.2需要生成的网络示意图

即输入程序用的txt文件内容如下

id1R1R5

id2R1R4

id3R1R2

id4R2R3

id5R5R6

id6R3R6

2.3程序运行结果

输入写好的网络信息txt文件route

更新前的路由表信息

更新路由表中

更新后的路由表信息

2.4程序代码

#include

#include

#include

#include

#include

usingnamespacestd;

#defineMAX100

classNet_sec;

//路由类相当于头结点

classRoute{

public:

stringroute;

Net_sec*next;

};

//网段类，包含相邻弧的信息（不用route_f，用next）,也可用于存储文件读入信息（用route_f，不用next）

classNet_sec{

public:

stringnet_id;

stringroute_f;

stringroute_n;

Net_sec*next;

};

//路由表内容类

classContents{

public:

stringnet_id;

intdiatance;

stringnext_stop;

};

/*

********************

上面是存储类型的三个类

********************

*/

//路由表和网段类

classRoute_net{

public:

voidopen_file（ifstream&infile）;

Route_net（）;

booljudge（stringstr）;

voidInit_routes（）;

voidshow（）;

voidchange（inti）;

voidupdate（inti）;

voidUPDATE（）;

boolneighbor（inti,intj）;//j和i相邻吗

private:

listli;//读取信息存储在这

Routeroute[MAX];//存储图的信息，即各路由的邻接表

listroutes[MAX];//存储各路由路由表

listtemp;//用于存储处理后的临时路由表

stringflection[MAX];//用于对应路由器与存储序列标号

intsum;//用于统计路由个数

};

//打开文件函数

voidRoute_net:

:

open_file（ifstream&infile）{

stringfilename;

cout<<"enterthenameofthefilewhichcontainsinformationofroutesandnetworksection:

";

cin>>filename;

infile.open（（filename+".txt"）.c_str（））;

if（!

infile）{

cerr<<"fileopenerror!

"<

exit

（1）;

}

}

//构造函数

Route_net:

:

Route_net（）{

ifstreaminfile;

istringstreamstrm;

stringa_line;

Net_sect1;

open_file（infile）;

while（getline（infile,a_line））{

strm.str（a_line）;

strm>>_id>>t1.route_f>>t1.route_n;

li.push_back（t1）;

strm.clear（）;

}

//以上把文件内容存入了类属性li中

list:

:

iteratorit1=li.begin（）,it2;

inti=0;

Net_sec*t2,*t3;

for（;it1!

=li.end（）;it1++）{

if（judge（（*it1）.route_f））{

flection[i]=（*it1）.route_f;

route[i].route=flection[i];

t3=t2=route[i].next=newNet_sec（）;

for（it2=li.begin（）;it2!

=li.end（）;it2++）{

if（flection[i]==（*it2）.route_f）{

t2->net_id=（*it2）.net_id;

t2->route_n=（*it2）.route_n;

t3=t2;

t2->next=newNet_sec（）;

t2=t2->next;

}

if（flection[i]==（*it2）.route_n）{

t2->net_id=（*it2）.net_id;

t2->route_n=（*it2）.route_f;

t3=t2;

t2->next=newNet_sec（）;

t2=t2->next;

}

}

t3->next=NULL;

i++;

}

if（judge（（*it1）.route_n））{

flection[i]=（*it1）.route_n;

route[i].route=flection[i];

t3=t2=route[i].next=newNet_sec（）;

for（it2=li.begin（）;it2!

=li.end（）;it2++）{

if（flection[i]==（*it2）.route_f）{

t2->net_id=（*it2）.net_id;

t2->route_n=（*it2）.route_n;

t3=t2;

t2->next=newNet_sec（）;

t2=t2->next;

}

if（flection[i]==（*it2）.route_n）{

t2->net_id=（*it2）.net_id;

t2->route_n=（*it2）.route_f;

t3=t2;

t2->next=newNet_sec（）;

t2=t2->next;

}

}

t3->next=NULL;

i++;

}

}

sum=i;

route[i].next=NULL;

//网络拓扑图的邻接表表示法

}

//判断一个路由是否已为其添加了路由表

boolRoute_net:

:

judge（stringstr）{

inti=0;

while（flection[i]!

=""&&i

i++;

if（str==flection[i]）

returnfalse;

}

returntrue;

}

//初始化各路由表

voidRoute_net:

:

Init_routes（）{

inti=0;

Net_sec*t;

Contentsp;

for（;route[i].next!

=NULL;i++）

for（t=route[i].next;t!

=NULL;t=t->next）{

p.diatance=1;

_id=t->net_id;

p.next_stop="直接交付";

routes[i].push_back（p）;

}

}

//显示各路由表

voidRoute_net:

:

show（）{

inti=0;

list:

:

iteratorp;

for（;i

cout<<"Thisisthetableof"<

for（p=routes[i].begin（）;p!

=routes[i].end（）;p++）

cout<<（*p）.net_id<<""<<（*p）.diatance

<<""<<（*p）.next_stop<

}

}

//对相邻路由表change一下，距离加1，下一跳变为该路由名字

voidRoute_net:

:

change（inti）{

Contentsco;

temp.erase（temp.begin（）,temp.end（））;

list:

:

iteratorp=routes[i].begin（）;

for（;p!

=routes[i].end（）;p++）{

co.diatance=（*p）.diatance+1;

_id=（*p）.net_id;

co.next_stop=flection[i];

temp.push_back（co）;

}

}

//对一个路由进行更新操作

voidRoute_net:

:

update（inti）{

intcount=0;

list:

:

iteratorit1=routes[i].begin（）;

list:

:

iteratorit2=temp.begin（）;

for（;it2!

=temp.end（）;it2++）{

for（it1=routes[i].begin（）;it1!

=routes[i].end（）;it1++）{

if（（*it1）.net_id==（*it2）.net_id）{

count++;

if（（（*it1）.next_stop）==（（*it2）.next_stop））{

（*it1）.diatance=（*it2）.diatance;

（*it1）.next_stop=（*it2）.next_stop;

}

if（（（*it1）.next_stop!

=（*it2）.next_stop）&&（（*it1）.diatance>（*it2）.diatance））{

（*it1）.diatance=（*it2）.diatance;

（*it1）.next_stop=（*it2）.next_stop;

}

}

}

if（count==0）

routes[i].push_back（*it2）;

count=0;

}

}

//对所有路由进行更新路由表操作

voidRoute_net:

:

UPDATE（）{

intj=0,i=0,I;

for（I=0;I

for（j=0;j

for（i=0;i

if（neighbor（j,i））{

change（i）;

update（j）;

}

}

}

cout<<"Thisisthe"<

}

}

//判断两路由是否相邻

boolRoute_net:

:

neighbor（inti,intj）{

Net_sec*p=route[i].next;

for（;p!

=NULL;p=p->next）

if（flection[j]==p->route_n）

returntrue;

returnfalse;

}

intmain（）{

Route_netroute_net;

route_net.Init_routes（）;

route_net.show（）;

route_net.UPDATE（）;

route_net.show（）;

return0;

}