1. Toy模板网首页
  2. > Toy博客

网络编程 -- 简易TCP网络程序

7月前 作者：云烟梦柳 分类：Toy博客 阅读(44) 违法举报

这篇具有很好参考价值的文章主要介绍了网络编程 -- 简易TCP网络程序。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一 字符串回响

1.1 核心功能

  字符串回响程序类似于 echo 指令，客户端向服务器发送消息，服务器在收到消息后会将消息发送给客户端，该程序实现起来比较简单，同时能很好的体现 socket 套接字编程的流程。

  网络编程 -- 简易TCP网络程序,网络,tcp/ip,网络协议

1.2 程序结构

  这个程序我们已经基于 UDP 协议实现过了，换成 TCP 协议实现时，程序的结构是没有变化的，同样需要 server.hpp、server.cc、client.hpp、client.cc 这几个文件。

server.hpp 头文件

 #pragma once

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include "err.hpp"
#include<cstring>

namespace My_server{

    const uint16_t default_port = 8888; // 默认端口号
    class server{
    public:

        server(const uint16_t port = default_port)
            :_port(port)
        {}

        ~server()
        {}

        // 初始化服务器
        void InitServer(){
         
        }

        // 启动服务器
        void StartServer()
        {}

    private:
        int _sock; // 套接字（存疑）
        uint16_t _port; // 端口号
    };
}

注意： 这里的 _sock 套接字成员后面需要修改

server.cc 头文件

//智能指针头文件
#include<memory>
#include"server.hpp"

using namespace My_server;

int main(){

    std::unique_ptr<server> usvr(new server());
     
    usvr->InitServer();
    
    usvr->StartServer();

    return 0;
}

创建 client.hpp 客户端头文件

#pragma once

#include<iostream>
#include<string>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include"err.hpp"

namespace My_client{
   
   class client{
     public:
        client(const std::string& ip,const uint16_t port)
         :server_ip(ip)
         ,server_port(port)
        {}

        ~client(){}
        
        //初始化客户端
        void InitClient(){}

        // 启动客户端
        void StartClient(){}

     private:
       int _sock;// 套接字
       std::string server_ip;//服务器ip
       uint16_t server_port; //服务器端口号

   };
}

创建client.cc文件
 

#include"client.hpp"
#include<memory>

using namespace My_client;

void Usage(char* program){

    std::cout<<"Usage : "<<std::endl;
    std::cout<<"\t "<<program<<" ServerIP ServerPort"<<std::endl;

}

int main(int argc,char *argv[]){
   
   if(argc!=3){
      Usage(argv[0]);
      return USAGE_ERR;
   }
   
   //获取服务器IP地址和端口号
    std::string ip(argv[1]);
    uint16_t port=std::stoi(argv[2]);

    std::unique_ptr<client> usvr(new client(ip,port));

    usvr->InitClient();
    usvr->StartClient();
    
    return 0;
}

同时需要Makefile文件

.PHONY:all
all:server client

server:server.cc
	g++ -o $@ $^ -std=c++14

client:client.cc
	g++ -o $@ $^ -std=c++14

.PHONY:clean
clean:
	rm -rf server client

和 err.hpp 头文件

#pragma once

// 错误码
enum
{
    USAGE_ERR=1 ,
    SOCKET_ERR,
    BIND_ERR
};

1.3 服务端

1.3.1 初始化服务端  

  基于 TCP 协议实现的网络程序也需要 创建套接字、绑定 IP 和端口号

在使用 socket 函数创建套接字时，UDP 协议需要指定参数2为 SOCK_DGRAM，TCP 协议则是指定参数2为 SOCK_STREAM

InitServer() 初始化服务器函数 — 位于 server.hpp 服务器头文件中的 server 类

 #pragma once

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include "err.hpp"
#include<cstring>

namespace My_server{

    const uint16_t default_port = 8888; // 默认端口号
    class server{
    public:

        server(const uint16_t port = default_port)
            :_port(port)
        {}

        ~server()
        {}

        // 初始化服务器
        void InitServer(){

          //1 创建套接字
           _sock = socket(AF_INET,SOCK_STREAM,0);
           if(_sock==-1){
              //绑定失败
              std::cerr<<"Create Socket Fail!"<<strerror(errno)<<std::endl;
              exit(SOCKET_ERR);
           }

           std::cout<<"Create Socket Success!"<<_sock<<std::endl;
          //2 绑定端口号和IP地址
          
          struct sockaddr_in lockal;
          bzero(&lockal,sizeof lockal);

          lockal.sin_family = AF_INET;
          lockal.sin_addr.s_addr = INADDR_ANY;
          lockal.sin_port = htons(_port);

          if(bind(_sock,(const sockaddr*)&lockal,sizeof(lockal))){
            std::cout<<"Bind IP&&Port Fali:"<<strerror(errno)<<std::endl;
            exit(BIND_ERR);
          }
         
        }

        // 启动服务器
        void StartServer()
        {}

    private:
        int _sock; // 套接字（存疑）
        uint16_t _port; // 端口号
    };
}

注意： 在绑定端口号时，一定需要把主机序列转换为网络序列

  为什么在绑定端口号阶段需要手动转换为网络序列，而在发送信息阶段则不需要？ 这是因为在发送信息阶段，recvfrom / sendto 等函数会自动将需要发送的信息转换为网络序列，接收信息时同样会将其转换为主机序列，所以不需要手动转换

  如果使用的 UDP 协议，那么初始化服务器到此就结束了，但我们本文中使用的是 TCP 协议，这是一个 面向连接 的传输层协议，意味着在初始化服务器时，需要设置服务器为 监听 状态

  使用到的函数是 listen 函数

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int listen(int sockfd, int backlog);

返回值：监听成功返回 0，失败返回 -1.

  listen函数 使得一个进程可以接受其它进程的请求，从而成为一个服务器进程。在TCP服务器编程中listen函数把进程变为一个服务器，并指定相应的套接字变为被动连接。

  这里的参数2需要设置一个整数，通常为 16、32、64...，表示 全连接队列 的最大长度，关于 全连接队列 的详细知识放到后续博客中讲解，这里只需要直接使用。

server.hpp 服务器头文件

  我们改变一下网络文件的名字

 #pragma once

#include<iostream>
#include<cerrno>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include "err.hpp"
#include<cstring>

namespace My_server{

    const uint16_t default_port = 8888; // 默认端口号
    const int backlog=32; //全连接队列的最大长度

    class server{
    public:

        server(const uint16_t port = default_port)
            :_port(port)
        {}

        ~server()
        {}

        // 初始化服务器
        void InitServer(){

          //1 创建套接字
           _listensock = socket(AF_INET,SOCK_STREAM,0);
           if(_listensock==-1){
              //绑定失败
              std::cerr<<"Create Socket Fail!"<<strerror(errno)<<std::endl;
              exit(SOCKET_ERR);
           }

           std::cout<<"Create Socket Success!"<<_listensock<<std::endl;

          //2 绑定端口号和IP地址
          struct sockaddr_in local;
          bzero(&local,sizeof(local));
          local.sin_family = AF_INET;
          local.sin_addr.s_addr = INADDR_ANY;//绑定任意可用IP地址
          local.sin_port = htons(_port);

          if(bind(_listensock,(const sockaddr*)&local,sizeof(local))){

            std::cout<<"Bind IP&&Port Fali:"<<strerror(errno)<<std::endl;
            exit(BIND_ERR);

          }
         
         //3. 监听
         if(listen(_listensock,backlog) == -1){
            std::cerr << "Listen Fail!" << strerror(errno) << std::endl;
            //新增一个报错
            exit(LISTEN_ERR);
         }
         std::cout<<"Listen Success!"<<std::endl;
         
        }

        // 启动服务器
        void StartServer()
        {}

    private:
        int _listensock; // 套接字（存疑）
        uint16_t _port; // 端口号
    };
}

  至此基于  TCP 协议 实现的初始化服务器函数就填充完成了，编译并运行服务器，显示初始化服务器成功。

// 示例代码中端口号为8088

网络编程 -- 简易TCP网络程序,网络,tcp/ip,网络协议

1.3.2 启动服务器

1.3.2.1 处理连接请求

  TCP 是面向连接，当有客户端发起连接请求时，TCP 服务器需要正确识别并尝试进行连接，当连接成功时，与其进行通信，可使用 accept 函数进行连接。

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

参数解读：

  • sockfd 服务器用于处理连接请求的 socket 套接字
  • addr 客户端的 sockaddr 结构体信息
  • addrlen 客户端的 sockaddr 结构体大写

  其中 addr 与 addrlen 是一个 输入输出型 参数，类似于 recvfrom 中的参数。

  返回值：连接成功返回一个用于通信的 socket 套接字（文件描述符），失败返回 -1。

  这也就意味着之前我们在 TcpServer 中创建的类内成员 sock_ 并非是用于通信，而是专注于处理连接请求，在 TCP 服务器中，这种套接字称为 监听套接字

使用 accept 函数处理连接请求

server.hpp 服务器头文件

 #pragma once

#include<iostream>
#include<cerrno>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include "err.hpp"
#include<cstring>

namespace My_server{

    const uint16_t default_port = 8888; // 默认端口号
    const int backlog=32; //全连接队列的最大长度

    class server{
    public:

        server(const uint16_t port = default_port)
            :_port(port)
        {}

        ~server()
        {}

        // 初始化服务器
        void InitServer(){

          //1 创建套接字
           _listensock = socket(AF_INET,SOCK_STREAM,0);
           if(_listensock==-1){
              //绑定失败
              std::cerr<<"Create Socket Fail!"<<strerror(errno)<<std::endl;
              exit(SOCKET_ERR);
           }

           std::cout<<"Create Socket Success!"<<_listensock<<std::endl;

          //2 绑定端口号和IP地址
          struct sockaddr_in local;
          bzero(&local,sizeof(local));
          local.sin_family = AF_INET;
          local.sin_addr.s_addr = INADDR_ANY;//绑定任意可用IP地址
          local.sin_port = htons(_port);

          if(bind(_listensock,(const sockaddr*)&local,sizeof(local))){

            std::cout<<"Bind IP&&Port Fali:"<<strerror(errno)<<std::endl;
            exit(BIND_ERR);

          }
         
         //3. 监听
         if(listen(_listensock,backlog) == -1){
            std::cerr << "Listen Fail!" << strerror(errno) << std::endl;
            //新增一个报错
            exit(LISTEN_ERR);
         }
         std::cout<<"Listen Success!"<<std::endl;
         
        }

        // 启动服务器
        void StartServer(){
            
            while(!_quit){
                //1 处理连接请求
                struct sockaddr_in client;
                socklen_t len=sizeof(client);

                int sock=accept(_listensock,(struct sockaddr*)&client,&len);

                //2 如果连接失败 继续尝试连接
                if(sock==-1){
                  std::cerr<<"Accept Fail!"<<strerror(errno)<<std::endl;
                  continue;
                }

                //连接成功，获取客户端信息
                std::string clientip=inet_ntoa(client.sin_addr);
                uint16_t clientport= ntohs(client.sin_port);

                std::cout<<"Server accept"<<clientip + "-"<<clientport<<sock<<" from "<<_listensock<<" success!"<<std::endl;

                //3 这里因为是字节流传递，一般而言我们会自己写一个函数
                Service(sock,clientip,clientport);
            }

        }

    private:
        int _listensock; // 套接字（存疑）
        uint16_t _port; // 端口号
        bool _quit; // 判断服务器是否结束运行
    };
}
1.3.2.2 业务处理

对于 TCP 服务器来说，它是面向字节流传输的，我们之前使用的文件相关操作也是面向字节流，凑巧的是在 Linux 中网络是以挂接在文件系统的方式实现的，种种迹象表明：可以通过文件相关接口进行通信

  • read 从文件中读取信息（接收消息）
  • write 向文件中写入信息（发送消息）

这两个系统调用的核心参数是 fd（文件描述符），即服务器与客户端在连接成功后，获取到的 socket 套接字，所以接下来可以按文件操作的套路，完成业务处理

Service() 业务处理函数 — 位于 server.hpp 服务器头文件中的 server 类

  void Service(int sock,const std::string& clientip,const uint16_t& clientport){

            char buff[1024];
            std::string who=clientip + "-" + std::to_string(clientport);
            while(true){
                //以C语言格式读取，预留'\0'的位置
                ssize_t n = read(sock,buff,sizeof(buff)-1);
                if(n>0){
                //读取成功
                std::cout<<"Server get: "<<buff<<" from "<<who<<std::endl;
                //实际处理可以交给上层逻辑指定
                std::string respond = _func(buff);
                //发送给服务器
                write(sock,buff,strlen(buff));
               }
               else if(n==0){

                //表示当前读到了文件末尾，结束读取
                std::cout<<"Client "<<who<<" "<<sock<<" quit!"<<std::endl;
                close(sock);
                break;
               }
               else{
                 // 读取出问题（暂时）
                  std::cerr << "Read Fail!" << strerror(errno) << std::endl;
                  close(sock); // 关闭文件描述符
                   break;
               }
            }
        }
1.3.2.2.1 回调函数

为了更好的实现功能解耦，这里将真正的业务处理函数交给上层处理，编写完成后传给 TcpServer 对象即可，当然，在 TcpServer 类中需要添加对应的类型

这里设置回调函数的返回值为 string，参数同样为 string

  using func_t = std::function<std::string(std::string)>;

server.hpp 服务器头文件

 #pragma once

#include<iostream>
#include<cerrno>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include "err.hpp"
#include<cstring>
#include <unistd.h>
#include<functional>

namespace My_server{

    const uint16_t default_port = 8888; // 默认端口号
    const int backlog=32; //全连接队列的最大长度
    
    using func_t = std::function<std::string(std::string)>;
    class server{
    public:

        server(const func_t &func,const uint16_t port = default_port)
            :_func(func)
            ,_port(port)
            ,_quit(false)
        {}

        ~server()
        {}

        // 初始化服务器
        void InitServer(){

          //1 创建套接字
           _listensock = socket(AF_INET,SOCK_STREAM,0);
           if(_listensock==-1){
              //绑定失败
              std::cerr<<"Create Socket Fail!"<<strerror(errno)<<std::endl;
              exit(SOCKET_ERR);
           }

           std::cout<<"Create Socket Success!"<<_listensock<<std::endl;

          //2 绑定端口号和IP地址
          struct sockaddr_in local;
          bzero(&local,sizeof(local));
          local.sin_family = AF_INET;
          local.sin_addr.s_addr = INADDR_ANY;//绑定任意可用IP地址
          local.sin_port = htons(_port);

          if(bind(_listensock,(const sockaddr*)&local,sizeof(local))){

            std::cout<<"Bind IP&&Port Fali:"<<strerror(errno)<<std::endl;
            exit(BIND_ERR);

          }
         
         //3. 监听
         if(listen(_listensock,backlog) == -1){
            std::cerr << "Listen Fail!" << strerror(errno) << std::endl;
            //新增一个报错
            exit(LISTEN_ERR);
         }
         std::cout<<"Listen Success!"<<std::endl;
         
        }

        // 启动服务器
        void StartServer(){
            
            while(!_quit){
                //1 处理连接请求
                struct sockaddr_in client;
                socklen_t len=sizeof(client);

                int sock=accept(_listensock,(struct sockaddr*)&client,&len);

                //2 如果连接失败 继续尝试连接
                if(sock==-1){
                  std::cerr<<"Accept Fail!"<<strerror(errno)<<std::endl;
                  continue;
                }

                //连接成功，获取客户端信息
                std::string clientip=inet_ntoa(client.sin_addr);
                uint16_t clientport= ntohs(client.sin_port);

                std::cout<<"Server accept"<<clientip + "-"<<clientport<<sock<<" from "<<_listensock<<" success!"<<std::endl;

                //3 这里因为是字节流传递，一般而言我们会自己写一个函数
                Service(sock,clientip,clientport);
            }
        }

        void Service(int sock,const std::string& clientip,const uint16_t& clientport){

            char buff[1024];
            std::string who=clientip + "-" + std::to_string(clientport);
            while(true){
                //以C语言格式读取，预留'\0'的位置
                ssize_t n = read(sock,buff,sizeof(buff)-1);
                if(n>0){
                //读取成功
                std::cout<<"Server get: "<<buff<<" from "<<who<<std::endl;
                //实际处理可以交给上层逻辑指定
                std::string respond = _func(buff);
                //发送给服务器
                write(sock,buff,strlen(buff));
               }
               else if(n==0){

                //表示当前读到了文件末尾，结束读取
                std::cout<<"Client "<<who<<" "<<sock<<" quit!"<<std::endl;
                close(sock);
                break;
               }
               else{
                 // 读取出问题（暂时）
                  std::cerr << "Read Fail!" << strerror(errno) << std::endl;
                  close(sock); // 关闭文件描述符
                   break;
               }
            }
        }

    private:
        int _listensock; // 套接字（存疑）
        uint16_t _port; // 端口号
        bool _quit; // 判断服务器是否结束运行
        func_t _func;// 回调函数
    };
}
1.3.2.2.2 server.cc文件

对于当前的 TCP 网络程序（字符串回响）来说，业务处理函数逻辑非常简单，无非就是直接将客户端发送过来的消息，重新转发给客户端

server.cc 服务器源文件

//智能指针头文件
#include<memory>
#include"server.hpp"
#include<string>

using namespace My_server;
// 业务处理回调函数（字符串回响）
std::string echo(std::string request){
    return request;
}

int main(){

    std::unique_ptr<server> usvr(new server(echo));
     
    usvr->InitServer();
    
    usvr->StartServer();

    return 0;
}

  尝试编译并运行服务器，可以看到当前 bash 已经被我们的服务器程序占用了，重新打开一个终端，并通过 netstat 命令查看网络使用情况（基于 TCP 协议）

网络编程 -- 简易TCP网络程序,网络,tcp/ip,网络协议

1.4 客户端

1.4.1 初始化客户端

 对于客户端来说，服务器的 IP 地址与端口号是两个不可或缺的元素，因此在客户端类中，  server_ip 和 server_port 这两个成员是少不了的，当然得有 socket 套接字

初始化客户端只需要干一件事：创建套接字，客户端是主动发起连接请求的一方，也就意味着它不需要使用 listen 函数设置为监听状态

注意： 客户端也是需要 bind 绑定的，但不需要自己手动绑定，由操作系统帮我们自动完成

client.hpp 客户端头文件

#pragma once

#include<iostream>
#include<string>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include"err.hpp"
#include<cerrno>
#include<cstring>

namespace My_client{
   
   class client{
     public:
        client(const std::string& ip,const uint16_t port)
         :server_ip(ip)
         ,server_port(port)
        {}

        ~client(){}
        
        //初始化客户端
        void InitClient(){

           // 1. 创建套接字
            _sock = socket(AF_INET, SOCK_STREAM, 0);
            if (_sock == -1)
            {
                std::cerr << "Create Socket Fail!" << strerror(errno) << std::endl;
                exit(SOCKET_ERR);
            }   
            std::cout << "Create Sock Succeess! " << _sock << std::endl;
            

        }

        // 启动客户端
        void StartClient(){}

     private:
       int _sock;// 套接字
       std::string server_ip;//服务器ip
       uint16_t server_port; //服务器端口号

   };
}

1.4.2 启动客户端

1.4.2.1 尝试进行连接

  因为 TCP 协议是面向连接的，服务器已经处于处理连接请求的状态了，客户端现在需要做的就是尝试进行连接，使用 connect 函数进行连接。

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数解读：

  • sockfd 需要进行连接的套接字
  • addr 服务器的 sockaddr 结构体信息
  • addrlen 服务器的 sockaddr 结构体大小

返回值：连接成功返回 0，连接失败返回 -1.

  在连接过程中，可能遇到很多问题，比如 网络传输失败、服务器未启动 等，这些问题的最终结果都是客户端连接失败，如果按照之前的逻辑（失败就退出），那么客户端的体验感会非常不好，因此在面对连接失败这种常见问题时，客户端应该尝试重连，如果重连数次后仍然失败，才考虑终止进程

注意： 在进行重连时，可以使用 sleep() 等函数使程序睡眠一会，给网络恢复留出时间

StartClient() 启动客户端函数 — 位于 client.hpp 中的client 类.

#pragma once

#include<iostream>
#include<string>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include"err.hpp"
#include<cerrno>
#include<cstring>
#include<unistd.h>
namespace My_client{
   
   class client{
     public:
        client(const std::string& ip,const uint16_t port)
         :server_ip(ip)
         ,server_port(port)
        {}

        ~client(){}
        
        //初始化客户端
        void InitClient(){

           // 1. 创建套接字
            _sock = socket(AF_INET, SOCK_STREAM, 0);
            if (_sock == -1)
            {
                std::cerr << "Create Socket Fail!" << strerror(errno) << std::endl;
                exit(SOCKET_ERR);
            }   
            std::cout << "Create Sock Succeess! " << _sock << std::endl;
            

        }

        // 启动客户端
        void StartClient(){
          
          //填充服务器的sockaddr_int 结构体信息
          struct sockaddr_in server;
          socklen_t len=sizeof(server);
          bzero(&server,len);
          server.sin_family = AF_INET;
          inet_aton(server_ip.c_str(), &server.sin_addr); // 将点分十进制转化为二进制IP地址的另一种方法
          server.sin_port = htons(server_port);

          //尝试重连五次
          int n=5;
          while(n){
            int ret = connect(_sock,(const struct sockaddr*)&server,len);
            if(ret==0){
               // 连接成功，可以跳出循环
               break;
            }
                 // 尝试进行重连
             std::cerr << "网络异常，正在进行重连... 剩余连接次数: " << --n << std::endl;
             sleep(1);
          }

            // 如果剩余重连次数为 0，证明连接失败
          if(n == 0)
         {
           std::cerr << "连接失败! " << strerror(errno) <<    std::endl;
           close(_sock);
           exit(CONNECT_ERR);//新加错误标识符

          }

           // 连接成功
          std::cout << "连接成功!" << std::endl;

         // 进行业务处理
         // Service();
        }

     private:
       int _sock;// 套接字
       std::string server_ip;//服务器ip
       uint16_t server_port; //服务器端口号

   };
}
1.4.2.2 业务处理

客户端在进行业务处理时，同样可以使用 read 和 write 进行网络通信

Service() 业务处理函数 — 位于 client.hpp 客户端头文件中的 TcpClient 类

// 业务处理
void Service()
{
    char buff[1024];
    std::string who = server_ip + "-" + std::to_string(server_port);
    while(true)
    {
        // 由用户输入信息
        std::string msg;
        std::cout << "Please Enter >> ";
        std::getline(std::cin, msg);

        // 发送信息给服务器
        write(_sock, msg.c_str(), msg.size());
        // 接收来自服务器的信息
        ssize_t n = read(_sock, buff, sizeof(buff) - 1);
        if(n > 0)
        {
            // 正常通信
            buff[n] = '\0';
            std::cout << "Client get: " << buff << " from " << who << std::endl;
        }
        else if(n == 0)
        {
            // 读取到文件末尾（服务器关闭了）
            std::cout << "Server " << who  << " quit!" << std::endl;
            close(_sock); // 关闭文件描述符
            break;
        }
        else
        {
            // 读取异常
            std::cerr << "Read Fail!" << strerror(errno) << std::endl;
            close(_sock); // 关闭文件描述符
            break;
        }
    }
}

代码示例： 

网络编程 -- 简易TCP网络程序,网络,tcp/ip,网络协议文章来源地址https://www.toymoban.com/news/detail-857284.html

到了这里，关于网络编程 -- 简易TCP网络程序的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【网络编程】TCP/IP协议（互联网的基石）

    【网络编程】TCP/IP协议（互联网的基石）

    (꒪ꇴ꒪ )，Hello我是 祐言QAQ 我的博客主页：C/C++语言，数据结构，Linux基础，ARM开发板，网络编程等领域UP🌍 快上🚘，一起学习，让我们成为一个强大的攻城狮！ 送给自己和读者的一句鸡汤🤔： 集中起来的意志可以击穿顽石! 作者水平很有限，如果发现错误，请在评论区指

    2024年02月10日
    浏览(49)
  • Linux 网络编程学习笔记——一、TCP/IP 协议族

    Linux 网络编程学习笔记——一、TCP/IP 协议族

    数据链路层实现了网卡接口的网络驱动程序，以处理数据在物理媒介（以太网、令牌环等）上的传输，不同的物理网络具有不同的电气特性，网络驱动程序隐藏了这些细节，为上层协议提供一个统一的接口。最常用的协议是 ARP（Address Resolve Protocol，地址解析协议）和 RARP（

    2024年02月02日
    浏览(74)

  • 网络编程day2——基于TCP/IP协议的网络通信

            计算机S                                                 计算机C      创建socket对象                                   创建socket对象      准备通信地址(自己的ip(非公网ip))      准备通信地址                                     (计算

    2024年02月10日
    浏览(68)
  • 网络编程1—— IP地址 + 端口号 +TCP/IP协议 + 协议分层的封装与应用

    网络编程1—— IP地址 + 端口号 +TCP/IP协议 + 协议分层的封装与应用

    本人是一个刚刚上路的IT新兵,菜鸟!分享一点自己的见解,如果有错误的地方欢迎各位大佬莅临指导,如果这篇文章可以帮助到你,劳请大家点赞转发支持一下! 从本篇文章开始就要分享网络编程的内容了，越发的感受到了编程的魅力，鸡汤来喽！！ 1️⃣单机阶段：计算机跟计算

    2024年02月12日
    浏览(42)
  • 【Java网络编程】OSI七层网络模型与TCP/IP协议簇

    【Java网络编程】OSI七层网络模型与TCP/IP协议簇

    1.1、OSI七层网络模型 OSI七层网络模型中，每层的功能如下： 应用层：人与计算机网络交互的窗口。 表示层：负责数据格式的封装，如加密、压缩、编解码等。 会话层：建立、终止、管理不同端间的会话连接。 传输层：提供端到端（两台机器）之间的传输机制，以及提供流

    2024年04月11日
    浏览(48)
  • Java网络编程之IP，端口号，通信协议（UDP，TCP）

    Java网络编程之IP，端口号，通信协议（UDP，TCP）

    ① C/S ：客户端/服务器 在用户本地需要下载安装客户端程序，在远程有一个服务器端程序。 优点：画面精美，用户体验好 缺点：用户需要下载更新 ② B/S ：浏览器/服务器 只需要一个浏览器，用户通过指定网址访问对应的服务器。 优点：不需要开发客户端，只需要页面+服务

    2024年02月03日
    浏览(84)
  • 【Java EE初阶十五】网络编程TCP/IP协议（二）

    【Java EE初阶十五】网络编程TCP/IP协议（二）

            tcp的socket api和U大片的socket api差异很大，但是和前面所讲的文件操作很密切的联系         下面主要讲解两个关键的类：         1、ServerSocket：给服务器使用的类，使用这个类来绑定端口号         2、Socket：即会给服务器使用，又会给客户端使用；         

    2024年02月20日
    浏览(51)

  • TCP/IP网络编程(二) 套接字协议及其数据传输特性

    关于协议 如果相隔比较远的两人进行通话，必须先决定通话方式，如果一方选择电话，另一方也必须选择电话，否则接受不到消息。 总之，协议就是为了完成数据交换而定好的约定。 创建套接字 协议族 通过socket函数的第一个参数传递套接字中使用的协议分类信息，此协议

    2024年02月10日
    浏览(62)
  • 【网络编程】传输层协议——TCP协议

    【网络编程】传输层协议——TCP协议

    TCP报头当中各个字段的含义如下 源/目的端口号 ：表示数据是从哪个进程来，到发送到对端主机上的哪个进程。 32位序号/32位确认序号 ：分别代表TCP报文当中每个字节数据的编号以及对对方的确认，是TCP保证可靠性的重要字段。 4位TCP报头长度 ：表示该TCP报头的长度，以4字

    2024年02月17日
    浏览(59)
  • 《TCP IP网络编程》

    《TCP IP网络编程》

            2023.6.28 正式开始学习网络编程。 每一章每一节的笔记都会记录在博客中以便复习。         网络编程又叫套接字编程。所谓网络编程，就是编写程序使两台连网的计算机相互交换数据。 为什么叫套接字编程？ 我们平常将插头插入插座上就能从电网中获取电力，同

    2024年02月11日
    浏览(48)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包