大端序和小端序的转换

PC中对整型数据的表示有两种方式：大端序和小端序，大端序的高位字节在低地址，小端序的高位字节在高地址。例如：对数字 -10，其4字节表示的大端序内容为FF FF FF F6，小端序内容为F6 FF FF FF。

现输入一个字符串表示的十进制整数（含负数），请分别输出以4字节表示的大端序和小端序：

• 负数以补码形式表示。
• 如果输入的整数的值超出 [-2^31, 2^32) 范围，则输出字符串overflow。

#include <iostream>
#include <string>
#include <utility>
#include <algorithm>
#include <sstream>
#include <iomanip>
#include <climits>
#include<vector>
using namespace std;

class Solution {
public:
    
        // 将long long整数转换为16进制字符串表示
    string GetHexString(long long input, int byteCount) {
        stringstream ss;
        ss << hex << uppercase << setw(8) << setfill('0');
        
        if (input < 0) {
            // 处理负数，转换为补码形式
            unsigned long long unum = static_cast<unsigned long long>(input);
            unum += (1ULL << (byteCount * 8)); // 转换为补码  是一个位运算操作，用于计算一个掩码  1ULL 是一个无符号长整型的 1
            //<< (byteCount * 8) 将 1 左移 byteCount * 8 位。byteCount 是字节数，乘以8是因为每个字节有8位。
            //补码的计算方式是：对于一个负数，其补码等于其绝对值的二进制表示取反后加1。在这里，通过加上 2^n（其中 n 是位数）来实现这个效果。
            ss << unum;
        } else {
            ss << input;
        }
        
        string hexStr = ss.str();
        // 去除前导零（除了最后一个字节可能需要保留）
        size_t nonZeroPos = hexStr.find_first_not_of('0');
        if (nonZeroPos != string::npos) {
            hexStr = hexStr.substr(nonZeroPos);
        } else {
            hexStr = "00"; // 全零的情况
        }
        
        // 补足到正确的字节数
        while (hexStr.length() < byteCount * 2) {
           hexStr = "0" + hexStr;
        }
        
        return hexStr;
    }
 
    // 获取大端序表示
    string GetBigEndian(const string& hexStr) {
        vector<string> bytes;
        for (size_t i = 0; i < hexStr.length(); i += 2) {
            string byte = hexStr.substr(i, 2);
           
            bytes.push_back(byte);
        }
       
        string result;
        for (size_t i = 0; i < bytes.size(); ++i) {
            if (i != 0) result += " ";
            result += bytes[i];
        }
        return result;
    }
 
    // 获取小端序表示
    string GetLittleEndian(const string& hexStr) {
        vector<string> bytes;
        for (int i = hexStr.length() - 2; i >= 0; i -= 2) {
            string byte = hexStr.substr(i, 2);
           
            bytes.push_back(byte);
        }
        string result;
        for (size_t i = 0; i < bytes.size(); ++i) {
            if (i != 0) result += " ";
            result += bytes[i];
        }
        return result;
    }
 
    // 处理输入并输出结果
    pair<string, string> ProcessInput(const string& input) {
     
        // 转换为long long
        long long num=stoll(input);
     
        // 确定需要的字节数
        int byteCount = 0;
        if (num == 0) {
            byteCount = 1;
        } else {
            unsigned long long unum = static_cast<unsigned long long>(num < 0 ? -num : num);
            byteCount = 0;
            while (unum > 0) {
                byteCount++;
                unum >>= 8;//右移
            }
            if (num < 0) {
                // 负数需要额外的符号位，确保不超过4字节
                byteCount = min(byteCount + 4, 4);
            } else {
                byteCount = min(byteCount, 4);
            }
        }
              
        // 转换为16进制字符串
        string hexStr = GetHexString(num, byteCount);
        
        // 获取端序表示
        string bigEndian = GetBigEndian(hexStr);//大端序
        string littleEndian = GetLittleEndian(hexStr);//小端序
        
        return {bigEndian, littleEndian};
    }
    // 待实现函数，在此函数中填入答题代码;
    string GetHexString(long long input)
    {
        const long long min_val = -2147483648LL;
        const long long max_val = 4294967296LL;
        if (input < min_val || input > max_val) {
            return {"overflow"};
        }
        string result;
        string input_str=std::to_string(input);
        
        auto str=ProcessInput(input_str);
        result=str.first+'\n'+str.second;
        return result;
    }
};