c++ - 类型的指针数组

Question

今天由于汽车故障，我错过了课。将要输入的指针数组如下所示吗？

void *ary[10];
ary[0] = new int();
ary[1] = new float();

我还是有点模糊。

Answer 1

如果这是C代码，则需要指出一些注意事项。首先(如下所述)，new无效C。它在C++中有效，但是不能在C中以这种方式分配内存。相反，您将需要使用malloc()来分配内存和free()来代替C++的delete(这些功能包含在#include <stdlib.h>中)。

现在，针对您的评论。似乎您对指针实际上是什么感到困惑。指针是指向内存中某个位置的东西。也就是说，指针在您的系统上是某种类型的(例如unsigned long)，最终会保存一些数字。该数字是您分配的某些数据的存储位置(请注意，实际上由于虚拟内存，这些数字并不直接对应于物理RAM地址)。

所以在C中，当您执行以下操作时

char* x = (char*)malloc(sizeof(char));

您为单个 char分配了一块内存。 malloc()的返回值是 void*，这就是我们将其强制转换为 char*的原因，因为这就是我们要使用此内存的原因。此 void*是您请求的内存(通过调用 malloc())的位置，操作系统已将其分配给您使用。为了实际使用此内存，您需要取消引用(即 *运算符)内存位置。因此，在分配了此内存之后，我们可以尝试类似

*x = 'a';

现在，内存位置 x的值为 a。在代码中，这可以表示为

if(*x == 'a')
  printf("True");

重要的是要注意 sizeof(int*) == sizeof(char*)即使 sizeof(int) != sizeof(char)。这是一个重要的区别。请注意，第一个比较如何比较指针地址的大小，第二个比较如何比较数据结构的大小(在这种情况下为类型原语)。之所以重要，是因为它使您的上面的代码可以实际工作。由于所有指针地址的大小相同，因此您可以创建一个 void*数组，并在其中覆盖任何所需的指针类型，而无需覆盖缓冲区(即，每个指针分别适合 array[i])。 void*的强大功能是您可以将任何内容作为 void*传递(是的，您可以在技术上将任何内容强制转换为其他任何内容，但这有时很方便)。但是， void*的主要损失是您不能直接使用它。就是说，如果我有这样的代码:

void passData(void* data)
{
  char* x = (char*)data; // I _must_ do this to access the data
  printf("%s\n", x);
}

int main()
{
  char* x = (char*)malloc(10*sizeof(char));
  *x = "test";
  passData((void*)test);
  free(x);
  return 0;
}

我必须知道我的数据类型才能使用 void*(或者您必须使用元数据或类似数据才能知道如何处理)。

既然我们已经有了一些有关内存分配和指针实际作用的基础，那么我将谈谈您的意见。由于指针只是指向内存地址，因此，如果您有两个指向同一内存地址的指针，那么您仅需使用访问相同数据的方式。例如，请考虑以下代码段

#include <stdio.h>
int main()
{
  int x = 0; // Stack variable

  int* xPtr = &x; // & is the reference operator - it gives you the memory location of an object

  x = 5;

  printf("%d == %d\n", x, *xPtr); // xPtr == 5 since it points to the same memory location as x

  *xPtr = 10;

  printf("%d == %d\n", x, *xPtr); // x == 10 since we changed the value at the memory location of xPtr which is the same memory location which x is located at

  return 0;
}

如果您还不太了解指针的概念，那么下面的示例可能会更清晰一些，因为它仅处理堆内存:

#include <stdio.h>
int main()
{
  int* xPtr = (int*)malloc(sizeof(int));
  int* yPtr = xPtr; // Point yPtr to the same address as xPtr

  *xPtr = 10; // The value of xPtr == 10 and so does the value of yPtr since they point to the same place
  *yPtr = 12; // In a similar way, we modified the value again for both pointers.

  yPtr = NULL; // Unset the memory location of yPtr - now yPtr no longer points to the same memory location as xPtr.
               // In fact, now yPtr == NULL, so do _NOT_ try to dereference it or you will crash. In any event, the values of the pointers are now independent

  *xPtr = 15; // Memory at the location xPtr points to has changed to 15. But yPtr no longer points to that location, so the value at the location yPtr points to has not changed.

  yPtr = xPtr; // Change the memory location of yPtr to point to xPtr. Now yPtr's value is exactly the same as xPtr's value.

  free(xPtr); // Only free ONE of the items pointing to the same memory location (otherwise you will double free)
  return 0;
}

如您所见，您只是在访问内存中特定位置的数据。指针仅指向内存中的该位置。到处移动指针并使它们指向不同的位置称为 pointer manipulation。因此，这就是为什么您可以在一个位置更改内存，并且更改指向该内存位置的任何其他指针的值的原因。

原始回复(最初标记为 C++的问题)

实际上，您要做的更多是 C-style。这在技术上是有效的(只要您强制转换)，但是以后要对这些类型进行任何操作，您将必须确切地知道哪种类型在什么位置，并将其适当地强制返回。

在给出的示例中，您创建了一个可以容纳 void指针的数组。也就是说， void*几乎是任何“原始”类型(因为从技术上讲，您可以转换为任何东西，但是如果您没有适当地访问内存，则肯定会崩溃)。但是您不能取消引用或对 void*进行任何实际工作，因此您需要知道内存的实际内容才能将其回退。无论如何，要注意的是，在 C++中，最好不要对默认/空构造函数使用 ()-因此 new float;可以很好地工作。

之所以可以做到这一点而又不会搞砸任何东西(即不同的数据结构具有不同的大小)，是因为指针只是 ptr_t类型(在许多机器上可能是 unsigned long或类似的类型)。因此，实际上，指针只是指向内存中的某个位置，但是即使指向的对象的大小不同，所有指针(即地址)的大小也相同。

在 C++中，最好使用多态来执行此操作。例如，创建一个“球”指针数组，这些指针全部(至少是基类)为 Ball类。然后，您可以使它们更具体。例如，您可能有棒球，篮球等。

我不确定在没有适当上下文的情况下您要尝试什么，但这应该看起来像这样

#include <isotream>
using namespace std;
class Ball
{
public:
  virtual void ballType() const = 0;
};

class Basketball : public Ball
{
public:
  virtual void ballType() const {
    cout << "Basketball" << endl;
  }
};

class Baseball : public Ball
{
public:
  virtual void ballType() const {
    cout << "Baseball" << endl;
  }
};

然后，通常，如果您按如下方式使用它:

Ball* x[10];
x[0] = new Basketball;
x[1] = new Baseball;

x[0]->ballType();
x[1]->ballType();

delete x[0];
delete x[1];

这将打印“篮球”，后跟“棒球”。如果您可以提供有关您要做什么的更多信息，那么我可以更好地调整此答复以针对您的问题。