Question

class MainClass
{
    string _ClassName;
public:
    string MainClass(string _C)
    {
        _ClassName = _C;
    }

    SubClass s1;

};

class SubClass : public MainClass
{
public:
    string Method_1()
    {
        return a;
    }
     string Method_2()
    {
        return a;
    }

};

为什么 SubClass s1 不起作用有人可以告诉我我错过了什么我是 OOP 的新手。我想在 MainClass 中实例化 SubClass 对象，但它似乎不起作用。基本上，我的目标是在 MainClass 对象在 Main 方法中实例化时访问 SubClass 函数，如下所示：

int Main()
{
  MainClass M1("test");
  M1.s1.Method_1();    <--------- this
}

Answer 1

第一个问题是，当您尝试实例化对象时，MainClass 对 SubClass 一无所知。

您需要使用前向声明和指针才能使其工作。

头文件：

class SubClass;    //Forward declaration, allows pointer.
class MainClass
{
    string _ClassName;
public:
    MainClass(string _C); //No return type on constructor
    ~MainClass();

    SubClass *s1;    //Size: 4 Bytes on 32bit system

    protected:
        MainClass();

};

class SubClass : public MainClass
{
public:
    string Method_1();
    string Method_2();
};

CPP 文件：

#include "headerFile.h"

MainClass::MainClass(string _C) : 
    _ClassName(_C),
    s1(new SubClass)    //Class definition is now known.
{
}

MainClass::MainClass() : s1(nullptr)    //Nullptr -> No new object, no infinite recursion.
{
}

MainClass::~MainClass() 
{
    delete s1;    //Do not forget to clean up your pointer.
}

string SubClass::Method_1()
{
    return "a";
}

string SubClass::Method_2()
{
    return "a";
}

调用：

int main()
{
  MainClass M1("test");
  M1.s1->Method_1();    //-> to dereference the pointer.
}

正如 Richard Critten 所指出的，第二个问题是无限递归，这会导致您的程序很快崩溃。

每次实例化一个 SubClass 时，你也创建了一个子类，它创建了另一个 MainClass 等

为了避免这种情况，您需要一个受保护的构造函数，它不会创建子类成员。

第三个问题：您在您的方法中返回 a，这表明了一个变量。如果你想返回'a'，你需要把它们放在引号中。

最后，为了编译它，你需要用一个小的 Main (m) 编写 int main()，否则链接器会报错。

但是，正如“不是数字”先生正确指出的那样，上述编辑只会使您的代码编译。

然而，您实际上可能会使用 virtual 函数，这些函数可以被子类覆盖以专门化行为。

使用实际继承的示例代码：

头文件：

class MainClass
{
    string _ClassName;
public:
    MainClass(string _C); //No return type on constructor
    virtual ~MainClass();    //All base classes that have at least one virtual method should also have a virtual destructor, even if it is empty.

    virtual void doSomething();
};

class SubClass : public MainClass
{
    public:
        SubClass(string className);
        void doSomething();
};

CPP 文件：

#include "headerFile.h"
#include <stdio.h>

MainClass::MainClass(string _C) : _ClassName(_C)
{
}

MainClass::~MainClass()
{}

void MainClass::doSomething()
{
    printf("Called from MainClass\n");
}

SubClass::SubClass(string className) : MainClass(className)
{
}

void SubClass::doSomething()
{
    printf("Called from SubClass\n");
}

调用：

int main()
{
    MainClass M1("test");
    SubClass sub("SubClass");
    MainClass *pointer = &sub;

    M1.doSomething();         //Outputs 'Called from MainClass'.
    sub.doSomething();        //Outputs 'Called from SubClass'.
    pointer->doSomething();   //Also outputs 'Called from SubClass', since it points to sub and because sub overrides the behaviour from MainClass.
}

要从子方法调用父方法，您需要从父类的覆盖中调用该方法。

示例（在 SubClass::doSomething 中）：MainClass::doSomething()。

C++ 继承（在基类中实例化派生类）

1 个答案: