如何在CPP中解析联合中的结构？

Question

我有一个联合和枚举，例如：

typedef union{
    Home   HomeInfo;        
    Office OfficeInfo;          
} Info;

typedef enum{                               
    eHOME,  
    eOFFICE

} InfoType;

Home和Office是其他结构。

我还有另一个函数，它的原型是

void SetInfo(InfoType, Info);

在函数调用过程中，如果InfoType为eHOME，我会创建一个对象Info，Info info;，并填充HomeInfo details info.HomeInfo，然后调用

SetInfo(eHONE, info);

SetInfo定义：

SetInfo(InfoType infotype, Info info)
{
    if (eHOME == infotype)
    {
        // get the details from info.HomeInfo structure
         }
         else if(eOFFICE == infotype)
         {
            // get the details from info.OffiiceInfo structure
         }
}

如果我将eHOME作为InfoType传递，并传递OfficeInfo的详细信息，我如何获得无效的案例？虽然我过去常常在这个时候获取HomeInfo的详细信息，但其中有一些无用的值，所以错误不会被获取。在InfoType检查之后可以检查结构是什么吗？

Answer 1

我不确定您在这里试图实现什么，但这种方法几乎可以肯定是错误的。我建议在这里使用继承：

enum InfoType
{
    eHome,
    eOffice,
};

class Info
{
public:
    InfoType type() const { return type_; }

protected:
    Info(InfoType t) : type_(t) {}

private:
    InfoType type_;
};

class HomeInfo : public Info
{
public:
    HomeInfo() : Info(eHome) {}
};

class OfficeInfo : public Info
{
public:
    OfficeInfo() : Info(eOffice) {}
};

现在SetInfo函数非常简单，如下所示：

void SetInfo(Info* info)
{
    if (info->type() == eHome)
    {
        HomeInfo* hi = (HomeInfo*)info;
        // ...
    }
    else if (info->type() == eOffice)
    {
        OfficeInfo* oi = (OfficeInfo*)info;
        // ...
    }
}

Answer 2

void SetInfo(InfoType a，Info b)；

也许您可以将&b转换为Home*，然后将Home和Office的第一个“类变量”硬编码为一个字符，您可以检测该字符，并使用特定值进行初始化以便于检测。

这有什么意义吗，，，

Answer 3

在这种情况下，应该确保每次调用SetInfo时Info和InfoType都是一致的。

如果您想使用不一致的Info和InfoType调用SetInfo，例如：

InfoType type = eHOME;
Info info;
info.OfficeInfo.xxx = xxx;
SetInfo(type, info);

基本上，作为一个联合，如果没有这两种类型的进一步信息，您就无法区分info是OfficeInfo还是HomeInfo。