c++ ip数据包捕获

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了c++ ip数据包捕获，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9210字，纯文字阅读大概需要14分钟。

内容图文

IpPack.h


#pragma once

#ifndef __IP_PACK_H__
#define __IP_PACK_H__

#include <wtypes.h>
#include <string>

#define MAX_IP_PACK_LEN		(USHORT)(0xFFFF)

#define IP4_PROTOCOL			4
#define IP6_PROTOCOL			6

#define IP_VER(ver_ihl)			((ver_ihl)&(0x0f))
#define IS_IP4(ver_ihl)			(IP4_PROTOCOL == IP_VER(ver_ihl))
#define IS_IP6(ver_ihl)			(IP6_PROTOCOL == IP_VER(ver_ihl))


/* 4 bytes IP address */
 typedef union _Ip4_Address
 {
	 struct
	 {
		 u_char	byte1;
		 u_char	byte2;
		 u_char	byte3;
		 u_char	byte4;
	 };

 	u_long	ul;
 
 }Ip4_Address;

 /* IPv4 header */
 typedef struct _Ip4_Header
 {
	 u_char			ver_ihl;		// Version (4 bits) + Internet header length (4 bits)
	 u_char			tos;			// Type of service 
	 u_short		tlen;			// Total length 
	 u_short		identification; // Identification
	 u_short		flags_fo;		// Flags (3 bits) + Fragment offset (13 bits)
	 u_char			ttl;			// Time to live
	 u_char			proto;			// Protocol
	 u_short		crc;			// Header checksum
	 Ip4_Address	saddr;		// Source address
	 Ip4_Address	daddr;		// Destination address
 }Ip4_Header,*PIp4_Header;

 /* UDP header*/
 typedef struct _Udp_Header
 {
	 u_short sport;			// Source port
	 u_short dport;			// Destination port
	 u_short len;			// Datagram length
	 u_short crc;			// Checksum
 }Udp_Header;

 /* TCP header*/
 typedef struct _Tcp_Header
 {
	 u_short sport;				//	Source port
	 u_short dport;				//  Destination port
	 u_int	 sequence_num;		//	Sequence Number
	 u_int	 acknowledgment;	//  Acknowledgment
	 u_char	 hdr_len;			//  header len
	 u_char  flags;				//  flags
	 u_short window_size;		//
	 u_short crc;
	 u_short urg_ptr;
 }Tcp_Header,*PTcp_Header;

 /* Dns header*/
 typedef struct _Dns_Header
 {

 }Dns_Header,*PDns_Header;

class IIpPack
{
public:
	virtual ~IIpPack(){};
	virtual VOID GetPack(PVOID pPack, int iLen) = 0;
};

class test : public IIpPack
{
public:
	virtual VOID GetPack(PVOID pPack, int iLen)
	{
		PIp4_Header p = (PIp4_Header)pPack;

		char buf[128];
		std::string str = "@@@ 协议版本：";
		sprintf_s(buf, "%d", (p->ver_ihl >> 4));
		str += buf;

		std::string src = inet_ntoa(*(in_addr*)&p->saddr);
		std::string dst = inet_ntoa(*(in_addr*)&p->daddr);

		str += " 源ip：";
		str += src;
		
		str += " 目标ip：";
		str += dst;

		OutputDebugStringA(str.c_str());
	}
};

#endif

IpPackCap.h



#pragma once

#ifndef __IP_PACK_CAPTURE_H__
#define __IP_PACK_CAPTURE_H__

#include <windows.h>
#include <ws2tcpip.h>
#include <list>
#include "IpPack.h"

enum IP_FAMILY
{
	IP_UNKNOW_FAMILY	= 0,
	IP4_FAMILY			= AF_INET,
	IP6_FAMILY			= AF_INET6,
};

typedef struct _IP_ADDRESS
{
	IP_FAMILY		Type;
	union 
	{
		ULONG	Ipv4;
		struct  in_addr InAddr;
		UCHAR	Ipv6[16];
		struct  in6_addr In6Addr;
	};

	_IP_ADDRESS()
	{
		Type = IP_UNKNOW_FAMILY;
	};

}IP_ADDRESS,*PIP_ADDRESS;

typedef struct _IP_ENPOINT
{
	IP_ADDRESS	Address;
	ULONG		Port;
	
	_IP_ENPOINT()
	{
		Port = 0;
	};

}IP_ENPOINT,*PIP_ENPOINT;

class CIpPackCap
{
public:
	CIpPackCap();
	~CIpPackCap();

	DWORD   Start(IP_ENPOINT& ipEndpoint, IIpPack* pPackDeal);
	VOID	Stop();

private:
	static DWORD WINAPI _WorkFunction(LPVOID lpParam);

private:
	BOOL		m_bStop;
	HANDLE		m_hThread;
	SOCKET		m_socket;
	PVOID		m_pPackBuf;
	ULONG		m_ulPackBufLen;
	IIpPack*	m_pPackDeal;

};

class CIpPackCapManager
{
public:
	typedef struct _IP_LISTEN
	{
		IP_ENPOINT	stListenEnpoint;
		CIpPackCap *pPackCap;
		IIpPack	   *pIpPack;

		_IP_LISTEN()
		{
			pPackCap = NULL;
			pIpPack = NULL;
		};

	}IP_LISTEN, *PIP_LISTEN;

public:
	CIpPackCapManager();
	~CIpPackCapManager();


	DWORD	Init();
	VOID	UnInit();

	DWORD   Start();
	VOID	Stop();

private:
	VOID	_Clear();

private:
	std::list<IP_LISTEN>	m_ltIpListenTable;
	BOOL					m_bInit;

};

#endif

IpPackCap.cpp


#include "stdafx.h"
#include "IpPackCap.h"
#include <winsock2.h>
#include <ws2tcpip.h>
#include <mstcpip.h>

#pragma comment(lib, "ws2_32.lib")

#define MAX_SAF_HOSTNAME_LEN		(256+1)

CIpPackCap::CIpPackCap()
{
	m_bStop			= TRUE;
	m_hThread		= NULL;
	m_socket		= INVALID_SOCKET;
	m_pPackBuf		= NULL;
	m_ulPackBufLen	= 0;
	m_pPackDeal		= NULL;
}

CIpPackCap::~CIpPackCap()
{
	Stop();
}

DWORD CIpPackCap::Start(IP_ENPOINT& ipEndpoint, IIpPack* pPackDeal)
{
	DWORD dwError = ERROR_SUCCESS;

	do 
	{
		if (NULL != m_hThread ||
			IP_UNKNOW_FAMILY == ipEndpoint.Address.Type ||
			NULL == pPackDeal)
		{
			dwError = ERROR_FUNCTION_FAILED;
			return dwError;
		}

		m_pPackBuf = ::HeapAlloc(::GetProcessHeap(), 0,
								MAX_IP_PACK_LEN);
		if (NULL == m_pPackBuf)
		{
			dwError = ERROR_NOT_ENOUGH_MEMORY;
			break;
		}
		m_ulPackBufLen = MAX_IP_PACK_LEN;

		m_socket = ::socket(
			ipEndpoint.Address.Type,
			SOCK_RAW,
			IPPROTO_IP);
		if (INVALID_SOCKET == m_socket)
		{
			dwError = ::WSAGetLastError();
			break;
		}

		int iResult;

		std::string str;
		if (IP4_FAMILY == ipEndpoint.Address.Type)
		{
			struct sockaddr_in address4;
			
			address4.sin_family = ipEndpoint.Address.Type;
			address4.sin_port = ::htons(ipEndpoint.Port);
			address4.sin_addr = ipEndpoint.Address.InAddr;
			
			str = inet_ntoa(address4.sin_addr);

			iResult = ::bind(m_socket, 
							(struct sockaddr*)&address4, 
							sizeof(struct sockaddr_in));
		}
		else
		{
			dwError = ERROR_FUNCTION_FAILED;
			break;
		}

		if (SOCKET_ERROR == iResult)
		{
			dwError = ::WSAGetLastError();
			break;
		}

		DWORD dwInBuff = RCVALL_IPLEVEL;
		DWORD dwRetLen = 0;

		iResult = ::WSAIoctl(
					m_socket,
					SIO_RCVALL,
					&dwInBuff,
					sizeof(dwInBuff),
					NULL,
					0,		
					&dwRetLen,
					NULL,
					NULL);
		if (SOCKET_ERROR == iResult)
		{
			dwError = ::WSAGetLastError();
			break;
		}

		//阻塞模式
		u_long bioarg = 0;
		iResult = ioctlsocket(m_socket, FIONBIO, &bioarg);
		if (SOCKET_ERROR == iResult)
		{
			dwError = ::WSAGetLastError();
			break;
		}

		m_bStop = FALSE;
		m_pPackDeal = pPackDeal;

		m_hThread = ::CreateThread(
					NULL, 0, _WorkFunction,
					this, 0, NULL);
		if (NULL == m_hThread)
		{
			m_bStop = TRUE;
			dwError = ::GetLastError();
			break;
		}

	} while (0);

	if (ERROR_SUCCESS != dwError)
	{
		if (INVALID_SOCKET != m_socket)
		{
			::closesocket(m_socket);
			m_socket = NULL;
		}

		if (NULL != m_pPackBuf)
		{
			::HeapFree(GetProcessHeap(), 0, m_pPackBuf);
			m_pPackBuf		= NULL;
			m_ulPackBufLen	= 0;
		}
	}

	return dwError;
}

VOID CIpPackCap::Stop()
{
	if (NULL != m_hThread)
	{
		m_bStop = TRUE;

		m_pPackDeal = NULL;
		
		if (INVALID_SOCKET != m_socket)
		{
			::closesocket(m_socket);
			m_socket = INVALID_SOCKET;
		}

		DWORD dwWaitResult = 
			::WaitForSingleObject(m_hThread, 1000);
		if (WAIT_OBJECT_0 != dwWaitResult)
		{
			::TerminateThread(m_hThread, 0);
		}

		m_hThread = NULL;

		if (NULL != m_pPackBuf)
		{
			::HeapFree(GetProcessHeap(), 0, m_pPackBuf);
			m_pPackBuf = NULL;
			m_ulPackBufLen = 0;
		}
	}
}

DWORD CIpPackCap::_WorkFunction(LPVOID lpParam)
{
	DWORD dwError = ERROR_SUCCESS;

	CIpPackCap* pThis = (CIpPackCap*)lpParam;
 
	while(FALSE == pThis->m_bStop)
	{
		if (NULL == pThis)
			break;

		int iLen = ::recv(
			pThis->m_socket, 
			(char*)pThis->m_pPackBuf,
			pThis->m_ulPackBufLen, 0);
		if (SOCKET_ERROR == iLen)
		{
			dwError = ::WSAGetLastError();
			break;
		}

		if (pThis->m_pPackDeal)
		{
			pThis->m_pPackDeal->GetPack(
				pThis->m_pPackBuf, iLen);
		}
	}

	return dwError;
}

CIpPackCapManager::CIpPackCapManager()
{
	Init();
}

CIpPackCapManager::~CIpPackCapManager()
{
	UnInit();
}

DWORD CIpPackCapManager::Init()
{
	DWORD dwError = ERROR_SUCCESS;

	BOOL  bStartup = FALSE;

	struct addrinfo *result = NULL;

	do
	{
		if (TRUE == m_bInit)
			break;

		WORD wVersionRequested;
		WSADATA wsaData;
		wVersionRequested = MAKEWORD(2, 2);

		int err = ::WSAStartup(wVersionRequested, &wsaData);
		if (0 != err)
		{
			dwError = ERROR_FUNCTION_FAILED;
			break;
		}

		bStartup = TRUE;

		if (LOBYTE(wsaData.wVersion) != 2 ||
			HIBYTE(wsaData.wVersion) != 2)
		{
			dwError = ERROR_FUNCTION_FAILED;
			break;
		}

		char hostName[MAX_SAF_HOSTNAME_LEN] = { 0 };

		int iResult =
			::gethostname(hostName, MAX_SAF_HOSTNAME_LEN);
		if (SOCKET_ERROR == iResult)
		{
			dwError = ::WSAGetLastError();
			break;
		}
	
		struct addrinfo *ptr = NULL;
		struct addrinfo hints;

		struct sockaddr_in  *sockaddr_ipv4;
		struct sockaddr_in6 *sockaddr_ipv6;

		ZeroMemory(&hints, sizeof(hints));
		hints.ai_family = AF_UNSPEC;
		hints.ai_flags = AI_PASSIVE;
		hints.ai_protocol = IPPROTO_IPV4;

		dwError = ::getaddrinfo(hostName, NULL, &hints, &result);
		if (0 != dwError)
		{
			break;
		}

		for (ptr = result; NULL != ptr; ptr = ptr->ai_next)
		{
			IP_LISTEN ip_listen;

			PVOID	pPackBuf = NULL;

			switch (ptr->ai_family)
			{
			case AF_INET:
			{
				ip_listen.stListenEnpoint.Address.Type = IP4_FAMILY;
				sockaddr_ipv4 = (struct sockaddr_in *) ptr->ai_addr;
				ip_listen.stListenEnpoint.Address.InAddr = sockaddr_ipv4->sin_addr;

				break;
			}
			default:
			{
				continue;
			}

			}

			m_ltIpListenTable.push_back(ip_listen);
		}

		if (ERROR_SUCCESS != dwError)
			break;

		m_bInit = TRUE;

	} while (0);

	if (ERROR_SUCCESS != dwError)
	{
		m_ltIpListenTable.clear();

		if(TRUE == bStartup)
			::WSACleanup();
	}

	if (NULL != result)
	{
		::freeaddrinfo(result);
	}

	return dwError;
}

VOID CIpPackCapManager::UnInit()
{
	if (TRUE == m_bInit)
	{
		Stop();

		::WSACleanup();

		m_bInit = FALSE;
	}
}

DWORD CIpPackCapManager::Start()
{
	DWORD	dwError = ERROR_SUCCESS;

	do
	{
		if (FALSE == m_bInit)
		{
			dwError = ERROR_FUNCTION_FAILED;
			break;
		}

		std::list<IP_LISTEN>::iterator it;
		it = m_ltIpListenTable.begin();
		for (; it != m_ltIpListenTable.end(); it++)
		{
			CIpPackCap *pPackCap = new CIpPackCap;
			IIpPack	   *pIpPack = new test;
			it->stListenEnpoint.Port = 0;
			dwError = pPackCap->Start(it->stListenEnpoint, pIpPack);
			
			if (ERROR_SUCCESS != dwError)
			{
				delete pPackCap;
				delete pIpPack;
				//break;
			}
			else
			{
				it->pPackCap = pPackCap;
				it->pIpPack = pIpPack;
			}
		}

	} while (0);

	if (ERROR_SUCCESS != dwError)
	{
		_Clear();
	}

	return dwError;
}

VOID CIpPackCapManager::Stop()
{
	_Clear();
}

VOID CIpPackCapManager::_Clear()
{
	std::list<IP_LISTEN>::iterator it;
	it = m_ltIpListenTable.begin();
	for (; it != m_ltIpListenTable.end(); it++)
	{
		if (NULL != it->pPackCap)
		{
			delete it->pPackCap;
			it->pPackCap = NULL;
		}
		if (NULL != it->pIpPack)
		{
			delete it->pIpPack;
			it->pIpPack = NULL;
		}
	}
}

CIpPackCapManager m_manager;

m_manager.Init();

m_manager.Start();

管理员启动，window7 及以上系统都无法捕获数据输入ip包所以我已经放弃治疗了哎。。。。。。

选择winpcap玩玩咯或者以后自己写驱动咯。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

内容总结

以上是互联网集市为您收集整理的c++ ip数据包捕获全部内容，希望文章能够帮你解决c++ ip数据包捕获所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/855252.html

来源：【匿名】

【上一篇】vc++如何创建程序-析构函数01 【下一篇】c++有个库什么的吗?

更多 ►

【c++ ip数据包捕获】教程文章相关的互联网学习教程文章

(期末考试快到了，所以比较粗糙，请各位读者理解。。)一、概念DBSCAN是一种产生划分聚类的基于密度的聚类算法，簇的个数由算法自动地确定。低密度区域中的点被视为噪声而忽略，因此DBSCAN不产生完全聚类。二、伪代码1 将所有点标记为核心点、边界点和噪声点。2 删除噪声点。3 为距离在Eps之内的所有核心点之间赋予一条边。4 每组连通的核心点形成一个簇。5 将每个边界点指派到一个与之关联的核心点的簇中。...

visualC/C++连接MySql数据库

vs连接数据库其实就是将mysql数据库.h头文件接口、lib链接文件和dll执行文件加入到项目中。下面是配置如何加入。转于http://www.cnblogs.com/justinzhang/archive/2011/09/23/2185963.html一、VS2013工程设置工作首先，建立一个windows应用程序的工程，将C/C++->预处理器->预处理器定义下的_WINDOWS改为_CONSOLE，将连接器->系统->子系统选择为控制台。由于我们要使用Mysql的API，并且我们机子上肯定安装了Mysql数据库，所以我们...

如何在Lua与C/C++之间实现table数据的交换【代码】

之前在《C/C++和Lua是如何进行通信的？》一文中简单的介绍了lua与宿主之间的通信。简单的说两种不同的语言之间数据类型不一样又如何进行数据交换呢？那就是lua_State虚拟栈，通过栈操作和lua库函数，我们很轻松就能完成两者之间的数据交换。　　开始之前，明确几个问题，lua中的虚拟栈的索引编号问题（我们假设栈大小为n），编号1是栈底，n视栈顶，编号-1是栈顶，-n是栈底。lua中的库函数需要访问和操作栈上的数据都是通过索引编号...

《C++反汇编与逆向分析技术揭秘》——基本数据类型的表现形式【图】

---恢复内容开始---基本的浮点数指令示例代码： Visual Studio 2013的反汇编代码是：对于movss，表示移动标量单精度浮点值将标量单精度浮点值从源操作数（第二个操作数）移到目标操作数（第一个操作数）。源操作数与目标操作数可以是 XMM 寄存器或 32 位内存位置。此指令可用于将单精度浮点值移入/移出 32 位内存位置与 XMM 寄存器的低位双字，或是用于在两个 XMM 寄存器的低位双字之间移动单精度浮点值。此指令不能用于在内存位置...

读书笔记－－Accelerated C++ Chapter11 定义抽象数据类型

Vec类——实现Vec类——复制控制——动态的Vec类型对象——灵活的内存管理实现Vec类为了实现通用性，需要写一个模板类。如下所示：template <class T> class Vec{public: //接口private:}; 当使用 Vec<int> V;时，编译器会将所有T的地方都替换成为int。内存分配需要注意的是，当使用new T[n]为Vec分配空间时，会运行T的构造函数为元素进行默认初始化。也就是说，只有在T具有默认构造函数的时候才能创建一个Vec<T>。构造...

C++中的容器可以同时保存各种数据类型

[原]C++制作一个泛型容器（可以盛放各种类型的对象）2014-5-4阅读494 评论0如果你想要一个可以盛放各种类型的对象，那么基本上可以说在C++里没有，或者你可以用vector<boost::any>或者其他的什么来模拟，我说那都不怎么好。问题就在于我的类型会在运行时动态的增加，你不可能知道我会增加什么类型，我的头文件也不会给你。现在是不是觉得C++的泛型用不上了，是的，C++的泛型本质上是对相似代码的复用，做的事情都是同一件事情，但...

C++数据结构知识点【代码】【图】

数据结构(data stucture)的定义：数据结构由数据元素的集合和该集合中数据元素之间的关系组成。即{D,R}。线性结构，即线性表(linearlist). ---数组(array)，文件，栈(stack)，队列(queue)，优先级队列非线性结构 ---集合，图C++类默认访问级别是privatestruct默认访问级别是 public 这可以说是他们的惟一区别。union默认访问级别也是 public流是个简单的字符序列cout<<endl; 输出一个换行符，并清空流。C++的输入输出：void main...

黑马基础阶段测试题：创建一个存储字符串的集合list，向list中添加以下字符串：”C++”、”Java”、” Python”、”大数据与云计算”。遍历集合，将长度小于5的字符串从集合中删除，删除成功后，打印集合中的所有元素【代码】【图】

package com.swift;import java.util.ArrayList; import java.util.List; import java.util.ListIterator;publicclass Collections {publicstaticvoid main(String[] args) {/** 完成以下需求：*创建一个存储字符串的集合list，向list中添加以下字符串：”C++”、”Java”、” Python”、”大数据与云计算”。*遍历集合，将长度小于5的字符串从集合中删除。*删除成功后，打印集合中的所有元素。*PS：控制台打印示例*/List<String> ...

Matlab中导入文本文件中的数据矩阵合并以及C++中删除文件操作【代码】

今天用到了Matlab读取文本文件中按照一定格式存储好的数据，然后进行后续的分析计算等，因此涉及到Matlab的文件读取，记录在这里，供以后查阅: 1 fid = fopen(‘train.set‘, ‘r‘);2 A = [];3 B = [];4while(~feof(fid))5 tline = fgetl(fid);6 [a,b]=textread(tline, ‘%f %f‘);7 A = [A; a];8 B = [B; b];9end 10 C = [A, B];其中train.set中保存着所有的待读取的文件的文件名，在这个例子中每个文件中存储的...

求变量的数据类型，typeid,bool,C和C++的不同，new和delete,C++中的枚举，inline和可变参数模板，auto和函数模板，宽字符【图】

求变量的数据类型，通过函数typeid(变量名).name();获得变量的数据类型。案例如下：#include<iostream>#include<stdlib.h> voidmain(){ doubledb = 10.9; double *pdb= &db; autonum = pdb; //通过typeid的方式获得数据类型 std::cout<< typeid(db).name()<< std::endl; std::cout<< typeid(num).name()<< std::endl; std::cout<< typeid(pdb).name()<< std::endl; //typeid(db).name() db2 //decltype...

C++程序设计实践指导1.12数组中数据线性变换改写要求实现【代码】

改写要求1：分别用指针pa、pb代替数组改写要求2：从键盘输入data元素元素个数任意，输入0结束#include <cstdlib> #include <iostream>usingnamespace std; class DATA {double *pa,*pb;double max,min;double new_max,new_min;int length;public:DATA(double a1[],double x,double y,int len){int i;length=len;pa=newdouble[len];pb=newdouble[len];for(i=0;i<length;i++)pa[i]=a1[i];new_max=x;new_min=y;max=min=pa[0];for(i=0...

用Matlab与c++程序生成的数据文件绘制sin函数

软件： MatlabR2014a CodeBlock 1.新建个工程2.输入程序，求得坐标并保存到txt文件中3.用MATLAB建个M文件4.输入绘图代码，如图5.点击运行，M文件保存在新建工程所在的文件夹下6.绘图完成7.如果想把图像以其他格式保存，则点击文件->另存为，选择保存类型，这里选择pdf格式，如图所示，这就是保存下来的图像。总结：本来很简单的东西，上课听了之后没动手实践，同学一问发现自己根本没记住，-_-#自己好好反思一下吧。cpp源代码：/...

【数据结构】3、模拟银行窗口排队叫号系统——C++【图】

这里我们模拟一下银行排队叫号系统的实现：假设一个银行有4个窗口对外接待客户。由于每个窗口在某一时刻只能接待一个客户，在客户众多的时候需要排队，对于刚进入银行的客户，如果某个窗口正空闲，则可上前办理业务，如果所有窗口都不空闲则排在人数最少的窗口。现在要求模拟银行的某一时间段内的4个窗口的客户排队情况。这里客户到达的时刻和办理业务的时间都是随机的。首先我们银行发生事件，我们得有一个类表示事件对象/* *功...

C++初始化数据成员【代码】

在C++初始化类的成员数据有两种方式1. 在构造函数中实现2. 定义初始化成员列表来初始化成员数据class point {private:int x,y;public:point(int m,int n){x=m;y=n;} };class point {private:int x,y;public:point(int m=0,int n=0):x(m),y(n){} }; 这两种初始化成员数据方式有差别，用构造函数初始化成员数据其实就是用赋值来实现，用初始化成员列表则只是直接对数据成员进行初始化。具体在以下三种情况下使用初始化...

【C++/数据结构】单链表的基本操作【图】

#pragma once #ifndef _CLIST_H_ #define _CLIST_H_#include <iostream> #include <assert.h> using namespace std;template<class Type> class List;typedef enum { FALSE, TRUE }Status;template<class Type> class ListNode {friend class List<Type>; public:ListNode() :data(Type()), next(NULL){}ListNode(Type d, ListNode<Type> *n = NULL): data(d), next(n){}~ListNode(){}void setData(const Type &d){data = d;}Type ...

首页 / C++ / c++ ip数据包捕获

c++ ip数据包捕获

内容导读

内容图文

内容总结

内容备注

内容手机端

【c++ ip数据包捕获】教程文章相关的互联网学习教程文章

数据挖掘算法：DBSCAN算法的C++实现【图】

visualC/C++连接MySql数据库

如何在Lua与C/C++之间实现table数据的交换【代码】

《C++反汇编与逆向分析技术揭秘》——基本数据类型的表现形式【图】

读书笔记－－Accelerated C++ Chapter11 定义抽象数据类型

C++中的容器可以同时保存各种数据类型

C++数据结构知识点【代码】【图】

Matlab中导入文本文件中的数据矩阵合并以及C++中删除文件操作【代码】

求变量的数据类型，typeid,bool,C和C++的不同，new和delete,C++中的枚举，inline和可变参数模板，auto和函数模板，宽字符【图】

C++程序设计实践指导1.12数组中数据线性变换改写要求实现【代码】

用Matlab与c++程序生成的数据文件绘制sin函数

【数据结构】3、模拟银行窗口排队叫号系统——C++【图】

C++初始化数据成员【代码】

【C++/数据结构】单链表的基本操作【图】

数据包 - 相关标签

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程