C++ 如何使用纯虚拟类

我有一个关于类声明的非常愚蠢的基本问题

假设我有一个类（名为class_a），根据我的理解，如果我想从这个类创建一个新对象，我将使用以下代码：

class_a* myclass=new class_a(); 

现在我不确定在这种情况下会发生什么：

class_a* myclass;

class_a* myclass;

---

这只是我正在使用的已经创建的myclass的引用，它可能是在其他地方创建的，还是这也创建了一个新类？

您的问题似乎与“纯虚拟类”无关。除此之外

根据我的理解，如果我想从这个类创建一个新对象，我将使用以下代码

不一定，你可以说

class_a myclass;

现在我不确定在这种情况下会发生什么：

class\u a*myclass

您正在声明一个名为
myclass
的指向
class\u a
的指针。它不指向任何有用的东西，也不在任何地方实例化任何
class\u a
对象

class_a* myclass;

声明一个名为
myclass
的变量。该变量包含指向
class\u a
的指针，但未初始化（尤其是未创建class
class\u a
的对象）

取消引用未初始化的变量将导致错误

是在堆栈上创建的变量。它包含垃圾值（无效的内存地址）。
要使其引用（指向）有效的内存位置或“存储
a类
值的房屋”您可以执行以下操作：

myclass= new deriv_class_a();

或

myclass=&class的某些类型

要访问该房屋及其价值，您可以执行以下操作：

（*myclass）。
*
是取消引用的取消引用运算符，并且

“
是访问其值的句点运算符。
或同时取消引用和访问：

myclass->someValue
因此在两种情况下：

class_a* myclass = new class_a(); 

在这种情况下，将创建一个指向
class_a
的指针，然后在堆上创建
class_a
的实例，并将指针设置为新创建实例的地址

在这种情况下：

class_a* myclass;

class_a* myclass;

已定义指针，但未创建实例。正因为如此，
myclass
指向零。只有将该指针分配给
类\u a
（或派生类）的实例，才能使用该指针。尝试使用未指向
类a
实例的指针将导致未定义的行为，这可能（或可能不会）导致程序崩溃。
假设类是纯虚拟类：

class class_a
{
public:
  virtual void foo() = 0;
};

。。。那么你就不能实例化它了。相反，您可以/必须实例化从该类派生（子类或继承其接口）的非纯虚拟类：

class class_b : public class_a
{
public:
  virtual void foo() { printf("hello"); }
};

所以这是非法的：

class_a* myclass = new class_a(); // illegal because class_a is pure virtual

这是合法的：

class_a* myclass = new class_b(); // legal because class_b is not pure virtual

上面的语句使用
new
关键字在堆上创建类_b的实例

新实例的地址被分配给
class\u a*
指针，这是合法的，因为

要在堆栈上创建实例，请执行以下操作：

class_a myclass_a; // illegal because class_a is pure virtual

class_b myclass_b; // legal because class_b is not pure virtual

class_a* ptr_myclass_a = &myclass_b; // this is legal too

下面定义了一个指针，但没有初始化（为指针指定任何定义的值），也没有为指针创建类或实例：

class_a* myclass;

在初始化未初始化的指针之前，您不能使用（取消引用）它。
纯虚拟类是一个不打算直接使用的类，而是作为其他类的基础，但您的问题主体似乎真的在谈论指针，所以我将试着解释一下它们

让我们先看看
int

int x = 7;

将
x
设置为7

现在我们可以开始了

int * y;

这将创建一个指向
int
的指针，该指针不指向任何地方，因此无法使用

y = new int;

现在
y
可以用作

*y =7;

当我们完成
y
时，我们需要返回它的内存。既然我们做了一个
new
，我们需要做一个
delete
。通常，每个
新
必须与一个
删除

delete y;

但是
y
仍然是一个指针，但由于它指向已删除（不可用）的内存，我们现在无法使用它。如果我们将它指向另一个有效的内存地址，则可以再次使用它：

y=&x;

&
表示获取指向
x
的指针或地址。现在
y
指向
x
拥有的内存

*y = 3;  // note that x == 3 now since the memory is the shared

这也会将
x
的值更改为3，因为
x
和
*y
是访问同一内存的两种不同方式。当我们处理完
y
时，不要删除它，因为
x
拥有内存，如果执行
删除y
，很可能会发生非常糟糕的事情

同样，我们可以将其应用于类：

myclass a;

myclass * b=new myclass;

myclass * c=b;

c=&a;

delete b;

学习一些关于变量声明、定义和初始化的知识。这可能有助于我编辑您问题的标题，以更好地反映您的问题。@KarlNicoll我已恢复您的编辑，因为OP可能有意询问“纯虚拟”。@KarlNicoll您的新标题不能很好地反映他们的问题。OP似乎认为创建一个新对象需要一个指针，而事实并非如此。@ChrisW-没问题，但我在问题内容中没有看到任何一条信息将其与纯虚拟对象联系起来。这个问题完全讨论了基本的堆分配。也许OP需要澄清他或她的问题。但是
新类a（）
如果类a是“纯虚拟的”就不合法。@ChrisW你是对的，我会解决它。但我认为这里的困惑在于如何使用类指针。详细解释请参见+1。很遗憾看到最好的答案在底部。