Question

代码示例只是对我的实际程序的简单模拟，它试图从基本向量中的单个基类中保存不同的类。然后使用虚函数调用来获取* this，返回派生。这样我就不需要多个容器了。

    #include "stdafx.h"
#include <iostream>
#include <vector>

class Base
{
public:
    virtual Base* getThis() { return this; }
    virtual void printClass() const { std::cout << "Base" << std::endl; }
};

class Derived : public Base
{
public:
    virtual Derived* getThis() { return this; }
    virtual void printClass() const { std::cout << "Derived" << std::endl; }
};


int main(int argc, _TCHAR* argv[])
{   
    Base Bar;
    Derived Foo;

    typedef std::vector<Base*> vContainer;

    vContainer Objects;
    Objects.push_back(new Derived);

    for (vContainer::iterator it = Objects.begin(); it != Objects.end(); ++it)
    {
        Bar = **it; // works to get Base but not wanted

        // attempts     
        //Foo = it->getThis(); // the pointer selector doesnt work...
        //Foo = static_cast<Derived>(**it);  // utterly confused!       
    }

    Bar.printClass(); // prints base as expected
    //Foo.printClass();  // Mean't to print Derived

    std::cin.get();
    return 0;
}

我一直在寻找一个更好的理解这几个小时，但每个人只是谈论克隆，这不是我想要的。任何帮助将不胜感激。

尼尔

Answer 1

为安全起见，请使用dynamic_cast。

for (vContainer::iterator it = Objects.begin(); it != Objects.end(); ++it)
{
    Bar* basePtr = *it;
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
    if ( derivedPtr ) // Check whether the dynamic_cast was successful.
    {
       // Use derivedPtr
    }
}

Answer 2

您的代码

Bar = **it; // works to get Base but not wanted

没有从vector到Bar的对象。这只是与这一个相同的赋值（添加了一些输出）：

class Base
{
public:
    virtual Base* getThis() { return this; }
    virtual void printClass() const { std::cout << "Base" << std::endl; }
    Base& operator=(Base& one) { std::cout << "operator = is working" << std::endl; return *this;}
};

所以，如果你想拥有存储在向量中的对象的指针，不要试图复制对象，复制指针（* iterator）。

Answer 3

您尝试实现的是虚方法的全部目的，即无论静态类型如何，该方法的动态绑定。您所要做的就是使用指针或对容器中这些对象的引用。请查看以下代码：

#include <iostream>
#include <vector>

class Base
{
public:
    virtual void printClass() const { std::cout << "Base" << std::endl; }
};

   class Derived : public Base
{
public:
    Derived(){};
    virtual void printClass() const { std::cout << "Derived" << std::endl; }
};


int main()
{   

    typedef std::vector<Base*> vContainer;

    vContainer Objects;
    Objects.push_back(new Base);
    Objects.push_back(new Derived);


    for (vContainer::iterator it = Objects.begin(); it != Objects.end(); ++it)
    {
         // prints Base on 1st iteration
         // prints Derived on 2nd iteration
        (*it)->printClass();
   }

    return 0;
}

你的尝试不起作用的原因是Bar是局部变量而不是引用/指针。这意味着内存中Bar的大小是在编译时确定的，并且是sizeof（Base）。将Derived对象分配到其中将按值复制对象并自动删除存储在Derived对象中的额外信息并将其作为Base对象（额外信息无法存储在该数量的内存中）。如果bar的类型为Base *并且您指向Derived对象，那么Bar-＆gt; printClass（）将打印Derived。

希望澄清它。

如何使用协变返回从基类中检索派生类？

3 个答案: