网络 TCP协议(C++代码 通过tcp协议实现客户端与服务端之间的通信)_c++ tcp

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

客户端操作流程：

1. 创建套接字：在内核中创建socket结构体，关联进程与网卡之间的联系
2. 为套接字绑定地址信息：描述在内核中创建的socket结构体的源端地址信息；发送的数据中源端地址信息就是绑定的地址信息（不推荐主动绑定地址，降低端口冲突的概率，从而确保数据发送的安全性）
3. 向服务端发起连接请求：当服务端处于监听状态时就可以进行连接；但是当服务端不处于监听状态，请求会丢失
4. 收发数据：被服务端特定套接字服务
5. 关闭套接字：释放资源

举一个足疗店的例子来帮助你理解服务端与客户端之间的通信

服务端接口信息
1、创建套接字int socket(int domain, int type, int protocol) 参数内容(domian：地址域(本地通信-AF_LOCAL、IPv4-AF_INET、IPv6-AF_INET6等)确定本次socket通信使用哪种协议版本的地址结构，不同的协议版本有不同的地址结构;type：套接字类型(流式套接字-SOCK_STREAM、数据报套接字-SOCK_DGRAM等);protocol：协议类型(TCP-IPPROTO_TCP、UDP-IPPROTO_UDP) ，默认为0-流式默认TCP，数据报默认UDP)
返回值：文件描述符-非负整数， 套接字所有其他接口的操作句柄，失败返回-1

2、为套接字绑定地址信息int bind(int sockfd, struct sockaddr *addr, socklen_t len)参数内容(sockfd：创建套接字返回的操作句柄；addr：要绑定的地址信息；len：要绑定的地址信息长度)

3、开始监听listen(int sockfd, int backlog) 参数内容(sockfd：将sockfd的套接字设置为监听状态，并且监听状态后可以开始接收客户端连接请求；backlog：同一时间的并发连接数，决定同一时间最多接收多少个客户端的连接请求<内核中可创建套接字数量是有限的，防止存在恶意请求导致资源耗尽>)

4、获取新建连接，从已完成连接队列中取出一个socket，并且返回这个socket的描述符操作句柄int accept(int sockfd, struct sockaddr* cli_addr, socklen_t *len)参数内容(sockfd：表示获取哪个tcp服务端套接字的新建连接；cli_addr：这个新建的套接字对应的客户端地址信息；len：地址信息长度) 返回值：新建的socket套接字的描述符，也就是外部进程中对该套接字的操作句柄

5、收发数据。在tcp套接字中已经标示了五元组，因此接收数据时不需要获取对方地址信息，发送数据时也不需要指定对方的地址信息。接收：ssize_t recv(int sockfd, char *buf, int len, int flag) 返回值：成功返回接收数据的长度，等于0表示断开连接，小于0表示出错。发送：ssize_t send(int sockfd, char *data, int len, int flag) ：返回值：成功返回发送数据的长度，等于0表示断开连接，小于0表示出错。若断开连接触发异常信号SIGPIPE

6、关闭套接字int close(fd)

客户端接口信息：将服务端的2、3、4步去掉，合成一步
1、创建套接字int socket(int domain, int type, int protocol)
2、向服务端发起连接请求int connect(int sockfd, struct sockaddr *srv_addr, int len) 参数内容(sockfd：哪个服务端发送请求连接；src_addr：服务端地址信息，给该服务端发送请求)这个connect接口也会在sockfd客户端的套接字socket中描述对端的地址信息
3、收发数据。接收：ssize_t recv(int sockfd, char *buf, int len, int flag) 发送：ssize_t send(int sockfd, char *data, int len, int flag)
4、关闭套接字int close(fd)

代码实现
创建一个类用于封装各端的操作
tcpsocket.hpp

//tcpsocket.hpp
#include <cstdio>
#include <unistd.h>
#include <string>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
using namespace std;

//该值表示用一时间能够接收多少客户端连接
//并非指整个通信最多接收多少客户端连接
#define MAX\_LISTEN 5
#define CHECK\_RET(q) if((q) == false){return -1;}
class TcpSocket
{
	public:
		TcpSocket()
			:\_sockfd(-1)
		{}
		bool Socket()
		{
			_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
			if (_sockfd < 0)
			{
				perror("socket error");
				return false;
			}
			return true;
		}
		bool Bind(const string &ip, uint16_t port)
		{
			struct sockaddr_in addr;
			addr.sin_family = AF_INET;
			addr.sin_port = htons(port);
			addr.sin_addr.s_addr = inet\_addr(ip.c\_str());
			socklen_t len = sizeof(struct sockaddr_in);
			
			int ret = bind(_sockfd, (struct sockaddr\*)&addr, len);
			if (ret < 0)
			{
				perror("bind error");
				return false;
			}
			return true;
		}
		bool Listen(int backlog = MAX_LISTEN)
		{
			int ret = listen(_sockfd, backlog);
			if (ret < 0)
			{
				perror("listen error");
				return false;
			}
			return true;
		}
		bool Accept(TcpSocket \*new_sock, string \*ip = NULL, uint16_t \*port = NULL)
		{
			struct sockaddr_in addr;
			socklen_t len = sizeof(struct sockaddr_in);
			int new_fd = accept(_sockfd, (struct sockaddr\*)&addr, &len);
			cout << "dsdsdds";
			if (new_fd < 0)
			{
				perror("accept error");
				return false;
			}
			new_sock->_sockfd = new_fd;
			if (ip != NULL)
			{
				\*ip = inet\_ntoa(addr.sin_addr);
			}
			if (port != NULL)
			{
				\*port = ntohs(addr.sin_port);
			}
			return true;
		}
		bool Recv(string \*buf)
		{
			char tmp[4096] = {0};
			int ret = recv(_sockfd, tmp, 4096, 0);
			if (ret < 0)
			{
				perror("recv error");
				return false;
			}
			else if (ret == 0)//默认阻塞，没有数据就会等待，返回0表示连接断开
			{
				printf("connection broken\n");
				return false;
			}
			buf->assign(tmp, ret);
			return true;
		}
		bool Send(const string &data)
		{
			int ret = send(_sockfd, data.c\_str(), data.size(), 0);
			if (ret < 0)
			{
				perror("send error");
				return false;
			}
			return true;
		}
		bool Close()
		{
			if (_sockfd > 0)
			{
				close(_sockfd);
				_sockfd = -1;
			}
			return true;
		}
		bool Connect(const string &ip, uint16_t port)
		{
			struct sockaddr_in addr;
			addr.sin_family = AF_INET;
			addr.sin_port = htons(port);
			addr.sin_addr.s_addr = inet\_addr(ip.c\_str());
			socklen_t len = sizeof(struct sockaddr_in);
			int ret = connect(_sockfd, (struct sockaddr\*)&addr, len);
			if (ret < 0)
			{
				perror("connect error");
				return false;
			}
			return true;
		}
	private:
		int _sockfd;
};


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

tcp_srv.cpp

//tcp\_srv.cpp
#include <cstdio>
#include <iostream>
#include "tcpsocket.hpp"

using namespace std;

int main(int argc, char \*argv[])
{
	if (argc != 3)
	{
		cout << "Usage:./tcp\_srv ip port" << endl;
		return -1;
	}
	string ip = argv[1];
	uint16_t port = stoi(argv[2]);

	TcpSocket lst_sock;
	//穿件套接字
	CHECK\_RET(lst_sock.Socket());
	//为套接字绑定地址信息
	CHECK\_RET(lst_sock.Bind(ip, port));
	//开始监听
	CHECK\_RET(lst_sock.Listen());
	while (1)
	{
		TcpSocket new_sock;
		//获取连接
		bool ret = lst_sock.Accept(&new_sock);
		if (ret == false)
		{
			continue;//服务端不能因为获取一个新建套接字失败就退出
		}
		string buf;
		new_sock.Recv(&buf);
		cout << "client say: " << buf << endl;

		buf.clear();
		cout << "server say: ";
		cin >> buf;
		new_sock.Send(buf);
	}
	lst_sock.Close();
	return 0;
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

tcp_cli.cpp

//tcp\_cli.cpp
#include <iostream>
#include <string>
#include "tcpsocket.hpp"
using namespace std;

int main(int argc, char \*argv[])
{
	if (argc != 3)
	{
		cout << "Usage: ./tcp\_cli ip port" << endl;
		return -1;
	}
	string srv_ip = argv[1];
	uint16_t srv_port = stoi(argv[2]);

	TcpSocket sock;
	CHECK\_RET(sock.Socket());
	CHECK\_RET(sock.Connect(srv_ip, srv_port));
	while (1)
	{
		string buf;
		cout << "client say: ";
		cin >> buf;
		sock.Send(buf);

		buf.clear();
		sock.Recv(&buf);
		cout << "server say: "<< buf << endl;
	}
	sock.Close();
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

makefile

all:tcp_srv tcp_cli
  tcp_srv:tcp_srv.cpp
      g++ -std=c++11 $^ -o $@
  tcp_cli:tcp_cli.cpp
      g++ -std=c++11 $^ -o $@


1
2
3
4
5
6
7

查看网卡信息

先运行服务端，等待新的连接。

运行客户端，并发送消息

服务端收到消息并回复

客户端收到消息并回复

但是此时客户端并没有接收到客户端发来的消息，一直停留在上一次发送消息完后的样子

简单分析服务端while循环，while循环中第一步获取连接时阻塞等待的，当一个新的客户端来是会为它创建一个新的套接字与它通信。客户端第一次发送消息，服务端走到第二步接收消息，再走到第三步发送消息。发送完消息第一次循环就结束了，又重新到了第一步等待获取连接。此时新创建的套接字丢失，所以此时客户端再给服务端发送消息，就无法接收。

这时候我们就得引入多线程或者多进程来完成这项任务。在获取到一个新的连接时,就启动一个新的执行流，让这个新的执行流去与该客户端进行通信。这样子做的好处是：没有了因为新连接到来的阻塞，就不会影响与客户端之间的通信；与客户端通信时的阻塞，并不会影响获取新的连接

多进程使用TCP实现通信
只要修改服务端
tcp_process.cpp

//tcp\_process.cpp
#include <cstdio>
#include <iostream>
#include <signal.h>
#include <sys/wait.h>
#include "tcpsocket.hpp"

using namespace std;

void sigcb(int no)
{
	while (waitpid(-1, NULL, WNOHANG) > 0);
}

int main(int argc, char \*argv[])
{
	if (argc != 3)
	{
		cout << "Usage:./tcp\_srv ip port" << endl;
		return -1;
	}
	//子进程退出处理方式
	signal(SIGCHLD, sigcb);
	string ip = argv[1];
	uint16_t port = stoi(argv[2]);

	TcpSocket lst_sock;
	//穿件套接字
	CHECK\_RET(lst_sock.Socket());
	//为套接字绑定地址信息
	CHECK\_RET(lst_sock.Bind(ip, port));
	//开始监听
	CHECK\_RET(lst_sock.Listen());
	while (1)
	{


![img](https://img-blog.csdnimg.cn/img_convert/70001dd4bc621d8b7729b710692826e8.png)
![img](https://img-blog.csdnimg.cn/img_convert/5ec7f7e4cd06ed22e450675f9c4107c5.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**

ip, port));
	//开始监听
	CHECK\_RET(lst_sock.Listen());
	while (1)
	{


[外链图片转存中...(img-87gyYD3A-1715886898346)]
[外链图片转存中...(img-mmrbMLCd-1715886898346)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62