C++ 将逗号分隔的十六进制（字符串）数组转换为整数或浮点

阵列的设置如下所示：

string * str = new string[11];

其中字符串的内容如下所示：

str[0]=AAAAAAAA,BBBBBBBB,CCCCCCCC,DDDDDDDD,EEEE,FFFFFFFF,GGGGGGGG,HHHH,IIII,JJJJ,KKKK
str[1]=AAAAAAAA,BBBBBBBB,CCCCCCCC,DDDDDDDD,EEEE,FFFFFFFF,GGGGGGGG,HHHH,IIII,JJJJ,KKKK
str[2]=AAAAAAAA,BBBBBBBB,CCCCCCCC,DDDDDDDD,EEEE,FFFFFFFF,GGGGGGGG,HHHH,IIII,JJJJ,KKKK
...
str[12]=AAAAAAAA,BBBBBBBB,CCCCCCCC,DDDDDDDD,EEEE,FFFFFFFF,GGGGGGGG,HHHH,IIII,JJJJ,KKKK

string * type = new string[11];

另一个数组如下所示：

str[0]=AAAAAAAA,BBBBBBBB,CCCCCCCC,DDDDDDDD,EEEE,FFFFFFFF,GGGGGGGG,HHHH,IIII,JJJJ,KKKK
str[1]=AAAAAAAA,BBBBBBBB,CCCCCCCC,DDDDDDDD,EEEE,FFFFFFFF,GGGGGGGG,HHHH,IIII,JJJJ,KKKK
str[2]=AAAAAAAA,BBBBBBBB,CCCCCCCC,DDDDDDDD,EEEE,FFFFFFFF,GGGGGGGG,HHHH,IIII,JJJJ,KKKK
...
str[12]=AAAAAAAA,BBBBBBBB,CCCCCCCC,DDDDDDDD,EEEE,FFFFFFFF,GGGGGGGG,HHHH,IIII,JJJJ,KKKK

string * type = new string[11];

其中内容为：

type[0]="1";
type[1]="1";
type[2]="1";
type[3]="1";
type[4]="2";
type[5]="1";
type[6]="1";
type[7]="2";
type[8]="2";
type[9]="2";
type[10]="2";

这些类型对应于字符串中的每个值，因此，对于第一个字符串：

1=浮点，2=整数

• AAAAA将是1；或者是一个浮子
• BBBBBBBB将1；或者是一个浮子
• CCCC将是1；或者是一个浮子
• dddddd将是1；或者是一个浮子
• EEEE将是2；还是整数
• FFFFFFFF将为1；或者是一个浮子
• gggggggggggg将1；或者是一个浮子
• HHHH将是2；还是整数
• IIII将是2；还是整数
• JJJJ将是2；还是整数
• KKKK将是2；还是整数

此外，单一类型数组适用于str数组中的所有字符串

现在回答我的问题： 如何使用上述信息从字符串中提取每个单独的值，并根据类型数组中的值将其转换为整数或浮点。

请注意： Boost对我不可用

转换函数如下所示：（除整数外，其他函数的格式类似）

unsigned int-BinaryParser:：hexToFloat（std:：string-hextinput）
{   
std:：stringstream ss（十六进制输入）；
无符号整数浮点输出；
ss>>十六进制>>浮点输出；
返回重新解释（浮点输出）；
}

好的，第一部分：提取逗号分隔的字符串。一种方法是：

std::vector<std::string> split( std::string s ){
  std::vector<std::string> vec;
  int pos = 0;
  while( std::string::npos != (pos = s.find( ',', pos ) ) ){
    vec.push_back( s.substr( 0, pos ) );
    s = s.substr( pos + 1 );
  }
  vec.push_back( s );
  return vec;
}

无法使用std:：hex读取浮点，因此我们假设hh是浮点的字节，被解释为int32\t

float convFloat( std::string & hexInput ){
  std::istringstream iss (hexInput);
  uint32_t intOutput;
  iss >> std::hex >> intOutput;
  return reinterpret_cast<float&>(intOutput);
}

float-convFloat（标准：：字符串和十六进制输入）{
std:：istringstream iss（hexInput）；
uint32输入输出；
iss>>标准：：十六进制>>输入输出；
返回重新解释（输入输出）；
}

为了存储结果，我们可以使用：

enum TypeTag { eInt, eFloat };

class IntOrFloat {
public:
  IntOrFloat( int i ) : typeTag(eInt),integer(i),floating(0) { }
  IntOrFloat( float f ) : typeTag(eFloat),integer(0),floating(f) { }
  virtual ~IntOrFloat(){}
  int getInt() const { return integer; }
  float getFloat() const { return floating; }
  TypeTag getTypeTag() const { return typeTag; }
private:
  TypeTag typeTag;
  int integer;
  float floating;
};


std::ostream& operator<< (std::ostream& os, const IntOrFloat& iof){
  switch( iof.getTypeTag() ){
  case eInt:
    os << iof.getInt();
    break;
  case eFloat:
    os << iof.getFloat();
    break;
  }
  return os;
}

enum TypeTag{eInt，eFloat}；
将类划分为类{
公众：
IntOrFloat（inti）：类型标签（eInt），整数（i），浮点（0）{
IntOrFloat（float f）：类型标签（eFloat），整数（0），浮点（f）{}
虚拟~IntOrFloat（）{}
int getInt（）常量{返回整数；}
float getFloat（）常量{return floating；}
TypeTag getTypeTag（）常量{return TypeTag；}
私人：
类型标签类型标签；
整数；
浮动；
};
std:：ostream&operator大小为X的数组只能在0到X-1之间寻址。您所做的str和类型初始化都是无效的。这只是我输入的错误。抱歉，整数只有4个十六进制数字？不寻常。十六进制数字的顺序是小端还是大端？问题出在哪里？可以将十六进制数字对转换为字符值吗？可以将字符值存储到字符数组[2]或字符数组[4]中吗？您可以获取浮点或整数的地址？你可以叫memcpy吗？@laune你能给我举个例子吗。我对C++不太好，对我来说很陌生。好，跟我来。我对向量不太熟悉。这将分离每个单独的字符串，并将其放入向量中自己的索引中，对吗？如果是这样，那么它将无法处理字符串数组，而只能处理单个字符串。我是否需要创建多个向量来接收信息？是否有方法创建类似于二维阵列的二维向量？这样，所有数据都可以保存在一个向量中。函数不确定它们的结果存储在向量中的方式。如果十六进制字符串在11/12/13字符串中的原始位置无关紧要，您可以将它们全部归档到一个向量中。非常感谢！！我必须了解向量是如何工作的，但我想我大部分都理解这个概念。它们似乎比数组更适合我要做的事情…所以也谢谢你指出这一点。
std::vector<IntOrFloat> convert( const std::vector<std::string> t, const std::string s ){
  std::vector<IntOrFloat> results;
  std::vector<std::string> hexes = split( s );
  for( int i = 0; i < hexes.size(); i++ ){
    if( t[i] == "1" ){
      results.push_back( IntOrFloat( convFloat( hexes[i] ) ) );
    } else {
      results.push_back( IntOrFloat( convInt( hexes[i] ) ) );
    }
  }
  return results;
}

std::vector<std::string> fromArray( std::string strs[], int n ){
  std::vector<std::string> strings;
  for( int i = 0; i < n; i++ ) strings.push_back( std::string( strs[i] ) );
  return strings;
}
#define fromArray(a) fromArray( a, (sizeof(a)/sizeof(a[0])) )

#define LENGTH(a) (sizeof(a)/sizeof(a[0]))
int main(){
  std::string t[] = {"2","1","1","2"};
  std::string s[] = {
    "8000,4048f5c3,bf000000,FFFF",
    "0001,42f6e979,c44271ba,7FFF",
    "1234,00000000,447a0000,5678"
  };

  std::vector<std::string> types = fromArray( t );
  std::vector<std::string> strings  = fromArray( s );
  for( std::vector<std::string>::iterator it = strings.begin() ; it != strings.end(); ++it ){
    std::vector<IntOrFloat> results = convert( types, *it );
    std::cout << "converting string " << *it << ", " << results.size() << " values:" <<   std::endl;
    for( std::vector<IntOrFloat>::iterator iof = results.begin() ; iof != results.end(); ++iof ){
      std::cout << "  " << *iof << std::endl;
    }
  }
}