接口 PTR 的返回向量C++

我正在尝试创建一个返回接口向量的接口，同时在另一端使用它来实现。

我知道不清楚，所以这里有一些例子：

class IComponent
{
public:
virtual ~IComponent() {}
virtual int getValue() const = 0;
};
class ICollection
{
public:
virtual ~ICollection() {}
virtual IComponent* getComp() = 0;
};
class Component : public IComponent
{
public:
virtual int getValue() const { return 42; }
};
class Collection : public ICollection
{
public:
Collection()
{
m_comp = new Component();
}
virtual Component* getComp()
{
return m_comp;
}
private:
Component* m_comp;
};

这编译和工作，因为Component*隐式转换为IComponent*。这允许我使用完全实现的Collection和Component。

#include <vector>
class IComponent
{
public:
virtual ~IComponent() {}
virtual int getValue() const = 0;
};
class ICollection
{
public:
virtual ~ICollection() {}
virtual std::vector<IComponent*> &getComp() = 0;
};
class Component : public IComponent
{
public:
virtual int getValue() const { return 42; }
};
class Collection : public ICollection
{
public:
Collection()
{
m_comp.push_back(new Component());
m_comp.push_back(new Component());
}
virtual std::vector<Component*> &getComp()
{
return m_comp;
}
private:
std::vector<Component*> m_comp;
};

但是这次我无法使用完全实现的集合和组件。

当然很容易理解为什么，因为Component *是IComponent *，但严格来说，std::vector<Component *>并不std::vector<IComponent *>。这个问题也适用于所有模板类型，如迭代器、smart_ptr等......

相反，在Collection::getComp()我必须返回一个std::vector<IComponent *>。我也许可以在返回它时投m_comp(我什至不确定它是否有效，它不是一个右值吗？我还可以存储 2 个vector，一个Component *，一个IComponent *，并使它们保持同步，但我认为这是丑陋的代码。

是否有一些解决方法，或者我不知道如何处理它？

更多详情：

我真正想要的是能够在Collection中使用Component。如果我m_comp更改为std::vector<IComponent *>并且getComp()返回类型它将起作用，但我将被迫使用指向IComponent的指针，而不是在Collection中Component。

所以是的，我可以同步两个向量，或者在getComp()中创建副本，但我想知道是否有更好的方法。

活动详情：

以下是我想如何使用它的示例： (我只是在Component中添加了getDouble()方法，并在Collection中调用了它)

#include <iostream>
#include <vector>
class IComponent
{
public:
virtual ~IComponent() {}
virtual int getValue() const = 0;
};
class ICollection
{
public:
virtual ~ICollection() {}
virtual std::vector<IComponent*> &getComp() = 0;
};
class Component : public IComponent
{
public:
virtual int getValue() const { return 42; }
double getDouble() const { return 3.14; }
};
class Collection : public ICollection
{
public:
Collection()
{
m_comp.push_back(new Component());
m_comp.push_back(new Component());
}
// Impossible because it does not override the good method
virtual std::vector<Component*> &getComp()
{
std::cout << m_comp[0]->getDouble() << std::endl;
return m_comp;
}
private:
std::vector<Component*> m_comp;
};

如果我更改返回类型，集合将变为：

class Collection : public ICollection
{
public:
Collection()
{
m_comp.push_back(new Component());
m_comp.push_back(new Component());
}
virtual std::vector<IComponent*> &getComp()
{
// This time this line is impossible without cast
// because m_comp[0] is IComponent*
std::cout << m_comp[0]->getDouble() << std::endl;
return m_comp;
}
private:
std::vector<IComponent*> m_comp;
};

一种解决方案是这样的：

class Collection : public ICollection
{
public:
Collection()
{
// Useless and redundant code here
m_comp.push_back(new Component());
m_icomp.push_back(m_comp.back());
m_comp.push_back(new Component());
m_icomp.push_back(m_comp.back());
}
// Impossible because it does not override the good method
virtual std::vector<IComponent*> &getComp()
{
std::cout << m_comp[0]->getDouble() << std::endl;
return m_icomp;
}
private:
// Duplicated storage for "nothing"
std::vector<Component*> m_comp;
std::vector<IComponent*> m_icomp;
};

在我看到的响应中，有一些关于实现pop()和push()方法的东西，但在我的项目中，我使用的是Map而不是Collection，并且有块向量。这允许通过执行map[y][x]来访问块。

问题是存储是固定的。一种解决方案是改为添加方法getBlock(size_t x, size_t y)。但我想看到我能对第一个案例做的最好的事情:)

不确定此解决方案是否可以在您的情况下工作，但是...在ICollection中将Component派生类作为模板参数传递怎么样？

不完全是奇怪的重复模板模式，而是类似的东西。

我的意思是，类似的东西

template <typename CompT>
class ICollection
{
public:
virtual ~ICollection() {}
virtual std::vector<CompT*> &getComp() = 0;
};

所以Collection成为

class Collection : public ICollection<Component>
{
public:
Collection()
{
m_comp.push_back(new Component());
m_comp.push_back(new Component());
}
virtual std::vector<Component*> &getComp()
{
return m_comp;
}
private:
std::vector<Component*> m_comp;
};

甚至，如果您在模板类中转换Collection

template <typename CompT>
class Collection : public ICollection<CompT>
{
public:
Collection()
{
m_comp.push_back(new CompT());
m_comp.push_back(new CompT());
}
virtual std::vector<CompT*> &getComp()
{
return m_comp;
}
private:
std::vector<CompT*> m_comp;
};

如果您知道返回的vector元素指向Component对象，则可以：

Collection coll;
std::vector<IComponent*>& v = coll.getComp();
Component& comp = *dynamic_cast<Component*>(v[0]);

如果你只需要来自IComponent接口的虚拟方法，你甚至不需要强制转换;你可以使用动态调度来调用它们。但是，强制转换为子类型的引用将获得它添加的任何方法。

我还建议让你的抽象少一点泄漏。你可以通过operator[]、push()/pop()或任何有意义的方式访问元素。然后，内部存储可以是任何类型的指针的任何类型的容器，并且公共接口不必更改。

一个不太安全的选择是回到C方式。你可以把m_comp.data()当作IComponent**，把它投射到Component**，然后返回。

无论如何你都需要将Collection::getComp的返回类型更改为std::vector<IComponent*>&，否则它无法覆盖ICollection::getComp。由于std::vector<IComponent*>也可以包含指向Component的指针，只需将您的成员更改为该成员，您应该没问题。

如果在某处需要指向Component而不是其接口的指针，则可以使用 dynamic_cast 将其向下转换。

相关内容

最新更新

热门标签：