这一系列文章的目的是在学习了C++基础后，继续补充一些C++基础和进阶的知识点，包括C++11的相关内容。

1 TCP

client

//头文件
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

// TCP配置
    //1、创建socket套接字
        // AF_INET（地址域：IPV4），AF_INET6（地址域：IPV6）
        // SOCK_STREAM（套接字类型 流式 TCP 套接字），SOCK_DGRAM：（套接字类型 数据报 UDP 套接字）
        // 0（协议类型 默认），返回-1表示创建失败
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
        return -1;

    //2、配置IP和端口
    struct sockaddr_in srv;                         //统一接口sockaddr_in 对应 IPV4
    srv.sin_family=AF_INET;
    srv.sin_port=htons(atoi("1122"));               //server的端口
    srv.sin_addr.s_addr=inet_addr("192.168.1.100"); //server的IP

    //3、连接
    socklen_t len=sizeof(struct sockaddr_in);
    if(connect(sockfd,(struct sockaddr*)&srv,len)<0)
        return -1;

// TCP收发
    //接收
    unsigned char buff_recv[1024];                  //定义接收的数据缓存
    memset(buff_recv, 0x00, sizeof(buff_recv));     //初始化为0
    recv(sockfd, buff_recv, sizeof(buff_recv)-1, 0);//阻塞接收 recv(sockfd, 数据缓存，接收数据长度，默认0)
    //发送
    unsigned char buff_send[2]={0x01,0x02}；     //定义一个待发送的数据
    send(sockfd, buff_send, sizeof(buff_send), 0);  //发出 send(sockfd，数据，数据长度，默认0)

//关闭socket
    close(sockfd);

server

//头文件
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

// TCP配置
    //1、创建socket套接字
        // AF_INET（地址域：IPV4），AF_INET6（地址域：IPV6）
        // SOCK_STREAM（套接字类型 流式 TCP 套接字），SOCK_DGRAM：（套接字类型 数据报 UDP 套接字）
        // 0（协议类型 默认），返回-1表示创建失败
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
        return -1;

    //2、配置本地IP和端口
    struct sockaddr_in server;                      //统一接口sockaddr_in 对应 IPV4
    server.sin_family=AF_INET;
    server.sin_port=htons(atoi("1122"));                //server的端口（本机监听的端口）
    server.sin_addr.s_addr=inet_addr("192.168.1.100");  //server的IP（本机IP）

    //3、绑定本地IP和端口
    int bind_result = bind(sockfd, (struct sockaddr*)&server, sizeof(server));
    if (bind_result == -1)
    {
        close(sockfd);
        return -1;
    }

    //4、开始监听
    int listen_result = listen(sockfd,5); 
    if(listen_result == -1)
        return -1;

    //5、建立连接
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
    int  new_fd = accept(sockfd, (struct sockaddr*)&client, &len);

// TCP收发
    //接收
    unsigned char buff_recv[1024];              //定义接收的数据缓存
    memset(buff_recv, 0x00, sizeof(buff_recv)); //初始化为0
    recv(new_fd, buff_recv, sizeof(buff_recv)-1, 0);//阻塞接收 recv(sockfd, 数据缓存，接收数据长度，默认0)
    //发送
    unsigned char buff_send[2]={0x01,0x02}； //定义一个待发送的数据
    send(new_fd, buff_send, sizeof(buff_send), 0);  //发出 send(sockfd，数据，数据长度，默认0)

//关闭socket
    close(sockfd);

2 UDP

广播发送

//头文件
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

// UDP配置
    //1、创建socket套接字
        // AF_INET（地址域：IPV4），AF_INET6（地址域：IPV6）
        // SOCK_STREAM（套接字类型 流式 TCP 套接字），SOCK_DGRAM：（套接字类型 数据报 UDP 套接字）
        // 0（协议类型 默认），返回-1表示创建失败
        int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if(-1==sockfd)
            return -1;

    //2、配置socket为广播类型
        const int opt = 1;   
        int bro_result = setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, (char *)&opt, sizeof(opt));  
        if(bro_result == -1)  
            return -1;  

    //3、配置广播地址和端口
        struct sockaddr_in addr_to;  
        socklen_t addr_to_len=sizeof(addr_to);
        memset(&addr_to, 0, addr_to_len);
        addr_to.sin_family=AF_INET;   
        addr_to.sin_port=htons(6000);  
        addr_to.sin_addr.s_addr=htonl(INADDR_BROADCAST);  

// UDP广播接收  
    // 定义数据缓存
        char buffer[] = {"abcdef"};
    //发送  
        int ret=sendto(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&addr_to, addr_to_len);   

//关闭socket
    close(sockfd);

广播接收

//头文件
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

// UDP配置
    //1、创建socket套接字
        // AF_INET（地址域：IPV4），AF_INET6（地址域：IPV6）
        // SOCK_STREAM（套接字类型 流式 TCP 套接字），SOCK_DGRAM：（套接字类型 数据报 UDP 套接字）
        // 0（协议类型 默认），返回-1表示创建失败
        int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if(-1==sockfd)
            return -1;

    //2、设置接收的IP和端口
        struct sockaddr_in addr_local;
        socklen_t addr_local_len=sizeof(addr_local);
        memset(&addr_local, 0, addr_local_len);
        addr_local.sin_family      = AF_INET;               // Use IPV4
        addr_local.sin_port        = htons(6000);           // 绑定端口          
        addr_local.sin_addr.s_addr = htonl(INADDR_ANY);     // 接收任意IP发来的数据

    //3、绑定上述设置到socket
        int bind_result = bind(sockfd, (struct sockaddr*)&addr_local, addr_local_len); 
        if (bind_result == -1)
        {
            close(sockfd);
            return -1;
        }

// UDP广播接收  
    // 定义数据缓存
        char buffer[30];
        memset(buffer, 0, 30);

        struct sockaddr_in addr_from;               // 用于保存消息来源的地址，即数据由哪个IP广播的
        socklen_t addr_from_len=sizeof(addr_from);
   //接收     
        int len = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&addr_from, &addr_from_len);

//关闭socket
    close(sockfd);

3 非阻塞接收

#include <fcntl.h>  //接收数据阻塞与否，默认为阻塞模式

//配置为非阻塞模式（不用ioctl）
    int flag_fcntl = fcntl(sockfd, F_GETFL, 0);
    fcntl(sockfd, F_SETFL, flag_fcntl|O_NONBLOCK);

4 recv recvfrom read send sendto write

ssize_t write(int fd, const void*buf, size_t nbytes); //ssize_t 即有符号的size_t
ssize_t read(int fd, void *buf, size_t nbyte);

int recv(int sockfd, void *buf, int len, int flags);
int send(int sockfd, void *buf, int len, int flags);

int recvfrom(int sockfd, void *buf, int len, unsigned int flags, struct sockaddr *from, int *fromlen);
int sendto(int sockfd, const void *buf, int len, unsigned int flags, const struct sockaddr *to, int tolen);

1. 参考：Linux下，write/read，recv/send， recvfrom/sendto的区别
2. read/wirte是通用的文件描述符操作；recv/send 通常应用于TCP；recvfrom/sendto通常应用于UDP。
3. recv/send函数的最后一个参数为0时，功能上与read和write基本一致。
4. read/wirte：从文件描述符fd中直接读写数据。
5. recv/send：增加第四个参数控制读写操作。
6. recvfrom/sendto：接收数据时获取对方IP，发送数据时指明对方IP。