使用pthread“u create调用类型为”的C函数；整数argc，字符**argv->；int"；_C_Pthreads

使用pthread“u create调用类型为”的C函数；整数argc，字符**argv->；int"；

使用pthread“u create调用类型为”的C函数；整数argc，字符**argv->；int"；,c,pthreads,C,Pthreads,我需要使用pthread_create调用类型为的C函数 int main_original(int argc, char** argv) 我试过这样的方法： pthread_create(&t, NULL, main_original, NULL); 编译器给了我一个类型错误从“int（*）（int，char**）”到“void*（）（void）”的转换无效那么，调用main_original以使其参数得到良好传递的正确方法是什么函数pthread\u create只能调用具

我需要使用pthread_create调用类型为的C函数

int main_original(int argc, char** argv)

我试过这样的方法：

pthread_create(&t, NULL, main_original, NULL);

编译器给了我一个类型错误

从“int（*）（int，char**）”到“void*（）（void）”的转换无效

那么，调用main_original以使其参数得到良好传递的正确方法是什么

函数

pthread\u create

只能调用具有以下签名的函数：

void *fn(void *)

即使您确实设法将指针强制转换为具有不同签名的函数，并成功地将其传递给

pthread\u create

，您的程序可能会崩溃，因为

pthread\u create

将尝试按照平台对只有一个

void*

参数的函数的调用约定来设置堆栈/寄存器，这将导致您的函数处于不确定状态

解决问题的方法是使用专门为

pthread\u create

调用而设计的包装函数，如下所示：

void *main_original_start_routine(void *arg)
{
    main_original(argc, argv);
    return NULL;
}

但是，这可能还不够，除非

argc

和

argv

是全局变量。您可能会发现，您还需要以某种方式将这些值从调用

pthread\u create

的作用域传递到此函数。这可以通过

pthread_create

的

void*arg

参数来实现，方法是创建一个包含所需状态的结构，并通过一个强制转换的void指针传递它：

struct main_original_context {
    int argc;
    char **argv;
};

void *main_original_start_routine(void *arg)
{
    /* Convert the void pointer back to the struct pointer it
     * really is. */
    struct main_original_context *ctx = arg;
    main_original(ctx->argc, ctx->argv);
    return NULL;
}

int main(int argc, char **argv)
{
    pthread_t t;

    struct main_original_context ctx = {
        argc,
        argv
    };

    /* Pass a pointer to our context struct to the thread routine. */
    pthread_create(&t, NULL, &main_original_start_routine, &ctx);

    pthread_join(&t, NULL);

    return 0;
}

但是请记住，在这种情况下，

ctx

只有

main

函数的生存期。如果我们在其中创建pthread的函数在返回之前没有与

pthread\u join

连接（并使用于向线程提供上下文的结构无效），那么这将是不安全的。因此，我们必须使用动态分配，并使线程承担释放任何动态分配内存的责任：

struct main_original_context {
    int foo;
    int bar;
};

void *foobar_start_routine(void *arg)
{
    struct main_original_context *ctx = arg;
    foobar(ctx->foo, ctx->bar);

    /* Free memory we have been given responsibility for. */
    free(ctx);

    return NULL;
}

void asdf(int foo, int bar)
{
    pthread_t t;

    struct main_original_context *ctx;

    /* Allocate memory. */
    ctx = malloc(sizeof *ctx);

    ctx->foo = foo;
    ctx->bar = bar;

    /* Assume `main_original_start_routine` is now responsible for freeing
     * `ctx`. */
    pthread_create(&t, NULL, &foobar_start_routine, ctx);

    /* Now we can safely leave this scope without `ctx` being lost.  In
     * the real world, `t` should still be joined somewhere, or
     * explicitly created as a "detached" thread. */
}

函数

pthread\u create