如何在C 中调用对象的虚拟函数

How to call virtual function of an object in C++

本文关键字：对象 虚拟 函数 调用      更新时间：2023-10-16

可能的重复：
覆盖父母的函数

我正在努力调用C 中的虚拟功能。

我在C 方面没有经验，我主要使用C＃和Java，所以我可能会有一些妄想，但是请忍受。

我必须编写一个程序，如果可能的话，我必须避免动态内存分配。我做了一个名为列表的课程：

template <class T> class List {
public:
    T items[maxListLength];
    int length;

    List() {
        length = 0;
    }
    T get(int i) const {
        if (i >= 0 && i < length) {
            return items[i];
        } else {
            throw "Out of range!";
        }
    };
    // set the value of an already existing element
    void set(int i, T p) {
        if (i >= 0 && i < length) {
            items[i] = p;
        } else {
            throw "Out of range!";
        }
    }
    // returns the index of the element
    int add(T p) {
        if (length >= maxListLength) {
            throw "Too many points!";
        }
        items[length] = p;
        return length++;
    }
    // removes and returns the last element;
    T pop() {
        if (length > 0) {
            return items[--length];
        } else {
            throw "There is no element to remove!";
        }
    }
};

它只是制成给定类型的数组，并管理它的长度。

不需要动态内存分配，我只能写下：

List<Object> objects;
MyObject obj;
objects.add(obj);

myObject继承形式对象。对象具有一个虚拟函数，该功能应在MyObject中被覆盖：

struct Object {
    virtual float method(const Input& input) {
        return 0.0f;
    }
};
struct MyObject: public Object {
    virtual float method(const Input& input) {
        return 1.0f;
    }
};

我得到的元素为：

objects.get(0).method(asdf);

问题是，即使第一个元素是myObject，也调用了对象的方法函数。我猜想将对象存储在一系列对象中，而不动态分配内存，但我不确定。

有没有办法调用MyObject的方法函数？如何？它应该是一个异质的收藏，所以这就是为什么首先存在继承的原因。

如果无法调用MyObject的方法函数，那么我应该首先列出我的列表？

我也无法访问Math.h和stdlib.h之外的库，因此不可用。例如。

您需要将指针存储在列表中。尝试以下操作：

List<Object*> objects;
Object *obj1 = new Object;
MyObject *obj2 = new MyObject;
Object *obj3 = new MyObject;
objects.add(obj1);
objects.add(obj2);
objects.add(obj3);
// This calls the implementation in Object class
objects.get(0)->method(asdf);
// This calls the implementation in MyObject class
objects.get(1)->method(asdf);
// This calls the implementation in MyObject class
// Polymorphism here
objects.get(2)->method(asdf);

希望这会有所帮助。

执行此操作时：

objects.add(obj);

您将MyObject的对象部分添加到列表中，因此它不再是MyObject。

您可能很想尝试这样做：

int add(T const &p) {
    if (length >= maxListLength) {
        throw "Too many points!";
    }
    items[length] = p; // now the problem is here
    return length++;
}

但是现在P的对象部分的副本发生在分配期间。

要使列表是异质的，它将必须是指针的列表，但是您也希望避免动态内存分配。如果您小心，可以避免动态内存分配：

 Object obj1;
 MyObject obj2;
 List<Object*> object_ptrs;
 object_ptrs.add(&obj1);
 object_ptrs.add(&obj2);
 object_ptr.get(1)->method(input);
 object_ptr.get(0)->method(input);

但是，您必须非常小心。该列表现在指向堆栈上的两个对象。如果您从此功能返回，那两个对象将被破坏。请注意，我故意将对象指针的列表放在对象之后，以便将列表在对象之前被销毁，因此不会将列表指向垃圾。但是，如果您返回列表的副本，您仍然会有问题。

相关文章：