具有某些公共成员的强制转换结构

Question

假设我有 2 个structs：

typedef struct
{
    uint8_t useThis;            
    uint8_t u8Byte2;             
    uint8_t u8Byte3; 
    uint8_t u8Byte4;  
} tstr1

和

typedef struct
{
    uint8_t u8Byte1;            
    uint8_t u8Byte2;             
    uint8_t useThis;  
} tstr2

我将仅在函数中需要 useThis 成员，但在某些情况下，我需要转换一个结构或另一个：

void someFunction()
{
    someStuff();
    SOMETHING MyInstance;
    if(someVariable)
    {
        MyInstance = reinterpret_cast<tstr1*>(INFO_FROM_HARDWARE); //This line of course doesn't work
    }
    else
    {
        MyInstance = reinterpret_cast<tstr2*>(INFO_FROM_HARDWARE); //This line of course doesn't work
    }
    MyInstance->useThis; //Calling this memeber with no problem

    moreStuff();
}

• 所以我想使用useThis，不管演员是什么。如何做到这一点？

• 我想避免 someFunction() 成为模板（只是为了避免 this kind of things）

• 注意像this 这样的问题也有类似的问题，但结构成员的顺序相同

编辑：

在 RealLife 中，这些结构体要大得多，并且有几个“同名”成员。直接将uint8_t 转换为reinterpret_cast<tstr1*>(INFO_FROM_HARDWARE)->useThis 会很乏味，并且需要几个reinterpret_casts（尽管这是我在编辑之前的问题的有效解决方案）。这就是为什么我坚持MyInstance 是“完整的”。

Answer 1

使用virtual 调度通常不是您在映射到硬件时想要的，但它是一种替代方法。

例子：

// define a common interface
struct overlay_base {
    virtual ~overlay_base() = default;
    virtual uint8_t& useThis() = 0;
    virtual uint8_t& useThat() = 0;
};

template<class T>
class wrapper : public overlay_base {
public:
    template<class HW>
    wrapper(HW* hw) : instance_ptr(reinterpret_cast<T*>(hw)) {}
    uint8_t& useThis() { return instance_ptr->useThis; }
    uint8_t& useThat() { return instance_ptr->useThat; }

private:
    T* instance_ptr;
};

这样，您可以声明一个基类指针，对其进行赋值，并在if 语句之后使用：

int main(int argc, char**) {

    std::unique_ptr<overlay_base> MyInstance;

    if(argc % 2) {
        MyInstance.reset( new wrapper<tstr1>(INFO_FROM_HARDWARE) );
    } else {
        MyInstance.reset( new wrapper<tstr2>(INFO_FROM_HARDWARE) );
    }

    std::cout << MyInstance->useThis() << '\n';
    std::cout << MyInstance->useThat() << '\n';
}

Demo

关于我的评论的解释：“它可以工作，但除非编译器非常聪明并且可以优化掉你内部循环中的虚拟调度，否则它会比你真正花时间键入 cast":

将virtual 调度视为在运行时使用了一个查找表（vtable）（这通常是实际发生的情况）。当调用virtual 函数时，程序必须使用该查找表来查找要调用的实际成员函数的地址。当无法优化查找时（正如我在上面的示例中通过使用仅在运行时可用的值确保的那样），与进行静态转换相比，它确实需要额外的几个 CPU 周期。

Answer 2

正如 AndyG 所建议的那样，std::variant 怎么样（没有提到您正在使用的 c++ 标准，所以也许 c++17 解决方案是可以的 - 如果没有 c++17，也值得使用 可用）。

这是example

std::variant 知道其中存储了什么类型，您可以随时使用 visit 来使用其中的任何成员（为了清楚起见，此处为 sn-p）：

// stolen from @eerrorika (sorry for that :( )
struct hardware {
    uint8_t a = 'A';
    uint8_t b = 'B';
    uint8_t c = 'C';
    uint8_t d = 'D';
};

struct tstr1 {
    uint8_t useThis;            
    uint8_t u8Byte2;             
    uint8_t u8Byte3; 
    uint8_t u8Byte4;  
};

struct tstr2 {
    uint8_t u8Byte1;            
    uint8_t u8Byte2;             
    uint8_t useThis;  
};

// stuff

if(true)
{
    msg = *reinterpret_cast<tstr1*>(&hw);
} 
else
{
    msg = *reinterpret_cast<tstr2*>(&hw);
}

std::visit(overloaded {
    [](tstr1 const& arg) { std::cout << arg.useThis << ' '; }, 
    [](tstr2 const& arg) { std::cout << arg.useThis << ' '; }
}, msg);

编辑：您还可以使用指针的变体 EDIT2：忘记逃避一些东西......

Answer 3

这就是模板的用途：

template<class tstr>
std::uint8_t
do_something(std::uint8_t* INFO_FROM_HARDWARE)
{
    tstr MyInstance;
    std::memcpy(&MyInstance, INFO_FROM_HARDWARE, sizeof MyInstance);
    MyInstance.useThis; //Calling this memeber with no problem
    // access MyInstance within the template
}

// usage
if(someVariable)
{
    do_something<tstr1>(INFO_FROM_HARDWARE);
}
else
{
    do_something<tstr2>(INFO_FROM_HARDWARE);
}

---

我想避免 someFunction() 成为模板（只是为了避免这种事情）

为什么我不能将我的模板类的定义与它的声明分开并将其放在一个 .cpp 文件中？

链接问题对您的用例来说不是问题，因为潜在的模板参数集是有限集。下一个常见问题解答entry 解释了如何：使用模板的显式实例化。

Answer 4

您可能需要对结构成员的简单引用：

uint8_t &useThis=SomeVariable
 ?reinterpret_cast<tstr1*>(INFO_FROM_HARDWARE)->useThis
 :reinterpret_cast<tstr2*>(INFO_FROM_HARDWARE)->useThis;