【网络】Socket编程TCP/UDP&&序列化和反序列化理解应用层（C++实现）&&Json::Value

客户端发送一个SYN段（同步序号）指明客户打算连接的服务器端口，以及初始化序号(ISN)
服务器发回包含服务器的初始序号的SYN报文段作为应答。同时，将确认序号(ACK)设置为客户的ISN加1以对客户的SYN 报文段进行确认。一个SYN将占用一个序号
客户必须将确认序号设置为服务器的ISN加1以对服务器的SYN报文段进行确认

1.2 基本UDP客户—服务器程序设计基本框架

1.3 Socket编程

Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解Socket接口。

Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话，就很容易了解Socket了。网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。常用的Socket类型有两种：流式Socket（SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。

1.3.1 socket API

socket调用库函数主要有：

1.创建套接字
socket(af,type,protocol)

2.建立地址和套接字的联系
bind(sockid, local addr, addrlen)

3.服务器端侦听客户端的请求
        listen( Sockid ,quenlen)

4.建立服务器/客户端的连接 (面向连接TCP）
        客户端请求连接
connect(sockid, destaddr, addrlen)

        服务器端等待从编号为Sockid的Socket上接收客户连接请求

                newsockid=accept(Sockid，Clientaddr, paddrlen)

5.发送/接收数据

        面向连接：
                send(sockid, buff, bufflen)

                recv( )

        面向无连接：

                sendto(sockid,buff,…,addrlen)

                recvfrom( )

6.释放套接字

        close(sockid)

1.3.1.1 socket()

int socket(int domain, int type, int protocol);

socket()打开一个网络通讯端口,如果成功的话,就像 open()一样返回一个文件描述符;
应用程序可以像读写文件一样用 read/write 在网络上收发数据;
如果 socket()调用出错则返回-1;
对于 IPv4, family 参数指定为 AF_INET;
对于 TCP 协议,type 参数指定为 SOCK_STREAM, 表示面向流的传输协议
protocol 参数的介绍从略,指定为 0 即可

1.3.1.2 bind()

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

服务器程序所监听的网络地址和端口号通常是固定不变的,客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接; 服务器需要调用 bind 绑定一个固定的网络地址和端口号
bind()成功返回 0,失败返回-1
bind()的作用是将参数 sockfd 和 myaddr 绑定在一起, 使 sockfd 这个用于网络通讯的文件描述符监听 myaddr 所描述的地址和端口号
struct sockaddr *是一个通用指针类型,myaddr 参数实际上可以接受多种协议的 sockaddr 结构体,而它们的长度各不相同,所以需要第三个参数 addrlen 指定结构体的长度

我们的程序中对 myaddr 参数是这样初始化的:

将整个结构体清零
设置地址类型为 AF_INET
网络地址为 INADDR_ANY, 这个宏表示本地的任意 IP 地址,因为服务器可能有多个网卡,每个网卡也可能绑定多个 IP 地址, 这样设置可以在所有的 IP 地址上监听,直到与某个客户端建立了连接时才确定下来到底用哪个 IP 地址
端口号为 SERV_PORT

1.3.1.3 listen()

int listen(int sockfd, int backlog);

listen()声明 sockfd 处于监听状态, 并且最多允许有 backlog 个客户端处于连接等待状态, 如果接收到更多的连接请求就忽略, 这里设置不会太大(一般是 5)
listen()成功返回 0,失败返回-1;

1.3.1.4 accept()

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

三次握手完成后, 服务器调用 accept()接受连接
如果服务器调用 accept()时还没有客户端的连接请求,就阻塞等待直到有客户端连接上来;
addr 是一个传出参数,accept()返回时传出客户端的地址和端口号
如果给 addr 参数传 NULL,表示不关心客户端的地址
addrlen 参数是一个传入传出参数(value-result argument), 传入的是调用者提供的, 缓冲区 addr 的长度以避免缓冲区溢出问题, 传出的是客户端地址结构体的实际长度(有可能没有占满调用者提供的缓冲区)

我们的服务器程序结构是这样的:

1.3.1.5 connect()

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

客户端需要调用 connect()连接服务器
connect 和 bind 的参数形式一致, 区别在于 bind 的参数是自己的地址, 而connect 的参数是对方的地址
connect()成功返回 0,出错返回-1

1.3.2 TCP/IP应用编程接口（API）

1.3.2.1 服务器

服务器的工作流程：首先调用socket函数创建一个Socket，然后调用bind函数将其与本机地址以及一个本地端口号绑定，然后调用listen在相应的socket上监听，当accpet接收到一个连接服务请求时，将生成一个新的socket。服务器显示该客户机的IP地址，并通过新的socket向客户端发送字符串" hi,I am server!"。最后关闭该socket

int main()
{ 
    int sock_fd,client_fd; /*sock_fd：监听socket；client_fd：数据传输socket */ 
    struct sockaddr_in ser_addr; /* 本机地址信息 */ 
    struct sockaddr_in cli_addr; /* 客户端地址信息 */ 
    char msg[MAX_MSG_SIZE];/* 缓冲区*/
    ser_sockfd=socket(AF_INET,SOCK_STREAM,0);/*创建连接的SOCKET */
    if(ser_sockfd<0)
    {/*创建失败 */
        fprintf(stderr,"socker Error:%s\n",strerror(errno));
        exit(1);
    } 
    /* 初始化服务器地址*/
    addrlen=sizeof(struct sockaddr_in);
    bzero(&ser_addr,addrlen);
    ser_addr.sin_family=AF_INET;
    ser_addr.sin_addr.s_addr=htonl(INADDR_ANY);
    ser_addr.sin_port=htons(SERVER_PORT);
    if(bind(ser_sockfd,(struct sockaddr*)&ser_addr,sizeof(struct sockaddr_in))<0)
    { /*绑定失败 */
        fprintf(stderr,"Bind Error:%s\n",strerror(errno));
        exit(1);
    } 
    /*侦听客户端请求*/
    if(listen(ser_sockfd,BACKLOG)<0)
    {
        fprintf(stderr,"Listen Error:%s\n",strerror(errno));
        close(ser_sockfd);
        exit(1);
    }
    while(1)
    {/* 等待接收客户连接请求*/
        cli_sockfd=accept(ser_sockfd,(struct sockaddr*) & cli_addr,&addrlen);
        if(cli_sockfd<=0)
        {
            fprintf(stderr,"Accept Error:%s\n",strerror(errno));
        }
        else
        {/*开始服务*/
            recv(cli_addr,msg,MAX_MSG_SIZE,0); /* 接受数据*/
            printf("received a connection from %sn",inet_ntoa(cli_addr.sin_addr));
            printf("%s\n",msg);/*在屏幕上打印出来 */ 
            strcpy(msg,"hi,I am server!");
            send(cli_addr,msg,sizeof(msg),0); /*发送的数据*/
            close(cli_addr); 
        }
    }
    close(ser_sockfd);
}

1.3.2.2 客户端

客户端的工作流程：首先调用socket函数创建一个Socket，然后初始化服务器地址结构，调用connect函数请求连接服务器，通过新的socket向客户端发送字符串" hi,I am client!"。最后关闭该socket。

int main()
{
    int cli_sockfd;/*客户端SOCKET */
    int addrlen;
    char seraddr[14];
    struct sockaddr_in ser_addr,/* 服务器的地址*/
    char msg[MAX_MSG_SIZE];/* 缓冲区*/
    GetServerAddr(seraddr);
    cli_sockfd=socket(AF_INET,SOCK_STREAM,0);/*创建连接的SOCKET */
    if(ser_sockfd<0)
    {/*创建失败 */
        fprintf(stderr,"socker Error:%s\n",strerror(errno));
        exit(1);
    }
    /* 初始化服务器地址*/
    addrlen=sizeof(struct sockaddr_in);
    bzero(&ser_addr,addrlen);
    ser_addr.sin_family=AF_INET;
    ser_addr.sin_addr.s_addr=inet_addr(seraddr);
    ser_addr.sin_port=htons(SERVER_PORT);
    if(connect(cli_sockfd,(struct sockaddr*)&ser_addr,&addrlen)!=0)/*请求连接*/
    {
        /*连接失败 */
        fprintf(stderr,"Connect Error:%s\n",strerror(errno));
        close(cli_sockfd);
        exit(1);
    }
    strcpy(msg,"hi,I am client!");
    send(sockfd,msg,sizeof(msg),0);/*发送数据*/
    recv(sockfd,msg,MAX_MSG_SIZE,0); /* 接受数据*/
    printf("%s\n",msg);/*在屏幕上打印出来 */
    close(cli_sockfd);
}

1.3.3 UDP/IP应用编程接口（API）

1.3.3.1 服务器

服务器的工作流程：首先调用socket函数创建一个Socket，然后调用bind函数将其与本机地址以及一个本地端口号绑定，接收到一个客户端时，服务器显示该客户端的IP地址，并将字串返回给客户端。

int main(int argc, char **argv)
{
    int ser_sockfd;
    int len;
    // int addrlen;

    socklen_t addrlen;
    char seraddr[100];
    struct sockaddr_in ser_addr;
    /*建立socket*/
    ser_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (ser_sockfd < 0)
    {
        printf("I cannot socket success\n");
        return 1;
    }
    /*填写sockaddr_in 结构*/
    addrlen = sizeof(struct sockaddr_in);
    bzero(&ser_addr, addrlen);
    ser_addr.sin_family = AF_INET;
    ser_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    ser_addr.sin_port = htons(SERVER_PORT);
    /*绑定服务器*/
    if (bind(ser_sockfd, (struct sockaddr *)&ser_addr, addrlen) < 0)
    {
        printf("connect");
        return 1;
    }
    while (1)
    {
        bzero(seraddr, sizeof(seraddr));
        len = recvfrom(ser_sockfd, seraddr, sizeof(seraddr), 0, (struct sockaddr *)&ser_addr, &addrlen);
        /*显示client端的网络地址*/
        printf("receive from %s\n", inet_ntoa(ser_addr.sin_addr));
        /*显示客户端发来的字串*/
        printf("recevce:%s", seraddr);
        /*将字串返回给client端*/
        sendto(ser_sockfd, seraddr, len, 0, (struct sockaddr *)&ser_addr, addrlen);
    }
}

1.3.3.2 客户端

客户端的工作流程：首先调用socket函数创建一个Socket，填写服务器地址及端口号，从标准输入设备中取得字符串，将字符串传送给服务器端，并接收服务器端返回的字符串。最后关闭该socket。

int GetServerAddr(char * addrname)
{
    printf("please input server addr:");
    scanf("%s",addrname);
    return 1;
}
int main(int argc,char **argv)
{
    int cli_sockfd;
    int len;
    socklen_t addrlen;
    char seraddr[14];
    struct sockaddr_in cli_addr;
    char buffer[256];
    GetServerAddr(seraddr);
    /* 建立socket*/
    cli_sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(cli_sockfd<0)
    {
        printf("I cannot socket success\n");
        return 1;
    }
    /* 填写sockaddr_in*/
    addrlen=sizeof(struct sockaddr_in);
    bzero(&cli_addr,addrlen);
    cli_addr.sin_family=AF_INET;
    cli_addr.sin_addr.s_addr=inet_addr(seraddr);
    //cli_addr.sin_addr.s_addr=htonl(INADDR_ANY);

    cli_addr.sin_port=htons(SERVER_PORT);
    bzero(buffer,sizeof(buffer));
    /* 从标准输入设备取得字符串*/
    len=read(STDIN_FILENO,buffer,sizeof(buffer));
    /* 将字符串传送给server端*/
    sendto(cli_sockfd,buffer,len,0,(struct sockaddr*)&cli_addr,addrlen);
    /* 接收server端返回的字符串*/
    len=recvfrom(cli_sockfd,buffer,sizeof(buffer),0,(structsockaddr*)&cli_addr,&addrlen);
    //printf("receive from %s\n",inet_ntoa(cli_addr.sin_addr));

    printf("receive: %s",buffer);
    close(cli_sockfd);
}

1.3.4 调试 makefile

CC=gcc
        all:server client
        CFLAGS=-o
        server: server.c
         $(CC) $(CFLAGS) $@ server.c
        client: client.c
        $(CC) $(CFLAGS) $@ client.c
clean:
        rm -f server client

2.Socket 编程 UDP

2.1 udp echo server

简单的回显服务器和客户端代码

udp_echo_server程序源码：mnxcc/linuxdc - Gitee.com

2.2 udp dict server

实现一个简单的英译汉的网络字典

udp_dict_server程序源码：mnxcc/linuxdc - Gitee.com

2.3 简单聊天室

udp_chat_server程序源码：mnxcc/linuxdc - Gitee.com

UDP 协议支持全双工，一个 sockfd，既可以读取，又可以写入，对于客户端和服务端同样如此

2.4 地址转换函数

基于 IPv4 的 socket 网络编程,sockaddr_in 中的成员 struct in_addr.sin_addr 表示 32 位的 IP 地址in_addr转字符串的函数:

但是我们通常用点分十进制的字符串表示 IP 地址,以下函数可以在字符串表示和 in_addr 表示之间转换;

字符串转 in_addr 的函数:

in_addr转字符串的函数:

其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr,还可以转换IPv6的in6_addr,因此函数接口是void*addrptr。

2.4.1 关于inet_ntoa

inet_ntoa这个函数返回了一个char*，很显然是这个函数自己在内部为我们申请了一块内存来保存ip的结果那么是否需要调用者手动释放呢?

man手册上说，inet_ntoa函数，是把这个返回结果放到了静态存储区.这个时候不需要我们手动进行释放

那么问题来了，如果我们调用多次这个函数，会有什么样的效果呢?

因为inet_ntoa把结果放到自己内部的一个静态存储区，这样第二次调用时的结果会覆盖掉上一次的结果

多线程调用inet_ntoa代码示例如下

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
void *Func1(void *p)
{
    struct sockaddr_in *addr = (struct sockaddr_in *)p;
    while (1)
    {
        char *ptr = inet_ntoa(addr->sin_addr);
        printf("addr1: %s\n", ptr);
    }
    return NULL;
}
void *Func2(void *p)
{
    struct sockaddr_in *addr = (struct sockaddr_in *)p;
    while (1)
    {
        char *ptr = inet_ntoa(addr->sin_addr);
        printf("addr2: %s\n", ptr);
    }
    return NULL;
}
int main()
{
    pthread_t tid1 = 0;
    struct sockaddr_in addr1;
    struct sockaddr_in addr2;
    addr1.sin_addr.s_addr = 0;
    addr2.sin_addr.s_addr = 0xffffffff;
    pthread_create(&tid1, NULL, Func1, &addr1);
    pthread_t tid2 = 0;
    pthread_create(&tid2, NULL, Func2, &addr2);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

3.Socket 编程 TCP

3.1 tcp echo server

tcp_echo_server程序源码：mnxcc/linuxdc - Gitee.com

3.2 多线程远程命令执行

command_server程序源码：mnxcc/linuxdc - Gitee.com

4.应用层自定义协议与序列化

4.1 应用层

我们程序员写的一个个解决我们实际问题, 满足我们日常需求的网络程序, 都是在应用层

协议是一种 "约定". socket api 的接口, 在读写数据时, 都是按 "字符串" 的方式来发送接收的. 如果我们要传输一些 "结构化的数据" 怎么办呢?

其实，协议就是双方约定好的结构化的数据

4.2 重新理解 read、write、recv、send 和 tcp 为什么支持全双工

所以：

在任何一台主机上，TCP 连接既有发送缓冲区，又有接受缓冲区，所以，在内核中，可以在发消息的同时，也可以收消息，即全双工
这就是为什么一个 tcp sockfd 读写都是它的原因
实际数据什么时候发，发多少，出错了怎么办，由 TCP 控制，所以 TCP 叫做传输控制协议

4.3 网络版计算器

cal_server程序源码：mnxcc/linuxdc - Gitee.com

例如, 我们需要实现一个服务器版的加法器. 我们需要客户端把要计算的两个加数发过去, 然后由服务器进行计算, 最后再把结果返回给客户端

约定方案一:

客户端发送一个形如"1+1"的字符串;
这个字符串中有两个操作数, 都是整形;
两个数字之间会有一个字符是运算符, 运算符只能是 + ;
数字和运算符之间没有空格

约定方案二:

定义结构体来表示我们需要交互的信息;
发送数据时将这个结构体按照一个规则转换成字符串, 接收到数据的时候再按照相同的规则把字符串转化回结构体
这个过程叫做 "序列化" 和 "反序列化"

无论我们采用方案一, 还是方案二, 还是其他的方案, 只要保证, 一端发送时构造的数据,在另一端能够正确的进行解析, 就是 ok 的. 这种约定, 就是 应用层协议

但是，为了让深刻理解协议，我们自定义实现一下协议的过程

采用方案 2，也要体现协议定制的细节
要引入序列化和反序列化，直接采用现成的方案 -- jsoncpp库
要对 socket 进行字节流的读取处理

期望的报文格式

所以，完整的处理过程应该是：

4.3.1 Jsoncpp

Jsoncpp 是一个用于处理 JSON 数据的 C++ 库。它提供了将 JSON 数据序列化为字符串以及从字符串反序列化为 C++ 数据结构的功能。Jsoncpp 是开源的，广泛用于各种需要处理 JSON 数据的 C++ 项目中

4.3.1.1 特性

简单易用：Jsoncpp 提供了直观的 API，使得处理 JSON 数据变得简单。
高性能：Jsoncpp 的性能经过优化，能够高效地处理大量 JSON 数据。
全面支持：支持 JSON 标准中的所有数据类型，包括对象、数组、字符串、数字、布尔值和 null
错误处理：在解析 JSON 数据时，Jsoncpp 提供了详细的错误信息和位置，方便开发者调试。
当使用 Jsoncpp 库进行 JSON 的序列化和反序列化时，确实存在不同的做法和工具类可供选择

4.3.1.2 安装

ubuntu：sudo apt-get install libjsoncpp-dev
Centos: sudo yum install jsoncpp-devel

4.3.2 序列化和反序列化

4.3.2.1 序列化

序列化指的是将数据结构或对象转换为一种格式，以便在网络上传输或存储到文件中。Jsoncpp 提供了多种方式进行序列化：

1.使用 Json::Value 的 toStyledString 方法：

优点：将 Json::Value 对象直接转换为格式

#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>
int main()
{
    Json::Value root;
    root["name"] = "joe";
    root["sex"] = "男";
    std::string s = root.toStyledString();
    std::cout << s << std::endl;
    return 0;
}

2.使用 Json::StreamWriter

优点：提供了更多的定制选项，如缩进、换行符等

#include <iostream>
#include <string>
#include <sstream>
#include <memory>
#include <jsoncpp/json/json.h>
int main()
{
    Json::Value root;
    root["name"] = "joe";
    root["sex"] = "男";
    Json::StreamWriterBuilder wbuilder; // StreamWriter 的工厂
    std::unique_ptr<Json::StreamWriter>
        writer(wbuilder.newStreamWriter());
    std::stringstream ss;
    writer->write(root, &ss);
    std::cout << ss.str() << std::endl;
    return 0;
}

3.使用 Json::FastWriter：

优点：比 StyledWriter 更快，因为它不添加额外的空格和换行符

#include <iostream>
#include <string>
#include <sstream>
#include <memory>
#include <jsoncpp/json/json.h>
int main()
{
    Json::Value root;
    root["name"] = "joe";
    root["sex"] = "男";
    Json::FastWriter writer;
    std::string s = writer.write(root);
    std::cout << s << std::endl;
    return 0;
}

4.3.2.2 反序列化

反序列化指的是将序列化后的数据重新转换为原来的数据结构或对象。Jsoncpp 提供了以下方法进行反序列化

1.使用 Json::Reader：

优点：提供详细的错误信息和位置，方便调试

#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>
int main()
{
    // JSON 字符串
    std::string json_string = "{\"name\":\"张三\",\"age\":30, \"city\":\"北京\"}";
    // 解析 JSON 字符串
    Json::Reader reader;
    Json::Value root;
    // 从字符串中读取 JSON 数据
    bool parsingSuccessful = reader.parse(json_string,
                                          root);
    if (!parsingSuccessful)
    {
        // 解析失败，输出错误信息
        std::cout << "Failed to parse JSON: " << reader.getFormattedErrorMessages() << std::endl;
        return 1;
    }
    // 访问 JSON 数据
    std::string name = root["name"].asString();
    int age = root["age"].asInt();
    std::string city = root["city"].asString();
    // 输出结果
    std::cout << "Name: " << name << std::endl;
    std::cout << "Age: " << age << std::endl;
    std::cout << "City: " << city << std::endl;
    return 0;
}

2. 使用 Json::CharReader 的派生类：

在某些情况下，你可能需要更精细地控制解析过程，可以直接使用 Json::CharReader 的派生类

但通常情况下，使用 Json::parseFromStream 或 Json::Reader 的 parse 方法就足够了

4.4 Json::Value

Json::Value 是 Jsoncpp 库中的一个重要类，用于表示和操作 JSON 数据结构。以下是一些常用的 Json::Value 操作列表

4.4.1 构造函数

Json::Value()：默认构造函数，创建一个空的 Json::Value 对象。
Json::Value(ValueType type, bool allocated = false)：根据给定的ValueType（如 nullValue, intValue, stringValue 等）创建一个 Json::Value 对象

4.4.2 访问元素

Json::Value& operator[](const char* key)：通过键（字符串）访问对象中的元素。如果键不存在，则创建一个新的元素
Json::Value& operator[](const std::string& key)：同上，但使用std::string 类型的键
Json::Value& operator[](ArrayIndex index)：通过索引访问数组中的元素。如果索引超出范围，则创建一个新的元素
Json::Value& at(const char* key)：通过键访问对象中的元素，如果键不存在则抛出异常
Json::Value& at(const std::string& key)：同上，但使用 std::string类型的键

4.4.3 类型检查

bool isNull()：检查值是否为 null
bool isBool()：检查值是否为布尔类型
bool isInt()：检查值是否为整数类型
bool isInt64()：检查值是否为 64 位整数类型
bool isUInt()：检查值是否为无符号整数类型
bool isUInt64()：检查值是否为 64 位无符号整数类型
bool isIntegral()：检查值是否为整数或可转换为整数的浮点数
bool isDouble()：检查值是否为双精度浮点数
bool isNumeric()：检查值是否为数字（整数或浮点数）
bool isString()：检查值是否为字符串
bool isArray()：检查值是否为数组
bool isObject()：检查值是否为对象（即键值对的集合）

4.4.4 赋值和类型转换

Json::Value& operator=(bool value)：将布尔值赋给 Json::Value 对象
Json::Value& operator=(int value)：将整数赋给 Json::Value 对象
Json::Value& operator=(unsigned int value)：将无符号整数赋给Json::Value 对象
Json::Value& operator=(Int64 value)：将 64 位整数赋给 Json::Value 对象
Json::Value& operator=(UInt64 value)：将 64 位无符号整数赋给 Json::Value 对象
Json::Value& operator=(double value)：将双精度浮点数赋给 Json::Value 对象
Json::Value& operator=(const char* value)：将 C 字符串赋给 Json::Value 对象
Json::Value& operator=(const std::string& value)：将 std::string 赋给 Json::Value 对象
bool asBool()：将值转换为布尔类型（如果可能）
int asInt()：将值转换为整数类型（如果可能）
Int64 asInt64()：将值转换为 64 位整数类型（如果可能）
unsigned int asUInt()：将值转换为无符号整数类型（如果可能）
UInt64 asUInt64()：将值转换为 64 位无符号整数类型（如果可能）
double asDouble()：将值转换为双精度浮点数类型（如果可能）
std::string asString()：将值转换为字符串类型（如果可能）

4.4.5 数组和对象操作

size_t size()：返回数组或对象中的元素数量
bool empty()：检查数组或对象是否为空
void resize(ArrayIndex newSize)：调整数组的大小
void clear()：删除数组或对象中的所有元素
void append(const Json::Value& value)：在数组末尾添加一个新元素
Json::Value& operator[](const char* key, const Json::Value& defaultValue = Json::nullValue)：在对象中插入或访问一个元素，如果键不存在则使用默认值
Json::Value& operator[](const std::string& key, const Json::Value& defaultValue = Json::nullValue)：同上，但使用 std::string 类型的

原文地址：https://blog.csdn.net/m0_74722801/article/details/143894745

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：从0开始机器学习--Day30--异常检测算法
下一篇：电脑系统重装小白教程

论文阅读——Intrusion detection systems using longshort‑term memory (LSTM)
作者提出的 LSTM 模型能够有效区分正常网络流量和攻击流量。除此之外，模型结合主成分分析（PCA）和互信息作为降维方法。实验结果表明，基于 PCA 的模型（特别是使用2个主成分）在二分类和多分类任务
阅读更多2024-11-21
用源码编译虚幻引擎，并打包到安卓平台
本文详细介绍了如何用源码编译虚幻引擎，并将其打包到安卓平台。
阅读更多2024-11-21
Vue项目开发 element-UI 前端实现 1到10排列选择的按钮
在 Element UI 中，你可以通过来实现按钮的排列选择，例如让用户选择 1 到 10 之间的数字。为了实现这一功能，我们可以使用来动态生成 1 到 10 的按钮，并通过按钮点击事件来更新
阅读更多2024-11-21
Java EE 【知识改变命运】01计算机的一些知识点
计算机一些基础知识
阅读更多2024-11-21
04 —— Webpack打包CSS代码
加载器style-loader：把解析后的css代码插入到DOM。加载器css-loader ：解析css代码。直接引用，不用变量接收。
阅读更多2024-11-21
万能程序补丁工具 C# 源代码详解
万能程序补丁工具程序目的：搜索二进制可执行 EXE 或 DLL 文件分析的特征代码，替换特征代码，达到调试修正目标程序的功能。
阅读更多2024-11-21
【MySQL数据库】C#实现MySQL数据库最简单的查询和执行函数
C#和MySQL数据库是常见的数据交互，标准的查询和执行方法如下，做个记录。
阅读更多2024-11-21
单条推理转批量推理prompt
在每个线程中设置环境变量 CUDA_VISIBLE_DEVICES，以确保每个线程只使用指定的GPU。使用 concurrent.futures.ThreadPoolExecutor 来管理多线程任务
阅读更多2024-11-21
【AIGC】ChatGPT提示词Prompt解析：情感分析，分手后还可以做朋友吗？
【AIGC】在情感博弈中，最重要的是保持清醒的认知和优雅的态度。识别控制话术不是为了对抗，而是为了更好地保护自己的情感自由，实现真正的成长。
阅读更多2024-11-21
pycharm中配置pyqt5
PyQt和wxPython则提供了更多的控件和更强大的功能，适合于需要复杂用户界面的应用程序。pyQt生成的应用程序，引用图片通常是将资源文件装换为 python 文件，然后引用资源文件，而不能直接加
阅读更多2024-11-21