【问题标题】:How can I change pointer parameter contents in C++如何在 C++ 中更改指针参数内容
【发布时间】:2016-03-23 06:20:05
【问题描述】:

给定一个函数声明:

void foo(void *ptr);

我无法更改函数的签名。 现在我需要在 foo 中分配内存,从 ptr 开始。 如果我写:

void foo(void *ptr) {
  ptr = malloc(NUM * sizeof(TYPE));
}

当我调用它时它实际上并没有改变指针的内容:

void *myPtr = NULL;
foo(myPtr);

而且我知道原因,因为我将 myPtr 的副本传递给 foo()。

我需要做的是将输入参数声明为指针的引用:

foo(void *& ptr) {
  ptr = malloc(...);
}

但是,我无法将输入类型从 (void *) 更改为 (void *&)。 我该如何解决这个问题?


我忘记了返回值不是签名的一部分,是的,我不能更改返回值。

我认为在 C++ 中我确实不能这样做。我必须在这个函数之外分配内存。

【问题讨论】:

  • 你能返回一个指针吗?
  • 除非您可以更改返回类型,否则您无能为力。顺便说一句,它是 C++,而不是 C/C++。
  • @kfsone - 你打算如何在不改变函数 sig 的情况下做到这一点?
  • @paperifish C 没有引用。
  • 是否允许传递指针地址而不是指针作为参数?您不必为此更改签名。

标签: c++ pointers


【解决方案1】:

如果不更改函数签名或调用站点,则无法实现您想要的。即一个非常肮脏的黑客将是:

void foo(void *ptr) {
  *((void **)ptr) = malloc(NUM * sizeof(TYPE));
}

int main() {
    void *myPtr = NULL;
    foo(&myPtr);
}

但是,对于大多数情况(特别是,如果您不想更改现有的调用站点),如果您编写一个新函数来执行您想要的操作并将 foo 封装为它,您可能会更好(反之亦然,具体取决于 foo 之前应该做什么):

void new_foo (void*& ptr ) {
     // ... whatever came before in the original foo
     ptr = malloc(NUM * sizeof(TYPE));
     // ... whatever came after in the original foo
}

void foo (void* ptr) {//<-- called on old call sites
     void * tptr=ptr;
     new_foo(tptr);
     // free(tptr) ?

}

int main() {
   void* ptr2=NULL;
   foo(ptr1) //<- old call site)

   //...

   void* ptr2=NULL;
   new_foo(ptr2); //<- new call site       
}

【讨论】:

  • 您可以在不触及这两者的情况下执行此操作(请参阅我的回答)。
  • @KerryLand 据我所知,您更改了调用站点(您现在调用的是 trap_foo 而不是 foo)
  • 这只是为了方便。如果您阅读我的回答,您会发现事实并非如此。您调用相同的函数,但使用陷阱钩子围绕对它的调用。 trap_foo 只是把它变成了一个辅助函数。
  • @KerryLAnd:你仍然调用必须调用某个函数(无论是foo_trap 还是trap_malloc_set,以`myPtr`(some_ptr)的地址作为参数。事实上,你必须明确地调用辅助函数意味着你必须控制调用站点。
  • 没有。这意味着您必须控制呼叫站点为那些需要它的人。我的意思是,您不必像您所说的那样更改“调用语法”。当且仅当您的代码需要检索指针时,您才调用包装函数。您的回答将使任何依赖旧界面的旧代码崩溃,因此必须更改 all 代码。我的没有这个要求。如果 OP 不能更改签名,很可能是因为该函数已经被大量使用,但现在需要被新代码使用,而仅仅为此更改旧代码可能并不可行。
【解决方案2】:

你真的应该问这个标记为 C 的问题——这种 void* 指针愚蠢行为在 C++ 中是不受欢迎的。尽管它是该语言的一部分,并且偶尔也有它的用途,但您可能更幸运地从寻找 C 问题的人那里获得所需的专业知识。

继续您的问题,我认为您想做的事情(至少您发布的示例)根本不可能——特别是:

void *myPtr = NULL;
foo(myPtr);

考虑一下您在这里实际在做什么。您正在声明一个具有 void* 类型的变量 myPtr,并为其分配一个占位符值——一个无效的内存区域 C 程序员调用 NULL,它通常为 0(C++ 程序员更喜欢 nullptr,它是一种特定类型,提供了一些安全性好处)。

现在你将它传递给 foo:

void foo(void *ptr) {
  ptr = malloc(NUM * sizeof(TYPE));
}

foo 接收到一个 NULL 指针——一个无效的内存地址,通常为 0。当你调用 ptr = malloc(...) 语句时,你的变量 ptr 获取 malloc 返回的内存地址的值——它为你并返回了一个地址指向到那个内存。

你没有修改变量myPtr的内容,它包含一个无效的内存地址NULL。

您需要更改函数的签名,以便它可以使用有效地址填充 myPtr —— 您刚刚分配的内存地址。你可以这样做:

 1:  void* foo(void* ptr) { return malloc(...);} // return the address.
 2:  void foo(void** ptr) { *ptr = malloc(...);} // ptr to ptr.
 3:  void foo(void*& ptr) { ptr = malloc(...);} // C++:  reference to ptr.

我没有看到任何其他方法。顺便说一句,我更喜欢选项 1,因为在阅读时最清楚发生了什么:

myPtr = foo(myPtr);

除非你对 foo 中的 myPtr 的内容做任何事情(例如,你正在检查它是否为空,否则分配),你应该丢失参数。

【讨论】:

    【解决方案3】:

    如果您可以在不更改其签名的情况下将代码移入/移出foo,并且这对于您的用例是可行的,您可以执行类似...

    void underlying_foo(void *ptr)
    {
        // Do the stuff.
    }
    
    void foo(void *ptr)
    {
        ptr = malloc(...);
        underlying_foo(ptr);
    }
    
    void new_foo(void **ptr)
    {
        *ptr = malloc(...);
        underlying_foo(*ptr);
    }
    

    如果您不想/不能对foo 扭曲太多,那么您可以使用这样的丑陋解决方法...

    #include <cstddef>
    
    static void **trap_malloc_trap = nullptr;
    
    void trap_malloc_set(void **trap)
    {
        trap_malloc_trap = trap;
    }
    
    void trap_malloc_unset()
    {
        trap_malloc_trap = nullptr;
    }
    
    void *trap_malloc(size_t size)
    {
        void *ptr = malloc(size);
        if(trap_malloc_trap != nullptr)
            *trap_malloc_trap = ptr;
    
        return ptr;
    }
    
    void foo(void *ptr)
    {
        ptr = trap_malloc(NUM * sizeof(TYPE));
        // Whatever else goes here...
    }
    

    那么……

    #include "foo_header.h"
    
    int main()
    {
        void *some_pointer;
        trap_malloc_set(&some_pointer):
        foo(some_pointer);
        trap_malloc_unset();
    
        return 0;
    }
    

    这样,任何调用原始函数的代码仍然可以工作,而需要检索指针的新代码可以使用trap_foo()。

    您可以使用另一个。它更快/更紧凑,但它会破坏任何依赖现有 API 的现有代码...

    void foo(void *trap_ptr)
    {
        void **ptr = (void**)trap_ptr;
        *ptr = malloc(NUM * sizeof(TYPE));
        // Et cetera...
    }
    

    那么……

    void hacky_foo(void **ptr)
    {
        foo((void*)ptr);
    }
    
    int main()
    {
        void *the_pointer;
        hacky_foo(&the_pointer);
    
        return 0;
    }
    

    【讨论】:

    • “解决方法”涉及调用不同的函数。还不如根本不使用foo,摆脱所有的复杂性。
    • 你能解释一下,是什么让第一个版本比第二个版本少?
    • @juanchopanza:更仔细地阅读代码。您实际上不需要调用不同的函数,而是用陷阱钩子包围调用 foo 的代码。
    • @MikeMB:没什么特别的,但第一个版本允许旧代码以它的方式工作,而“新”(无论它是否是新的)代码需要检索指针的值来获取它,使用它们两个相同的底层函数。
    • 基本上,您的代码所说的是 “foo 无法使用给定接口更改指针的值,因此只需忽略它并调用不同的函数,即可满足您的需求” - 只是以一种不必要的复杂方式。
    猜你喜欢
    • 2021-11-19
    • 1970-01-01
    • 2021-05-31
    • 1970-01-01
    • 2021-08-15
    • 1970-01-01
    • 2015-03-28
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多