linux c++ uint8_t转string

要将 `uint8_t` 类型的变量转换为字符串，可以使用标准库中的 `sprintf` 函数。以下是一个示例代码，演示如何将 `uint8_t` 转换为字符串：

#include <stdio.h>
#include <stdint.h>

int main() {
    uint8_t num = 123;
    char str[4];
    
    sprintf(str, "%hhu", num);
    
    printf("String representation: %s\n", str);
    
    return 0;
}

在上面的代码中，我们使用 `%hhu` 格式说明符来将 `num` 变量转换为字符串。这个格式说明符用于无符号字符类型 `uint8_t`。转换后的字符串将存储在字符数组 `str` 中。

请注意，`sprintf` 函数用于将格式化的输出存储到字符串中。在这个例子中，我们将输出存储在 `str` 中。然后，我们使用 `printf` 函数打印出转换后的字符串。

运行上述代码将输出：

String representation: 123

这样，你就成功地将 `uint8_t` 类型的变量转换为字符串了。

相关问题

Linuxc++socket 接收protobuf并解码的demo，消息头定义了消息类型，消息长度，C++定义如下: #include<stdint.h> #pragma pack(push,1) enum FiuType { FIU_Heartbeat = 0, FIU_InstrumentDefine = 1, FIU_Snap = 2, FIU 金融数据服务 20 FIU_Order = 3, FIU_Trade = 4, FIU_Equilibrium = 5, FIU_CODE_END = 6, FOU_MAX }; struct FiuHeader { FiuHeader() { memset(this, 0, sizeof(*this)); usLen = sizeof(*this); } uint16_t usLen; uint8_t cType; }; #pragma pack(pop)

以下是一个简单的示例代码，演示如何在 Linux C++ Socket 中接收 Protobuf 并解码，前提是你已经将 Protobuf 安装在了你的系统上。

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <google/protobuf/message.h>
#include "header.pb.h"

using namespace std;

int main() {
    // 创建一个 TCP Socket
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        cerr << "Failed to create socket!" << endl;
        return -1;
    }

    // 设定服务器的 IP 地址和端口号
    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(8000);
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    // 连接服务器
    int ret = connect(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
    if (ret == -1) {
        cerr << "Failed to connect to server!" << endl;
        close(sockfd);
        return -1;
    }

    // 接收消息头
    FiuHeader header;
    int n = recv(sockfd, &header, sizeof(header), 0);
    if (n != sizeof(header)) {
        cerr << "Failed to receive message header!" << endl;
        close(sockfd);
        return -1;
    }

    // 根据消息类型解码 Protobuf 消息
    google::protobuf::Message* message = nullptr;
    switch (header.cType) {
        case FIU_Heartbeat:
            message = new Heartbeat;
            break;
        case FIU_InstrumentDefine:
            message = new InstrumentDefine;
            break;
        case FIU_Snap:
            message = new Snap;
            break;
        case FIU_Order:
            message = new Order;
            break;
        case FIU_Trade:
            message = new Trade;
            break;
        case FIU_Equilibrium:
            message = new Equilibrium;
            break;
        case FIU_CODE_END:
        default:
            cerr << "Invalid message type!" << endl;
            close(sockfd);
            return -1;
    }

    // 接收 Protobuf 消息
    n = recv(sockfd, message, header.usLen - sizeof(header), 0);
    if (n != header.usLen - sizeof(header)) {
        cerr << "Failed to receive Protobuf message!" << endl;
        close(sockfd);
        return -1;
    }

    // 打印 Protobuf 消息
    cout << "Received message: " << endl;
    cout << message->DebugString() << endl;

    // 关闭 Socket
    close(sockfd);
    return 0;
}

在此示例代码中，我们通过 Socket 接收消息头（即结构体 FiuHeader），然后根据消息类型（即结构体 FiuHeader 中的字段 cType）创建相应的 Protobuf 消息对象，并通过 Socket 接收 Protobuf 消息。最后，我们将接收到的 Protobuf 消息打印出来。请注意，此示例代码仅适用于仅包含一个 Protobuf 消息的情况，如果你的消息中包含多个 Protobuf 消息，你可能需要更复杂的逻辑来处理。

Linux C++ 发送DHCP报文获取DHCP信息

要发送DHCP报文获取DHCP信息，可以使用Linux下的socket编程来实现。具体步骤如下：

1. 创建socket对象，使用raw socket类型。
2. 设置socket属性，包括IP地址、端口号等。
3. 创建DHCP报文，并填充报文字段。
4. 发送DHCP报文。
5. 接收DHCP服务器的响应报文。
6. 解析响应报文，获取DHCP信息。

以下是一个简单的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define BUF_SIZE 1024
#define DHCP_PORT 67
#define DHCP_SERVER_PORT 68

typedef struct {
    uint8_t op;          // Message op code / message type.
    uint8_t htype;       // Hardware address type (e.g., '1' = 10mb ethernet).
    uint8_t hlen;        // Hardware address length (e.g., '6' for 10mb ethernet).
    uint8_t hops;        // Client sets to zero, optionally used by relay agents when booting via a relay agent.
    uint32_t xid;        // Transaction ID, a random number chosen by the client, used by the client and server to associate messages and responses between a client and a server.
    uint16_t secs;       // Filled in by client, seconds elapsed since client began address acquisition or renewal process.
    uint16_t flags;      // Broadcast flag.
    struct in_addr ciaddr;      // Client IP address; only filled in if client is in BOUND, RENEW or REBINDING state and can respond to ARP requests.
    struct in_addr yiaddr;      // 'your' (client) IP address.
    struct in_addr siaddr;      // IP address of next server to use in bootstrap; returned in DHCPOFFER, DHCPACK by server.
    struct in_addr giaddr;      // Relay agent IP address, used in booting via a relay agent.
    uint8_t chaddr[16];  // Client hardware address.
    char sname[64];      // Optional server host name, null terminated string.
    char file[128];      // Boot file name, null terminated string; "generic" name or null in DHCPDISCOVER, fully qualified directory-path name in DHCPOFFER.
    uint32_t magic_cookie;      // Fixed value: 0x63825363.
    uint8_t options[308];       // Optional parameters field.
} dhcp_packet;

int main(int argc, char* argv[]) {
    int sockfd;
    struct sockaddr_in servaddr, cliaddr;
    char buf[BUF_SIZE];
    socklen_t len = sizeof(cliaddr);
    dhcp_packet packet;

    // 创建socket对象
    sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
    if (sockfd < 0) {
        perror("socket");
        exit(1);
    }

    // 设置socket属性
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(DHCP_SERVER_PORT);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0) {
        perror("bind");
        exit(1);
    }

    // 创建DHCP报文
    memset(&packet, 0, sizeof(packet));
    packet.op = 0x01;   // Message type: Boot Request
    packet.htype = 0x01;    // Hardware type: Ethernet
    packet.hlen = 0x06; // Hardware address length: 6
    packet.xid = random();  // Transaction ID
    packet.magic_cookie = htonl(0x63825363); // DHCP Magic Cookie
    // DHCP Option 53: DHCP Discover
    packet.options[0] = 0x35;   // Option 53
    packet.options[1] = 0x01;   // Length
    packet.options[2] = 0x01;   // DHCP Discover
    // DHCP Option 55: Parameter Request List
    packet.options[3] = 0x37;   // Option 55
    packet.options[4] = 0x04;   // Length
    packet.options[5] = 0x01;   // Subnet Mask
    packet.options[6] = 0x03;   // Router
    packet.options[7] = 0x06;   // Domain Name Server
    packet.options[8] = 0x0f;   // Domain Name
    packet.options[9] = 0x2c;   // Static Route
    packet.options[10] = 0xff;  // End

    // 发送DHCP报文
    memset(&cliaddr, 0, sizeof(cliaddr));
    cliaddr.sin_family = AF_INET;
    cliaddr.sin_port = htons(DHCP_PORT);
    cliaddr.sin_addr.s_addr = inet_addr("255.255.255.255");
    if (sendto(sockfd, &packet, sizeof(packet), 0, (struct sockaddr*)&cliaddr, sizeof(cliaddr)) < 0) {
        perror("sendto");
        exit(1);
    }

    // 接收DHCP服务器的响应报文
    memset(buf, 0, sizeof(buf));
    if (recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr*)&cliaddr, &len) < 0) {
        perror("recvfrom");
        exit(1);
    }

    // 解析响应报文，获取DHCP信息
    // ...

    close(sockfd);
    return 0;
}