Question

我正在设计虚拟处理器，我想代表虚拟cpu将使用的不同大小的寄存器。我还想将它们包含在一个容器中，而不管它们的实际大小和类型如何。

我会有一个看起来像这样的结构来存储寄存器

struct Memory {
    std::vector<std::shared_ptr<Register>> bank;
};

我正在尝试这样创建一个空基类：

struct Register {};

现在，我将从该基类继承来创建我支持的寄存器的不同类型。这些寄存器还取决于一些typedef ...

typedef std::int8_t   i8;
typedef std::int16_t i16;
typedef std::int32_t i32;
typedef std::int64_t i64;

typedef std::uint8_t   u8;
typedef std::uint16_t u16;
typedef std::uint32_t u32;
typedef std::uint64_t u64;

const u16 BYTE = 0x08, WORD = 0x10, DWORD = 0x20, QWORD = 0x40;

让我们说我想拥有一个寄存器，其基础数据类型是u8，另一个是u16，依此类推...

struct Register8 : Register {
    u8 value;
    u8 getValue() const { return value; }
};

struct Register16 : Register {
    u16 value;
    u8 getValue() const { return value; }
};

struct Register32 : Register {
    u32 value;
    u32 getValue() const { return value; }
};

struct Register64 : Register {
    u64 value;
    u64 getValue() const { return value; }
};

所以这很简单，但是我不喜欢以不同的方式命名每个寄存器类的事实，而且我看到一些重复的代码（类型不同），因此我们应该能够创建模板...

struct Register{};

template<typename T>
Register_t : Register {
    T value;
    T getValue() const { return value; }
};

这很容易；但是，我想专门研究这个课程：

struct Register {};

template<typename T>
struct Register_t : Register {
    T value;
    T getValue() const { return value; }
};

template<>
struct Register_t<u8> {
    u8 value;
    u8 getValue() const { return value; }
};

template<>
struct Register_t<u16> {
    u16 value;
    u16 getValue() const { return value; }
};  

template<>
struct Register_t<u32> {
    u16 value;
    u16 getValue() const { return value; }
};

template<>
struct Register_t<u64> {
    u16 value;
    u16 getValue() const { return value; }
};

好吧，这可以追溯到我之前提到的关于重复代码的内容，并且我们将介绍更多内容，但是在我的情况下，这些将是唯一可接受的类型，因此这部分重复不是问题。

到目前为止一切都很好...

现在假设我尝试使用此...

main.cpp

#include <iostream>
#include "Register.h"

int main () {
    Register_t<u8> r8;
    r8.value = 8;
    Register_t<u16> r16;
    r16.value = 16;
    Register_t<u32> r32;
    r32.value = 32;
    Register_t<u64> r64; 
    r64.value = 64;

    Memory mem;
    mem.bank.push_back( std::make_shared<Register>( r8 ) );
    mem.bank.push_back( std::make_shared<Register>( r16 ) );
    mem.bank.push_back( std::make_shared<Register>( r32 ) );
    mem.bank.push_back( std::make_shared<Register>( r64 ) );

    return EXIT_SUCCESS;
};

好的，所以我成功地将它们作为共享指针存储到向量中。现在出现问题了……让我们尝试从类中访问这些值

int main () {
    // ....

    for ( auto& b : mem.bank ) {
        std::cout << b->getValue() << '\n'; // Uh oh class Register has no member getValue() ...
    }

    return EXIT_SUCCESS;
}

这是我的问题；我不确定如何间接调用继承的类的getValue()函数或如何正确继承这种类型的设计结构-类层次结构。或者，如果我应该完全消除专业化的话……这就是我受阻的地方，所有帮助都将是感激的。

Answer 1

我认为您需要这样的东西：

struct Register {
    virtual int: getValue() = 0;
};

从基类继承类模板的正确方法，同时专门化模板

1 个答案: