精华内容
下载资源
问答
  • 2022-01-08 01:59:25

    1、服务端

    #include <iostream>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <unistd.h>
    #include <string.h>
    
    #define PORT 8111
    #define MESSAGE_LEN 1024  // 消息的长度
    
    int main(int argc, char* argv[])
    {
    	// 创建socket
    	int socket_fd, accept_fd;
    	int on = 1;
    	int ret = -1;
    	int backlog = 10;
    	
    	struct sockaddr_in localaddr,remoteaddr;
    	char in_buff[MESSAGE_LEN] = {0,}; // 缓冲区
    
    
    	socket_fd = socket(PF_INET, SOCK_STREAM, 0);
    	if (socket_fd == -1){
    		std::cout << "create socket failed" << std::endl;
    		exit(-1);
    	}
    	
    	ret = setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    	if (ret == -1){
    		std::cout << "failed set socket options" << std::endl;
    		exit(-1);
    	}
    	
    	localaddr.sin_family = AF_INET;
    	localaddr.sin_port = PORT;
    	localaddr.sin_addr.s_addr = INADDR_ANY;
    	bzero(&(localaddr.sin_zero), 8);
    
    	//绑定
    	ret = bind(socket_fd, (struct sockaddr *)&localaddr, sizeof(struct sockaddr));
    	if (ret == -1){
    		std::cout << "failed to bin addr" << std::endl;
    		exit(-1);
    	}
    
    	ret = listen(socket_fd, backlog);
    	if (ret == -1){
    	        std::cout << "failed to listen addr" << std::endl;
                    exit(-1);
    
    	}
    	for(;;){
    		socklen_t  addr_len = sizeof(struct sockaddr);
    		accept_fd = accept(socket_fd, (struct sockaddr *)&remoteaddr, &addr_len);
    		for (;;){
    			ret = recv(accept_fd, (void *)in_buff, MESSAGE_LEN, 0);
    			if (ret == 0){
    				std::cout << "quit" << std::endl;
    				break;
    			}
    			std::cout << "recv: " << in_buff << std::endl;
    			send(accept_fd, (void*)in_buff,MESSAGE_LEN, 0);
    		}
    		close(accept_fd);
    
    	}	
    	close(socket_fd);
    }
    
    

    二、客户端

    #include<iostream>
    #include<stdio.h>
    #include <cstring>
    #include<string.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/socket.h>
    #include<netinet/in.h>
    #include<arpa/inet.h>
    
    #define PORT 8111
    #define MESSAGE_LEN 1024
    int main(int argc, char*argv[])
    {
    	int ret = -1;
    	int socket_fd;
    	
    	struct sockaddr_in serveraddr;
    	socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    	
    	char sendbuf[MESSAGE_LEN] = {0,};
    	char recvbuf[MESSAGE_LEN] = {0,};
    	if (socket_fd < 0){
    		std::cout << "failed to create socket" << std::endl;
    		exit(-1);
    	}
    	serveraddr.sin_family = AF_INET;
    	serveraddr.sin_port = PORT;
    	serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    	 
    	ret = connect(socket_fd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr));
    	
    	if (ret < 0){		
    		std::cout << "failed to connect socket" << std::endl;
    		exit(-1);
    	}
    	
    	while(1){
    		memset(sendbuf, 0, MESSAGE_LEN);
    		//用sendbuf接收控制台的数据
    		std::cin.getline(sendbuf, MESSAGE_LEN);
    		ret = send(socket_fd, sendbuf, strlen(sendbuf), 0);
    		if (ret < 0){
    			std::cout << "failed to send socket" << std::endl;
    			break;
    		}
    		
    		// 退出指令
    		if (strcmp(sendbuf, "quit") == 0){
    			std::cout << "quit" << std::endl;
    			break;
    		}
    		
    		ret = recv(socket_fd, recvbuf, MESSAGE_LEN, 0);
    		recvbuf[ret] = '\0';
    		std::cout << "recv:" << recvbuf << std::endl;
    	}
    	close(socket_fd);
    }
    

    三、效果

    在这里插入图片描述

    更多相关内容
  • 简单tcp socket 客户端 服务端代码实现 附C++代码源码
  • socket分为socketserver和socketclient,socketserver是一个简单...客户端部署到服务器上,启动服务即与服务端建立长连接; 长连接建立以后用http://localhost:8080/socketclient/servlet/Test 发起请求与服务端通信
  • 一个基于WPF + SuperSocket的TCP长连接小...你无须了解如何使用 Socket, 如何维护 Socket 连接和 Socket 如何工作,我们可以有更多的时间用在业务逻辑上,SuperSocket有效的利用自己的协议解决粘包及各种事件通知机制。
  • 服务端代码: import socket import time print("服务端开启") # 创建套接字 mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 设置IP和端口 # host = socket.gethostname() host = '127.0.0.1' ...

    服务端代码:

    import socket
    import time
    
    print("服务端开启")
    # 创建套接字
    mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置IP和端口
    # host = socket.gethostname()
    host = '127.0.0.1'
    port = 3333
    # bind绑定该端口
    mySocket.bind((host, port))
    # 监听
    mySocket.listen(10)
    while True:
        # 接收客户端连接
        print("等待连接....")
        client, address = mySocket.accept()
        print("新连接")
        print("IP is %s" % address[0])
        print("port is %d\n" % address[1])
        while True:
            # 发送消息
            msg = "连接成功"
            client.send(msg.encode(encoding='utf-8'))
            print("发送完成")
            print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))  # 格式化时间戳为标准格式
            if msg == "EOF":
                break
            if msg == "quit":
                client.close()
                mySocket.close()
                print("程序结束\n")
                exit()
    
            # 读取消息
            msg = client.recv(1024)
            print("服务端接收:", msg.decode("utf-8"))  # 把接收到的数据进行解码
            print("读取完成")
            if msg == b"EOF":
                break
            if msg == b"quit":
                client.close()
                mySocket.close()
                print("程序结束\n")
                exit()

    客户端代码:连接后保持连接

    import socket
    
    print("客户端开启")
    # 创建套接字
    mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置ip和端口
    # host = socket.gethostname()
    host = '127.0.0.1'
    port = 3333
    
    try:
        mySocket.connect((host, port))  ##连接到服务器
        print("连接到服务器")
    except:  ##连接不成功,运行最初的ip
        print('连接不成功')
    
    while 1:
        # 接收消息
        msg = mySocket.recv(1024)
        print("客户端接收:%s" % msg.decode("utf-8"))  # 把接收到的数据进行解码
        print("读取完成")
        if msg == b"EOF":
            break
        if msg == b"quit":
            mySocket.close()
            print("程序结束\n")
            exit()
    
        # 发送消息
        msg = input("客户端发送:")
        mySocket.send(msg.encode(encoding='utf-8'))
        print("发送完成")
        if msg == "EOF":
            break
        if msg == "quit":
            mySocket.close()
            print("程序结束\n")
            exit()
    print("程序结束\n")

    客户端代码:发送后自动断开连接

    import socket
    sk = socket.socket()
    sk.connect(('127.0.0.1',3333))
    msg = sk.recv(1024).decode('utf-8')  # 最多接受1024字节
    print(msg)
    sk.send('你好'.encode('utf-8'))
    #sk.close()

     

     

    展开全文
  • socket起源于unix,京客户端服务端各自管理一个文件,是其能分别对文件进行读写操作 socket的通信流程: (二)代码实现: 编写TCP和UDP实现服务端客户端的通信: TCP实现: import java.net.ServerSocket; ...

    (一)Socket概念:

    socket时TCP/IP协议的抽象,是操作系统对外开放的接口
    在这里插入图片描述
    socket起源于unix,京客户端和服务端各自管理一个文件,是其能分别对文件进行读写操作
    socket的通信流程:
    socket的通信流程

    (二)代码实现:

    运行代码时要先运行服务器端,在运行客户端

    编写TCP和UDP实现服务端与客户端的通信:

    只能固定发送数据

    TCP实现:

    服务器端实现:

    • 创建Socket,并将socket绑定端口
    • while循环使得socket一直在等待状态
    • 监听端口
    • 获取客户端请求信息后,执行相关业务逻辑
    import java.net.ServerSocket;
    import java.net.Socket;
            public class TCPServer{
                 public static void main(String []agrs)throws Exception{
                      ServerSocket ss=new ServerSocket(65000);      //创建Socket,并将socket绑定端口
                      while(true){                                 //while循环使得socket一直在等待状态
                          Socket socket=ss.accept();               //监听端口
                          new LengthCalculator(socket).start();     //获取客户端请求信息后,执行相关业务逻辑
                          }
                     }
       }
    

    线程运行持续获得客户端的请求后,回送信息:

    • 获取socket输入流
    • 获取socket输出流
    • buff读取输入内容
    • 将接受流的byte数组转化为字符串
    • 回送客户端字符串长度
    • 关闭
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    public class LengthCalculator extends Thread{
                private Socket socket;
                public LengthCalculator(Socket socket){
                       this.socket=socket;
                       }
                 public void run(){
                         try{
                              //获取socket输入流
                              OutputStream os=socket.getOutputStream();   
                              //获取socket输出流
                              InputStream is=socket.getInputStream();
                              int ch=0;
                              //buff读取输入内容
                              byte[]buff=new byte[1024];
                              ch=is.read(buff);
                              //将接受流的byte数组转化为字符串
                              String content=new String(buff,0,ch);
                              //回送客户端字符串长度
                                 os.write(String.valueOf(content.length()).getBytes());
                              //关闭
                              is.close();
                              os.close();
                              socket.close();
                      }catch(IOException e){
                      e.printStackTrace();
             }
          }
      }
    

    客户端的实现:

    • 创建socket,并指定连接端口
    • 获取输出流
    • 获取输入流
    • 将要传递给server的字符串转换为byte数组
    • buff读取输入内容
    • ch获取读取长度
    • 关闭输入流及socket
    import java.io.OutputStream;
    import java.io.InputStream;
    import java.net.Socket;
    import java.net.Socket;
    
        public class TCPClient{
             public static void main(String []args)throws Exception{
                   //创建socket,并指定连接端口
                    Socket socket=new Socket(new InetSocketAddress("127.0.0.1",65000);
                    //获取输出流
                    OutputStream os=socket.getOutputStream();
                    //获取输入流
                    InputStream is=socket.getInputStream();
                    //将要传递给server的字符串转换为byte数组
                    os.write(new String("hello world").getBytes());
                    int ch=0;
                    //buff读取输入内容
                    byte[]buff=new byte[1024];
                    //ch获取读取长度
                    ch=is.read(buff);
                    String connect=new String (buff,0,ch);
                    System.out.println(connect);
                    //关闭输入流及socket
                    is.close();
                    os.close();
                    socket.close();
              }
         }
    
    

    UDP实现:

    运行代码时要先运行服务器端,在运行客户端
    服务器端

    • 服务器端接受客户端发送的数据报
      • 监听端口号
      • 存储从客户端接收的内容
      • 将客户端发送的内容封装进入DatagramPacket中
      • 将数据从二进制转化为字符串的形式
      • 将要发送的信息转化为二进制
    • 服务端发送数据报
      • 从DatagramPacket对象中获取到数据的来源地址和端口号
      • 发送数据给客户端
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    
            public class UDPServer{
                public static void main(String []args)  throws Exception{
                //服务器端接受客户端发送的数据报
                 //监听端口号
                    DatagramSocket socket=new DatagramSocket(65001);
                    //存储从客户端接收的内容
                    byte[]buff=new byte[100];
                    //将客户端发送的内容封装进入DatagramPacket中
                    DatagramPacket packet=new DatagramPacket(buff,buff.length);
                    socket.receive(packet);
                    //将数据从二进制转化为字符串的形式
                    byte[]data=packet.getData();
                    String content=new String(data,0,packet.getLength());
                    System.out.println(content);
                   // 将要发送的信息转化为二进制
                   byte[]sendedContent=String.valueOf(content.length()).getBytes();
                
                //服务端发送数据报
                //从DatagramPacket对象中获取到数据的来源地址和端口号
                  DatagramPacket packetToClient=new DatagramPacket(sendedContent,sendedContent.length,packet.getAddress(),packet.getPort());
                  //发送数据给客户端
                  socket.send(packetToClient);
                 }
            }  
                
    

    客户端实现

    • 客户端给服务器端发送数据
      • 存储要发送的数据
      • 将IP地址封装成InetAddres对象
      • 将要发送给服务器端的数据封装为DatagramPacket对象,要写上ip与端口号
      • 发送数据给服务器
    • 客户端接收服务器的数据
      • 创建DatagramPacket对象来存储服务器发送的数据
      • 将服务器端发送的数据取出并打印到控制台
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    
    public class UDPClient{
          public static void main(String[]args)throws Exception{
                      //客户端给服务器端发送数据
                     DatagramSocket socket=new DatagramSocket();
                     //存储要发送的数据
                     byte[]buf="hello world".getBytes();
                     //将IP地址封装成InetAddres对象
                     InetAddress address=InetAddress.getByName("127.0.0.1");
                     //将要发送给服务器端的数据封装为DatagramPacket对象,要写上ip与端口号
                     DatagramPacket packet=new DatagramPacket(buf,buf.length,address,65001);
                     //发送数据给服务器
                     socket.send(packet);
                             
                        //客户端接收服务器的数据
                        byte[]data=new byte[100];
                        //创建DatagramPacket对象来存储服务器发送的数据
                        DatagramPacket receivedPacket=new DatagramPacket(buf,buf.length);
                  
                     socket.receive(receivedPacket);
                     //将服务器端发送的数据取出并打印到控制台
                     String content=new String(receivedPacket.getData(),0,receivedPacket.getLength());
                     System.out.println(content);
            }
        }
    

    (三)升级版

    可从键盘输入数据并发送

    import java.io.*;
    import java.net.Inet4Address;
    import java.net.InetSocketAddress;
    import java.net.Socket;
    
    public class Client {
    	public static void main(String[] args) throws IOException {
    		Socket socket = new Socket();
    		// 连接本地
    		socket.setSoTimeout(3000);
    		 // 连接本地,端口2000;超时时间3000ms
    	    socket.connect(new InetSocketAddress(Inet4Address.getLocalHost(), 2000), 3000);
    
    	    System.out.println("已发起服务器连接,并进入后续流程~");
    	    System.out.println("客户端信息:" + socket.getLocalAddress() + " P:" + socket.getLocalPort());
    	    System.out.println("服务器信息:" + socket.getInetAddress() + " P:" + socket.getPort());
    
    	    try {
    	        // 发送接收数据
    	        todo(socket);
    	    } catch (Exception e) {
    	        System.out.println("异常关闭");
    	    }
    
    	    // 释放资源
    	    socket.close();
    	    System.out.println("客户端已退出~");
    
    	}
    
    	private static void todo(Socket client) throws IOException {
    	    // 构建键盘输入流
    	    InputStream in = System.in;
    	    BufferedReader input = new BufferedReader(new InputStreamReader(in));
    	    // 得到Socket输出流,并转换为打印流
    	    OutputStream outputStream = client.getOutputStream();
    	    PrintStream socketPrintStream = new PrintStream(outputStream);
    	    // 得到Socket输入流,并转换为BufferedReader
    	    InputStream inputStream = client.getInputStream();
    	    BufferedReader socketBufferedReader = new BufferedReader(new InputStreamReader(inputStream));
    
    	    boolean flag = true;
    	    do {
    	        // 键盘读取一行
    	        String str = input.readLine();
    	        // 发送到服务器
    	        socketPrintStream.println(str);
    	        // 从服务器读取一行
    	        String echo = socketBufferedReader.readLine();
    	        if ("bye".equalsIgnoreCase(echo)) {
    	            flag = false;
    	        }else {
    	            System.out.println(echo);
    	        }
    	    }while (flag);
    
    	    // 资源释放
    	    socketPrintStream.close();
    	    socketBufferedReader.close();
    
    	}
    }
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Server {
        public static void main(String[] args) throws IOException {
            ServerSocket server = new ServerSocket(2000);
            System.out.println("服务器准备就绪~");
            System.out.println("服务器信息:" + server.getInetAddress() + " P:" + server.getLocalPort());
            // 等待客户端连接
            for (; ; ) {
                // 得到客户端
                Socket client = server.accept();
                // 客户端构建异步线程
                ClientHandler clientHandler = new ClientHandler(client);
                // 启动线程
                clientHandler.start();
            }
    
        }
    
        /**
         * 客户端消息处理
         */
        private static class ClientHandler extends Thread {
            private Socket socket;
            private boolean flag = true;
    
            ClientHandler(Socket socket) {
                this.socket = socket;
            }
    
            @Override
            public void run() {
                super.run();
                System.out.println("新客户端连接:" + socket.getInetAddress() +
                        " P:" + socket.getPort());
    
                try {
                    // 得到打印流,用于数据输出;服务器回送数据使用
                    PrintStream socketOutput = new PrintStream(socket.getOutputStream());
                    // 得到输入流,用于接收数据
                    BufferedReader socketInput = new BufferedReader(new InputStreamReader(
                            socket.getInputStream()));
    
                    do {
                        // 客户端拿到一条数据
                        String str = socketInput.readLine();
                        if ("bye".equalsIgnoreCase(str)) {
                            flag = false;
                            // 回送
                            socketOutput.println("bye");
                        } else {
                            // 打印到屏幕。并回送数据长度
                            System.out.println(str);
                            socketOutput.println("回送:" + str.length());
                        }
    
                    } while (flag);
    
                    socketInput.close();
                    socketOutput.close();
    
                } catch (Exception e) {
                    System.out.println("连接异常断开");
                } finally {
                    // 连接关闭
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
                System.out.println("客户端已退出:" + socket.getInetAddress() +
                        " P:" + socket.getPort());
    
            }
        }
    }
    
    

    服务器端运行后如图:
    在这里插入图片描述
    客户端运行后如图:
    在这里插入图片描述
    在客户端输入数据后如图效果
    在这里插入图片描述
    输入bye时退出:
    在这里插入图片描述

    运行代码时要先运行服务器端,在运行客户端

    展开全文
  • 在计算机通信领域,socket 被翻译为“套接字”,它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定,一台计算机可以接收其他计算机的数据,也可以向其他计算机发送数据。 socket 的典型应用就是 ...
  • 复制代码 代码如下:import socket#socket通信客户端def client(): mysocket=socket.socket(socket.AF_INET,socket.SOCK_STREAM) mysocket.connect((‘127.0.0.1’,8000)) mysocket.send(‘hello’) while 1: ...
  • 主要介绍了javaweb启动时启动socket服务端代码实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 服务端客户端中分别对socket进行的操作,进行socket连接
  • 基于c#的socket的简单通信,仅用于学习,代码包含客服端和服务端
  • 本文实例讲述了通过node.js的net模块实现nodejs socket服务端客户端简单通信功能,可以用作客户端对服务端的端口监听以及事件回执。 server端代码 var net = require('net'); //模块引入 var listenPort = 8080;/...
  • 对unix网络编程源码稍作改动,以recvmsg以及sendmsg方式收发消息,stream方式
  • socket服务端客户端代码,聊天程序应用
  • C++ 实现socket通讯(服务端代码

    千次阅读 2021-11-28 14:53:18
    主要学习用C++的方式实现socket

    1.所需头文件:

    #include <stdio.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <string.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>

    2.定义TCP服务端类

    //定义TCP服务端类
    class CTcpServer{
    public:
      int m_listenfd;
      int m_clientfd;
    
      //构造函数
      CTcpServer();
    
      //初始化服务端
      bool initServer();
    
      //accept
      bool Accept();
    
      //send data
      int Send(void *buff, int bufflen);
    
      //recv data
      int Recv(void *buff, int bufflen);
    
      //close listen fd
      void listenClose();
    
      //close client fd
      void clientClose();
    
      //析构函数
      ~CTcpServer();
    };

    3.主函数实现:

    //main函数实现
    int main()
    {
      char buff[1024+1] = {0};
    
      //实例化一个server类
      CTcpServer tcpserver;
    
      //初始化服务器
      if(tcpserver.initServer() == false) {printf("init server error\n"); return false;}
    
      while(1){
        if(tcpserver.Accept() == false) continue;
    
        if(fork() > 0) {tcpserver.clientClose(); continue;}  //父进程负责监听,关闭client fd
    
        tcpserver.listenClose();  //子进程关闭listen fd
    
        printf("##############server start###############\n");
        while(tcpserver.Recv(buff, sizeof(buff)) > 0){
          printf("server recv: %s\n", buff);
          strcat(buff, "---@ok");
          tcpserver.Send(buff, strlen(buff));
          memset(buff, 0x00, sizeof(buff));
          printf("----------------------------------------\n");
        }
        return 0;
      }
      return 0;
    }

    4.构造函数、析构函数实现

    //构造函数
    CTcpServer::CTcpServer(){
      m_listenfd = 0;
      m_clientfd = 0;
    }
    
    //析构函数
    CTcpServer::~CTcpServer(){
      if(m_listenfd!=0) close(m_listenfd);
      if(m_clientfd!=0) close(m_clientfd);
    }

    5.初始化实现:

    //初始化
    bool CTcpServer::initServer(){
    
      if (m_listenfd!=0) { close(m_listenfd); m_listenfd=0; }
      m_listenfd = socket(AF_INET,SOCK_STREAM,0);     // 创建服务端的socket
    
      // 把服务端用于通信的地址和端口绑定到socket上
      struct sockaddr_in servaddr;                    // 服务端地址信息的数据结构
      memset(&servaddr,0,sizeof(servaddr));
      servaddr.sin_family = AF_INET;                  // 协议族,在socket编程中只能是AF_INET
    
      servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   // 本主机的任意ip地址
      servaddr.sin_port = htons(8000);                // 绑定通信端口
    
      if (bind(m_listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) != 0 )
        {close(m_listenfd); m_listenfd=0; return false;}
    
      // 把socket设置为监听模式
      if (listen(m_listenfd,5) != 0 ) { close(m_listenfd); m_listenfd=0; return false; }
    
      return true;
    }

    6.accept、send、recv、关闭等函数实现:

    //accept
    bool CTcpServer::Accept(){
    
    /****************************************************
    * len表示第二个参数addr的大小,不顾要求给定地址
    * addr: 用于记录发起连接请求的那个客户端的IP端口
    * 建立连接时服务器的TCP协议会自动解析客户端发来的数据包,从中获取客户端的IP和端口号
    * 这里如果服务器应用层需要用到客户端的 IP和端口号,可以给accept指定第二个参数addr,以获取TCP链接时的客户端ip和端口号;如果服务器应用层不需要,则写NULL即可
    * addr的结构体类型为 struct sockaddr,在listen函数详解中我们有介绍过,由于这个结构体用起来不是非常方便,我们需要定义struct sockaddr_in结构体来使得sockaddr结构体操作更为便捷。
    *****************************************************/
      m_clientfd = accept(m_listenfd, NULL, 0);
      if(m_clientfd == -1) return false;
      return true;
    }
    
    //send
    int CTcpServer::Send(void *buff, int bufflen){
      return send(m_clientfd, buff, bufflen, 0);
    }
    
    //recv
    int CTcpServer::Recv(void *buff, int bufflen){
      return recv(m_clientfd, buff, bufflen, 0);
    }
    
    //listenclose
    void CTcpServer::listenClose(){
      if (m_listenfd!=0) { close(m_listenfd); m_listenfd=0;}
    }
    
    //clientclose
    void CTcpServer::clientClose(){
      if (m_clientfd!=0) { close(m_clientfd); m_clientfd=0; }
    }

    7.运行结果:

    服务端:

    客户端:

     

    展开全文
  • Winform的socket服务端客户端代码
  • 主要介绍了Java通过socket客户端保持连接服务端实现代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • vs2010实现的socket服务端代码,C++编程,适合入门者下载看看
  • SuperSocket服务端 1.用WinForm实现。 2.可以给客户端发送消息。 注意:nuget安装包SuperSocket 基于1.6.6.1、SuperSocket.Engine 基于1.6.6.1、log4net最新即可
  • socket实现简单聊天室功能socket实现简单聊天室功能socket实现简单聊天室功能socket实现简单聊天室功能socket实现简单聊天室功能
  • Socket通信含服务端客户端、WebSocket,代码完整清晰
  • java 实现socket 客户端 服务端

    千次阅读 2021-07-15 11:48:54
    Socket服务端 package com.integration.controller.task.code; import org.junit.Test; import java.io.*; import java.net.ServerSocket; import java.net.Socket; import java.nio.charset.StandardCharsets; ...
  • C#socket客户端服务端代码详细见博文
  • 本代码为java socket网络编程实例代码,包括客户端和服务端,实现客户端发送消息,服务端接收并反馈消息。 server.java为服务端代码。 client.java为客户端代码
  • 产生一个 socket 服务端 <?php /*文件名:socket_server.php*/ // 设置一些基本的变量 $host="127.0.0.1";//Socket运行的服务器的IP地址 $port=1234;//Socket运行的服务器的端口,端口取值为1到65535之间的数字...
  • vb.net Socket服务端支持多客户端连接,并且实时监控客户端是否断开连接,代码注释明了,初学者很容易看得懂
  • 主要介绍了Java编程Socket实现多个客户端连接同一个服务端代码,具有一定参考价值,需要的朋友可以了解下。
  • C# socket 服务端客户端通信详细编写实例socket 通信socket 通信服务端编写实例过程 socket 通信 具体得 基于TCP/IP的通信基本上都是利用SOCKET套接字进行数据通讯,程序一般分为服务器端和用户端两部分。设计思路...
  • C++实现服务端客户端通信,已验证 简单例子,适合新手学习 , 创建工程直接运行即可 ,有兴趣的可以共同学习 ,

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 129,325
精华内容 51,730
关键字:

socket服务端客户端代码