C++ Socket实现TCP与UDP网络编程

2024-12-04 23:38:39

前言

socket编程分为TCP和UDP两个模块，其中TCP是可靠的、安全的，常用于发送文件等，而UDP是不可靠的、不安全的，常用作视频通话等。

如下图：

头文件与库：

#include <WinSock2.h>

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

准备工作：

创建工程后，首先右键工程，选择属性

然后选择 C/C++ - 预处理器 - 预处理器定义

将字符串 _WINSOCK_DEPRECATED_NO_WARNINGS 添加到里面去，点击应用即可！

TCP

连接过程图：

创建tcp服务器和客户端都是按照上图的步骤来操作的！

1). 服务器

初始化套接字库
对应图中socket()

WORD wVersion;
WSADATA wsaData;
int err;

// 设置版本，可以理解为1.1
wVersion = MAKEWORD(1, 1);	// 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来

// 启动
err = WSAStartup(wVersion, &wsaData);

创建tcp套接字
对应图中socket()

// AF_INET:ipv4   AF_INET6:ipv6
SOCKET sockSrv = socket(AF_INET, SOCK_STREAM, 0);

绑定到本机
对应图中bind()

// 准备绑定信息
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);	// 设置绑定网卡
addrSrv.sin_family = AF_INET;		// 设置绑定网络模式
addrSrv.sin_port = htons(6000);		// 设置绑定端口
// hton: host to network  x86:小端    网络传输：htons大端

// 绑定到本机
int retVal = bind(sockSrv, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));

监听
对应图中listen()

// 同时能接收10个链接，主要看参数二的设置个数
listen(sockSrv, 10);

接收连接请求，返回针对客户端的套接字
对应图中accept()

SOCKET sockConn = accept(sockSrv, (SOCKADDR *)&addrCli, &len);

发送数据
对应图中write()

sprintf_s(sendBuf, "hello client!\n");
int iSend = send(sockConn, sendBuf, strlen(sendBuf) + 1, 0);

接收数据
对应图中read()

recv(sockConn, recvBuf, 100, 0);

关闭套接字
对应图中close()

closesocket(sockConn);

清理套接字库

WSACleanup();

具体实现代码：

#include <iostream>
#include <stdio.h>
#include <WinSock2.h>

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

int main(void) {

	// 1.初始化套接字库
	WORD wVersion;
	WSADATA wsaData;
	int err;

	// 设置版本，可以理解为1.1
	wVersion = MAKEWORD(1, 1);	// 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来

	// 启动
	err = WSAStartup(wVersion, &wsaData);
	if (err != 0) {
		return err;
	}
	// 检查：网络低位不等于1 || 网络高位不等于1
	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
		// 清理套接字库
		WSACleanup();
		return -1;
	}

	// 2.创建tcp套接字		// AF_INET:ipv4   AF_INET6:ipv6
	SOCKET sockSrv = socket(AF_INET, SOCK_STREAM, 0);

	// 准备绑定信息
	SOCKADDR_IN addrSrv;
	addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);	// 设置绑定网卡
	addrSrv.sin_family = AF_INET;		// 设置绑定网络模式
	addrSrv.sin_port = htons(6000);		// 设置绑定端口
	// hton: host to network  x86:小端    网络传输：htons大端

	// 3.绑定到本机
	int retVal = bind(sockSrv, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
	if (retVal == SOCKET_ERROR) {
		printf("Failed bind:%d\n", WSAGetLastError());
		return -1;
	}

	// 4.监听，同时能接收10个链接
	if (listen(sockSrv, 10) == SOCKET_ERROR) {
		printf("Listen failed:%d", WSAGetLastError());
		return -1;
	}

	std::cout << "Server start at port: 6000" << std::endl;

	SOCKADDR_IN addrCli;
	int len = sizeof(SOCKADDR);

	char recvBuf[100];
	char sendBuf[100];
	while (1) {
		// 5.接收连接请求，返回针对客户端的套接字
		SOCKET sockConn = accept(sockSrv, (SOCKADDR *)&addrCli, &len);
		if (sockConn == SOCKET_ERROR) {
			//printf("Accept failed:%d", WSAGetLastError());
			std::cout << "Accept failed: " << WSAGetLastError() << std::endl;
			break;
		}

		//printf("Accept client IP:[%s]\n", inet_ntoa(addrCli.sin_addr));
		std::cout << "Accept client IP: " << inet_ntoa(addrCli.sin_addr) << std::endl;

		// 6.发送数据
		sprintf_s(sendBuf, "hello client!\n");
		int iSend = send(sockConn, sendBuf, strlen(sendBuf) + 1, 0);
		if (iSend == SOCKET_ERROR) {
			std::cout << "send failed!\n";
			break;
		}

		// 7.接收数据
		recv(sockConn, recvBuf, 100, 0);
		std::cout << recvBuf << std::endl;

		// 关闭套接字
		closesocket(sockConn);
	}

	// 8.关闭套接字
	closesocket(sockSrv);

	// 9.清理套接字库
	WSACleanup();

	return 0;
}

2). 客户端

初始化套接字库
对应图中socket()

WORD wVersion;
WSADATA wsaData;
int err;

// 可以理解为1.1
wVersion = MAKEWORD(1, 1);	// 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来

// 启动
err = WSAStartup(wVersion, &wsaData);

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

连接服务器
对应图中connect()

// 连接服务器
int err_log = connect(sockCli, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));

发送数据到服务器
对应图中write()

char sendBuf[] = "你好，服务器，我是客户端！";
send(sockCli, sendBuf, strlen(sendBuf) + 1, 0);

接收服务器的数据
对应图中read()

char recvBuf[100];
recv(sockCli, recvBuf, sizeof(recvBuf), 0);

关闭套接字并清除套接字库
对应图中close()

closesocket(sockCli);
WSACleanup();

具体实现代码：

#include <iostream>
#include <WinSock2.h>

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

int main(void) {

	// 1.初始化套接字库
	WORD wVersion;
	WSADATA wsaData;
	int err;

	// 可以理解为1.1
	wVersion = MAKEWORD(1, 1);	// 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来

	// 启动
	err = WSAStartup(wVersion, &wsaData);
	if (err != 0) {
		return err;
	}
	// 检查：网络地位不等于1 || 网络高位不等于1
	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
		// 清理套接字库
		WSACleanup();
		return -1;
	}

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

	SOCKADDR_IN addrSrv;
	addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");	// 服务器地址
	addrSrv.sin_port = htons(6000);		// 端口号
	addrSrv.sin_family = AF_INET;		// 地址类型(ipv4)

	// 2.连接服务器
	int err_log = connect(sockCli, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
	if (err_log == 0) {
		printf("连接服务器成功！\n");

	} else {
		printf("连接服务器失败！\n");
		return -1;
	}

	char recvBuf[100];
	char sendBuf[] = "你好，服务器，我是客户端！";
	// 3.发送数据到服务器
	send(sockCli, sendBuf, strlen(sendBuf) + 1, 0);

	// 4.接收服务器的数据
	recv(sockCli, recvBuf, sizeof(recvBuf), 0);
	std::cout << recvBuf << std::endl;

	// 5.关闭套接字并清除套接字库
	closesocket(sockCli);
	WSACleanup();

	system("pause");

	return 0;
}

运行效果：

3). TCP聊天小项目

下面是根据上面的代码修改的一个聊天小项目(使用到了多线程)

只有一个服务器，服务器一直开启等待客户端连接；
客户都安可以开启多个，且可以一直连续的与服务器进行发送接收消息；
服务器给客户端发送数据，得通过1 - 9来区分到底给那个客户端发送消息，例如给第二个客户端发送消息：2你好，客户端
客户端那边接收到的数据是：你好，客户端

服务器代码：

#include <iostream>
#include <WinSock2.h>
#include <stdio.h>
#include <Windows.h>
#include <process.h>
#include <vector>
#include <conio.h>
#include <string.h>
#include <string>

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

SOCKET sockSrv;
std::vector<SOCKET> vec_sockConn;
std::vector<SOCKADDR_IN> vec_sockaddr_in;
std::vector<int> vec_sockIndex;

// 这个结构体用作线程参数
typedef struct SERVER_CLIENT {
	SOCKET server;
	SOCKADDR_IN client;
	int clientIndex;
}SC;

// 判断有没有断开连接
bool IsSocketClosed(SOCKET clientSocket) {
	bool ret = false;
	HANDLE closeEvent = WSACreateEvent();
	WSAEventSelect(clientSocket, closeEvent, FD_CLOSE);

	DWORD dwRet = WaitForSingleObject(closeEvent, 0);

	if (dwRet == WSA_WAIT_EVENT_0)
		ret = true;
	else if (dwRet == WSA_WAIT_TIMEOUT)
		ret = false;

	WSACloseEvent(closeEvent);
	return ret;
}

// 接收请求
unsigned int WINAPI  ThreadAccept(LPVOID p) {
	static int i = 0;
	while (1) {
		SOCKADDR_IN addrCli;
		int len = sizeof(SOCKADDR);

		// 5.接收连接请求，返回针对客户端的套接字
		SOCKET sockConn = accept(sockSrv, (SOCKADDR *)&addrCli, &len);
		if (sockConn == SOCKET_ERROR) {
			printf("Accept failed:%d", WSAGetLastError());
		}

		// 存储当前服务器与客户端 连接绑定的socket
		vec_sockIndex.emplace_back(i++);
		vec_sockaddr_in.emplace_back(addrCli);
		vec_sockConn.emplace_back(sockConn);

		printf("\033[0;%d;40m客户端[%d]上线\033[0m\n", 31, i);
	}

	return 0;
}

unsigned int WINAPI  _ThreadRecv(LPVOID p) {
	char recvBuf[100];
	memset(recvBuf, 0, 100);

	SC _sc = *(SC *)p;

	while (1) {
		Sleep(20);

		if (IsSocketClosed(_sc.server) == true) {
			printf("客户端 [%d] 断开连接！\n", _sc.clientIndex + 1);
			break;
		}

		// 接收数据
		recv(_sc.server, recvBuf, 100, 0);
		if (strlen(recvBuf) == 0) {
			continue;
		}

		printf("接收到客户端 [%d] 的消息：%s\n", _sc.clientIndex + 1, recvBuf);
		memset(recvBuf, 0, 100);
	}
	return 0;
}

unsigned int WINAPI  ThreadRecv(LPVOID p) {

	static int index = 0;

	while (1) {
		// 还没有客户端与服务器进行连接
		if (vec_sockConn.size() == 0) {
			continue;
		}

		// 接收线程已经开启和客户端个数相等
		if (vec_sockConn.size()  == index) {
			continue;
		}

		SC sc;
		sc.server = vec_sockConn.at(index);
		sc.client = vec_sockaddr_in.at(index);
		sc.clientIndex = vec_sockIndex.at(index);

		HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, _ThreadRecv, (void *)&sc, 0, NULL);

		index++;
		Sleep(20);
	}

	return 0;
}

int main(void) {

	// 1.初始化套接字库
	WORD wVersion;
	WSADATA wsaData;
	int err;

	// 设置版本，可以理解为1.1
	wVersion = MAKEWORD(1, 1);	// 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来

	// 启动
	err = WSAStartup(wVersion, &wsaData);
	if (err != 0) {
		return err;
	}
	// 检查：网络低位不等于1 || 网络高位不等于1
	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
		// 清理套接字库
		WSACleanup();
		return -1;
	}

	// 2.创建tcp套接字		// AF_INET:ipv4   AF_INET6:ipv6
	sockSrv = socket(AF_INET, SOCK_STREAM, 0);

	// 准备绑定信息
	SOCKADDR_IN addrSrv;
	addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);	// 设置绑定网卡
	addrSrv.sin_family = AF_INET;		// 设置绑定网络模式
	addrSrv.sin_port = htons(6000);		// 设置绑定端口
	// hton: host to network  x86:小端    网络传输：htons大端

	// 3.绑定到本机
	int retVal = bind(sockSrv, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
	if (retVal == SOCKET_ERROR) {
		printf("Failed bind:%d\n", WSAGetLastError());
		return -1;
	}

	// 4.监听，同时接收10个链接
	if (listen(sockSrv, 10) == SOCKET_ERROR) {
		printf("Listen failed:%d", WSAGetLastError());
		return -1;
	}

	std::cout << "Server start at port: 6000" << std::endl;

	// 线程句柄				// 创建线程
	HANDLE hThread_1 = (HANDLE)_beginthreadex(NULL, 0, ThreadAccept, NULL, 0, NULL);
	HANDLE hThread_2 = (HANDLE)_beginthreadex(NULL, 0, ThreadRecv, NULL, 0, NULL);

	//uiInit();
	//editPrint(0, ">");

	char sendBuf[100];
	while (1) {

		//printf("请输入发送内容：");

		char c = getchar();				// 输入发送给谁
		scanf_s("%s", sendBuf, 100);	// 输入发送的内容

		if (strlen(sendBuf) == 0) {
			printf("输入内容为空或者超长！\n");
		}

		// 1 至 9
		if (c < '1' || c > '9' || vec_sockConn.size() == 0 || c - '0' >= vec_sockConn.size() + 1) {
			while ((c = getchar()) != '\n');	// 清空输入缓冲区
			memset(sendBuf, 0, 100);
			printf("输入内容不符合规则！\n");
			continue;
		}

		// 发送数据
		int index = --c - '0';	// 因为下标是从零开始的，所以c要先自减
		int iSend = send(vec_sockConn.at(index) , sendBuf, strlen(sendBuf) + 1, 0);
		if (iSend == SOCKET_ERROR) {
			std::cout << "send failed!\n";
			break;
		}

		memset(sendBuf, 0, 100);
		while ((c = getchar()) != '\n');	// 清空输入缓冲区
	}

	// 关闭套接字
	std::vector<SOCKET>::iterator it = vec_sockConn.begin();
	for (; it != vec_sockConn.end(); it++) {
		closesocket((SOCKET)(*it));
	}

	WaitForSingleObject(hThread_1, INFINITE);
	WaitForSingleObject(hThread_2, INFINITE);

	CloseHandle(hThread_1);
	CloseHandle(hThread_2);

	// 7.关闭套接字
	closesocket(sockSrv);

	// 8.清理套接字库
	WSACleanup();

	return 0;
}

客户端：

#include <iostream>
#include <WinSock2.h>
#include <process.h>
#include <stdio.h>

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

SOCKET sockCli;

// 判断有没有断开连接
bool IsSocketClosed(SOCKET clientSocket) {
	bool ret = false;
	HANDLE closeEvent = WSACreateEvent();
	WSAEventSelect(clientSocket, closeEvent, FD_CLOSE);

	DWORD dwRet = WaitForSingleObject(closeEvent, 0);

	if (dwRet == WSA_WAIT_EVENT_0)
		ret = true;
	else if (dwRet == WSA_WAIT_TIMEOUT)
		ret = false;

	WSACloseEvent(closeEvent);
	return ret;
}

unsigned int WINAPI  ThreadRecv(LPVOID p) {
	char recvBuf[100];
	memset(recvBuf, 0, 100);

	while (1) {
		Sleep(20);

		if (IsSocketClosed(sockCli) == true) {
			printf("服务器 断开连接！\n");
			break;
		}

		// 接收服务器的数据
		recv(sockCli, recvBuf, sizeof(recvBuf), 0);
		if (strlen(recvBuf) == 0) continue;

		std::cout << recvBuf << std::endl;
		memset(recvBuf, 0, 100);
	}

	return 0;
}

int main(void) {

	// 1.初始化套接字库
	WORD wVersion;
	WSADATA wsaData;
	int err;

	// 可以理解为1.1
	wVersion = MAKEWORD(1, 1);	// 例：MAKEWORD(a, b) --> b | a << 8 将a左移8位变成高位与b合并起来

	// 启动
	err = WSAStartup(wVersion, &wsaData);
	if (err != 0) {
		return err;
	}
	// 检查：网络地位不等于1 || 网络高位不等于1
	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
		// 清理套接字库
		WSACleanup();
		return -1;
	}

	// 创建TCP套接字
	sockCli = socket(AF_INET, SOCK_STREAM, 0);

	SOCKADDR_IN addrSrv;
	addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");	// 服务器地址
	addrSrv.sin_port = htons(6000);		// 端口号
	addrSrv.sin_family = AF_INET;		// 地址类型(ipv4)

	// 连接服务器
	int err_log = connect(sockCli, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
	if (err_log == 0) {
		printf("连接服务器成功！\n");

	} else {
		printf("连接服务器失败！\n");
		return -1;
	}

	// 线程句柄				// 创建线程
	HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, ThreadRecv, NULL, 0, NULL);

	char sendBuf[100];
	while (1) {

		//printf("请输入发送内容：");
		scanf_s("%s", sendBuf, 100);

		// 发送数据到服务器
		send(sockCli, sendBuf, strlen(sendBuf) + 1, 0);

		memset(sendBuf, 0, 100);
		char c;
		while ((c = getchar()) != '\n');
	}

	WaitForSingleObject(hThread, INFINITE);
	CloseHandle(hThread);

	// 关闭套接字并清除套接字库
	closesocket(sockCli);
	WSACleanup();

	system("pause");

	return 0;
}

运行效果：

UDP

UDP就比较简单了，步骤比tcp要少一些。

连接过程图：

1). 服务器

初始化套接字库

WORD wVersion;
WSADATA wsaData;
int err;

wVersion = MAKEWORD(1, 1);

创建套接字

SOCKET sockSrv = socket(AF_INET, SOCK_DGRAM, 0);

绑定

// SOCKADDR_IN addrSrv; 省略了定义和赋值
bind(sockSrv, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));

接收数据

char recvBuf[100];
recvfrom(sockSrv, recvBuf, 100, 0, (SOCKADDR *)&addrCli, &len);

发送数据

char sendBuf[] = "hello Client，I'm Server！\n";
sendto(sockSrv, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR *)&addrCli, len);

关闭

closesocket(sockSrv);
WSACleanup();

具体实现代码：

#include <WinSock2.h>
#include <iostream>

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

int main(void) {
	// 初始化套接字库
	WORD wVersion;
	WSADATA wsaData;
	int err;

	wVersion = MAKEWORD(1, 1);
	err = WSAStartup(wVersion, &wsaData);
	if (err != 0) {
		return err;
	}

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

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

	SOCKADDR_IN addrSrv;
	addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
	addrSrv.sin_family = AF_INET;
	addrSrv.sin_port = htons(6001);

	// 绑定到本机6001端口
	bind(sockSrv, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));

	// 接收请求，处理请求
	SOCKADDR_IN addrCli;
	int len = sizeof(SOCKADDR);

	char sendBuf[] = "hello Client，I'm Server！\n";
	char recvBuf[100];

	std::cout << "start UDP server with port 6001" << std::endl;
	while (1) {
		// 接收数据
		recvfrom(sockSrv, recvBuf, 100, 0, (SOCKADDR *)&addrCli, &len);
		std::cout << "Recv:" << recvBuf << std::endl;

		// 发送数据
		sendto(sockSrv, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR *)&addrCli, len);
		std::cout << "Send:" << sendBuf << std::endl;
	}

	closesocket(sockSrv);
	WSACleanup();

	return 0;
}

2). 客户端

初始化套接字库

WORD wVersion;
WSADATA wsaData;
int err;

wVersion = MAKEWORD(1, 1);

创建UDP套接字

SOCKET sockCli = socket(AF_INET, SOCK_DGRAM, 0);
SOCKADDR_IN addrSrv;

接收数据

char recvBuf[100];
recvfrom(sockCli, recvBuf, 100, 0, (SOCKADDR *)&addrCli, &len);

发送数据

char sendBuf[] = "hello Client，I'm Server！\n";
sendto(sockCli, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR *)&addrSrv, len);

关闭

closesocket(sockSrv);
WSACleanup();

具体实现代码：

#include <WinSock2.h>
#include <iostream>

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

int main(void) {

	// 初始化套接字库
	WORD wVersion;
	WSADATA wsaData;
	int err;

	wVersion = MAKEWORD(1, 1);
	err = WSAStartup(wVersion, &wsaData);
	if (err != 0) {
		return err;
	}

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

	// 创建UDP套接字
	SOCKET sockCli = socket(AF_INET, SOCK_DGRAM, 0);
	SOCKADDR_IN addrSrv;
	addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
	addrSrv.sin_family = AF_INET;
	addrSrv.sin_port = htons(6001);

	SOCKADDR_IN addrCli;
	int len = sizeof(SOCKADDR);

	char sendBuf[] = "hello, I'm Client!\n";
	char recvBuf[100];

	std::cout << "send to Server: " << sendBuf << std::endl;
	sendto(sockCli, sendBuf, strlen(sendBuf) + 1, 0, (SOCKADDR *)&addrSrv, len);

	recvfrom(sockCli, recvBuf, 100, 0, (SOCKADDR *)&addrCli, &len);
	std::cout << "recv from: " << recvBuf << std::endl;

	closesocket(sockCli);
	WSACleanup();

	system("pause");
	return 0;
}

运行效果：

总结

socket的具体细节用法我不太清楚，现阶段也只是熟悉TCP的一些简单操作，UDP的话也还不是太懂，不懂的是不知道在具体项目中该如何进行使用它们。
那个TCP的小项目也只是自己琢磨搞出来的，不知掉具体项目会不会这样去写！

到此这篇关于C++ Socket实现TCP与UDP网络编程的文章就介绍到这了,更多相关C++ Socket实现TCP与UDP内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

C语言编写基于TCP和UDP协议的Socket通信程序示例

Tcp多线程服务器和客户端程序服务器程序: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <arpa/inet.h> #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #define PORT 8082 #define BUFSIZE 512 cha
C++ Socket实现TCP与UDP网络编程

目录前言 TCP 1). 服务器 2). 客户端 3). TCP聊天小项目 UDP 1). 服务器 2). 客户端总结前言 socket编程分为TCP和UDP两个模块,其中TCP是可靠的.安全的,常用于发送文件等,而UDP是不可靠的.不安全的,常用作视频通话等. 如下图: 头文件与库: #include <WinSock2.h> #pragma comment(lib, "ws2_32.lib") 准备工作: 创建工程后,首先右键工程,选择属性然后选择 C/C++
在Python下进行UDP网络编程的教程

TCP是建立可靠连接,并且通信双方都可以以流的形式发送数据.相对TCP,UDP则是面向无连接的协议. 使用UDP协议时,不需要建立连接,只需要知道对方的IP地址和端口号,就可以直接发数据包.但是,能不能到达就不知道了. 虽然用UDP传输数据不可靠,但它的优点是和TCP比,速度快,对于不要求可靠到达的数据,就可以使用UDP协议. 我们来看看如何通过UDP协议传输数据.和TCP类似,使用UDP的通信双方也分为客户端和服务器.服务器首先需要绑定端口: s = socket.socket(socket.
C++基于socket UDP网络编程实现简单聊天室功能

本文实例为大家分享了C++基于socket UDP实现简单聊天室功能的具体代码,供大家参考,具体内容如下 0.通信步骤流程图 (左:服务器:右:客户端:) 1.服务器代码 1.1服务器类头文件(CServer_UDP.h) #pragma once #include <winsock2.h> class CServer_UDP { public: CServer_UDP(); void SendMsg(const char sendBuf[]); void RecMsg(); ~CServer
QT UDP网络编程实现简单消息传输

本文实例为大家分享了QT UDP实现简单消息传输的具体代码,供大家参考,具体内容如下这几天看了下Qt的udp,顺便实现了下简单的消息传输,看起来比较简单. UDP服务器: 截图如下: 代码: server.h #ifndef WIDGET_H #define WIDGET_H #include <QWidget> #include<QUdpSocket> #include<QtNetwork> #include<QLabel> #include<QP
Python网络编程之TCP与UDP协议套接字用法示例

本文实例讲述了Python网络编程之TCP与UDP协议套接字用法.分享给大家供大家参考,具体如下: TCP协议服务器端: #!/usr/bin/env python from socket import * from time import ctime HOST = '' PORT = 21567 BUFSIZ = 1024 ADDR = (HOST, PORT) tcpSerSock = socket(AF_INET, SOCK_STREAM) ##创建服务器TCP套接字 tcpSerSoc
Pythony运维入门之Socket网络编程详解

Socket是什么? Socket 是电脑网络中进程间数据流的端点Socket 是操作系统的通信机制应用程序通过Socket进行网络数据的传输首先,简单了解一下TCP通信过程: TCP三次握手(面试常考): 第一次握手:客户端发送SYN报文,设置随机数序号X,服务器由SYN=1知道,客户端要求建立联机第二次握手:服务器端接收到客户端的报文之后,经过处理,返回给客户端SYN+ACK报文,同时设置随机序号Y,此时返回的报文确认ACK=X+1 第三次握手:接收到报文的客户端,会在处理确认之后,再
详解Android 基于TCP和UDP协议的Socket通信

本来想讲一下基础的网络通信方面的知识点,发现太枯燥乏味了,不过笔试中也经常会问到这方面的问题,所以关于通信方面的知识点,小编会放到面试中去,因为实战中也就面试会用到这方面知识点 Android与服务器的通信方式主要有两种,一是Http通信,一是Socket通信.两者的最大差异在于,http连接使用的是"请求-响应方式",即在请求时建立连接通道,当客户端向服务器发送请求后,服务器端才能向客户端返回数据. 而Socket通信中基于TCP/IP协议的通信则是在双方建立起连接后就可以直接进行数
详解Java网络编程

一.网络编程 1.1.概述 1.计算机网络是通过传输介质.通信设施和网络通信协议,把分散在不同地点的计算机设备互连起来,实现资源共享和数据传输的系统.网络编程就就是编写程序使联网的两个(或多个)设备(例如计算机)之间进行数据传输.Java语言对网络编程提供了良好的支持,通过其提供的接口我们可以很方便地进行网络编程. 2.Java是 Internet 上的语言,它从语言级上提供了对网络应用程序的支持,程序员能够很容易开发常见的网络应用程序. 3.Java提供的网络类库,可以实现无痛的网络连接,联
Java 全面掌握网络编程篇

目录计算机网络网络模型客户机服务器模式(Client/Server) TCP/IP的概念和实现 TCP三次握手(Three-way handshake) TCP编程 UDP的概念和实现 UDP编程 TCP和UDP的区别聊天室服务器处理线程客户端处理线程服务器客户端效果计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议的管理和协调下,实现资源共享和信息传递的计算机系统.包括局域网(intrane
Python socket网络编程TCP/IP服务器与客户端通信

Python socket网络编程初学 python,前段时间买了两本书<python 编程从入门到实践><Python 核心编程第三版>,第一本书主要讲的是一些基本语法和一些基本的使用方法,而第二本则深入很多,自己看来也是一知半解,刚好看到了这部分网络编程,依然有好多不太理解的地方,不过想来通过自己不断的摸索,不断地搜寻资料学习,早晚应该会变得通透吧....... 这部分主要使用的模块就是 socket 模块,在这个模块中可以找到 socket()函数,该函数用于创建套接字对象

C++ Socket实现TCP与UDP网络编程

目录

前言

TCP

1). 服务器

2). 客户端

3). TCP聊天小项目

UDP

1). 服务器

2). 客户端

总结

相关推荐

随机推荐