c++关于局域网，路由器。

最新推荐文章于 2025-06-20 09:01:38 发布
原创 最新推荐文章于 2025-06-20 09:01:38 发布 · 1.7k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #udp

重启路由器：qt5.8

#include <stdio.h>
#include <winsock2.h>
#include <QDebug>
#pragma comment( lib , "ws2_32" )
int main()
{
    char  Fs[1000];
    char  Js[1000];

    WSADATA   wsadata;
    SOCKET    Socket;
    SOCKADDR_IN   Local, to;

    {
        WSAStartup( 0x0202, &wsadata );
    }
    Socket = socket( AF_INET, SOCK_STREAM, 0 );
    if (!Socket)
    {
        return -1;
    }

    Local.sin_family  =  AF_INET;
    Local.sin_port    =  htons(102);
    Local.sin_addr.S_un.S_addr  =  htonl(INADDR_ANY);

    to.sin_family     =  AF_INET;
    to.sin_port       =  htons(80);
    to.sin_addr.S_un.S_addr  =  inet_addr("192.168.1.1");

    if (bind(Socket, (SOCKADDR*)&Local, sizeof(Local)) == SOCKET_ERROR)
    {
        return -1;
    }
    if (connect(Socket, (SOCKADDR*)&to, sizeof(SOCKADDR)) == SOCKET_ERROR)
    {
        return -1;
    }
    {
        memset(Fs, 0, 1000);
        memset(Js, 0, 1000);

        strcpy(Fs, "GET /userRpm/SysRebootRpm.htm?Reboot=%D6%D8%C6%F4%C2%B7%D3%C9%C6%F7 HTTP/1.1\r\n" );
        strcat(Fs, "Host: 192.168.1.1\r\n" );
        strcat(Fs, "Authorization: Basic YWRtaW46YWRtaW4=\r\n" );
        strcat(Fs, "\r\n");
    }
    if (send(Socket, Fs, strlen(Fs), 0) == SOCKET_ERROR)
    {
        return -1;
    }
    closesocket(Socket);
    WSACleanup();
    qDebug()<<"sssss";
    return 0;
}

c++获取路由表：

// libnet.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <stdio.h>  
#include <windows.h>  
#include <Iphlpapi.h>  

#pragma comment(lib, "Iphlpapi.lib")  
#pragma comment(lib, "WS2_32.lib")  


PMIB_IPFORWARDTABLE MyGetIpForwardTable(BOOL bOrder);
void MyFreeIpForwardTable(PMIB_IPFORWARDTABLE pIpRouteTab);
void PrintIpForwardTable();



int main()
{
	PrintIpForwardTable();
	getchar();
	return 0;
}

void PrintIpForwardTable()
{
	PMIB_IPFORWARDTABLE pIpRouteTable = MyGetIpForwardTable(TRUE);
	if (pIpRouteTable != NULL)
	{
		DWORD i, dwCurrIndex;
		struct in_addr inadDest;
		struct in_addr inadMask;
		struct in_addr inadGateway;
		PMIB_IPADDRTABLE pIpAddrTable = NULL;

		char szDestIp[128];
		char szMaskIp[128];
		char szGatewayIp[128];

		printf("Active Routes:\n\n");

		printf("  Network Address          Netmask  Gateway Address        Interface  Metric\n");
		for (i = 0; i < pIpRouteTable->dwNumEntries; i++)
		{
			dwCurrIndex = pIpRouteTable->table[i].dwForwardIfIndex;

			// 目的地址  
			inadDest.s_addr = pIpRouteTable->table[i].dwForwardDest;
			// 子网掩码  
			inadMask.s_addr = pIpRouteTable->table[i].dwForwardMask;
			// 网关地址  
			inadGateway.s_addr = pIpRouteTable->table[i].dwForwardNextHop;

			strcpy(szDestIp, inet_ntoa(inadDest));
			strcpy(szMaskIp, inet_ntoa(inadMask));
			strcpy(szGatewayIp, inet_ntoa(inadGateway));
			printf("  %15s %16s %16s %16d %7d\n",
				szDestIp,
				szMaskIp,
				szGatewayIp,
				pIpRouteTable->table[i].dwForwardIfIndex,    // 可以在此调用GetIpAddrTable获取索引对应的IP地址  
				pIpRouteTable->table[i].dwForwardMetric1);
		}
		MyFreeIpForwardTable(pIpRouteTable);
	}
}

PMIB_IPFORWARDTABLE MyGetIpForwardTable(BOOL bOrder)
{
	PMIB_IPFORWARDTABLE pIpRouteTab = NULL;
	DWORD dwActualSize = 0;

	// 查询所需缓冲区的大小  
	if (::GetIpForwardTable(pIpRouteTab, &dwActualSize, bOrder) == ERROR_INSUFFICIENT_BUFFER)
	{
		// 为MIB_IPFORWARDTABLE结构申请内存  
		pIpRouteTab = (PMIB_IPFORWARDTABLE)::GlobalAlloc(GPTR, dwActualSize);
		// 获取路由表  
		if (::GetIpForwardTable(pIpRouteTab, &dwActualSize, bOrder) == NO_ERROR)
			return pIpRouteTab;
		::GlobalFree(pIpRouteTab);
	}
	return NULL;
}

void MyFreeIpForwardTable(PMIB_IPFORWARDTABLE pIpRouteTab)
{
	if (pIpRouteTab != NULL)
		::GlobalFree(pIpRouteTab);
}

本机流量监控类：

MFNetTraffic.h

#ifndef MFNetTraffic_H
#define MFNetTraffic_H
#if !defined(AFX_MFNETTRAFFIC_H__9CA9C41F_F929_4F26_BD1F_2B5827090494__INCLUDED_)  
#define AFX_MFNETTRAFFIC_H__9CA9C41F_F929_4F26_BD1F_2B5827090494__INCLUDED_  
#if _MSC_VER > 1000  
#pragma once  
#endif // _MSC_VER > 1000  
#include <afxtempl.h>  
class MFNetTraffic
{
public:
	enum TrafficType //流量类型  
	{
		AllTraffic = 388,//总的流量  
		IncomingTraffic = 264,//输入流量  
		OutGoingTraffic = 506 //输出流量  
	};
	void    SetTrafficType(int trafficType);        //设置流量类型  
	DWORD   GetInterfaceTotalTraffic(int index);    //得到index索引接口的总流量  
	BOOL    GetNetworkInterfaceName(CString *InterfaceName, int index);//得到网络接口名字  
	int     GetNetworkInterfacesCount();            //得到接口的数目  
	double  GetTraffic(int interfaceNumber);        //得到流量  
	DWORD   GetInterfaceBandwidth(int index);       //得到index索引接口的带宽  
	MFNetTraffic();
	virtual ~MFNetTraffic();

private:
	BOOL        GetInterfaces();
	double      lasttraffic;
	CStringList Interfaces;
	CList < DWORD, DWORD &>       Bandwidths; //带宽  
	CList < DWORD, DWORD &>       TotalTraffics;//总的流量  
	int CurrentInterface;
	int CurrentTrafficType;
};
#endif // !defined(AFX_MFNETTRAFFIC_H__9CA9C41F_F929_4F26_BD1F_2B5827090494__INCLUDED_)  
#endif // CARMODEL_H

MFNetTraffic.cpp

#include "stdafx.h"
#include "MFNetTraffic.h"  
#include "float.h"  
#ifdef _DEBUG  
#undef THIS_FILE  
static char THIS_FILE[] = __FILE__;
#define new DEBUG_NEW  
#endif  
#include "winperf.h"  
MFNetTraffic::MFNetTraffic()
{
	lasttraffic = 0.0;
	CurrentInterface = -1;
	CurrentTrafficType = AllTraffic;
	GetInterfaces();
}
MFNetTraffic::~MFNetTraffic()
{

}
PERF_OBJECT_TYPE *FirstObject(PERF_DATA_BLOCK *dataBlock)
{
	return (PERF_OBJECT_TYPE *)((BYTE *)dataBlock + dataBlock->HeaderLength);
}
PERF_OBJECT_TYPE *NextObject(PERF_OBJECT_TYPE *act)
{
	return (PERF_OBJECT_TYPE *)((BYTE *)act + act->TotalByteLength);
}
PERF_COUNTER_DEFINITION *FirstCounter(PERF_OBJECT_TYPE *perfObject)
{
	return (PERF_COUNTER_DEFINITION *)((BYTE *)perfObject + perfObject->HeaderLength);
}
PERF_COUNTER_DEFINITION *NextCounter(PERF_COUNTER_DEFINITION *perfCounter)
{
	return (PERF_COUNTER_DEFINITION *)((BYTE *)perfCounter + perfCounter->ByteLength);
}
PERF_COUNTER_BLOCK *GetCounterBlock(PERF_INSTANCE_DEFINITION *pInstance)
{
	return (PERF_COUNTER_BLOCK *)((BYTE *)pInstance + pInstance->ByteLength);
}
PERF_INSTANCE_DEFINITION *FirstInstance(PERF_OBJECT_TYPE *pObject)
{
	return (PERF_INSTANCE_DEFINITION *)((BYTE *)pObject + pObject->DefinitionLength);
}
PERF_INSTANCE_DEFINITION *NextInstance(PERF_INSTANCE_DEFINITION *pInstance)
{
	PERF_COUNTER_BLOCK  *pCtrBlk = GetCounterBlock(pInstance);
	return (PERF_INSTANCE_DEFINITION *)((BYTE *)pInstance + pInstance->ByteLength + pCtrBlk->ByteLength);
}
char *WideToMulti(wchar_t *source, char *dest, int size)
{
	WideCharToMultiByte(CP_ACP, 0, source, -1, dest, size, 0, 0);
	return dest;
}



//得到接口号为interfaceNumber的接口流量  
double MFNetTraffic::GetTraffic(int interfaceNumber)
{
	try
	{
#define DEFAULT_BUFFER_SIZE 40960L  
		POSITION pos;
		CString InterfaceName;
		pos = Interfaces.FindIndex(interfaceNumber);
		if (pos == NULL)
			return 0.0;
		//得到当前的接口名字  
		InterfaceName = Interfaces.GetAt(pos);
		//为性能数据缓冲  
		unsigned char *data = new unsigned char[DEFAULT_BUFFER_SIZE];
		// 从RegQueryValueEx返回的值:本例中忽略改变量  
		DWORD type;
		// 缓冲的尺寸  
		DWORD size = DEFAULT_BUFFER_SIZE;
		// RegQueryValueEx返回的值  
		DWORD ret;
		// 从网络对象(索引是510)查询性能数据  
		while ((ret = RegQueryValueEx(HKEY_PERFORMANCE_DATA, L"510", NULL, &type, data, &size)) != ERROR_SUCCESS)
		{
			if (ret == ERROR_MORE_DATA)
			{
				// 缓冲尺寸太小，增加内存分配  
				size += DEFAULT_BUFFER_SIZE;
				delete[] data;
				data = new unsigned char[size];
			}
			else
			{
				// 未定义的错误  
				return 1;
			}
		}
		//性能数据块  
		PERF_DATA_BLOCK *dataBlockPtr = (PERF_DATA_BLOCK *)data;
		//枚举链表中第一个对象  
		PERF_OBJECT_TYPE *objectPtr = FirstObject(dataBlockPtr);
		//遍历链表   
		for (int a = 0; a<(int)dataBlockPtr->NumObjectTypes; a++)
		{
			char nameBuffer[255];
			// 判断是否是网络对象索引号是510  
			if (objectPtr->ObjectNameTitleIndex == 510)
			{
				// 偏移变量  
				DWORD processIdOffset = ULONG_MAX;
				// 找到第一个计数器  
				PERF_COUNTER_DEFINITION *counterPtr = FirstCounter(objectPtr);
				// 遍历链表  
				for (int b = 0; b<(int)objectPtr->NumCounters; b++)
				{
					// 判断接收的数据类型是否是我们需要的  
					if ((int)counterPtr->CounterNameTitleIndex == CurrentTrafficType)
						processIdOffset = counterPtr->CounterOffset;
					// 下一个计数器  
					counterPtr = NextCounter(counterPtr);
				}
				//数据类型不是我们需要的  
				if (processIdOffset == ULONG_MAX) {
					delete[] data;
					return 1;
				}
				// 找到第一个实列(instance)  
				PERF_INSTANCE_DEFINITION *instancePtr = FirstInstance(objectPtr);
				DWORD fullTraffic;
				DWORD traffic;
				//遍历整个实列  
				for (int b = 0; b<objectPtr->NumInstances; b++)
				{
					wchar_t *namePtr = (wchar_t *)((BYTE *)instancePtr + instancePtr->NameOffset);
					// 得到这个实列的PERF_COUNTER_BLOCK  
					PERF_COUNTER_BLOCK *counterBlockPtr = GetCounterBlock(instancePtr);
					// 现在我们得到了接口的名字  
					char *pName = WideToMulti(namePtr, nameBuffer, sizeof(nameBuffer));
					CString iName;
					wchar_t str_s[20] = { L"%s" };
					iName.Format(str_s, pName);
					POSITION pos = TotalTraffics.FindIndex(b);
					if (pos != NULL)
					{
						fullTraffic = *((DWORD *)((BYTE *)counterBlockPtr + processIdOffset));
						TotalTraffics.SetAt(pos, fullTraffic);
					}
					// 如果当前的接口就是我们选择的接口  
					if (InterfaceName == iName)
					{
						traffic = *((DWORD *)((BYTE *)counterBlockPtr + processIdOffset));
						double acttraffic = (double)traffic;
						double trafficdelta;
						// 判断处理的接口是否是新的  
						if (CurrentInterface != interfaceNumber)
						{
							lasttraffic = acttraffic;
							trafficdelta = 0.0;
							CurrentInterface = interfaceNumber;
						}
						else
						{
							trafficdelta = acttraffic - lasttraffic;
							lasttraffic = acttraffic;
						}
						delete[] data;
						return(trafficdelta);
					}
					//下一个实列  
					instancePtr = NextInstance(instancePtr);
				}
			}
			// 下一个对象  
			objectPtr = NextObject(objectPtr);
		}
		delete[] data;
		return 0;
	}
	catch (...)
	{
		return 0;
	}
}


//枚举安装的接口  
BOOL MFNetTraffic::GetInterfaces()
{
	try
	{
#define DEFAULT_BUFFER_SIZE 40960L  

		Interfaces.RemoveAll();
		unsigned char *data = (unsigned char*)malloc(DEFAULT_BUFFER_SIZE);
		DWORD type;
		DWORD size = DEFAULT_BUFFER_SIZE;
		DWORD ret;
		char s_key[4096];
		sprintf(s_key, "%d", 510);
		WCHAR wszClassName[256] = { 0 };//定义宽字符缓冲区
		memset(wszClassName, 0, sizeof(wszClassName));
		MultiByteToWideChar(CP_ACP, 0, s_key, strlen(s_key) + 1,
			wszClassName,
			sizeof(wszClassName) / sizeof(wszClassName[0]));
		//RegQueryValueEx的固定调用格式          
		while ((ret = RegQueryValueEx(HKEY_PERFORMANCE_DATA, wszClassName, 0, &type, data, &size)) != ERROR_SUCCESS) {
			while (ret == ERROR_MORE_DATA)
			{
				size += DEFAULT_BUFFER_SIZE;
				data = (unsigned char*)realloc(data, size);
			}
			if (ret != ERROR_SUCCESS)
			{
				return FALSE;
			}
		}
		//得到数据块       
		PERF_DATA_BLOCK  *dataBlockPtr = (PERF_DATA_BLOCK *)data;
		//得到第一个对象  
		PERF_OBJECT_TYPE *objectPtr = FirstObject(dataBlockPtr);
		for (int a = 0; a<(int)dataBlockPtr->NumObjectTypes; a++)
		{
			char nameBuffer[255];
			if (objectPtr->ObjectNameTitleIndex == 510)
			{
				DWORD processIdOffset = ULONG_MAX;
				PERF_COUNTER_DEFINITION *counterPtr = FirstCounter(objectPtr);
				for (int b = 0; b<(int)objectPtr->NumCounters; b++)
				{
					if (counterPtr->CounterNameTitleIndex == 520)
						processIdOffset = counterPtr->CounterOffset;
					counterPtr = NextCounter(counterPtr);
				}
				if (processIdOffset == ULONG_MAX) {
					free(data);
					return 1;
				}
				PERF_INSTANCE_DEFINITION *instancePtr = FirstInstance(objectPtr);
				for (int b = 0; b<objectPtr->NumInstances; b++)
				{
					wchar_t *namePtr = (wchar_t *)((BYTE *)instancePtr + instancePtr->NameOffset);
					PERF_COUNTER_BLOCK *counterBlockPtr = GetCounterBlock(instancePtr);
					char *pName = WideToMulti(namePtr, nameBuffer, sizeof(nameBuffer));
					DWORD bandwith = *((DWORD *)((BYTE *)counterBlockPtr + processIdOffset));
					DWORD tottraff = 0;
					Interfaces.AddTail(CString(pName));
					Bandwidths.AddTail(bandwith);
					TotalTraffics.AddTail(tottraff);
					instancePtr = NextInstance(instancePtr);
				}
			}
			objectPtr = NextObject(objectPtr);
		}
		free(data);
		return TRUE;
	}
	catch (...)
	{
		return FALSE;
	}
}


//返回安装的接口数  
int MFNetTraffic::GetNetworkInterfacesCount()
{
	return Interfaces.GetCount() - 1;
}


//返回接口名称  
BOOL MFNetTraffic::GetNetworkInterfaceName(CString *InterfaceName, int index)
{
	POSITION pos = Interfaces.FindIndex(index);
	if (pos == NULL)
		return FALSE;
	wchar_t strname[20] = {L"%s"};
	InterfaceName->Format(strname, Interfaces.GetAt(pos));
	return TRUE;
}


//返回接口带宽  
DWORD MFNetTraffic::GetInterfaceBandwidth(int index)
{
	POSITION pos = Bandwidths.FindIndex(index);
	if (pos == NULL)
		return 0;
	else
		return Bandwidths.GetAt(pos) / 8;
}


//具体接口接收和发送的数据量  
DWORD MFNetTraffic::GetInterfaceTotalTraffic(int index)
{
	DWORD   totaltraffic = 0;
	POSITION    pos;
	pos = TotalTraffics.FindIndex(index);
	if (pos != NULL)
	{
		totaltraffic = TotalTraffics.GetAt(pos);
		if (totaltraffic == 0.0)
		{
			GetTraffic(index);
			pos = TotalTraffics.FindIndex(index);
			if (pos != NULL)
			{
				totaltraffic = TotalTraffics.GetAt(pos);
			}
		}
	}
	return(totaltraffic);
}


void MFNetTraffic::SetTrafficType(int trafficType)
{
	CurrentTrafficType = trafficType;
}

C++：实现网络寻路(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-26 480
C++：实现网络寻路(附完整源码)
c++实现判断局域网内机器是否在线
qq_44614115的博客
01-25 1894
本文利用ICMP报文来判断局域网内机器是否在线
vc++实现简单路由器功能
07-22
简单实现路由器功能的小程序 供参考 不足请批评指正
c++ 利用winpcap编制简单的路由程序_TCP/IP详解卷一笔记之ip选路和动态路由协议...
weixin_33379878的博客
01-17 666
IP选路选路是IP最重要的功能之一。是IP层处理过程的简单流程。需要进行选路的数据报可以由本地主机产生，也可以由其他主机产生。在后一种情况下，主机必须配置成一个路由器，否则通过网络接口接收到的数据报，如果目的地址不是本机就要被直接丢弃。(悄无声息)1. 路由表路由操作对于运行TCP／IP的系统来说是最基本的，不管是主机还是路由器。路由表项的内容很简单，包括：5bit标志、目的IP地址(主机、网络或...
C++ 实现局域网文件传输及断点续传技术
最新发布
weixin_35755640的博客
06-20 801
文件传输协议（File Transfer Protocol，FTP）是一种用于在网络上进行文件传输的协议。除了FTP，还有其他一些常用的文件传输协议，例如：：轻量级的FTP版本，不需要用户认证，但是缺乏错误恢复机制。：最初用于网页传输，现在也广泛用于文件传输。：基于SSH协议，提供了加密的文件传输服务。套接字编程主要通过一组API实现，这组API广泛存在于各种类Unix系统中。
C++网络编程
bsegebr的博客
08-14 555
accept等待到客户端的连接后，创建一个新的socket，函数返回值就是这个新的socket，服务端用于这个新的socket和客户端进行报文的收发。UDP不是一个可靠的协议，对数据的长度有限制，但是它的速度比较高。计算机是通过TCP/IP协议进行互联从而进行通信的，为了把复杂的TCP/IP协议隐藏起来，更方便的实现计算机中两个程序进行通信，引出了socket这个概念。函数功能：服务端把用于通信的地址和端口绑定到socket上，当bind函数返回0时，为正确绑定，返回-1，则为绑定失败。...
我的C/C++之路-005课(模拟路由表的路由选择功能)
mzlqh的专栏
04-22 4851
#include #include /* 模拟路由表的路由选择功能：预先设置路由表，当有一个数据包到来的时候， 查看其目的地址，用该地址与路由表每项的子网掩码相与，若得到的地址与该项地址一致， 则把该数据包从有这个地址的端口转发出去(本例子只适合静态路由，当然没动态路由那么复杂) */ //由于路由表长度未知(由路由器管理员添加)，不能使用数组了，这里使用链表吧，如果不会，也可以使用数组模拟
C++获取所有局域网可用IP ping源码
11-08
在C++编程中，获取局域网内所有可用的IP并进行ping操作是网络编程中的一个常见需求。这个任务涉及到网络接口的枚举、IP地址的解析以及ping命令的实现。下面将详细介绍如何通过C++来实现这个功能。 首先，我们需要...
Visual C++实现局域网IP多播.doc
11-26
《Visual C++实现局域网IP多播》 在计算机网络通信中，IP多播是一种高效的数据传输方式，尤其在局域网环境中，对于需要向多个接收者同时发送相同信息的应用场景，多播技术显得尤为重要。Visual C++作为强大的开发...
用Visual C++在局域网实现IP多播.pdf
11-28
标题中的“用Visual C++在局域网实现IP多播”指的是使用Microsoft的Visual C++编程环境，在局域网（LAN）中实现IP多播技术。IP多播是一种通信方式，允许一个数据发送者向局域网内的多个接收者同时发送数据，而无需为...
C++实现局域网简易聊天软件教程
总结以上知识点，可以看出，一个简单的C++局域网聊天程序涵盖了从基础的C++语法到高级的网络通信技术，是一块很好的学习网络编程的跳板。对于初学者而言，通过逐步学习和完善这样的程序，可以逐步构建起对整个网络...
g6-router:通用C ++路由器
04-11
通用CPP路由器 该项目提供了c ++ 20路由器实现。 它使用进行路由模式匹配。 安装 这是仅标头的库，因此，只需获取它的副本即可。 用法 基本的 // define a router g6::router::router my_router{ g6::router::on< R>([]( const std::string &value) -> std::string { // ^ captured value ^ goes here return value; }), g6::router::on< R>([]() -> std::string { return " not found " ;
simple-cpp-router:用于 C++ 的简单 URI 路由库
06-12
简单的 C++ URI 路由库 要求 支持正则表达式的 C++11 编译器 示例用法 Router router; router.registerPath( " /simple_path " ); router.registerPath( " /one/two " ); router.registerPath( " /path/with/:dynamic_var " ); router.registerPath( " /path/to/:one_var/and/:another_var " ); PathMatch match = router.matchPath( " /path/to/dynvar_1/and/dynvar_2 " ); assert (match.pathTemplate() ==
C/C++ telnet自动登录路由器获取wifi密码
02-05
打开后输入IP地址范围，然后程序会自动连接这些ip地址，若IP地址打开了23端口且为弱密码就能连上，然后程序会自动传送wlctl show命令获取wifi ssid和key，并且保存在d盘下的txt上。想获取周围的wifi密码可以试一试本主机所在的网段。
traceroute在windows下的c++实现源代码
01-30
traceroute socket windows c++ 源代码原理 详细解析traceroute的工作原理和实现细节
VC实现局域网组播 C++交流群QQ群：77278127 非一年以上经验勿入。
C++编程的专栏
06-08 2002
在局域网中，管理员常常需要将某条信息发送给一组用户。如果使用一对一的发送方法，虽然是可行的，但是过于麻烦，也常会出现漏发、错发。为了更有效的解决这种组通信问题，出现了一种多播技术（也常称为组播通信），它是基于IP层的通信技术。为了帮助读者理解，下面将简要的介绍一下多播的概念。 众所周知，普通IP通信是在一个发送者和一个接收者之间进行的，我们常把它称为点对点的通信，但对于有些应用，这种点对点的通信
距离矢量路由算法C++实现源代码——计算机网络实验
qq_43722079的博客
06-27 5291
创作日志： 昨天检查完了计网实验，我就来贡献源代码啦！这个代码完全是我自己码的，当时做的时候网上似乎找不到。 使用说明书： 数据结构： 1. 用来存储网络结点拓扑图的图结构 (class G) 2. 路由表结构（class route_table) 3. 路由表的每一行的表项结构（class route_node) 数据输入： 我是采用读取文件的形式，这样子给老师展示的时候也不用手动输入浪费时间了，并且...
VC++ 实现获取路由表信息
weixin_30279751的博客
11-07 370
所谓路由表，指的是路由器或者其他互联网网络设备上存储的表，该表中存有到达特定网络终端的路径，在某些情况下，还有一些与这些路径相关的度量。 静态路由表在计算机网络中，路由表或称路由择域信息库（RIB）是一个存储在路由器或者联网计算机中的电子表格（文件）或类数据库。路由表存储着指向特定网络地址的路径（在有些情况下，还记录有路径的路由度量值）。路由表中含有网络周边的拓扑信息。路由表建立的主要目标是...
【计算机网络】网络基础
m0_72940975的博客
07-20 516
也就是说，虽然客户端和服务器可能使用的是不同种类的操作系统，但每个系统实现网络协议栈的方法包括各种细节都是一样的，因此双方对数据进行封包和解包操作都是一样的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

vqt5_qt6

你的鼓励是我们创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值