TCP通讯程序的编写

最新推荐文章于 2023-07-14 20:18:26 发布
最新推荐文章于 2023-07-14 20:18:26 发布
阅读量1.1k 收藏 6
点赞数
分类专栏： linux 文章标签： tcp/ip 网络 网络协议 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46153828/article/details/126475480
版权

目录

1.TCP和UDP区别

2.TCP通讯程序的编写流程

3.实现一次循环通信

4.改进---多进程方式实现多次通信 

5.改进---多线程方式实现多次通信 

6.改进---多线程方式+字典方式实现多次通信 

 

1.TCP和UDP区别

TCP：面向连接、可靠传输、面向字节流  应用场景：文件传输（安全性高于实时性）

UDP：无连接、不可靠、面向数据报  应用场景：视频、音频（实时性高于安全性）

2.TCP通讯程序的编写流程

服务器端：

  1. 创建套接字
  2. 为套接字绑定地址信息
  3. 开始监听---将套接字状态置为LISTEN 告诉系统这个套接字可以开始处理连接，tcp服务器会为每个客户端创建一个新的套接字用于与指定客户端通信
  4. 获取新建连接socket的套接字描述符
  5. 收发数据
  6. 关闭套接字

客户端：

  1. 创建套接字
  2. 绑定地址信息（不推荐客户端主动绑定地址信息）
  3. 向服务器发起数据
  4. 收发数据
  5. 关闭套接字

3.实现一次循环通信

代码如下：

tcp_socket.hpp:

#include<iostream>
#include<string>
#include<vector>
#include<unistd.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/socket.h>

#define MAX_LISTEN 5
#define CHECK_RES(q) if((q)==false) { return -1;}
class TcpSocket{
   private:
       int _sockfd;
   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 std::string &ip,uint16_t port)
       {
         struct sockaddr_in addr;//先定义一个ipv4的地址结构
         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 Connect(const std::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;
     }
     
   //服务器开始监听
    bool Listen(int backlog = MAX_LISTEN)
     {
      int ret = listen(_sockfd,backlog);
      if(ret < 0)
      {
        perror("listen error");
        return false;
      }
     return true;
    }

  //获取新建连接
    bool Accept(TcpSocket *sock,std::string *ip=NULL,uint16_t *port=NULL)
    {
     struct sockaddr_in addr;
     socklen_t len = sizeof(struct sockaddr_in);
     int newfd = accept(_sockfd,(struct sockaddr*)&addr,&len);
     if(newfd<0)
       {
        perror("accept error");
        return false;
       }
     sock->_sockfd = newfd;
     if(ip != NULL)
      {
        *ip = inet_ntoa(addr.sin_addr);
      }
     if(port != NULL)
      {
        *port = ntohs(addr.sin_port);
      }
     return true;
    }

   //接受数据
  bool Recv(std::string *body)
  {
   char tmp[4096] = {0};
   int ret = recv(_sockfd,tmp,4096,0);
   if(ret < 0)
   {
    perror("recv error");
    return false;
   }
   else if(ret == 0)
   {
    std::cout<<"peer shutdown!\n";
    return false;
   }
   body->assign(tmp,ret);//从tmp中截取ret长度大小的数据
   return true;
 }



   //发送数据
    bool Send(const std::string &body)
    {
       int ret;
       ret = send(_sockfd,body.c_str(),body.size(),0);
       if(ret < 0)
       {
         perror("send error");
         return false;
       }
     return true;
    }

  //关闭套接字
  bool Close()
  {
    if(_sockfd!= -1)
    {
      close(_sockfd);
    }
   return true;
  }
  



};

tcp_srv.cpp:

#include "tcp_socket.hpp"
int main()
{
  TcpSocket lst_sock;

  //创建套接字
   CHECK_RES(lst_sock.Socket());
  //绑定地址信息
   CHECK_RES(lst_sock.Bind("192.168.164.128",20000));
  //开始监听
   CHECK_RES(lst_sock.Listen());
   while(1)
   {
    //获取新建连接
     TcpSocket conn_sock;
     std::string cliip;
     uint16_t cliport;
     bool ret = lst_sock.Accept(&conn_sock,&cliip,&cliport);
     if(ret < 0)
     {
      continue;
     }
    std::cout<<"new connect:"<<cliip<<":"<<cliport<<std::endl;
     //使用新建连接与客户端通信
     std::string buf;
     ret = conn_sock.Recv(&buf);
     if(ret == false)
     {
      conn_sock.Close();
      continue;
     }
      std::cout<<"client say:"<<buf<<std::endl;
      std::cout<<"server say:";
      fflush(stdout);
      std::cin>>buf;
      ret = conn_sock.Send(buf);
      if(ret == false)
      {
       conn_sock.Close();
       continue;
      }
     }
   
   // 关闭套接字
   lst_sock.Close();
   return 0;
  }

tcp_cli.cpp:

#include "tcp_socket.hpp"

int main(int argc,char* argv[])
{
  if(argc!= 3)
  {
    std::cout<<"please input server address!\n";
    std::cout<<"USsage:./tcp_cli 192.168.164.128 20000\n";
    return -1;
  }
 std::string srv_ip = argv[1];
 uint16_t srv_port = std::stoi(argv[2]);
 TcpSocket cli_sock;
 //创建套接字
   CHECK_RES(cli_sock.Socket());
 //绑定地址信息（客户端不推荐）
 //向服务器发起连接
   CHECK_RES(cli_sock.Connect(srv_ip,srv_port));
   while(1)
   {
     //与服务器通信
     std::string buf;
     std::cout<<"client say:";
     fflush(stdout);
     std::cin>>buf;
     bool ret = cli_sock.Send(buf);
    if(ret == false)
    {
     cli_sock.Close();
     return -1;
    }
    buf.clear();
    ret = cli_sock.Recv(&buf);
    if(ret == false)
    {
     cli_sock.Close();
     return -1;
    }
    std::cout<<"server say:"<<buf<<std::endl;
  }
 //关闭套接字
  cli_sock.Close();
  return 0;
 }

makefile:

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

测试结果如下：

先运行服务器端程序：

 再运行客户端程序：

 客户端发送数据：

服务器端收到客户端发送的数据并进行回复：

客户端收到了服务器端的回复：

 

4.改进---多进程方式实现多次通信 

 服务器端代码改动 （cp tcp_srv.cpp process_srv.cpp)：

process_srv.cpp代码如下：

#include "tcp_socket.hpp"
#include<signal.h>

int new_worker(TcpSocket &conn_sock)
{
 pid_t pid = fork();
  if(pid < 0)
  {
    perror("fork error");
    return -1;
  }
  else if(pid == 0)
  {
    while(1)
    {
      std::string buf;
      bool ret = conn_sock.Recv(&buf);
      if(ret == false)
      {
        conn_sock.Close();
        break;
      }
      std::cout<<"client say:"<<buf<<std::endl;
      std::cout<<"server say:";
      fflush(stdout);
      std::cin>>buf;
      ret = conn_sock.Send(buf);
      if(ret == false)
      {
        conn_sock.Close();
        break;
      }
    }
   conn_sock.Close();
   exit(-1);
  }
return 0;
}



int main()
{

 //显示忽略子进程退出信号，相当于告诉系统，子进程退出直接释放资源
  signal(SIGCHLD,SIG_IGN); 

 TcpSocket lst_sock;

  //创建套接字
   CHECK_RES(lst_sock.Socket());
  //绑定地址信息
   CHECK_RES(lst_sock.Bind("192.168.164.128",20000));
  //开始监听
   CHECK_RES(lst_sock.Listen());
   while(1)
   {
    //获取新建连接
     TcpSocket conn_sock;
     std::string cliip;
     uint16_t cliport;
     bool ret = lst_sock.Accept(&conn_sock,&cliip,&cliport);
     if(ret < 0)
     {
      continue;
     }
    std::cout<<"new connect:"<<cliip<<":"<<cliport<<std::endl;
     //使用新建连接与客户端通信
    new_worker(conn_sock);
    //父进程必须关闭套接字，否则连接的客户端越多，创建的套接字越多
    //但父进程本质并不与客户端通信，所以最后会资源耗尽
    //因此必须关闭，而父子进程数据独有，因此父进程的关闭并不影响子进程
    conn_sock.Close();

    } 
     // 关闭套接字
   lst_sock.Close();
   return 0;
  }

makefile改动：

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

测试结果（可实现多次通信）：

 当前存在的问题：

若客户端1和客户端2都向服务器发送了数据，服务器在客户端1发送了数据之后并没有回复，在2发了之后才回复，此时回复的是客户端1。

测试结果如下（1向服务器发送tianyijingheile,2向服务器发送ganjinxiakeba,服务器端二者都可收到，回复xiake是回复给了客户端1）：

客户端1：

客户端2：

 服务器端：

5.改进---多线程方式实现多次通信 

 cp tcp_srv.cpp thread_srv.cpp

thread_srv.cpp:

#include "tcp_socket.hpp"
#include<pthread.h>

void* entry(void* arg)
{
 TcpSocket *conn_sock = (TcpSocket*)arg;
   while(1)
  {  
     std::string buf;
     bool ret = conn_sock->Recv(&buf);
     if(ret == false)
     {
      conn_sock->Close();
      break;
     }
      std::cout<<"client say:"<<buf<<std::endl;
      std::cout<<"server say:";
      fflush(stdout);
      std::cin>>buf;
      ret = conn_sock->Send(buf);
      if(ret == false)
      {
       conn_sock->Close();
       break;
      }
    }
  conn_sock->Close();
  delete conn_sock;
  return NULL;
}
bool new_worker(TcpSocket *conn_sock)
{
  pthread_t tid;
  int ret = pthread_create(&tid,NULL,entry,(void*)conn_sock);
  if(ret != 0)
  {
      std::cout<<"thread create error\n";
      return false;
  }
  pthread_detach(tid);
  return true;
 }

int main()
{
  TcpSocket lst_sock;

  //创建套接字
   CHECK_RES(lst_sock.Socket());
  //绑定地址信息
   CHECK_RES(lst_sock.Bind("192.168.164.128",20000));
  //开始监听
   CHECK_RES(lst_sock.Listen());
   while(1)
   {
    //获取新建连接,在堆上申请
     TcpSocket *conn_sock = new TcpSocket();
     std::string cliip;
     uint16_t cliport;
     bool ret = lst_sock.Accept(conn_sock,&cliip,&cliport);
     if(ret < 0)
     {
      continue;
     }
    std::cout<<"new connect:"<<cliip<<":"<<cliport<<std::endl;
     //使用新建连接与客户端通信
     new_worker(conn_sock);
      
    }
   
   // 关闭套接字
   lst_sock.Close();
   return 0;
  }

makefile:

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

测试结果和多进程方式一样，存在的问题也相同。

6.改进---多线程方式+字典方式实现多次通信 

cp thread_srv.cpp robot_srv.cpp

robot_srv.cpp:

#include "tcp_socket.hpp"

#include<pthread.h>
#include<unordered_map>

std::unordered_map<std::string,std::string>_dictionaries={
  {"nihao","你好"},
  {"leihou","雷猴"},
  {"hello","hi"}
 };

 std::string get_rsp(const std::string &key)
{ 
  auto it = _dictionaries.find(key);
  if(it!= _dictionaries.end())
  {
    return it->second;
  }
  return "不要乱说话";
}

void* entry(void* arg)
{
 TcpSocket *conn_sock = (TcpSocket*)arg;
   while(1)
  {  
     std::string buf;
     bool ret = conn_sock->Recv(&buf);
     if(ret == false)
     {
      conn_sock->Close();
      break;
     }
    std::string data = get_rsp(buf);  
    ret = conn_sock->Send(data);
      if(ret == false)
      {
       conn_sock->Close();
       break;
      }
    }
  conn_sock->Close();
  delete conn_sock;
  return NULL;
}
bool new_worker(TcpSocket *conn_sock)
{
  pthread_t tid;
  int ret = pthread_create(&tid,NULL,entry,(void*)conn_sock);
  if(ret != 0)
  {
      std::cout<<"thread create error\n";
      return false;
  }
  pthread_detach(tid);
  return true;
 }

int main()
{
  TcpSocket lst_sock;

  //创建套接字
   CHECK_RES(lst_sock.Socket());
  //绑定地址信息
   CHECK_RES(lst_sock.Bind("192.168.164.128",20000));
  //开始监听
   CHECK_RES(lst_sock.Listen());
   while(1)
   {
    //获取新建连接,在堆上申请
     TcpSocket *conn_sock = new TcpSocket();
     std::string cliip;
     uint16_t cliport;
     bool ret = lst_sock.Accept(conn_sock,&cliip,&cliport);
     if(ret < 0)
     {
      continue;
     }
    std::cout<<"new connect:"<<cliip<<":"<<cliport<<std::endl;
     //使用新建连接与客户端通信
     new_worker(conn_sock);
      
    }
   
   // 关闭套接字
   lst_sock.Close();
   return 0;
  }

makefile:

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

测试结果 客户端：

 

WJ8871
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
上位机+西门子PLC+TCP代码通讯实例
06-24
关于上位机通过TCP写入读取西门子PLC指定内容，数据类型转换，适合人群智能制造，工业行业。
即时通信小程序完善.docx
08-11
完善通信小程序的功能，实现服务端可以显示客户端的消息，在客户端不同的请求下实现不同的功能，以及最后的结果展示。
网络编程之TCP编程
2301_78347044的博客
07-14 1892
并发服务器即同一个时刻可以响应多个客户端的请求，上面建立的服务器和客户端都是一对一的，只能一个客户端连接。常用的并发服务技术有：多进程并发服务器、多线程并发服务器、IO复用并发服务器。这里讲述的是多进程并发服务器我们在多进程并发服务器当中，每个连接的数据收发都要创建一个新的子进程用来通信，这样对资源的消耗十分大。所以引入io设备的复用，接下来我们介绍一下io设备。
tcpip通信的c++代码
joker的博客
08-17 1846
tcpip通信server端的c++代码 #include <iostream> #include <unistd.h> #include <sys/socket.h> #include <arpa/inet.h> #include <string.h> #include <sstream> #include <e...
详解服务端/客户端|TCP网络通信编程|C++|MFC（上）
不唐
08-19 1117
文章内容0 前言1 客户端程序测试（connect）1.1 connect代码1.2 运行结果1.3 客户端简易模型1.4 客户端测试（默认端口号记录）1.5 【无】127.0.0.1和270151.6 不存在从string到从const char*的适当转换函数2 服务端(bind)2.1 bind()服务端代码2.2 运行结果2.3 服务端简易模型3 服务端客户端通信：accept()、recv()3.1 recv()和accpet()3.1.1 recv()3.1.2 accept()3.2 运行结果
网络编程之TCP通信协议
buith9879的博客
04-10 74
TCP是一种可靠的网络通信协议，它在通信的两端各建立一个Socket对象。通过Socket使用IO流进行网络通信。通信之前需要保证连接已经建立。
网络协议编程——TCP/UDP
weixin_46025531的博客
04-05 1553
文章目录一、TCP编程1、客户端发送信息给服务端，服务端将数据显示在控制台上2、客户端发送文件给服务器，服务端将文件保存在本地二、UDP编程1、发送方给接收方发消息2、连续发送多个消息 一、TCP编程 1、客户端发送信息给服务端，服务端将数据显示在控制台上 客户端： package TcpDemo1; import jdk.net.Sockets; import java.io.IOException; import java.io.OutputStream; import java.net.Inet
TCP/IP通信协议
wangzhuo0978的专栏
12-26 4951
Java 网络编程网络通信协议:通信计算机要实现互联必须遵守一定的规则。 在计算机网络中，这些连接和通信的规则被称之为网络通信协议，它对数据的传输格式、传输速率、传输步骤做了统一的规定，通信双方必须同时遵守才能够完成数据交换。网络通信协议有很多，目前最广泛的通信协议是TCP/IP协议(Transmission Control Protocol)Tcp/Ip协议中的四层分别是应用层,传输层,网络层和...
欧姆龙服务器显示oE,欧姆龙CP1H-E系列PLC实现Modbus TCP\RTU\ASCII通信视频教程
weixin_42102713的博客
08-10 2677
一、欧姆龙CP1H-E系列PLC实现Modbus TCP以太网通信客户端视频教程：欧姆龙CP1H-E系列PLC之Modbus TCP客户端功能块使用Socket编程实现，通过编程实现支持Modbus之01、02、03、04、05、06、0F、10、17等9个功能码。Modbus Slave调试助手做Modbus TCP服务器，视频详细讲解测试了9个功能码功能块。另有编写调试封装完成的欧姆龙CP1L...
一个简单的TCP通信程序
zsysingapore的博客
10-27 1288
1.基本通信过程 （1）调用socket()函数建立一个套接字，用于监听 （2）调用bind()函数为套接字绑定一个端口号，IP地址 （3）listen()函数，设置套接字处于监听状态 （4）若程序不退出，则反复执行 1）accept()函数等待客户机的连接。若远程计算机连接请求到来，则一个新的套接字与客户机直接的通信连接 2）rev()，send()利用新建连接与客户机通信 3)通信完 ，调用closesocket()函数关闭连接 （5）closesocket()关闭监听套接字，程序结束。 重点：！！！！
使用 PyQt5 编写的 TCP客户端程序
07-04
TCP客户端连接程序是一个使用PyQt5编写的简单网络应用程序。它旨在通过TCP协议连接到指定的服务器，并能够向服务器发送数据并接收来自服务器的数据。该程序提供了一个用户友好的图形用户界面，允许用户输入服务器的...
MFC编程TCP通信程序
06-12
MFC编写的TCP/IP通信程序，包括服务器、客户端，实现了注册、登录、私聊、群聊等功能。
异步TCP通讯程序
07-09
异步TCP通讯程序 异步 TCP socket 通讯 程序
基于tcp，编写基于流式套接字的通信程序。
12-20
基于tcp，编写基于流式套接字的通信程序。 任务一：C++版同步通信程序 客户端连接后服务器能够发送一个欢迎消息给客户端，客户端发送time，发送当前时间（字符串形式）给客户端；客户端发送date，发送当前日期...
java编写TCP方式的通信程序
02-01
java编写TCP方式的通信程序
＜网络＞TCP代码协议编写
weixin_63246064的博客
07-08 953
这篇文章我们就主要实现一下如何使用TCP进行完整的网络通信首先我们需要了解什么事TCP，TCP是一种传输控制协议，我们暂且先记住这个。现在我们先开始，第一呢，我们要实现客户端和服务端的网络通信，两个不同的主机之间通信是通过什么？答案是每台主机的网络IP，在我们的电脑进行上网的时候，会自动给我们的电脑分配一个该局域网内的IP。好的，现在我们的两台主机相互的找到了对方，然后再看看我们要做的是什么，两台主机之间的通信对不对！
基于TCPIP的网络编程（C++语言编程）
m0_54866636的博客
08-28 533
基于TCP/IP的通信基本上都是利用SOCKET套接字进行数据通讯，程序一般分为服务器端和用户端两部分。二、服务器套接字进行信息绑定（bind），并开始监听连接（listen）。二、与远程服务器进行连接（connect），如被接受则创建接收进程。三、接受来自用户端的连接请求（accept）。四、开始数据传输(send/receive)。五、关闭套接字（closesocket）。四、关闭套接字（closesocket）。一、创建服务器套接字（create）。一、创建客户套接字（create）。...
C++11实现计算机网络中的TCP/IP连接（Windows端）
面条有点辣
02-12 5783
网络通信TCP/IP协议实现笔记。
套接字编程：TCP通信程序
m0_63020222的博客
10-29 1928
套接字编程：多进程&多线程，实现简易的TCP通信程序
200smart modbus tcp通讯客户端程序编写
最新发布
07-22
以下是一个简单的程序编写步骤： 1. 导入必要的库：程序需要导入能够实现Modbus TCP通信的相关库文件，例如modbus-tk库。 2. 创建Modbus主机：使用库提供的函数，创建一个Modbus主机对象，通过指定IP地址和端口号...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值