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

It is important to note that sizeof(int*) == sizeof(char*) even though sizeof(int) != sizeof(char). This is an important distinction. Notice how the first comparison compares sizes of pointer addresses and the second compares the size of the data structures (or, in this case, type primitives). The reason that this is important is that it enables your code above to actually work. Since all pointer addresses are of equal size, you can create an array of void* and store any pointer type you wish in it without overwriting the buffer (i.e. each pointer nicely fits in array[i] respectively). The power of void* is that you can pass anything as a void* (yes, you can technically cast anything to anything else, but this is convenient at times). The major loss of void*, however, is that you cannot directly use it. That said, if I have code like this:

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

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

我必须知道我的数据类型,以使用 (或你必须使用元数据或类似的元数据,知道如何处理)。

既然我们对记忆分配有某种依据,而且点人实际上做了些什么,我将谈谈你的意见。 既然点人只是记忆地址,如果你有两点人,注明了same记忆地址,那么你就不得不使用同样的数据。 例如,审议以下简称表

#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
", x, *xPtr); // xPtr == 5 since it points to the same memory location as x

  *xPtr = 10;

  printf("%d == %d
", 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;
}

你可以看到,你只是从记忆中获取特定地点的数据。 这位发言者只是要记住这个地点。 环绕点和向不同的地点点点点点点点点,称为<条码>点码>。 因此,你可以在某个地点改变记忆,并改变显示该记忆地点的任何其他点的价值。

www.un.org/spanish/ecosoc (问题原先编号C++)

在现实中,你做了更多的工作,即<条码>C型。 这在技术上是有效的(只要是你所投的),但为了在以后与这些类型做任何事,你必须知道exactly什么类型的位置,并适当退。

如你所示,你创建了一个阵列,可以持有<条码>。 也就是说, und* 基本上是指任何“vanilla”类型(因为你在技术上可以 anything取任何东西,但如果你不能适当获取你确信会坠毁的记忆)。 但是,你不能在<0> > void*上回避或做任何真正的工作,因此,你需要知道记忆是怎样的,才能回来。 无论如何,值得注意的是,在<代码>上。 C++ 据认为,不使用<代码>(<>>>>作为违约/无效建筑商使用的良好做法——即<代码>新浮动;将予以罚款。

如果不说明任何情况(即不同的数据结构有不同的大小),你就可以这样做,因为点人只是<代码>ptr_t。 类型(许多机器可能是unsign long或类似)。 因此,现实地说,点名人只是记忆中的某些地点,但所有点(即地址)的大小相同,即使点标的物体大小不同。

缩略语 最好利用多变方式做到这一点。 例如,创建一系列“Ball”点,所有点(至少是基级)为<代码>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];

这将印刷“篮球”,然后是“篮球”。 如果你能够就你所期望的做些什么提供更多情况,那么我就能够使这一反应更好地针对你的问题。