Templates 分配基类模板成员变量的简单方法是什么

我有一个名为interface的类，它接受用户输入提供的文件，然后根据该文件类型初始化BaseDefinitions类型的成员变量，该变量用于映射文件的特定字节

基础

template<class T, class U>
class BaseDefinition 
{
public:

    T getHeaderBlock()  { T new_header_block = {};  return new_header_block; };
    U getDataBlock()    { U new_data_block = {}; return new_data_block; };

    virtual bool        validateBytes(T& definition) = 0;  
    virtual float       getDataPoint(U& data) = 0;
};

class FileInterface
{
public:
    FileInterface();
    ~FileInterface();
    void loadDefinition(std::string &file_type);

private:
    void extract_header();
    BaseDefinition* definition_; //Here is the member variable I am trying to set
    std::vector<int> values_;   

模板
类基定义
{
公众：
T getHeaderBlock（）{T new_header_block={}；返回new_header_block；}；
U getDataBlock（）{U new_data_block={}；返回new_data_block；}；
虚拟布尔验证字节（T&definition）=0；
虚拟浮点getDataPoint（U&data）=0；
};

派生的

struct  FileAHeaderBlock {
    ...
};

struct FileADataBlock {
    ...
};

class FileADefinition : public BaseDefinition<FileAHeaderBlock, FileADataBlock >
{
public:
     bool       validateBytes(FileAHeaderBlock& definition) override;
     float      getDataPoint(FileADataBlock & data) override;
}

struct FileAHeaderBlock{
...
};
结构FileADataBlock{
...
};
类filedefinition：公共BaseDefinition
{
公众：
bool validateBytes（FileAHeaderBlock和definition）覆盖；
float getDataPoint（FileADataBlock&data）覆盖；
}

接口头文件

template<class T, class U>
class BaseDefinition 
{
public:

    T getHeaderBlock()  { T new_header_block = {};  return new_header_block; };
    U getDataBlock()    { U new_data_block = {}; return new_data_block; };

    virtual bool        validateBytes(T& definition) = 0;  
    virtual float       getDataPoint(U& data) = 0;
};

class FileInterface
{
public:
    FileInterface();
    ~FileInterface();
    void loadDefinition(std::string &file_type);

private:
    void extract_header();
    BaseDefinition* definition_; //Here is the member variable I am trying to set
    std::vector<int> values_;   

类文件接口
{
公众：
FileInterface（）；
~FileInterface（）；
无效加载定义（标准：：字符串和文件类型）；
私人：
void extract_header（）；
BaseDefinition*definition\u；//这是我试图设置的成员变量
std：：向量值；

})

接口.cpp

void FileInterface::load_defintion(const std::string& filepath)
{
    //Psuedo code
    if (file_type == std::string(".fileA"))
        definition_ = FileADefinition;
    else if (file_type == std::string(".fileB"))
        definition = FileBDefinition;
}

void FileInterface::extract_header()
{   
    auto header_buffer = definition_.getHeaderBlock();

    //read bits into header buffer
    
    if (!file_.read((char*)(&header_buffer), sizeof(header_buffer)))
    {
        throw std::runtime_error("File could not be read: ");
    }

    if (!definition_.validateBytes(header_buffer))
    {
        std::cout << "got: " << std::string(std::begin(header_buffer.MAGIC), std::end(header_buffer.MAGIC)) << std::endl;
    }
    
    values_ = header_buffer.DATA;
}

void FileInterface:：load\u定义（const std:：string和filepath）
{
//伪代码
if（file_type==std:：string（“.fileA”））
定义=文件定义；
else if（file_type==std:：string（“.fileB”））
定义=文件定义；
}
void FileInterface:：extract_header（）
{   
自动标头_buffer=definition_u.getHeaderBlock（）；
//将位读入报头缓冲区
如果（！file_uu.read（（char*）（&header_buffer）），sizeof（header_buffer）））
{
抛出std:：runtime_错误（“无法读取文件：”）；
}
如果（！定义\验证字节（头\缓冲区））
{
std：：cout也许是沿着这些思路的东西。这在功能上应该与您当前的示例相同

class BaseDefinition {
public:
  virtual std::vector<int> extract_header(std::istream& input) = 0;
};

template <typename T, typename U>
class BaseDefinitionImpl : public BaseDefinition {
protected:
  virtual bool        validateBytes(T& definition) = 0;  
public:
  std::vector<int> extract_header(std::istream& input) override {
    T header_buffer;
    if (!file_.read((char*)(&header_buffer), sizeof(header_buffer)))
    {
        throw std::runtime_error("File could not be read: ");
    }
    if (!validateBytes(header_buffer)) {
      std::cout << "Bad things happened";
    }
    return header_buffer.DATA;
  }
};

class FileADefinition : public BaseDefinitionImpl<FileAHeaderBlock, FileADataBlock >
{
public:
     bool validateBytes(FileAHeaderBlock& definition) override;
}

class FileInterface {
public:
    void loadDefinition(std::string &file_type) {
      if (file_type == std::string(".fileA"))
        definition_ = std::make_unique<FileADefinition>();
    }

private:
    void extract_header() {
      values_ = definition_->extract_header(file_);
    }
    std::unique_ptr<BaseDefinition> definition_;
    std::vector<int> values_;
};

类基本定义{
公众：
虚拟std:：vector extract_头（std:：istream&input）=0；
};
模板
类BaseDefinitionImpl：公共BaseDefinition{
受保护的：
虚拟布尔验证字节（T&definition）=0；
公众：
std:：vector extract_头（std:：istream&input）覆盖{
T头u缓冲器；
如果（！file_uu.read（（char*）（&header_buffer）），sizeof（header_buffer）））
{
抛出std:：runtime_错误（“无法读取文件：”）；
}
如果（！validateBytes（标头\缓冲区））{
std:：cout extract_头（文件_u）；
}
std：：唯一的ptr定义；
std：：向量值；
};
<>代码>我不知道在运行时，我需要什么类型，因为上面有解释，因为在什么文件中有用户输入。所以我不能把它放在成员类中。每种类型都必须在C++编译时知道，就像你不能定义一个数字变量，在运行时决定它是int还是浮点。你可以重新设计它。例如，
BaseDefinition
派生自一个公共类
BaseDefinition
，并存储一个指向
BaseDefinition
的指针，但这是另一个问题。这不会违背基类的目的吗？我在帖子中添加了更多的上下文，说明了我为什么要以这种方式构建它。我似乎在这里看到了我的想法It’我的代码有严重问题，我可以问什么问题，以便标题更合适。您列出的函数都取决于特定的类型
T，U
，并且它们对于不同的类型都（非常）不同，因此没有什么可“抽象”的关于这一点。假设您有其他更高级别的函数，这些函数独立于类型，并且可以在不同类型之间共享，您希望将它们放在一个公共基础中。但如果没有更多上下文，这很难猜测。其目的是让FileInterface处理更高级别的函数。它有一个使用fstream加载的文件，一个d一个用户定义的类，性质为FileADefinition，FileBDefinition派生自BaseDefinition，它告诉我们在哪里找到它需要的字节。因此，在后台，文件接口并不关心它是什么文件，因为处理过程是相同的。即加载一个文件定义，抓取头，解析头，然后抓取数据，解析数据。i t虽然我的代码在遇到这个问题之前还不错。我的代表实际上太低了，无法接受，但我只是想感谢您的回复。