Chuyển một int thành mảng ký tự 4 byte (C)

Này, tôi đang tìm cách chuyển đổi một số nguyên được người dùng đưa vào thành 4 byte, mà tôi đang gán cho một mảng ký tự. Điều này có thể giải quyết như thế nào?

Thí dụ:

Chuyển đổi đầu vào của người dùng là 175 thành

00000000 00000000 00000000 10101111

Vấn đề với tất cả các câu trả lời cho đến nay, chuyển đổi 255 sẽ dẫn đến 0 0 0 ffmặc dù nó in ra như sau:0 0 0 ffffffff

unsigned int value = 255;   

buffer[0] = (value >> 24) & 0xFF;
buffer[1] = (value >> 16) & 0xFF;
buffer[2] = (value >> 8) & 0xFF;
buffer[3] = value & 0xFF;

union {
    unsigned int integer;
    unsigned char byte[4];
} temp32bitint;

temp32bitint.integer = value;
buffer[8] = temp32bitint.byte[3];
buffer[9] = temp32bitint.byte[2];
buffer[10] = temp32bitint.byte[1];
buffer[11] = temp32bitint.byte[0];

cả hai kết quả 0 0 0 ffffffffthay vì0 0 0 ff

Một ví dụ khác là 175 khi đầu vào in ra như 0, 0, 0, ffffffafkhi nó phải là0, 0, 0, af

Cách di động để làm điều này (đảm bảo rằng bạn có thể 0x00 0x00 0x00 0xafở khắp mọi nơi) là sử dụng ca:

unsigned char bytes[4];
unsigned long n = 175;

bytes[0] = (n >> 24) & 0xFF;
bytes[1] = (n >> 16) & 0xFF;
bytes[2] = (n >> 8) & 0xFF;
bytes[3] = n & 0xFF;

Các phương pháp sử dụng kết hợp và memcpy()sẽ nhận được một kết quả khác nhau trên các máy khác nhau.

Vấn đề bạn đang gặp phải là với việc in chứ không phải là chuyển đổi. Tôi cho rằng bạn đang sử dụng charhơn là sử dụng unsigned charvà bạn đang sử dụng một dòng như thế này để in nó:

printf("%x %x %x %x\n", bytes[0], bytes[1], bytes[2], bytes[3]);

Khi bất kỳ kiểu nào hẹp hơn intđược chuyển đến printf, chúng sẽ được thăng cấp int(hoặc unsigned int, nếu intkhông thể giữ tất cả các giá trị của kiểu gốc). Nếu charđược ký trên nền tảng của bạn, thì 0xffcó khả năng không phù hợp với phạm vi của loại đó và thay vào đó, nó đang được đặt thành -1 (có đại diện 0xfftrên máy bổ sung 2s).

-1 được thăng cấp thành an int, và có đại diện 0xffffffffnhư một inttrên máy của bạn và đó là những gì bạn thấy.

Giải pháp của bạn là sử dụng thực sự hoặc sử dụng unsigned charkhác unsigned chartrong printfcâu lệnh:

printf("%x %x %x %x\n", (unsigned char)bytes[0],
                        (unsigned char)bytes[1],
                        (unsigned char)bytes[2],
                        (unsigned char)bytes[3]);

Bạn có muốn giải quyết từng byte riêng lẻ của một int 32 bit không? Một phương pháp khả thi là kết hợp:

union
{
    unsigned int integer;
    unsigned char byte[4];
} foo;

int main()
{
    foo.integer = 123456789;
    printf("%u %u %u %u\n", foo.byte[3], foo.byte[2], foo.byte[1], foo.byte[0]);
}

Lưu ý: đã sửa printf để phản ánh các giá trị chưa được đánh dấu.

Trong câu hỏi của mình, bạn đã nói rằng bạn muốn chuyển đổi đầu vào của người dùng là 175 thành 00000000 00000000 00000000 10101111, thứ tự byte cuối lớn , còn được gọi là thứ tự byte mạng .

Một cách chủ yếu di động để chuyển đổi số nguyên không dấu của bạn thành một mảng ký tự không dấu endian lớn, như bạn đã đề xuất từ ​​ví dụ "175" mà bạn đã đưa ra, sẽ là sử dụng htonl()hàm của C (được định nghĩa trong tiêu đề <arpa/inet.h>trên hệ thống Linux) để chuyển đổi số nguyên không dấu của bạn thành thứ tự byte cuối lớn, sau đó sử dụng memcpy()(được định nghĩa trong tiêu đề <string.h>cho C, <cstring>cho C ++) để sao chép các byte vào mảng char (hoặc char không dấu) của bạn.

Các htonl()chức năng có trong một số nguyên 32-bit unsigned như một cuộc tranh cãi (trái ngược với htons(), trong đó có một số nguyên 16-bit unsigned) và chuyển đổi nó vào mạng thứ tự byte từ thứ tự chủ byte (do đó từ viết tắt, Host ĐẾN Mạng Long, so với Host TO Network Viết tắt của htons), trả về kết quả là một số nguyên 32 bit không dấu. Mục đích của nhóm chức năng này là đảm bảo rằng tất cả các giao tiếp mạng xảy ra theo thứ tự byte cuối lớn, để tất cả các máy có thể giao tiếp với nhau qua một socket mà không gặp vấn đề về thứ tự byte. (Là một sang một bên, cho máy lớn về cuối nhỏ, các htonl(), htons(), ntohl()vàntohs() các hàm thường được biên dịch để chỉ là 'no op', bởi vì các byte không cần phải được lật lại trước khi chúng được gửi hoặc nhận từ một socket vì chúng đã có thứ tự byte thích hợp)

Đây là mã:

#include <stdio.h>
#include <arpa/inet.h>
#include <string.h>

int main() {
    unsigned int number = 175;

    unsigned int number2 = htonl(number);
    char numberStr[4];
    memcpy(numberStr, &number2, 4);

    printf("%x %x %x %x\n", numberStr[0], numberStr[1], numberStr[2], numberStr[3]);

    return 0;
}

Lưu ý rằng, như caf đã nói, bạn phải in các ký tự dưới dạng ký tự không dấu bằng cách sử dụng bộ %xđịnh dạng của printf .

Mã trên in 0 0 0 aftrên máy của tôi (máy x86_64, sử dụng thứ tự byte cuối ít), là hex cho 175.

Bạn co thể thử:

void CopyInt(int value, char* buffer) {
  memcpy(buffer, (void*)value, sizeof(int));
}

Tại sao bạn cần truyền trung gian thành void * trong C ++ Vì cpp không cho phép chuyển đổi trực tiếp giữa các con trỏ, bạn cần sử dụng reinterpret_cast hoặc ép kiểu để void * thực hiện điều đó.

int a = 1;
char * c = (char*)(&a); //In C++ should be intermediate cst to void*

Vấn đề với việc chuyển đổi (lý do nó mang lại cho bạn một ffffff ở cuối) là vì số nguyên hex của bạn (mà bạn đang sử dụng toán tử & nhị phân với) được hiểu là đã được ký. Truyền nó tới một số nguyên không dấu và bạn sẽ ổn.

An inttương đương với uint32_tvà charvới uint8_t.

Tôi sẽ trình bày cách tôi giải quyết giao tiếp máy khách-máy chủ, gửi thời gian thực (4 byte, được định dạng trong Unix epoch) trong mảng 1 bit, sau đó xây dựng lại nó ở phía bên kia. (Lưu ý: giao thức được gửi 1024 byte)

• Phía khách hàng

  uint8_t message[1024];
  uint32_t t = time(NULL);
  
  uint8_t watch[4] = { t & 255, (t >> 8) & 255, (t >> 16) & 255, (t >> 
  24) & 255 };
  
  message[0] = watch[0];
  message[1] = watch[1];
  message[2] = watch[2];
  message[3] = watch[3];
  send(socket, message, 1024, 0);
  

• Phía máy chủ

  uint8_t res[1024];
  uint32_t date;
  
  recv(socket, res, 1024, 0);
  
  date = res[0] + (res[1] << 8) + (res[2] << 16) + (res[3] << 24);
  
  printf("Received message from client %d sent at %d\n", socket, date);
  

Hy vọng nó giúp.

Vấn đề đang phát sinh vì ký tự không dấu là số 4 byte không phải số 1 byte như nhiều người nghĩ, vì vậy hãy thay đổi nó thành

union {
unsigned int integer;
char byte[4];
} temp32bitint;

và truyền trong khi in, để ngăn việc quảng bá thành 'int' (theo mặc định của C)

printf("%u, %u \n", (unsigned char)Buffer[0], (unsigned char)Buffer[1]);

Bạn chỉ cần sử dụng memcpynhư sau:

unsigned int value = 255;
char bytes[4] = {0, 0, 0, 0};
memcpy(bytes, &value, 4);