c++ 多个子类动态重写基类空类(抽象类)

本文介绍: 所以如果需要一个动态的、不受作用域限制的对象,还是需要通过 new在堆上创建,这才能返回一个指针使用,也不会有栈空间的限制。类的定义只是描述了类的结构和行为，但并没有实际创建对象或分配内存空间。这种情况下,su b class1对象会直接在栈空间上创建,而不会在堆空间上动态分配。而对象的创建才会真正地分配内存。对象可以在栈上创建,也可以在堆上创建。类的对象时，需要在堆或栈上分配内存空间来实例化对象。类的定义只是建立了一个类的蓝图,并没有实际创建任何对象占用内存。在C++中,类的定义和对象的创建是两个不同的概念。

基类:

纯虚函数1

纯虚函数2

纯虚函数3

纯虚函数4

x 函数(使用纯虚函数1 2 3 4 功能)

子类1:基类
 重写纯虚函数1 2 3 4 添加功能
 运行: 子类运行基类中 x函数

class BaseClass {
public:
  virtual void pureVirtualFunction1() = 0;
  virtual void pureVirtualFunction2() = 0;
  virtual void pureVirtualFunction3() = 0;
  virtual void pureVirtualFunction4() = 0;

  void xFunction() { # 非虚成员函数 在公共区域内存 子类只能调到基类的同名非虚函数
    pureVirtualFunction1();
    pureVirtualFunction2();
    pureVirtualFunction3();
    pureVirtualFunction4();
  }
};

class Subclass1 : public BaseClass {
public:
  void pureVirtualFunction1() override {
    // Implementation of pureVirtualFunction1()
  }

  void pureVirtualFunction2() override {
    // Implementation of pureVirtualFunction2()
  }

  void pureVirtualFunction3() override {
    // Implementation of pureVirtualFunction3()
  }

  void pureVirtualFunction4() override {
    // Implementation of pureVirtualFunction4()
  }
};

int main() {
  Subclass1* subclass1 = new Subclass1();
  subclass1-&gt;xFunction();
  delete subclass1
  return 0;
}

运行就是: 创建对象(给类的各个成员分配内存按逻辑(构造函数)运行)

int main() {
Subclas s1 subclass1;
subclass1.xFunction();
return 0;
}

这种情况下,subclass1对象会直接在栈空间上创建,而不会在堆空间上动态分配。

但是这种栈上创建的对象有一定的限制:

1. 栈空间内存有限,对象过大可能会栈溢出
2. 出了作用域后对象会被自动销毁
3. 无法返回对象的指针或引用给外部

所以如果需要一个动态的、不受作用域限制的对象,还是需要通过 new在堆上创建,这才能返回一个指针使用,也不会有栈空间的限制。

在C++中,类的定义和对象的创建是两个不同的概念。

类的定义只是建立了一个类的蓝图,并没有实际创建任何对象占用内存。

而对象的创建才会真正地分配内存。对象可以在栈上创建,也可以在堆上创建。

定义的类Subclass1并没有在定义时就分配内存空间。类的定义只是描述了类的结构和行为，但并没有实际创建对象或分配内存空间。因此，当您想要使用Subclass1类的对象时，需要在堆或栈上分配内存空间来实例化对象。在C++中，使用new关键字可以在堆上分配内存空间来创建对象。如果您不想在堆上创建对象，也可以直接声明一个Subclass1类型的对象，例如Subclass1 subclass1;，这样会在栈上分配内存空间来创建对象。