无法将参数1从“Component<W>*”转换为“Component<W>*”

Question

我创建了一个演示问题的小示例。我真不明白这里出了什么问题。使用2010。

这些类(非常松散)是以MFC为模型的，因为这正是我需要使用它的原因。基本上，我希望创建一个面板类，它可以包含其他面板或控件，因此我添加了一个组件类，它跟踪id和父类，以及面板类，它充当其组件的容器。

现在我不明白的是，为什么我会得到这个编译器错误，为什么我只在使用一个控件时才得到它，而不是在一个子面板中。

#include <iostream>
#include <algorithm>
#include <vector>

class CWnd
{
public:
    CWnd(CWnd *pParent = NULL, int nId = -1)
    {
        mId = nId;
        mParent = pParent;
        mClassname = NULL;
    }

    void setId(int nId) { mId = nId; }
    int getId(void) const { return mId; }

    void setParent(CWnd *pParent) { mParent = pParent; }
    CWnd *getParent(void) const { return mParent; }

    bool create(const char *pClassname, int nId, CWnd *pParent)
    {
        mId = nId;
        mParent = pParent;
        mClassname = pClassname;

        return true;
    }

private:
    int mId;
    CWnd *mParent;
    const char *mClassname;
};

class Ctrl : public CWnd
{
public:
    Ctrl(CWnd *pParent, int nId = -1)
        : CWnd(pParent, nId)
    {
    }
};

class Dialog : public CWnd
{
public:
    Dialog(CWnd *pParent, int nId = -1)
        : CWnd(pParent, nId)
    {
    }

    bool create(int nId, CWnd *pParent)
    {
        CWnd::create("dialog", nId, pParent);

        return true;
    }
};

class View : public CWnd
{
public:
    View(CWnd *pParent = NULL)
        : CWnd(pParent)
    {
    }
};

template <typename W>
class Component : public W
{
public:
    Component(CWnd *pParent = NULL)
        : W(pParent)
    {
        mId = -1;
        mParent = pParent;
    }

    virtual bool create(CWnd *pParent = NULL)
    {
        if(pParent)
            mParent = pParent;

        W::setParent(mParent);
        W::setId(mId);

        return true;
    }

private:
    int mId;
    CWnd *mParent;
};

class Panel : public Component<Dialog>
{
public:
    Panel(CWnd *pParent = NULL)
        : Component(pParent)
    {
    }

    virtual bool create(CWnd *pParent = NULL)
    {
        if(pParent != NULL)
            setParent(pParent);

        Dialog::create(getId(), pParent);

        for(Components::iterator it = mComponents.begin(); it != mComponents.end(); ++it)
        {
            if(!(*it)->create(this))
                return false;
        }

        return true;
    }

    void addComponent(Component *pComponent)
    {
        if(std::find(mComponents.begin(), mComponents.end(), pComponent) == mComponents.end())
            mComponents.push_back(pComponent);
    }

    void removeComponent(Component *pComponent)
    {
        Components::iterator pos = std::find(mComponents.begin(), mComponents.end(), pComponent);
        if(pos != mComponents.end())
            mComponents.erase(pos);
    }

protected:
    typedef std::vector<Component *> Components;

private:
    Components mComponents;
};

int main()
{
    View v;
    Panel d;
    Panel p;
    Component<Ctrl> listbox;
    Component<Ctrl> tab;

    // these are generating the error
    d.addComponent(&listbox);
    d.addComponent(&tab);

    // only this one works.
    d.addComponent(&p);

    std::cout << "\nDone! Press any key..." << std::endl;
    std::cin.ignore();

    return 0;
}

我得到的错误消息是：

'Panel::addComponent' : cannot convert parameter 1 from 'Component<W> *' to 'Component<W> *'

Answer 1

没有类型的Component，所以没有类型的Component*。但是，在Panel类的上下文中，由于它是从Component<Dialog>派生的，因此实际上注入了名称Component，并引用了Component<Dialog>。因此，addComponent的适当签名是：

void addComponent(Component<Dialog> *pComponent)

但是Component<Ctrl>不是从Component<Dialog>派生的，所以不能将Component<Ctrl>*传递给这个函数。

您可能要做的是从第二个基类派生Component (该基类不是从任何东西派生的)。

class Component_base
{
    // component common functionality
};

template<typename W>
class Component : public W, public Component_base
{
    ...
};

然后您的Panel类可以存储：

std::vector<Component_base*> Components;

Answer 2

有一种叫injected-class-name的东西。对于类模板，这意味着在类模板的范围内，类模板名称引用特定的实例化，而不是模板本身：

template <class T>
class C {
    C(C<T> const& ) = default; // one way to write the copy constructor
    C(C const& ) = default;    // exactly equivalent to the above
};

继承的类也继承所有注入的类名。所以当你写：

class Panel : public Component<Dialog>

我们有多个不同的注入名称：Panel、Component、Dialog和CWnd。这是第二个意义重大的问题:在Panel的范围内，Component指的是特定的类Component<Dialog>，而不是--类模板Component。因此：

void addComponent(Component *pComponent)

是(并完全等同于)的缩写：

void addComponent(Component<Dialog> *pComponent)

Component<Dialog>与Component<Ctrl>之间没有类关系，因此出现了错误。

根据您的注释，您实际上希望这是一个函数模板。所以你必须明确地把它变成一个：

template <class W>
void addComponent(Component<W> *pComponent) { ... }

但这是行不通的，因为你持有一个vector<Component<Dialog>*>。您也需要将其更改--可能会更改为vector<CWnd*>。

Answer 3

您的问题是，没有从Component<Ctrl>*到Component<Dialog>*的转换。d.addComponent(&p);之所以有效，是因为d和p是相同的类型。您需要为Component<Ctrl>*和Component<Dialog>*创建公共基类，以便在这两种类型之间进行转换或创建转换构造函数。