c++ - 在 C++ 中使用抽象类

Question

在将扩展对象作为参数传递给函数时，我尝试使用抽象类，但到目前为止我的尝试导致了一些编译器错误。

我有一些关于问题所在的线索，我显然不允许实例化抽象类，而且我相信 MyClass 中的一些代码正在尝试这样做，即使这不是我的意图。一些研究表明我应该将该对象作为指针引用来实现我想要的，但到目前为止我的尝试都失败了，我什至不确定这是不是答案（因此我在这里问）。

现在我将提交我对 Java 比对 C++ 更熟悉，并且我确信我的部分问题是由于这个。

这是我在我的程序中尝试做的一个例子：

class A {
    public:
        virtual void action() = 0;
};

class B : public A {
    public:
        B() {}

        void action() {
            // Do stuff
        }
};

class MyClass {

    public:

        void setInstance(A newInstance) {
            instance = newInstance;
        }

        void doSomething() {
            instance.action();
        }

    private:

        A instance;
};

int main(int argc, char** argv) {
    MyClass c;
    B myInstance;
    c.setInstance(myInstance);
    c.doSomething();
    return 0;
}

此示例产生了与我在程序中遇到的相同的编译器错误：

sean@SEAN-PC:~/Desktop$ gcc -o test test.cpp
test.cpp:20: error: cannot declare parameter ‘newInstance’ to be of abstract type ‘A’
test.cpp:2: note:   because the following virtual functions are pure within ‘A’:
test.cpp:4: note:   virtual void A::action()
test.cpp:30: error: cannot declare field ‘MyClass::instance’ to be of abstract type ‘A’
test.cpp:2: note:   since type ‘A’ has pure virtual functions
test.cpp: In function ‘int main(int, char**)’:
test.cpp:36: error: cannot allocate an object of abstract type ‘A’
test.cpp:2: note:   since type ‘A’ has pure virtual functions

更新

感谢大家的反馈。

从那以后，我将“MyClass::instance”更改为包含 A 类型的指针，但现在我得到了一些与 vtable 相关的奇怪错误：

sean@SEAN-PC:~/Desktop$ gcc -o test test.cpp
/tmp/ccoEdRxq.o:(.rodata._ZTI1B[typeinfo for B]+0x0): undefined reference to `vtable for __cxxabiv1::__si_class_type_info'
/tmp/ccoEdRxq.o:(.rodata._ZTI1A[typeinfo for A]+0x0): undefined reference to `vtable for __cxxabiv1::__class_type_info'
/tmp/ccoEdRxq.o:(.rodata._ZTV1A[vtable for A]+0x8): undefined reference to `__cxa_pure_virtual'
collect2: ld returned 1 exit status

我的修改代码如下（A和B没有修改）：

class MyClass {

    public:

        void setInstance(A* newInstance) {
            instance = newInstance;
        }

        void doSomething() {
            instance->action();
        }

    private:

        A* instance;
};

int main(int argc, char** argv) {
    MyClass c;
    B myInstance;
    c.setInstance(&myInstance);
    c.doSomething();
    return 0;
}

score 27 · Accepted Answer

您的问题是您应该在函数中接受引用。原因是引用实际上并没有复制传递的参数。但是，如果您接受A- 而不是引用A&- 那么您实际上将传递的参数复制到参数对象中，而您得到的是一个类型的对象A- 但实际上这是不允许的！

    // the reference parameter will reference the actual argument
    void setInstance(A &newInstance) {
            // assign the address of the argument to the pointer member
            // instance. 
            instance = &newInstance;
    }

然后您必须将类中的成员更改为指针。它不能是一个引用，因为setInstance它会改变它所引用的内容——一个引用在其整个生命周期内只能引用一个对象，而一个指针可以通过重新分配一个不同的地址来设置指向做不同的事情。剩下的部分看起来像这样

    void doSomething() {
        // call a member function on the object pointed to
        // by instance!
        instance->action();
    }

private:

    // a pointer to some object derived from A
    A *instance;

另请注意，您必须使用编译 C++ 程序g++，因为它另外将 C++ 标准库链接到您的代码

g++ -o test test.cpp # instead of gcc!

score 5 · Accepted Answer

您所做的将在 Java 中起作用，因为声明“A”类型的参数或成员变量实际上意味着“指向 A 的指针”。在 C++ 中，您实际上需要明确这一点，因为它们是两个不同的东西：

void setInstance(A* newInstance) { // pointer to an "A"
                instance = newInstance;
}

并在声明中：

A* instance; // Not an actual "A", but a pointer to an "A"

score 3 · Accepted Answer

我相信这就是你想要做的。它通过实际打印出取决于句柄类是否指向 B 或 C 的实例来演示多态性。其他人是正确的，您可能还需要一个虚拟析构函数。

这编译： g++ test.cpp -o Test

#include <stdio.h>

class A {
    public:
        virtual void action() = 0;
};

class B : public A {
    public:
        B() {}

        void action() {
                printf("Hello World\n");
        }
};

class C : public A {
    public:
        C() {}

        void action() {
                printf("Goodbye World\n");
        }
};

class AHandleClass {

    public:

        void setInstance(A *A_Instance) {
                APointer = A_Instance;
        }

        void doSomething() {
                APointer->action();
        }

    private:

        A *APointer;
};

int main(int argc, char** argv) {
    AHandleClass AHandle;
    B BInstance;
    C CInstance;
    AHandle.setInstance(&BInstance);
    AHandle.doSomething();
    AHandle.setInstance(&CInstance);
    AHandle.doSomething();
    return 0;
}

score 3 · Accepted Answer

你现在的问题是一个链接。对于 C++ 程序，必须添加标准 C++ 库：

gcc -o 测试-lstdc++测试.cpp

score 1 · Accepted Answer

您应该将 A 存储为指针。

A* instance;

编辑：我之前写过“参考”。C ++中存在差异。

score 1 · Accepted Answer

如果您辞去 setter 并使用构造函数，则不必使用指针。这是 C++ 的重要特性之一：构造函数中的基本初始化程序通常允许避免使用指针。

class MyClass {

        public:

                MyClass(A & newInstance) : instance(newInstance) {
                }

                void doSomething() {
                        instance.action();
                }

        private:

                A & instance;
};



int main(int argc, char** argv) {
        B myInstance;
        MyClass c(myInstance);

score 1 · Accepted Answer

我之前包含了这个parent.h问题iostream：

错误的：

include "parent.h"
include <iostream>

对：

include <iostream>
include "parent.h"

score 1 · Accepted Answer

Johannes Schaub - litb 是正确的。

在 C++ 中，抽象类不能用作函数的参数或返回类型。我们不能实例化一个抽象对象。

所以需要使用&或*。

score 0 · Accepted Answer

您必须使用指向 A 的指针作为 MyClass 的成员。

class MyClass {

    public:

        void setInstance(A *newInstance) {
                instance = newInstance;
        }

        void doSomething() {
                instance->action();
        }

    private:

        A *instance;
};

如果您不这样做，MyClass 构造函数将尝试实例化一个 A 对象（就像对任何成员对象一样），这是不可能的，因为 A 是抽象的。

score 0 · Accepted Answer

当你说

A instance;

您将创建一个类型为 A 的新对象。但是您已经说过 A 是一个抽象类，所以您不能这样做。正如其他几个人所指出的那样，您需要使用指针，或者使 A 非抽象。

score 0 · Accepted Answer

Dmitry 是正确的，如果你使用 gcc，你应该使用 -lstdc++，但更好的是使用它g++。（相同的语法）。
此外，您会注意到（我猜如果您添加 -Wall）您会收到警告说您的带有虚函数的类没有析构函数，所以一个好主意是向 A 添加一个（虚拟）析构函数。

c++ - 在 C++ 中使用抽象类

更新

11 回答 11

Related

Reference