Question

我有以下非常愚蠢的基本问题，涉及类的声明。

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

class_a* myclass=new class_a();

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

class_a* myclass;

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

Answer 1

在

class_a* myclass;

声明一个名为myclass的变量。该变量包含指向class_a的指针，但未初始化（特别是，没有创建类class_a的对象）。

取消引用未初始化的变量会产生undefined behaviour。

Answer 2

class_a* myclass;

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

myclass= new deriv_class_a();

或者

myclass= &some_type_of_class_a;

要访问该房屋及其价值，您可以这样做：

(*myclass). *是取消引用的解引用运算符，

"."是期间运算符以访问其值。或者同时取消引用和访问权限：

myclass->someValue

Answer 3

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

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

不一定，你可以说

class_a myclass;

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

您正在声明指向名为class_a的{{1}}的指针。它没有指向任何有用的东西，也没有在任何地方实例化任何myclass个对象。

Answer 4

假设class_s是纯虚拟类：

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关键字在堆上创建了一个class_b实例。

新实例的地址已分配给class_a*指针，这是合法的，因为class_b is-a class_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实例指向：

class_a* myclass;

在初始化之前，不得使用（取消引用）未初始化的指针。

Answer 5

所以在你的两个场景中：

class_a* myclass = new class_a();

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

在这种情况下：

class_a* myclass;

已定义指针，但未创建任何实例。因此，myclass指向什么都没有。在将其指定给class_a（或派生类）的实例之前，不能使用此指针。尝试使用未指向class_a实例的指针将导致未定义的行为，这可能（或可能不会）导致程序崩溃。

Answer 6

纯虚拟类是一个不是直接使用的类，而是作为其他类的基础，但是你的问题主体似乎真的在谈论指针，所以我会尝试解释它们。

让我们先看看int

int x = 7;

将x设为7

现在我们可以设置

int * y;

这将创建一个指向int的指针，该指针不指向任何位置，因此它无法使用;

y = new int;

现在y可以用作

*y =7;

当我们完成y时，我们需要回馈它的内存。由于我们执行了new，我们需要执行delete。通常，每个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拥有内存，如果执行delete y，可能会发生非常糟糕的事情。

我们可以将它应用于类：

myclass a;

myclass * b=new myclass;

myclass * c=b;

c=&a;

delete b;

如何使用纯虚拟类

6 个答案: