c++ 指向基类的指针没有派生类成员函数，但指针是用派生的

Question

我创建了一个类，它是指向基类的指针的容器。我可以添加基类对象以及派生类对象。但是，当我尝试使用派生类对象中的函数时，出现编译错误“'Base' class has not member named '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

但我在 cmets 中的代码中出现编译错误

Answer 1

C++ 在编译时静态解析名称。你告诉它你有一个Base*。这些是您可以通过该指针在该对象上使用的名称。想要访问Derived 中的那些你必须投射。

Answer 2

你应该把它变成一个虚函数并在派生类中重写它

#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 3

如果您希望能够通过基类指针调用方法，那么这些方法需要在基类中定义（可能是纯虚方法）。

如果你知道你有一个子类对象，你可能想static_cast（或者可能dynamic_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;
}