Question

我试图实现以下功能：

private void generateLogon()

其中 p 实际上是一个指向int值的 n-levels 指针，该函数必须返回该值。所以：

n = 0 ：int foo(const void *p, unsigned int n);
n = 1 ：value = (int)(p);
n = 2 ：p是指向int值的指针

等等......

所以，我认为以下实施可能是正确的：

value = *(int*)(p);

但是，在这段代码中，我假设指针的大小总是等于int的大小，我知道它不是真的。但是，由于 p 始终是指向int（ n 次）的指针，我想也许我总是可以将 p 强制转换为指向像我在代码中那样使用int。

我的想法是否正确？我在互联网上找不到类似的问题。

提前致谢！

Answer 1

您递归的底部情况不正确，因为这假设void*和int具有相同的宽度。

if (n == 1) return *(int*)p;

会更好。

Answer 2

我不确定你想要完成什么，但我怀疑有更好的方法。

无论如何，指向某事物的指针与指向某物的指针的指针大小相同。

所以你可以将（void *）转换为（void **）。

但是，将指针强制转换为int可能会丢失信息，因为sizeof(void*)可能是＆gt; sizeof(int)。

你应该写：

int foo(const void *p, unsigned int n) {

    //if n is 0, then p is already an int, but has been casted to a void*
    //This should probably never happend, so you should assert that n > 0

    //if n is 1, then p is actually a pointer to an int
    if (n == 1) return *(int*)p; 

    //else dereference it (by casting it to a (void**) and *then* dereferencing it)
    return foo(*(void**)p, n-1);
}

Answer 3

这假设您的int不大于void*：

int foo(const void *p, unsigned int n) {
  if (!n) {
    return reinterpret_cast<int>(p);
  }

  return foo(*static_cast<void**>(p), n - 1);
}

除了n=0案例之外，我们可以避免这种假设：

int foo(const void *p, unsigned int n) {
  if (!n) {
    return reinterpret_cast<int>(p);
  }
  if (n==1) {
    return *static_cast<int*>(p);
  }

  return foo(*static_cast<void**>(p), n - 1);
}

在C中，您可以将static_cast<X>和reinterpret_cast<X>条款替换为(X)。

Answer 4

一般情况下，如果可能，最好坚持使用迭代解决方案，而不是递归。

int foo(void *p, unsigned int n) {
    for (unsigned int i = 0; i < n; ++i) {
        p = *((void**)p);
    }
    return (int)p;
}

IDEONE：demo

它可以让你避免大概n的理论上可能堆栈溢出的问题（我不知道为什么你需要取消引用1000+级别的深指针，但我不知道为什么你首先需要这个函数，所以让我们保持函数安全）并避免不必要的函数调用开销（是的，它可能会被编译器优化，但为什么不首先以最佳方式写它？）

如何取消引用指向int指针的n级void指针

4 个答案: