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. from 的返回值malloc()是 avoid*这就是我们将其转换为的原因，char*因为这就是我们想要使用此内存的原因。这是操作系统分配给您使用void*的您请求（通过调用）的内存的位置。malloc()为了实际使用此内存，您需要取消引用（即*运算符）内存位置。所以在我们分配了这个内存之后，我们可以尝试类似

*x = 'a';

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

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

重要的是要注意，sizeof(int*) == sizeof(char*)即使sizeof(int) != sizeof(char). 这是一个重要的区别。请注意第一个比较如何比较指针地址的大小，第二个比较如何比较数据结构的大小（或者，在这种情况下，类型基元）。这很重要的原因是它使您上面的代码能够实际工作。由于所有指针地址的大小相同，因此您可以创建一个数组void*并在其中存储您希望的任何指针类型，而不会覆盖缓冲区（即每个指针都很好地array[i]分别适合）。of 的强大之void*处在于您可以将任何东西作为 a 传递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*几乎是任何“香草”类型（因为从技术上讲，您可以转换为任何东西，但如果您没有适当地访问内存，您肯定会崩溃）。但是您不能取消引用或对 a 进行任何实际工作，void*因此您需要知道内存实际上是什么才能将其回退。无论如何，值得注意的C++是，不使用()默认/空构造函数被认为是一种好习惯 - 所以就new float;可以了。

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

C++最好使用多态性来做到这一点。例如，创建一个“Ball”指针数组，它们都是 class 的（至少有一个基类）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];

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

Answer 2

指针是一个“整数”数字，它可以指向内存中你想要的任何东西，如果你有 void *array，它表示你有一个名为数组的 void 指针，现在取决于你如何使用它，你可以将它类型转换为 int 或其他事物和对象。

如果您使用创建指针数组的 void *array[10]，那么现在如何使用指针由您决定。您可以创建对象或将它们分配给您想要的任何数据类型，但这不是类型安全的，因为它是一个没有类型规范的空指针。它还需要强类型转换才能与数据类型一起使用。

从技术上讲，您可以在该数组中拥有具有不同数据类型的每个指针。