MFC 网络编程 -- 总结 .-阿里云开发者社区

基于 TCP 的 socket 编程

/*
服务器端程序流程：
1.加载套接字库     WSAStartup
2.创建套接字         socket
3.将我们创建的套接字，绑定到本机地址的某一端口上    bind
4.为套接字设置监听模式，准备客户请求                          listen
5.等待客户请求到来。当请求到来，将接受连接请求，并返回一个新的对应于此次连接的套接字     accept
6.用新返回的套接字和客户端进行通信                             send / recv
7.在通信结束后，关闭套接字                                           closesocket

客户端程序流程：
1.加载套接字库                         WSAStartup
2.创建套接字                              socket
3.向服务器发出请求连接           connect
4.和服务器进行通信                  send / recv
5.在通信结束后，关闭套接字    closesocket
*/

服务器端代码：

[cpp] view plain copy print ?

#include <Winsock2.h>
#include <stdio.h>
#pragma comment(lib, "Ws2_32.lib")
void main()
{
// 加载套接字库，并进行套接字的版本协商
WORD wVersionRequested; // 指定将要加载的 winsock 库版本
WSADATA wsaData; // 用于存储加载的 winsock 库版本信息
int result; // 用于检测 WSAStartup 函数运行结果
wVersionRequested = MAKEWORD(1, 1); // 设定版本
result = WSAStartup(wVersionRequested, &wsaData);
// 函数 WSAStartup 调用成功返回 0
// 出错处理
if (result != 0)
{
return;
}
if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
{
WSACleanup();
return;
}
// 创建套接字
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
// 绑定套接字
SOCKADDR_IN addrInfo; // 存储本地主机地址信息
addrInfo.sin_addr.S_un.S_addr = htonl(INADDR_ANY); // 本地主机地址
addrInfo.sin_port = htons(6000); // 端口号
addrInfo.sin_family = AF_INET; // 地址族
bind(sock, (SOCKADDR *)&addrInfo, sizeof(SOCKADDR));
// 设置套接字监听模式
listen(sock, 5);
SOCKADDR_IN addrInfoClient; // 存储客户端地址信息
int len = sizeof(SOCKADDR);
while (true)
{
// 等待客户请求到来，并返回用于通信的套接字
SOCKET sockConnect = accept(sock, (SOCKADDR *)&addrInfoClient, &len);
// 下面通过刚建立的套接字，来进行通信
// 发送数据
char sendBuf[100];
sprintf(sendBuf, "这是服务器端，主机地址：%s", inet_ntoa(addrInfo.sin_addr));
send(sockConnect, sendBuf, strlen(sendBuf), 0);
// 接收数据
char recvBuf[100];
recv(sockConnect, recvBuf, strlen(recvBuf), 0);
// 打印接收的数据
printf("%s\n", recvBuf);
closesocket(sockConnect);
}
}

#include <Winsock2.h>
#include <stdio.h>

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

void main()
{
	// 加载套接字库，并进行套接字的版本协商
	WORD		wVersionRequested;	// 指定将要加载的 winsock 库版本
	WSADATA		wsaData;			// 用于存储加载的 winsock 库版本信息
	int			result;				// 用于检测 WSAStartup 函数运行结果

	wVersionRequested	= MAKEWORD(1, 1);	// 设定版本

	result = WSAStartup(wVersionRequested, &wsaData);

	// 函数 WSAStartup 调用成功返回 0
	// 出错处理
	if (result != 0)				
	{
		return;
	}

	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
	{
		WSACleanup();
		return;
	}

	// 创建套接字
	SOCKET		sock	= socket(AF_INET, SOCK_STREAM, 0);

	// 绑定套接字
	SOCKADDR_IN	addrInfo;			// 存储本地主机地址信息

	addrInfo.sin_addr.S_un.S_addr	= htonl(INADDR_ANY);	// 本地主机地址
	addrInfo.sin_port				= htons(6000);			// 端口号
	addrInfo.sin_family				= AF_INET;				// 地址族

	bind(sock, (SOCKADDR *)&addrInfo, sizeof(SOCKADDR));

	// 设置套接字监听模式
	listen(sock, 5);

	SOCKADDR_IN		addrInfoClient;	// 存储客户端地址信息
	int				len	= sizeof(SOCKADDR);

	while (true)
	{
		// 等待客户请求到来，并返回用于通信的套接字
		SOCKET	sockConnect	= accept(sock, (SOCKADDR *)&addrInfoClient, &len);

		// 下面通过刚建立的套接字，来进行通信

		// 发送数据
		char	sendBuf[100];
		sprintf(sendBuf, "这是服务器端，主机地址：%s", inet_ntoa(addrInfo.sin_addr));
		send(sockConnect, sendBuf, strlen(sendBuf), 0);

		// 接收数据
		char	recvBuf[100];
		recv(sockConnect, recvBuf, strlen(recvBuf), 0);

		// 打印接收的数据
		printf("%s\n", recvBuf);

		closesocket(sockConnect);
	}

}

客户端代码：

[cpp] view plain copy print ?

#include <Winsock2.h>
#include <stdio.h>
#pragma comment(lib,"Ws2_32.lib")
void main()
{
// 加载套接字库，并进行套接字的版本协商
WORD wVersionRequested; // 指定将要加载的 winsock 库版本
WSADATA wsaData; // 用于存储加载的 winsock 库版本信息
int result; // 用于检测 WSAStartup 函数运行结果
wVersionRequested = MAKEWORD(1, 1); // 设定版本
result = WSAStartup(wVersionRequested, &wsaData);
// 函数 WSAStartup 调用成功返回 0
// 出错处理
if (result != 0)
{
return;
}
if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
{
WSACleanup();
return;
}
// 创建套接字
SOCKET sockConnect = socket(AF_INET, SOCK_STREAM, 0);
// 向服务器发出连接请求
SOCKADDR_IN addrInfoServer; // 存储服务器端地址信息
addrInfoServer.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
addrInfoServer.sin_port = htons(6000);
addrInfoServer.sin_family = AF_INET;
// 向服务器发出连接请求
connect(sockConnect, (SOCKADDR *)&addrInfoServer, sizeof(SOCKADDR));
// 接收数据
char recvBuf[100];
recv(sockConnect, recvBuf, sizeof(recvBuf), 0);
printf("%s\n", recvBuf);
// 发送数据
char sendBuf[100] = "这是客户端\n";
send(sockConnect, sendBuf, sizeof(sendBuf) + 1, 0);
//关闭套接字
closesocket(sockConnect);
WSACleanup();
system("pause");
return;
}

#include <Winsock2.h>
#include <stdio.h>

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

void main()
{
	// 加载套接字库，并进行套接字的版本协商
	WORD		wVersionRequested;	// 指定将要加载的 winsock 库版本
	WSADATA		wsaData;			// 用于存储加载的 winsock 库版本信息
	int			result;				// 用于检测 WSAStartup 函数运行结果

	wVersionRequested	= MAKEWORD(1, 1);	// 设定版本

	result = WSAStartup(wVersionRequested, &wsaData);

	// 函数 WSAStartup 调用成功返回 0
	// 出错处理
	if (result != 0)				
	{
		return;
	}

	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
	{
		WSACleanup();
		return;
	}

	// 创建套接字
	SOCKET		sockConnect	= socket(AF_INET, SOCK_STREAM, 0);

	// 向服务器发出连接请求
	SOCKADDR_IN		addrInfoServer;		// 存储服务器端地址信息
	addrInfoServer.sin_addr.S_un.S_addr	= inet_addr("127.0.0.1");
	addrInfoServer.sin_port				= htons(6000);
	addrInfoServer.sin_family			= AF_INET;

	// 向服务器发出连接请求
	connect(sockConnect, (SOCKADDR *)&addrInfoServer, sizeof(SOCKADDR));

	// 接收数据
	char	recvBuf[100];
	recv(sockConnect, recvBuf, sizeof(recvBuf), 0);
	printf("%s\n", recvBuf);

	// 发送数据
	char	sendBuf[100] = "这是客户端\n";
	send(sockConnect, sendBuf, sizeof(sendBuf) + 1, 0);

	//关闭套接字
	closesocket(sockConnect);

	WSACleanup();

	system("pause");
	return;
}

================================================

基于 UDP 无连接的 socket 编程

服务端程序流程：
1.加载套接字库       WSAStartup
2.创建套接字          socket
3.将创建的套接字绑定到一个本地地址和端口上     bind
4.等待接收数据。后与客户端实现实时交流           recvfrom / sendto
5.关闭套接字          closesocket

客户端程序流程：
1.加载套接字库    WSAStartup
2.创建套接字        socket
3.向服务器发送数据.后与服务端实现实时交流     recvfrom / sendto
4.关闭套接字       closesocket

服务器端代码：

[cpp] view plain copy print ?

#include <Winsock2.h>
#include <stdio.h>
#pragma comment(lib, "Ws2_32.lib")
void main()
{
// 加载套接字库，并进行套接字的版本协商
WORD wVersionRequested; // 指定将要加载的 winsock 库版本
WSADATA wsaData; // 用于存储加载的 wdnsock 库版本信息
int result; // 用于检测 WSAStartup 函数运行结果
wVersionRequested = MAKEWORD(1, 1); // 设定版本
result = WSAStartup(wVersionRequested, &wsaData);
// 函数 WSAStartup 调用成功返回 0
// 出错处理
if (result != 0)
{
return;
}
if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
{
WSACleanup();
return;
}
// 创建用于套接字
SOCKET sockConnect = socket(AF_INET, SOCK_DGRAM, 0);
// 绑定套接字
SOCKADDR_IN addrInfo; // 存储本地主机地址信息
addrInfo.sin_addr.S_un.S_addr = htonl(INADDR_ANY); // 本地主机地址
addrInfo.sin_port = htons(6000); // 端口号
addrInfo.sin_family = AF_INET; // 地址族
bind(sockConnect, (SOCKADDR *)&addrInfo, sizeof(SOCKADDR));
// 等待接收数据
char recvBuf[100]; // 接收数据缓冲
char sendBuf[100]; // 发送数据缓冲
char tempBuf[200];
SOCKADDR_IN addrInfoClient; // 存储客户端地址信息
int len = sizeof(SOCKADDR);
while (true)
{
recvfrom(sockConnect, recvBuf, strlen(recvBuf), 0, (SOCKADDR *)&addrInfoClient, &len);
if ('q' == recvBuf[0])
{
sendto(sockConnect, "q", strlen("q") + 1, 0, (SOCKADDR *)&addrInfoClient, len);
printf("聊天结束");
break;
}
sprintf(tempBuf, "%s 说：%s", inet_ntoa(addrInfoClient.sin_addr), recvBuf);
printf("%s\n", tempBuf);
// 发送数据
printf("我说：");
gets(sendBuf);
sendto(sockConnect, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR *)&addrInfoClient, len);
}
// 关闭套接字
closesocket(sockConnect);
WSACleanup();
}

#include <Winsock2.h>
#include <stdio.h>
#pragma comment(lib, "Ws2_32.lib")

void main()
{
	// 加载套接字库，并进行套接字的版本协商
	WORD		wVersionRequested;	// 指定将要加载的 winsock 库版本
	WSADATA		wsaData;			// 用于存储加载的 wdnsock 库版本信息
	int			result;				// 用于检测 WSAStartup 函数运行结果

	wVersionRequested = MAKEWORD(1, 1);		// 设定版本

	result	= WSAStartup(wVersionRequested, &wsaData);

	// 函数 WSAStartup 调用成功返回 0
	// 出错处理
	if (result != 0)
	{
		return;
	}

	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
	{
		WSACleanup();
		return;
	}

	// 创建用于套接字
	SOCKET	sockConnect	= socket(AF_INET, SOCK_DGRAM, 0);

	// 绑定套接字
	SOCKADDR_IN		addrInfo;		// 存储本地主机地址信息

    addrInfo.sin_addr.S_un.S_addr   = htonl(INADDR_ANY);    // 本地主机地址  
    addrInfo.sin_port               = htons(6000);          // 端口号  
    addrInfo.sin_family             = AF_INET;              // 地址族  
  
    bind(sockConnect, (SOCKADDR *)&addrInfo, sizeof(SOCKADDR));  

	// 等待接收数据
	char	recvBuf[100];	// 接收数据缓冲
	char	sendBuf[100];	// 发送数据缓冲
	char	tempBuf[200];	

	SOCKADDR_IN		addrInfoClient;	// 存储客户端地址信息
	int				len	= sizeof(SOCKADDR);

	while (true)
	{
		recvfrom(sockConnect, recvBuf, strlen(recvBuf), 0, (SOCKADDR *)&addrInfoClient, &len);
		if ('q' == recvBuf[0])
		{
			sendto(sockConnect, "q", strlen("q") + 1, 0, (SOCKADDR *)&addrInfoClient, len);
			printf("聊天结束");
			break;
		}

		sprintf(tempBuf, "%s 说：%s", inet_ntoa(addrInfoClient.sin_addr), recvBuf);
		printf("%s\n", tempBuf);

		// 发送数据
		printf("我说：");
		gets(sendBuf);
		sendto(sockConnect, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR *)&addrInfoClient, len);
	}

	// 关闭套接字
	closesocket(sockConnect);
	WSACleanup();

}

客户端代码：

[cpp] view plain copy print ?

#include <Winsock2.h>
#include <stdio.h>
#pragma comment(lib, "Ws2_32.lib")
void main()
{
// 加载套接字库，并进行套接字的版本协商
WORD wVersionRequested; // 指定将要加载的 winsock 库版本
WSADATA wsaData; // 用于存储加载的 wdnsock 库版本信息
int result; // 用于检测 WSAStartup 函数运行结果
wVersionRequested = MAKEWORD(1, 1); // 设定版本
result = WSAStartup(wVersionRequested, &wsaData);
// 函数 WSAStartup 调用成功返回 0
// 出错处理
if (result != 0)
{
return;
}
if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
{
WSACleanup();
return;
}
// 创建套接字
SOCKET sockConnect = socket(AF_INET, SOCK_DGRAM, 0);
// 向服务器发送数据
SOCKADDR_IN addrInfoServer; // 存储服务器地址信息
addrInfoServer.sin_addr.S_un.S_addr = inet_addr("127.0.0.1"); // 指定服务器地址
addrInfoServer.sin_port = htons(6000); // 端口号
addrInfoServer.sin_family = AF_INET; // 地址族
int len = sizeof(SOCKADDR);
char recvBuf[100]; // 接收数据缓冲
char sendBuf[100]; // 发送数据缓冲
char tempBuf[200];
while (true)
{
// 发送数据
printf("我说：");
gets(sendBuf);
sendto(sockConnect, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR*)&addrInfoServer, len);
// 等待并接收数据
recvfrom(sockConnect,recvBuf, strlen(recvBuf), 0, (SOCKADDR*)&addrInfoServer, &len);
if ('q' == recvBuf[0])
{
sendto(sockConnect, "q", strlen("q") + 1, 0, (SOCKADDR*)&addrInfoServer, len);
printf("聊天结束");
break;
}
sprintf(tempBuf, "%s 说：%s", inet_ntoa(addrInfoServer.sin_addr), recvBuf);
printf("%s\n", tempBuf);
}
// 关闭套接字
closesocket(sockConnect);
WSACleanup();
}

#include <Winsock2.h>
#include <stdio.h>
#pragma comment(lib, "Ws2_32.lib")

void main()
{
	// 加载套接字库，并进行套接字的版本协商
	WORD		wVersionRequested;	// 指定将要加载的 winsock 库版本
	WSADATA		wsaData;			// 用于存储加载的 wdnsock 库版本信息
	int			result;				// 用于检测 WSAStartup 函数运行结果

	wVersionRequested = MAKEWORD(1, 1);		// 设定版本

	result	= WSAStartup(wVersionRequested, &wsaData);

	// 函数 WSAStartup 调用成功返回 0
	// 出错处理
	if (result != 0)
	{
		return;
	}

	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
	{
		WSACleanup();
		return;
	}

	// 创建套接字
	SOCKET	sockConnect	= socket(AF_INET, SOCK_DGRAM, 0);

	// 向服务器发送数据
	SOCKADDR_IN		addrInfoServer;		// 存储服务器地址信息

    addrInfoServer.sin_addr.S_un.S_addr   = inet_addr("127.0.0.1");		// 指定服务器地址
    addrInfoServer.sin_port               = htons(6000);				// 端口号  
    addrInfoServer.sin_family             = AF_INET;					// 地址族 

	int		len = sizeof(SOCKADDR);

	char	recvBuf[100];	// 接收数据缓冲
	char	sendBuf[100];	// 发送数据缓冲
	char	tempBuf[200];	

	while (true)
	{
		// 发送数据
		printf("我说：");
		gets(sendBuf);
		sendto(sockConnect, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR*)&addrInfoServer, len);

		// 等待并接收数据
		recvfrom(sockConnect,recvBuf, strlen(recvBuf), 0, (SOCKADDR*)&addrInfoServer, &len);
		if ('q' == recvBuf[0])
		{
			sendto(sockConnect, "q", strlen("q") + 1, 0, (SOCKADDR*)&addrInfoServer, len);
			printf("聊天结束");
			break;
		}

		sprintf(tempBuf, "%s 说：%s", inet_ntoa(addrInfoServer.sin_addr), recvBuf);
		printf("%s\n", tempBuf);
	}

	// 关闭套接字
	closesocket(sockConnect);
	WSACleanup();

}

[cpp] view plain copy print ?

vc网络编程常用类型解析：
1. SOCKET 类型
SOCKET 是 socket 套接字类型，在 WINSOCK2.H 中有如下定义：
typedef unsigned u_int;
typedef u_int SOCKET;
可知套接字实际上就是一个无符号整形，它将被 Socket 环境管理和使用。
套接字将被创建、设置、用来发送和接收数据，最后会被关闭。
2.WORD 类型、MAKEWORD、LOBYTE、HIBYTE 宏
WORD 类型是一个 16 位的无符号整型，在 WTYPES.H 中被定义为：
typedef unsigned short WORD;
其目的是提供两个字节的存储，在 Socket 中这两个字节可以表示主版本号和副版本号。
使用 MAKEWORD 宏可以给一个 WORD 类型赋值。例如要表示主版本号 2，副版本号 0，可以使用如下代码：
WORD wVersionRequested;
wVersionRequested = MAKEWORD(2, 0);
注意低位内存存储主版本号 2，高位内存存储副版本号 0，其值为 0x0002。
使用宏 LOBYTE 可以读取 WORD 的低位字节， HIBYTE 可以读取高位字节。
3.WSADATA 类型和 LPWSADATA 类型
WSADATA 类型是一个结构，描述了 Socket 库的一些相关信息，其结构定义如下：
typedef struct WSAData
{
WORD wVersion;
WORD wHighVersion;
char szDescription[WSADESCRIPTION_LEN + 1];
char szSystemStatus[WSASYS_STATUS_LEN + 1];
unsigned short iMaxSockets;
unsigned short iMaxUdpDg;
char FAR* lpVendorInfo;
}WSADATA;
typedef WSADATA FAR* LPWSADATA;
值得注意的是 wVersion 字段，存储了 Socket 的版本类型。LPWSADATA 是 WSADATA 的指针类型。
他们通过 Socket 的初始化函数 WSAStartup 读取出来。
vc网络编程常用函数解析：
1. WSAStartup 函数
用于初始化 Socket 环境，函数原型：
int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);
其返回值为整型，调用方式为 PASCAL （即标准类型，PASCAL 等于__stdcall），参数有两个，
第一个参数为 WORD 类型，指明了 Socket 的版本号，第二个参数为 LPWSADATA，指向一个用于存储 Socket 库信息的WSAStartup结构。
返回值：
返回值为0，则初始化成功，若不为0则为失败。
2.WSACleanup 函数
这是 Socket 环境的退出函数，函数原型：
int WSACleanup (void);
返回值：
返回值为0表示成功，SOCKET_ERROR 表示失败。
3.socket 函数
socket 套接字的创建函数，函数原型：
SOCKET socket(int af, int type, int protocol );
第一个参数为：int af，代表网络地址族，目前只有一种取值有效，即 AF_INET, 代表 internet 地址族；
第二个参数为：int type，代表网络协议类型， SOCK_DGRAM 代表 UDP 协议， SOCK_STREAM 代表 TCP 协议。
第三个参数为：int protocol，指定网络地址族特殊协议，目前无用，赋值0即可。
返回值：
返回值为 SOCKET，若返回INVALID_SOCKET 则失败。
4.bind 函数
用于将套接字绑定到一个已知地址上，函数原型：
int bind(SOCKET s, const struct sockaddr FAR *name, int namelen);
第一个参数为：SOCKET s，指定将被绑定的套接字。
第二个参数为：SOCKADDR_IN *name，是一个sockaddr结构指针，该结构中包含了要绑定的地址和端口。
第三个参数为：int namelen，确定第二个参数的结构长度。
返回值：成功返回0，失败返回SOCKET_ERROR。
下面对其涉及的类型作一番解析：
sockaddr 类型：
sockaddr 类型是用来表示 Socket 地址的类型，同上面的 socketaddr_in 类型相比，sockaddr 的适用范围更广，
因为sockeaddr_in只适用于 TCP/IP 地址。sockaddr 的定义如下：
struct sockaddr
{
ushort sa_family;
char sa_data[14];
};
可知sockaddr 的16个字节，而sockaddr_in也有16个字节，所以sockaddr_in是可以强制类型转换为sockadddr的。
事实上也往往使用这种方法。
sockaddr_in 定义了socket发送和接收数据包的地址，其定义如下：
strucr sockaddr_in
{
short sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};
其中 in_addr 定义如下：
struct in_addr
{
union
{
struct {u_char s_b1, s_b2, s_b3, s_b4} S_un_b;
struct {u_short s_w1, s_w2} S_un_w;
u_long S_addr;
}S_un;
};
首先阐述 in_addr 的信义。
很显然它是一个存储 ip 地址的联合体，有三种表达方式：
第一种用四个字节来表示IP地址的四个数字；
第二种用两个双字节来表示IP地址；
第三种用一个长整型来表示IP地址；
给 in_addr 赋值的一种最简单方法是使用 inet_addr 函数，它可以把一个代表IP地址的字符串赋值
转换为in_addr类型。如：
addrServer.sin_addr = inet_addr("192.168.0.2");
其反函数是 inet_ntoa，可以把一个 in_addr 类型转换为一个字符串。
sockaddr_in的含义比in_addr的含义要广泛，其各个字段的含义和取值如下：
第一字段 short sin_family，代表网络地址族，如前所述，只能取值AF_INET;
第二字段 u_short sin_port，代表IP地址端口，由程序员指定；
第三字段 struct in_addr sin_addr，代表IP地址；
第四个字段char sin_zero[8]，是为了保证sockaddr_in与SOCKADDR类型的长度相等而填充进来的字段。
5.listen 函数
该函数让一个套接字在指定IP地址的指定端口处监听连接请求的到来，函数原型：
int listen( SOCKET s, int backlog );
该函数使得一个进程可以接受其他进程的请求，从而成为一个服务器进程。
在TCP服务器编程中listen函数把进程变为一个服务器，并指定相应的套接字变为被动连接。
listen 函数一般在调用bind之后、调用accept之前调用。
返回值：成功则返回0，失败返回SOCKET_ERROR，可以调用函数WSAGetLastError来取得错误代码。
6.accept函数
该函数从连接请求队列中获得连接信息，并创建新的套接字用于收发数据，实现服务器与客户端的通信。函数原型：
SOCKET accept(SOCKET s, struct sockaddr FAR *addr, int FAR *addrlen);
第一个参数：SOCKET s，监听套接字
第二个参数：struct sockaddr addr，存储请求连接的客户端IP地址、端口信息
第三个参数：int addrlen，第二个参数所占空间大小
返回值：
成功返回新套接字，失败返回错误信息
7.connect 函数
向指定的网络主机请求连接，函数原型：
int connect(SOCKET s, const struct sockaddr FAR *name, int namelen);
第一个参数：SOCKET s，客户端用于收发数据的套接字。
第二个参数：struct sockaddr *name，指定网络主机IP地址和端口号。
第三个参数：int namelen，第二参数长度
返回值：
成功返回0，失败返回-1。
8.sendto、recvfrom、send、recv函数
在 Socket 中有两套发送和接收函数。一是sendto 和recvfrom; 二是send 和 recv。
前一套在函数参数中要指明地址（UDP协议），
而后一套需要先将套接字和一个地址绑定，然后直接发送和接收，不需绑定地址。
函数原型：
int sendto( SOCKET s, const char FAR *buf, int len, int flags, const struct sockaddr FAR *to, int tolen);
int recvfrom(SOCKET s, char FAR* buf, int len, int flags, struct sockaddr FAR *from, int FAR *fromlen);
int send(SOCKET s,const char FAR *buf, int len, int flags);
int recv(SOCKET s, char FAR *buf, int len, int flags);
第一个参数：套接字
第二个参数：数据指针
第三个参数：数据长度
第四个参数：收发数据方式的标识，如果不需要特殊要求可以设置为0，其他值可参考MSDN；
第五个参数：目标主机地址
第六个参数：地址的长度
返回值：运行成功则返回收发数据的字节数，失败返回SOCKET_ERROR
9.closesocket 函数
关闭套接字，函数原型：
int closesocket( SOCKET s );
返回值：成功返回0，失败返回SOCKET_ERROR。

from：http://blog.csdn.net/ltag0110rtag/article/details/7390304

MFC 网络编程 -- 总结 .

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

MFC 网络编程 -- 总结 .

热门文章

最新文章

相关课程

相关电子书

相关实验场景