1

我有这样的任务：用户以十六进制输入数字 N1(str1) 和 N2(str2)。程序必须将数字从十六进制转换为 2 ^ 16 系统，并计算 2 ^ 16 系统中的数字 N1 和 N2 的总和，然后将结果转换为十六进制系统。

我有这样一个想法：先从十六进制转换为十进制（我可以这样做）。然后取每个数以 2 ^ 16 为模，取数 N1dec(dec11)（或 N2dec(dec22)）次的以 2 ^ 16 为底的对数，并将余数写入相应的数组中。这就是我的问题开始的地方。我从十进制到 2^16 系统的转换不起作用。希望您能提供帮助。

#include <iostream> 
using namespace std;

int main()
{
//HEX to decimal
const char* const str1 = "101D0";//7A120 = 500000; 101D0 = 66000;   //1F4 = 500=dec1=N1
cout << "Hello!\nFirst number in HEX system is " << str1 << endl;
istringstream is(str1);
int dec1;
is >> hex >> dec1;
if (!is && !is.eof()) throw "dammit!";
cout << "First number in decimal system: " << dec1 << endl;
const char* const str2 = "1567";//5479=dec2=num2
cout << "Second number in HEX system is " << str2 << endl;
istringstream iss(str2);
int dec2;
iss >> hex >> dec2;
if (!iss && !iss.eof()) throw "dammit!";
cout << "Second number in decimal system: " << dec2 << endl;
//

//Decimal to 2^16 system
int dec11 = dec1;//because dec11 will be = 0
int dec22 = dec2;//because dec22 will be = 0

int k = 1 << 16;
cout << "2^16 = " << k << endl;
int intPART1 = log(dec11) / log(k);
cout << "Int part of log2^16 (" << dec11 << ") is " << intPART1 << endl << "So num1 in 2^16 system will look like ";

int *n1 = new int[intPART1 + 1];
for (int i = 0; i <= intPART1; i++)
{
    if (i != 0)
    {
        n1[i] = dec11 % k*(1<<16-1);
        dec11 = dec11 / k;
    }
    else
    {
        n1[i] = dec11 % k;
        dec11 = dec11 / k;
    }
}
for (int i = intPART1; i >= 0; i--)
{
    cout << n1[i] << "   ";
}
cout << endl;
int intPART2 = log(dec22) / log(k);
cout << "Int part of log2^16 (" << dec22 << ") is " << intPART2 << endl << "So num2 in 2^16 system will look like ";

int *n2 = new int[intPART2 + 1];
for (int i = 0; i <= intPART2; i++)
{
    if (i != 0)
    {
        n2[i] = dec22 % k*(1 << 16 - 1);
        dec22 = dec22 / k;
    }
    else
    {
        n2[i] = dec22 % k;
        dec22 = dec22 / k;
    }
}

for (int i = intPART2; i >= 0; i--)
{
    cout << n2[i] << "   ";
}
cout << endl;
4

2 回答 2

2

由于十六进制值的基数为 16，假设 16^1 和基数 2^16 可以重新计算为 16^4，我们已经可以看到您的目标基数是源基数的倍数。这使得计算非常简单直接。我们所要做的就是稍微改变一下。

int hexToInt(char c)
{
    if (c >= 'a')
        return c - 'a' + 10;
    if (c >= 'A')
        return c - 'A' + 10;
    return c - '0';
}

// Converts hex to base 2^16. vector[0] holds the MSB.
std::vector<unsigned short> toBase0x10000(std::string const& hex)
{
    std::size_t bufSize = hex.size() / 4 + (hex.size() % 4 > 0);
    std::vector<unsigned short> number(bufSize);

    int shift = 0;
    int value = 0;
    std::size_t numIndex = number.size();

    for (int i = hex.size() - 1; i >= 0; i--)
    {
        value |= hexToInt(hex[i]) << shift;
        shift += 4;

        if (shift == 16)
        {            
            number[--numIndex] = static_cast<unsigned short>(value);
            shift = 0;
            value = 0;
        }
    }

    if (value != 0)
        number[--numIndex] = static_cast<unsigned short>(value);

    return number;
}

std::string fromBase0x10000(std::vector<unsigned short> const& num)
{
    std::stringstream ss;
    for (auto&& digit : num)
        ss << std::hex << digit;
    return ss.str();
}

toBase0x10000返回 astd::vector<unsigned short>所以向量中的每个元素代表你的 2^16 基数的一位数字（因为unsigned short可以保持该值范围的精确）。

作为副作用，此实现支持任何精度数字，因此您不受数字类型的值范围的限制，例如intor long。

这是一个完整的例子。

于 2019-10-01T23:25:07.380 回答
0

由于这看起来像是您想自己解决的学习练习，因此这里有两个提示。

一个十六进制数字代表四位，因此每个基数为 65,536 的数字由四个十六进制数字组成。因此，您可以读取四位一组的数字，而无需转换为十进制或从十进制转换。您学习解码四个十进制数字的相同算法将适用于十六进制，除了乘法将更加有效，因为编译器会将它们优化为左移指令。

对于这个算术，您应该使用uint16_tfrom 类型<stdint.h>，因为它的大小完全正确且无符号。无符号算术溢出被定义为环绕，这是你想要的。有符号溢出是未定义的行为。（或者如果您愿意，可以#include <cstdint>跟在后面。）using std::uint16_t;

要在任何底数b中添加数字，请取数字之和以b为模。当b是 2 的幂时，这会更容易，因为 x86 和许多其他 CPU 有一个 16 位无符号加法指令，可以在硬件中执行此操作，而在任何没有此功能的机器上，编译器都可以将其优化为位掩码& 0xFFFFU。

<<在这两种情况下，如果需要，您可以使用and&而不是*and手动写出二进制优化%。如果您使用有符号而不是无符号数学，这甚至可能会稍微改进生成的代码。但是，任何现代编译器都足够聪明，可以为您执行这种微优化。你最好不要过早地优化，编写更容易阅读和理解的代码。

于 2019-10-01T23:43:24.460 回答