本篇介绍C语言函数大全-- x 开头的函数

1. xdr_struct

1.1 函数说明

函数声明	函数功能
bool_t xdr_struct(XDR *xdrs, void *addr, ...);	用于编码或解码结构体数据

参数：

• xdrs ： 指向 XDR 数据结构的指针，表示要进行编码或解码的数据流
• addr ： 指向待编码或解码的结构体变量的指针
• … ： 任意数量和类型的参数，用于描述结构体的成员以及它们的序列化格式的

返回值：

• 如果编码或解码成功，则返回值为 TRUE；
• 否则返回值为 FALSE。

1.2 演示示例

#include <stdio.h>
#include <rpc/xdr.h>

struct person 
{
    char name[20];
    int age;
};

int main() 
{
    struct person p1 = {"Huazie", 18};
    struct person p2;

    XDR xdrs;
    char buffer[100];

    // 初始化xdr流
    xdrmem_create(&xdrs, buffer, sizeof(buffer), XDR_ENCODE);

    // 编码p1结构体
    if (!xdr_struct(&xdrs, "person", (char *)&p1, sizeof(p1))) {
        printf("编码失败\n");
        return -1;
    }

    // 重置xdr流
    xdr_destroy(&xdrs);
    xdrmem_create(&xdrs, buffer, sizeof(buffer), XDR_DECODE);

    // 解码结构体
    if (!xdr_struct(&xdrs, "person", (char *)&p2, sizeof(p2))) {
        printf("解码失败\n");
        return -1;
    }

    // 输出结果
    printf("p1: name=%s, age=%d\n", p1.name, p1.age);
    printf("p2: name=%s, age=%d\n", p2.name, p2.age);

    return 0;
}

在上面的示例代码中，
-首先，我们定义了两个 person 类型的变量 p1 和 p2，其中 p1 被初始化为 {name="Huazie", age=18}。

• 然后，使用 xdrmem_create() 函数创建了一个 xdr 流，将其与一个大小为 100 字节的 buffer 绑定；
• 接着，使用 xdr_struct() 函数对 p1 结构体进行编码；
• 再然后，调用 xdr_destroy() 函数重置了xdr 流，并使用 xdrmem_create() 函数将其重新绑定到 buffer 上；
• 再接着，使用 xdr_struct() 函数将编码后的数据解码到 p2 变量中，并检查是否解码成功。
• 最后，输出了 p1 和 p2 结构体对应的成员变量的值。

2. xdr_u_char

2.1 函数说明

函数声明	函数功能
bool_t xdr_u_char(XDR *xdrs, u_char *up);	用于编码或解码 unsigned char 类型的值

参数：

• xdrs ： 指向 XDR 结构体的指针
• up ： 指向 unsigned char 类型变量的指针

返回值：

• 如果编码或解码成功，则返回值为 TRUE；
• 否则返回值为 FALSE。

2.2 演示示例

#include <stdio.h>
#include <rpc/xdr.h>

int main() 
{
    XDR xdrs;
    u_char val = 'a';
    u_char result;

    char buf[1024];
    xdrmem_create(&xdrs, buf, sizeof(buf), XDR_ENCODE);
    if (!xdr_u_char(&xdrs, &val))
    {
        printf("编码失败！");
        return 1;
    }
    // 获取编码后数据的长度
    int len = xdr_getpos(&xdrs);  

    xdrmem_create(&xdrs, buf, len, XDR_DECODE);
    if (!xdr_u_char(&xdrs, &result)) 
    {
        printf("解码失败！");
        return 1;
    }

    printf("编码前的值：%c\n", val);
    printf("编码后的长度：%d\n", len);
    printf("解码后的值：%c\n", result);
    return 0;
}

在上面的这个示例中，

• 首先，我们定义了一个 unsigned char 类型的变量 val，并将其初始化为字符 'a'；
• 然后，使用 xdrmem_create() 函数创建了一个 XDR 流对象 xdrs，并指定流的编码方式为 XDR_ENCODE；
• 接着，调用 xdr_u_char() 函数对 val 进行编码，如果编码成功，则调用 xdr_getpos() 函数获取编码后数据的长度，该长度将作为解码时的参数；
• 再然后，再次调用 xdrmem_create() 函数创建一个 XDR 流对象 xdrs 并指定流的编码方式为 XDR_DECODE；
• 再接着，调用 xdr_u_char() 函数对编码后的数据进行解码，并将结果存储到变量 result 中；
• 最后输出编码前的值、编码后的长度和解码后的值。

3. xdr_u_hyper

3.1 函数说明

函数声明	函数功能
bool_t xdr_u_hyper(XDR *xdrs, u_hyper *uhp);	用于编码和解码 u_hyper 类型的数据

参数：

• xdrs ： 指向要编码或解码数据的 XDR 结构体的指针
• uhp ： 指向 u_hyper 类型变量的指针

返回值：

• 如果编码或解码成功，则返回值为 TRUE；
• 否则返回值为 FALSE。

3.2 演示示例

#include <stdio.h>
#include <rpc/xdr.h>

int main() 
{
    XDR xdrs;
    u_hyper value = 12345678901234567890ULL; // 定义一个 64 位无符号整数
    char buffer[16];
    char *bufptr = buffer;

    xdrmem_create(&xdrs, buffer, sizeof(buffer), XDR_ENCODE);
    if (!xdr_u_hyper(&xdrs, &value)) 
    { 
        printf("Serialization error");
        return 1;
    }

    // 将编码后的数据打印出来
    for (int i = 0; i < sizeof(buffer); i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");

    xdrmem_create(&xdrs, buffer, sizeof(buffer), XDR_DECODE);
    if (!xdr_u_hyper(&xdrs, &value)) 
    { 
        printf("Deserialization error");
        return 1;
    }

    printf("%llu\n", value); // 打印解码后的值

    return 0;
}

在上面的示例代码中，

• 首先，我们定义了一个 64 位无符号整数变量 value 并给它赋值 12345678901234567890ULL；
• 然后，使用 xdrmem_create() 函数创建了一个 XDR 流对象 xdrs，并指定流的编码方式为 XDR_ENCODE；
• 接着，调用 xdr_u_hyper() 函数进行编码操作；如果编码成功，则将编码后的数据打印出来；
• 再然后，再次调用 xdrmem_create() 函数创建一个 XDR 流对象 xdrs 并指定流的编码方式为 XDR_DECODE；
• 再接着，调用 xdr_u_hyper() 函数对编码后的数据进行解码，并将结果存储到变量 value 中；
• 最后，输出解码后的值。

4. xdr_u_int

4.1 函数说明

函数声明	函数功能
bool_t xdr_u_int(XDR *xdrs, u_int *a);	用于编码或解码无符号整数

参数：

• xdrs ： 指向要编码或解码数据的 XDR 结构体的指针
• a ： 指向要编码或解码的无符号整数的指针

返回值：

• 如果编码或解码成功，则返回值为 TRUE；
• 否则返回值为 FALSE。

4.2 演示示例

#include <stdio.h>
#include <rpc/xdr.h>

int main(void) 
{
    // 将无符号整数编码为 XDR 格式字节流
    unsigned int num = 123456789;
    XDR xdr;
    char buf[4];
    xdrmem_create(&xdr, buf, sizeof(buf), XDR_ENCODE);
    if (!xdr_u_int(&xdr, &num)) 
    {
        printf("Failed to encode unsigned int.\n");
        return 1;
    }
    printf("Encoded bytes: %02x %02x %02x %02x\n", buf[0], buf[1], buf[2], buf[3]);

    // 从 XDR 格式字节流中解码无符号整数
    unsigned int decoded_num;
    XDR xdr2;
    xdrmem_create(&xdr2, buf, sizeof(buf), XDR_DECODE);
    if (!xdr_u_int(&xdr2, &decoded_num)) 
    {
        printf("Failed to decode unsigned int.\n");
        return 1;
    }
    printf("Decoded number: %u\n", decoded_num);

    return 0;
}

在上面的这个示例程序中，

• 首先，我们首先创建了一个无符号整数变量 num 并将其设置为 123456789；
• 然后，使用 xdrmem_create() 函数创建了一个 XDR 对象 xdr，并和 buf 绑定；
• 接着，使用 xdr_u_int() 函数将无符号整数 num 编码为 XDR 格式字节流，并将其写入到缓冲区 buf 中。如果编码过程中出现错误，则输出一条错误消息并返回 1；如果编码成功，则输出编码后的字节流；
• 再然后，使用 xdrmem_create() 函数创建另一个 XDR 对象 xdr2 ；
• 再接着，调用xdr_u_int() 函数来解码 XDR 格式字节流中的无符号整数。如果解码过程中出现错误，则输出一条错误消息并返回 1；
• 最后，解码成功，则输出解码后的无符号整数。

5. xdr_u_long

5.1 函数说明

函数声明	函数功能
bool_t xdr_u_long(XDR *xdrs, u_long *objp);	用于编码或解码无符号长整型值

参数：

• xdrs ： 指向要编码或解码数据的 XDR 结构体的指针
• objp ： 指向要编码或解码的无符号长整型值得指针

返回值：

• 如果编码或解码成功，则返回值为 TRUE；
• 否则返回值为 FALSE。

5.2 演示示例

#include <stdio.h>
#include <rpc/xdr.h>

int main()
{
    XDR xdr;
    u_long value = 12345;

    // 打开XDR数据流
    xdrmem_create(&xdr, NULL, 0, XDR_ENCODE);

    // 编码无符号长整型值到XDR数据流中
    if (!xdr_u_long(&xdr, &value)) {
        printf("Unable to encode value.\n");
        return 1;
    }

    // 关闭XDR数据流
    xdr_destroy(&xdr);

    return 0;
}

6. xdr_u_short

6.1 函数说明

函数声明	函数功能
bool_t xdr_u_short(XDR *xdrs, unsigned short *objp);	用于编码或解码无符号短整型数据

参数：

• xdrs ： 指向要编码或解码数据的 XDR 结构体的指针
• objp ： 指向 无符号短整型的指针

返回值：

• 如果编码或解码成功，则返回值为 TRUE；
• 否则返回值为 FALSE。

6.2 演示示例

#include <stdio.h>
#include <rpc/rpc.h>

#define ARRAY_SIZE 3

int main(void) 
{
    XDR xdrs;
    char buffer[1024];
    unsigned short source_array[ARRAY_SIZE] = {1, 2, 3};
    unsigned short dest_array[ARRAY_SIZE];

    xdrmem_create(&xdrs, buffer, sizeof(buffer), XDR_ENCODE);
    for (int i = 0; i < ARRAY_SIZE; ++i) 
    {
        if (!xdr_u_short(&xdrs, &source_array[i])) 
        {
            printf("编码失败\n");
            return 1;
        }
    }
    xdr_destroy(&xdrs);
    printf("编码结果：\n");
    for (int i = 0; i < xdr_getpos(&xdrs); ++i) 
    {
        printf("%02X ", buffer[i]);
    }
    printf("\n");

    xdrmem_create(&xdrs, buffer, sizeof(buffer), XDR_DECODE);
    for (int i = 0; i < ARRAY_SIZE; ++i) 
    {
        if (!xdr_u_short(&xdrs, &dest_array[i])) 
        {
            printf("解码失败\n");
            return 1;
        }
    }
    xdr_destroy(&xdrs);
    printf("解码结果：\n");
    for (int i = 0; i < ARRAY_SIZE; ++i) 
    {
        printf("%u ", dest_array[i]);
    }
    printf("\n");

    return 0;
}

7. xdr_vector

7.1 函数说明

函数声明	函数功能
bool_t xdr_short(XDR *xdrs, short *sp);	用于编码或解码一个可变长度的向量

参数：

• xdrs ： 指向要编码或解码数据的 XDR 结构体的指针
• sp ： 指向要编码或解码的 short 类型数据的指针

返回值：

• 如果编码或解码成功，则返回值为 TRUE；
• 否则返回值为 FALSE。

7.2 演示示例

#include <stdio.h>
#include <stdlib.h>
#include <rpc/types.h>
#include <rpc/xdr.h>

#define MAXSIZE 100

void error(char *s) 
{
    fprintf(stderr, "error: %s\n", s);
    exit(1);
}

int main() 
{
    XDR xdrs;
    char buffer[MAXSIZE];
    int values[] = {1, 2, 3, 4, 5};
    u_int size = sizeof(values)/sizeof(int);

    xdrmem_create(&xdrs, buffer, MAXSIZE, XDR_ENCODE);
    if (!xdr_vector(&xdrs, (char *) values, &size, MAXSIZE, sizeof(int), (xdrproc_t) xdr_int)) 
    {
        error("serialization failed");
    }

    xdrmem_create(&xdrs, buffer, MAXSIZE, XDR_DECODE);
    if (!xdr_vector(&xdrs, (char *) values, &size, MAXSIZE, sizeof(int), (xdrproc_t) xdr_int)) 
    {
        error("deserialization failed");
    }

    for (int i = 0; i < size; i++) 
    {
        printf("%d ", values[i]);
    }
    printf("\n");

    return 0;
}

8. xdr_void

8.1 函数说明

函数声明	函数功能
bool_t xdr_void(void);	用于编码或解码空值【void类型】

返回值：
因为无任何值被编码或解码，所以总是返回 true

8.2 演示示例

#include <stdio.h>
#include <stdlib.h>
#include <rpc/rpc.h>

int main() 
{
    // 创建一个 xdr_void 数据结构
    XDR xdr;
    xdrmem_create(&xdr, NULL, 0, XDR_ENCODE);

    // 将空值序列化为 xdr_void 类型
    if (!xdr_void(&xdr, NULL))
    {
        fprintf(stderr, "序列化失败\n");
        exit(1);
    }

    // 打印序列化后的结果
    printf("序列化结果：\n");
    int i;
    for (i = 0; i < xdr_getpos(&xdr); i++) {
        printf("%02x ", ((unsigned char *)xdr_inline(&xdr, i))[0]);
    }
    printf("\n");

    // 反序列化 xdr_void 类型
    xdr_destroy(&xdr);
    xdrmem_create(&xdr, xdr_getpos(&xdr), xdr_getpos(&xdr), XDR_DECODE);

    // 尝试反序列化非空的数据到 xdr_void 类型，预期将会失败
    char data[] = {0x01};
    if (xdr_bytes(&xdr, &data, &i, sizeof(data)) != FALSE) {
        fprintf(stderr, "尝试反序列化非空数据到 xdr_void 类型，但成功了\n");
        exit(1);
    }

    // 打印反序列化结果
    printf("反序列化结果：空值\n");

    return 0;
}