C++ 从基类指针派生派生类的模板类型

考虑以下几点：

乙级

D类，哪一类

• 是从B类派生出来的
• 有一个模板参数T
• 具有类型为T的成员变量x

一个带参数的模板函数F

• 模板参数S
• 类型为S的参数y

一个指针p，它

• 有B型的*
• 指向模板参数T等于例如int的D类对象o

函数F不能被修改

F不能直接从类B或D调用

进一步考虑，只给出了指针p，调用F时参数y应等于对象o的成员变量x（这意味着类型S等于int）

如何修改B类和D类以实现这一点？我想需要某种机制来派生模板类型T。但我不知道怎么做

以下是相关代码：

文件F.h:

#include <iostream>
//////////// Consider that the lines up to the next comment cannot be changed
template< typename S > void F( S y )
{
    std::cout << y <<  " of some type" << std::endl; 
}

template<> void F<>( int y )
{
    std::cout << y << " of int type." << std::endl; 
}
//////////// -----------------------------

#包括
/////////////认为无法更改到下一条注释的行。
模板void F（S y）
{
std：：cout你可能会这样做

class B
{
public:
    virtual ~B() = default;
    virtual void f() const = 0;
};

template<typename T>
class D : public B
{
public:
    void f() const override { F(x); }
private:
    T x;
};

B类
{
公众：
virtual~B（）=默认值；
虚空f（）常数=0；
};
模板
D类：公共B类
{
公众：
void f（）常量重写{f（x）；}
私人：
tx；
};

您可以使用回调和虚拟成员函数来调用它：

class B
{
public:
    virtual ~B() = default;
    virtual void call() const = 0;
};

template <typename T>
class D : public B
{
public:
    explicit D(T t, std::function<void(T)> cb)
        : x(std::move(t)),
          callback(std::move(cb))
    {
    }
    void call() const override
    {
        callback(x);
    }
private:
    T x;
    std::function<void(T)> callback;
};

int main()
{
    D<int> o(3, F<int>);
    B* p = &o;
    p->call();
)

B类
{
公众：
virtual~B（）=默认值；
虚空调用（）常量=0；
};
模板
D类：公共B类
{
公众：
显式D（T，std:：函数cb）
：x（std：：move（t）），
回调（标准：：移动（cb））
{
}
void call（）常量重写
{
回调（x）；
}
私人：
tx；
函数回调；
};
int main（）
{
D o（3，F）；
B*p=&o；
p->call（）；
)

我试图将描述范围缩小到核心问题。实际上，我希望有一个
B
类型的指针数组或向量，这样我就可以使用不同的模板参数T联合访问或处理D类对象，例如，通过进一步扩展
B
s接口（甚至可以使用虚拟函数）。为什么不能包含F.h？这听起来像是一个X-Y问题，解决方案可能是绕过这个限制。（可能
F
可以向前声明？）可以
B
知道每个“可能”派生的
类D
？顺便说一句，你应该避免以使现有答案无效的方式编辑你的问题。（你可以问另一个例子）。@aschepler：首先，出于实际原因，因为我在（大型）中遇到了依赖性问题我正在从事的项目。这可能会得到解决，但是，这方面的努力还不清楚。第二，也是因为一些假定的原因，因为在没有F.h的情况下，应该可以在其他项目中使用BD.h。考虑到问题的第一个版本是如何提出的，这将是一个解决方案。但是，我有一个问题，即F的声明/定义不明确定义D和B时可用。我将相应地更新问题。
class B
{
public:
    virtual ~B() = default;
    virtual void f() const = 0;
};

template<typename T>
class D : public B
{
public:
    void f() const override { F(x); }
private:
    T x;
};

class B
{
public:
    virtual ~B() = default;
    virtual void call() const = 0;
};

template <typename T>
class D : public B
{
public:
    explicit D(T t, std::function<void(T)> cb)
        : x(std::move(t)),
          callback(std::move(cb))
    {
    }
    void call() const override
    {
        callback(x);
    }
private:
    T x;
    std::function<void(T)> callback;
};

int main()
{
    D<int> o(3, F<int>);
    B* p = &o;
    p->call();
)