Question

我有一个字符串，例如包含1000我需要将它存储在一个名为x的变量中（例如）所以整个事情是我需要将一个字符串存储为十六进制基本整数所以如果我加3（例如）

1000+3=1003
1003+3=1006
1006+3=1009
1009+3=100C
100C+3=100F
100F+3=1012

Answer 1

据我所知，你在一个字符串中有一个十六进制表示的数字，你希望将它放入int。然后，您希望能够添加到int，并再次以十六进制表示形式输出其新值以验证结果。

#include <sstream>
#include <ios>

int main() {
   std::string input = "1000";

   // Read the input string into a stream (streams have format conversion functionality)
   std::stringstream ss;
   ss << std::hex << input;

   // Read the numerical value back out into an int
   int x = 0;
   ss >> x;

   // Add 3 and display result in hex
   x += 3;
   std::cout << std::showbase << std::hex << x; // will output: 0x1003

   // Add another 10 and display result in hex
   x += 10;
   std::cout << std::showbase << std::hex << x; // will output: 0x100d
}

希望这有帮助。

Answer 2

听起来你正在获得一个十六进制字符串，并且需要将数值存储在变量中。然后，在将来的某个时刻，您需要从变量转换回字符串。

您不必担心基本数字类型（int，long，float）使用的内部表示。虽然计算机本身会将值存储在二进制文件中，但编程语言的设计使得这一事实（有些）对您隐藏，因此您不必担心它。

既然我们已经让语言将内部存储抽象为“数字”，那么我们所需要的只是一种读取和写入该数字的方法。所有语言都具有允许您以不同格式读/写数据的功能，并且您可以随时自行滚动（虽然除非您只是学习，否则不建议这样做）所以我使用的是C.

C提供scanf()和printf() - 还有其他功能可以完成这项工作，但这些都是你可以使用的东西的一个很好的例子。这些函数非常相似，因此编写一些代码很容易：

#include <errno.h>

#define FORMAT "%X"

// Converts string input into n integer
//
// args
//   str the string to convert
//   x   pointer to location for return value
//
// returns
//   0 on success
//   nonzero on failure
int get_num_from_hex_string(char* str, int* x)
{
  if( str == 0 ) return EINVAL;
  // we assume MAX_LEN is defined, somewhere...
  if( strlen(str) > MAX_LEN ) return EINVAL;

  int result = scanf(FORMAT, x);
  // there's prolly a better error, but good enough for now
  if( result != 1 ) return EIO; 

  return 0;
}

// Converts an integer into a hex string
//
// args
//   x    - the integer to convert
//   str  - the pre-allocated output buffer
//   len  - amount of space left in str.  Must be
//          at least 12 bytes.
//
// returns
//   0 on success
//   nonzero on failure
int get_hex_string(int x, char*str, int len)
{
  if( str == 0 ) return EINVAL;
  if( len < 12 ) return EINVAL;

  sprintf(str, FORMAT, x);
}

Answer 3

只需一个常规整数，当你需要显示它时，转换为十六进制格式。

Answer 4

假设您将字符串存储在变量中：

std::string mystring;

然后，为了对其进行计算，您可以使用自己定义的函数：

void AddSomeNumber(std::string& mystring, int n)
{
    // Convert the string to integer
    unsigned mynumber;
    sscanf(mystring.c_str(), "%x", &mynumber);

    // Add a number
    mynumber += n;

    // Convert the number to string
    char temp[9]; // pardon my style :-)
    sprintf(temp, "%x", mynumber);
    mystring = temp;
}

int main()
{
    std::string mystring("1009");
    AddSomeNumber(mystring, 3);
    std::cout << mystring << '\n'; // will print 100c
}

Answer 5

对不起提前的错误，我做得很快，不确定这是解决方案，这只是一个想法

#include <iostream>
#include <string>

using namespace std;

class hexa
{
public:
    hexa(const char* x);
    hexa(int x=0);

    hexa& operator+(int x);
    operator int& ();
    operator string () const;
private:
    int value_;
    friend istream& operator >>(istream &is, hexa& x);
    friend ostream& operator <<(ostream &os, const hexa& x);
};


int main()
{
    hexa x(0x1009);
    cout << "x = " << x << endl;

    hexa y("6");
    cout << "y = " << y << endl;

    cout << "x + y = " << x+y << endl;
    return 0;
}

hexa::hexa(const char* x)
    : value_(stoi(string(x), 0, 16))
{}

hexa::hexa(int x)
    : value_(x)
{}

hexa& hexa::operator+(int x)
{
    value_ += x;
    return *this;
}

hexa::operator int& ()
{
    return value_;
}

hexa::operator string () const
{
    return to_string(_Longlong(value_));
}

istream& operator >>(istream& is, hexa& x)
{
    is >> hex >> x.value_;
    return is;
}
ostream& operator <<(ostream& os, const hexa& x)
{
    os << hex << x.value_;
    return os;
}

如何转换包含十六进制整数的字符串

5 个答案: