C ++指向基类的指针尚未获得派生类成员函数，但使用派生创建了指针

Question

我做了一个类，它是指向基类的指针的容器。 我可以添加基类对象以及派生类对象。 但是，当我尝试使用派生类对象的函数时，出现编译错误“'Base'类没有名为'name'的成员”。 代码如下所示：

    #include <cstdio>
    #include <vector>

    using namespace std;

    enum Type{
        obj,
        obj1,
        obj2
    };

    class Base{
        public:
            void fun(){
                printf("I'm base\n");
            }
    };

    class Derived1 : public Base{
        public:
            void fun2(){
                printf("I'm derived1\n");
            }
    };

    class Derived2 : public Base{
        public:
            void fun3(){
                printf("I'm derived2\n");
            }
    };

    class myVector{
        private:
            vector<Base*> objects;
        public:
            void add(Type type){
                switch(type){
                    case obj:
                        objects.push_back(new Base);
                        break;
                    case obj1:
                        objects.push_back(new Derived1);
                        break;
                    case obj2:
                        objects.push_back(new Derived2);
                        break;
                }
            }

            Base* operator[](unsigned index){
                return objects[index];
            }
    };

    int main(){
        myVector vec;
        vec.add(obj);
        vec.add(obj1);
        vec.add(obj2);
        vec[0]->fun();     // ok
        vec[1]->fun1();    // error "Base" has not member named "fun1"
        vec[2]->fun2();    // error "Base" has not member named "fun2"
    }

它应该打印

我是基地
我是派生1
我是派生2

但是我在注释中的代码中遇到了编译错误

Answer 1

您只应使其成为虚函数并在派生类中重写它

#include <cstdio>
#include <vector>

using namespace std;

enum Type{
    obj,
    obj1,
    obj2
};

class Base{
    public:
        virtual void fun(){
            printf("I'm base\n");
        }
};

class Derived1 : public Base{
    public:
        void fun(){
            printf("I'm derived1\n");
        }
};

class Derived2 : public Base{
    public:
        void fun(){
            printf("I'm derived2\n");
        }
};

class myVector{
    private:
        vector<Base*> objects;
    public:
        void add(Type type){
            switch(type){
                case obj:
                    objects.push_back(new Base);
                    break;
                case obj1:
                    objects.push_back(new Derived1);
                    break;
                case obj2:
                    objects.push_back(new Derived2);
                    break;
            }
        }

        Base* operator[](unsigned index){
            return objects[index];
        }
};

int main(){
    myVector vec;
    vec.add(obj);
    vec.add(obj1);
    vec.add(obj2);
    vec[0]->fun();     // ok
    vec[1]->fun();     // now it works
    vec[2]->fun();     // now it works
}

Answer 2

C ++在编译时静态解析名称。 您告诉它您有一个Base* 。 这些是您可以通过该指针在该对象上使用的名称。 想要访问“ Derived ，则必须进行转换。

Answer 3

如果希望能够通过基类指针调用方法，则需要在基类中定义这些方法（也许是纯虚拟方法）。

如果知道您有一个子类对象，则可能需要static_cast （或者也许dynamic_cast和test），然后通过static_cast指针调用该方法。

如果不了解fun1()和fun2()的语义，就不可能知道哪种选择最适合您的情况。

这是一个满足您需要的版本-请注意， Base::fun被声明为virtual ，子类实现将其覆盖。

#include <iostream>
#include <vector>

struct Base {
    virtual void fun() const {
        std::cout << "I'm base" << std::endl;
    }
    virtual ~Base() = default;
};

struct Derived1 : public Base{
    void fun() const override {
        std::cout <<  "I'm derived1" << std::endl;
    }
};

struct Derived2 : public Base{
    void fun() const override {
        std::cout << "I'm derived2" << std::endl;
    }
};

int main(){
    std::vector<Base*> vec{new Base(), new Derived1(), new Derived2()};
    vec[0]->fun();
    vec[1]->fun();
    vec[2]->fun();

    // cleanup
    for (auto e: vec)
        delete e;
}