C++ 在函数之间传递函数指针

我正在为泛型堆栈编写程序。因此，我将函数指针传递给函数

StackNew（）

API。当我看到

StringFree

API的地址时，它是

0x012b2770

但是当我看到（*free）API的地址时，它是

0x012B13ED

我原以为指针的副本会被传递。正如你所看到的那样，这并没有发生，但程序正在按其应有的方式运行

---

我认为StringFree API的起始地址是被传递的，比如假设StringFree的起始地址是0x10，那么0x10被传递给free API，这样free也指向StringFree的起始地址，这样free的值也将是0x10，但这并没有发生。你能解释一下这里发生了什么吗？谢谢

我的节目：

#include<cstdio>  
#include<cstdlib>
#include<cstring>
#include<string.h>
#include<iostream>

using namespace std;

typedef struct
{
    void *elems;
    int loglen;
    int alloclen;
    int elemSize;
    void (*freefn) (void*);
}Stack;

void StringFree(void* target)
{
    char** s = (char**)target;
    free(*s);
    if (s != NULL) {
        std::cout << "Not null" << std::endl;
    }
    s = NULL;

}

void StackNew(Stack *s, int elemSize,void (*free) (void*))
{
    s->elemSize = elemSize;
    s->loglen = 0;
    s->alloclen = 4;
    s->elems = malloc(4 * elemSize);
    s->freefn = free;
    //assert(s->elems != 0 );

}

void StackDispose(Stack *s)
{
    if (s->freefn != 0)
    {
        for (int i = 0 ; i < 3 ; i++ )
        {
            void* source = (char*)s->elems + i*s->elemSize;
            s->freefn(source);
        }
    }

}

void StackPush(Stack *s, void* elemAddr)
{
    if (s->alloclen == s->loglen)
    {
        s->alloclen *= 2;
        s->elems = realloc(s->elems, s->alloclen * s->elemSize);

    }
    void* target = (char*)s->elems + s->loglen*s->elemSize;
    memcpy(target, elemAddr, s->elemSize);
    s->loglen++;

}

void* StackPop(Stack *s, void* elemAddr)
{
    s->loglen--;
    void* source = (char*)s->elems + s->loglen * s->elemSize;
    memcpy(elemAddr, source, s->elemSize);
    return elemAddr;
}


int main()
{

    Stack s;
    std::cout << sizeof(s.freefn) << std::endl;
    const char* friends[] = { "AlexJonesisabitchofjoerogan" , "Bob" , "Carl"};
    StackNew(&s, sizeof(char*),StringFree);
    for (int i = 0; i < 3; i++)
    {
        //int* cc = (int *)_strdup(friends[i]);
        char* copy = _strdup(friends[i]);
        std::cout << copy << std:: endl;
        StackPush(&s, &copy);
    }

    char* name;
    for (int i = 0; i < 3; i++)
    {
        StackPop(&s, &name);
        printf("%s\n", name);
        // free()
    }

    StackDispose(&s);
    std::cin.get();

    return 0;
}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
类型定义结构
{
无效*元素；
int loglen；
内特alloclen；
内部电气化；
无效（*freefn）（无效*）；
}堆叠；
void StringFree（void*目标）
{
字符**s=（字符**）目标；
免费（*s）；
如果（s！=NULL）{
标准：：cout loglen=0；
s->alloclen=4；
s->elems=malloc（4*elemSize）；
s->freefn=自由；
//断言->元素！=0；
}
void StackDispose（堆栈*s）
{
如果（s->freefn！=0）
{
对于（int i=0；i<3；i++）
{
void*source=（char*）s->elems+i*s->elemSize；
s->freefn（来源）；
}
}
}
void StackPush（堆栈*s，void*elemAddr）
{
如果（s->alloclen==s->loglen）
{
s->alloclen*=2；
s->elems=realloc（s->elems，s->alloclen*s->elemSize）；
}
void*target=（char*）s->elems+s->loglen*s->elemSize；
memcpy（target，elemAddr，s->elemSize）；
s->loglen++；
}
void*StackPop（堆栈*s，void*elemAddr）
{
s->loglen--；
void*source=（char*）s->elems+s->loglen*s->elemSize；
memcpy（elemAddr，source，s->elemSize）；
返回ELEMADR；
}
int main（）
{
堆栈s；
std:：cout指针仍然是按值传递的，因此当你传递指针时，它会复制指针的值，就像它对整数一样。
正如你所看到的那样，这并没有发生。
我一点也看不到。为什么你认为指针没有被复制？你所说的无字符串API的
地址和的
地址是什么意思（*免费）API
？我认为传递了StringFree API的起始地址，比如假设StringFree的起始地址是0x10，那么0x10被传递给free API，这样free也指向StringFree的起始地址，所以free的值也将是0x10，但这并没有发生，这就是我的意思。你是什么意思API？函数的同义词（*free）
的
地址具体是什么意思？你指的是
free
指针的值，对吗？你是如何发现它是0x012B13ED的？你是如何发现
StringFree
从0x012b2770开始的？我知道这一点。但这不是我的问题