C++ C++；父类方法调用

我正在创建一个从STL库继承队列的新类。类中唯一添加的是向量。该向量将具有相同大小的队列，并将存储一些与队列中每个对象对应的整数值

现在，我想重写pop（）和push（），但我只想向父类方法添加更多功能

例如，当对队列对象调用pop（）时，我还希望从向量中弹出一个对象。当对队列对象调用push（）时，我还希望在向量中插入一个新对象

我该怎么做

#include <iostream>
#include <iostream>
#include <queue>
#include <vector>

using namespace std;

template <typename type>
class CPU_Q : public queue<type>
{

  public:
    vector<int>  CPU_TIME;

    void increaseTime()
    {
      for(int ndx = 0; ndx < CPU_TIME.size(); ndx++)
      {
        CPU_TIME[ndx]++;
      }
    }

  void push(type insertMe)
  {
    //This is what I want to do
    super::push(); // or queue::push(); maybe?
    CPU_TIME.push_back(0);
  }
  void pop()
  {
    //Something very similar to push()
  }
}

#包括
#包括
#包括
#包括
使用名称空间std；
模板
类CPU_Q：公共队列
{
公众：
向量CPU时间；
void increaseTime（）
{
对于（int ndx=0；ndx

非常感谢

---

-Tri

简单的答案是这是不可能的。STL容器类不是为继承而设计的。它们的析构函数无法启动。如果你真的想做这样的事情，那么就写一个新的类来“包含”队列和向量，并在任何地方使用这个类。顺便说一下，C++中没有<代码>超级< /Cord>关键字不同于java。如果要调用基类方法，请使用

BaseClassName:：methodName（）
您询问过：

void push(type insertMe){
      //This is what I want to do
      super::push(); // or queue::push(); maybe?
      CPU_TIME.push_back(0);
}

这更像是：

void push(type insertMe) { 
   queue<type>::push(insertMe);
   CPU_TIME.push_back(0);
}

void push（键入insertMe）{
队列：：推送（insertMe）；
CPU时间。推回（0）；
}

除非您可能希望通过常量引用接受参数：

void push(type const &insertme) { 
    queue<type>::push(insertMe);
    CPU_TIME.push_back(0);
}

void push（类型const&insertme）{
队列：：推送（insertMe）；
CPU时间。推回（0）；
}

这就是说，标准容器类并不是真正为继承而设计的（例如，它们没有虚拟DTOR），因此您必须小心这一点——例如，当您销毁它时，您将需要静态类型作为派生类型；如果（例如）通过基类指针销毁一个，则会得到未定义的行为。
< P>除非新类具有<强> IS-< /强>关系> <代码> STD:：队列，我强烈考虑封装队列和向量，并按照您希望调用的顺序提供转发到适当的
std:：queue
/
std:：vector
方法的方法

另外，如果希望这个新类与标准算法兼容，则必须实现
begin（）
和
end（）
方法，该方法返回能够遍历数据结构的
迭代器类型；您可以使用
std:：queue
/
std:：vector
上的现有方法来完成此任务。
中的STL队列类不打算使用继承进行扩展。寻找更多关于这方面的信息。除此之外，
std:：queue
还有多个模板参数。您可以使用
std:：queue
作为模板类
CPU\u Q
的成员，而不是继承，如下所示：

template<typename T>
class CPU_Q
{
  std::queue<T> q;
public:
  void push( T val ) 
  { 
    q.push( val );
    // additional work
  }
};

模板
类CPU_Q
{
std：：队列q；
公众：
无效推力（T val）
{ 
q、 推（val）；
//附加工作
}
};
您是否认为从队列派生是有效的？如果足够小心，是的。我不确定我是否真的会推荐它，但并没有什么会使它自动无效。从队列派生肯定是无效的，但也不是“不可能”。我建议将队列作为一个实例变量，并转发任何push（）/pop（）调用。我想这取决于“当然无效”的含义。在任何适当的函数C++编译器都必须接受代码的情况下，它是“有效的”。从他的描述来看，从设计的角度来看，它甚至可能是“有效的”——他没有足够的表现来绝对肯定地说，但您可能可以在允许队列的任何地方替换他的派生类（唯一明显的例外是通过指针破坏队列的东西）。实际上，队列和堆栈都可以（适配器类）有一个受保护的成员变量
c
。这意味着它们可以安全地从中继承。这是很少需要的。是的，这是可能的。不可能的是将生成的类视为
std:：queue
。经典多态性不适用于STL。（但是编译时多态性可以。）是的..我的意思是你不能使用动态绑定重新路由对队列的pop（）etc方法的调用。我不理解最新的否决票..答案中有什么错误吗？它不是“不可能”。它不适用于大多数用例并不会改变这一点。@gf：那是“大多数用例”对我来说似乎很可疑。对我来说，我通常根本不传递容器。我只传递迭代器。此外，如果传递容器，为什么要将自己限制在
std:：queue
？只需将其作为模板参数，任何提供所需接口的其他容器也可以。所有这些情况都适用于从M <代码> STD:：队列，即使它们覆盖任何函数。唯一不起作用的是动态多态性。C++没有“<代码>超级< /Cord>”关键字的原因可能是C++中有多重继承。可以有几个基类/超类。因此，使用基类的适当类型：<代码>队列：：推（插入）
。但是，请务必阅读解释为什么从STL容器继承可能不是您想要的结果的答案。您是否也考虑过简单地将这些值放入它们自己的结构中，以便始终可以保证相关值一起添加和删除？这是包含而不是继承，可能是b更好，但可能需要一些解释