标签: pure-virtual

这是交易.我有一个大的类层次结构,我有一个方法,一直延伸.该方法总是必须在每个新级别查看一个或两个以上的变量,并且这些变量取决于层次结构中的实际类.我想要做的是检查那两个额外的变量然后调用同一个函数的超类版本.我希望能够定义此函数,因为所有它的直接孩子都会使用它,但我想强制该类的任何子项必须重新定义该方法(因为他们必须查看他们的新数据成员)

那我该怎么写呢？我通常使用= 0; 在.h文件中,但我假设我不能使用它并定义它...

只是想知道,因为我遇到的问题,是否有可能创建一个指针向量？如果是这样,怎么样？特别是关于使用迭代器和.begin()与它,即:我如何将此向量转换为指针向量:

class c
{
     void virtual func();
};

class sc:public c
{
     void func(){cout<<"using func";}
};

sc cobj;

vector<c>cvect
cvect.push_back(cobj);
vector<c>::iterator citer

for(citer=cvect.begin();citer<cvect.end();citer++)
{
     citer->func();
}

我有一个小包装器,它集中了与线程相关的内容:

class Thread {
protected:
    boost::thread *m_thread;

    virtual void work() = 0;

    void do_work() {
        work();
    }

public:
    Thread() : m_thread(NULL) {}
    virtual ~Thread() {
        catch_up();
        delete m_thread;
    }

    inline void catch_up() {
        if(m_thread != NULL) {
            m_thread->join();
        }
    }

    void run() {
        m_thread = new boost::thread(boost::bind(&Thread::do_work, boost::ref(*this)));
    }
};

当我实现它时,请说明如下:

class A : public Thread {
    void work() {}
};

在 :

A a; a.run();

我得到了一个运行时终止,显示了一个非常"纯粹的虚拟方法".我认为这是boost :: bind参数,但我不知道怎么说"使用虚拟纯实现"...

先谢谢了.

问候,

Mystère先生

为什么如果我们在基类中有纯虚拟赋值运算符,那么我们在派生类上实现该运算符,它会在基类上给出链接器错误？

目前我在http://support.microsoft.com/kb/130486上只有以下说明,它说该行为是设计的,因为正常的继承规则不适用.

我不清楚,为什么它会通过设计产生链接器错误？有人可以给我更明确的解释吗？

编辑:添加了我发生错误的简化代码:

class __declspec(dllexport) BaseClass {
public:
    int memberA;
    virtual BaseClass& operator=(const BaseClass& rhs) = 0;
};

class __declspec(dllexport) DerivedClass : public BaseClass {
public:
    int memberB;
    DerivedClass():memberB(0) {}
    virtual BaseClass& operator=(const BaseClass& rhs) {
        this->memberA = rhs.memberA;
        this->memberB = 1;
        return *this;
    }
};

int main(void)
{
    DerivedClass d1;
    DerivedClass d2;

    BaseClass* bd1 = &d1;
    BaseClass* bd2 = &d2;

    *bd1 = *bd2;
}

如果没有 __declspec(dllexport)和/或没有基类上的纯虚拟运算符=声明,代码将编译时没有错误.

在没有__declspec(dllexport) …

我正在使用boost.python来生成用c ++编写的python模块.我有一些基类与纯虚函数,我已导出如下:

class Base
{
    virtual int getPosition() = 0;
};

boost::python::class_<Base>("Base")
   .def("GetPosition", boost::python::pure_virtual(&Base::getPosition));

在Python中我有代码:

class Test(Base):
   def GetPosition(self):
      return 404

Test obj
obj.GetPosition()

RuntimeError:调用纯虚函数

怎么了？

我在使用引用变量时发现了一种奇怪的行为.

这是类实现:

class Base {
    public:
        virtual void Method() = 0;
};

class DerivedA : public Base {
    public:
        virtual void Method() {}
}

class DerivedB : public Base {
    public:
        virtual void Method() {}
}

这是一个具有奇怪行为的示例代码:

void main(int argc, char *argv[]) {
    DerivedA a;
    DerivedB b;
    Base &base = a;

    base.Method();   // Calls DerivedA::Method

    base = b;
    base.Method();   // Calls DerivedA::Method!!! Why doesn't call DerivedB.Method()?
}

总之,似乎只有在初始化引用变量时才确定与引用变量"关联"的虚函数指针表.如果我重新分配引用变量,则vfpt不会更改.

这里发生了什么？

所以我有一个没有抽象方法的抽象基类.为了强制抽象,我已经将(非平凡的)析构函数声明为纯虚拟:

class AbstractClass
{
public:
  AbstractClass()
  {
    std::wcout << L"AbstractClass::AbstractClass()" << std::endl;
  }
  virtual ~AbstractClass() = 0
  {
    std::wcout << L"AbstractClass::~AbstractClass()" << std::endl;
  }
};

class ConcreteClass : public AbstractClass
{
public:
  ConcreteClass()
  {
    std::wcout << L"ConcreteClass::ConcreteClass()" << std::endl;
  }
  virtual ~ConcreteClass()
  {
    std::wcout << L"ConcreteClass::~ConcreteClass()" << std::endl;
  }
};

这构建并按预期工作; 简单定义ConcreteClass实例的代码块的输出是

    AbstractClass::AbstractClass()
    ConcreteClass::ConcreteClass()
    ConcreteClass::~ConcreteClass()
    AbstractClass::~AbstractClass()

现在,当我从另一个用作接口类的类派生AbstractClass时,它本身具有(普通的)虚拟析构函数(纯或其他),它仍然有效:

class IAlpha
{
public:
  virtual ~IAlpha() = 0 {}
};

class AbstractClass : public IAlpha
{
public:
  AbstractClass()
  {
    std::wcout << L"AbstractClass::AbstractClass()" << …

问题是：尝试编译时，我不断收到未实现的纯虚拟方法错误。我已经在抽象基类中实现了所有纯虚方法。有任何想法吗？

这是抽象基类：

class record{
public:
    virtual int getID()=0;
    virtual record *clone(); 
};

和实施：

class sdata: public record{
public:
    sdata(std::string s = ""){data=s; ID=atoi(data.substr(0,8).c_str());}
    virtual int getID(){return ID;}
private:
    std::string data;
    int ID;
};

抱歉，这是完整的错误消息：

“record”中未实现的纯虚拟方法“getID”

也许这段代码导致了错误：

int hashTable::hash(record *x) {
   return floor(m * (x->getID() * A - floor(x->getID() * A)));
}

我通常使用纯虚函数来处理我的代码所需的那些方法.因此,我创建接口,然后其他用户实现其派生类.派生类只将这些虚函数作为公共函数,而一些其他方法应该作为私有实现,因为我的代码不会调用它们.我不知道这是否可以被认为是OOP的一个好习惯(有没有设计模式？).无论如何,我的问题是:用户可以重载纯虚函数吗？

即

class Base
{
public:
 Base();
 virtual ~Base();
 virtual void foo(int,double)=0;
};

class Derived:
public Base
{
 private:
  // methods
 public:
 Derived();
 virtual ~Derived();
 virtual void foo(int, double, double); //this doesn't work
 };

解决方案可能是:

 virtual void foo(int,double,double=0)=0;

在基类但它是非常有限的.你有什么想法？

谁能帮助解释这种意想不到的行为？

前提

我创建了包含成员std::thread变量的类Thread .Thread的ctor构造成员,std::thread提供指向静态函数的指针,该函数调用纯虚函数(由基类实现).

代码

#include <iostream>
#include <thread>
#include <chrono>

namespace
{

class Thread
{
public:
    Thread()
        : mThread(ThreadStart, this)
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl; // This line commented later in the question.
    }

    virtual ~Thread() { }

    static void ThreadStart(void* pObj)
    {
        ((Thread*)pObj)->Run();
    }

    void join()
    {
        mThread.join();
    }

    virtual void Run() = 0;

protected:
    std::thread mThread;
};

class Verbose
{
public:
    Verbose(int i) { std::cout << __PRETTY_FUNCTION__ << ": " << i …