动态访问工会

accessing unions dynamically

本文关键字：访问 动态      更新时间：2023-10-16

我有这个枚举，联合和结构：

union num {
    int i;
    short s;
    float f;
    double d;
};
enum tag {SHORT, INT, FLOAT, DOUBLE};
struct vrnumber {
    num num;
    tag type;
};

我想知道如何根据另一个变量（即用户的输入）动态访问联合内部的变量。（即）我想通过联合变量进行一定的操作，但我想知道在运行时可以访问哪个联合变量。因此，什么是更好的方法，而不是类似的方式：

vrnumber m; 
switch (m.type) {
    case SHORT: //an operation ..
    case INT: //same operation ...
    case FLOAT: //same operation ...
    case DOUBLE: //same operation ...
}

我认为，在每种情况下，我都非常冗长且多余，唯一的操作差异是当我访问联合以存储或使用该值时。

做到这一点的方法是在结构定义中定义将要使用的操作员。例如，如果要使用操作员-，请定义以下方法：

struct vrnumber {
    num num;
    tag type;
    //between vrnumbers
    vrnumber operator- (const vrnumber& rhs);
    //vrnumbers and basic types
    vrnumber operator- (const int& rhs);
    vrnumber operator- (const double& rhs);
    //if vrnumber is used as rhs
    friend vrnumber operator- (const int& lhs, const vrnumber& rhs);
    friend vrnumber operator- (const double& lhs, const vrnumber& rhs);
};

这些是其中一些方法的定义的示例：

vrnumber vrnumber::operator- (const vrnumber& rhs){
    switch(type){
        case SHORT:
            switch(rhs.type){
                //......
                //cases here
        }
        //......
        //cases here
    }
}
vrnumber vrnumber::operator- (const int& rhs){
    switch(type){
        case SHORT: return num.s-rhs;
        case INT: return num.i-rhs;
        case FLOAT: return num.f-rhs;
        case DOUBLE: return num.d-rhs;          
    }
}
vrnumber operator- (const int& lhs, const int& rhs){
    switch(rhs.type){
        //..........
        //...cases, same as the others
    }
}

以下是这些操作使用的一些示例：

vrnumber m1;
vrnumber m2;
int i1;
float f1;
//the example:
m1=f1-(m1-m2)-i1;

使用这种方法的权衡是冗长的操作员定义。但是，如果此类操作在代码中的时间上称为，则可能会缩短并简化代码。

相关文章：