标签: void-pointers

我的问题是我在多线程应用程序中看到了这样的代码:

void Thread( void* pParams )
{  
    int *milliseconds = (int *)pParams;
    Sleep(milliseconds);
    printf("Finished after %d milliseconds", milliseconds); //or something like that
}

这大大引起了我的兴趣,我知道malloc发回一个void指针,你可以把它转换成你想要的,这是否意味着我可以创建一个可以接受任何数据类型的函数？

例如我在没有测试的情况下编写的函数:

void myfunc( void* param )
{  
    switch(sizeof(param)) {
       case 1:
       char *foo = (char *)param; break;
       case 2:
       short *foo = (short *)param; break;
       case 4: 
       int *foo = (int *)param; break;
    }
}
myfunc(3.1415);
myfunc(0);
myfunc('a');

我可能完全错了,即使这确实有效也是可怕的做法？谢谢.

这是Make Controller固件中的一些C代码.我熟悉void指针是什么,但我从来没有见过像这个函数的第一行那样的语法.究竟是通过那种方式实现的？

void MakeStarterTask(void* parameters)
{
  (void)parameters;
  Run();
  TaskDelete(NULL);
}

我有以下函数从C中的链表中删除通用数据:

void removeData(void *data, struct accList *theList)
{
    struct accListNode* cur = theList->head;
    struct accListNode* prev = NULL;

    for(; cur != NULL; prev = cur, cur = cur->next)
    {
        if(cur->data == data)
        {
            if(cur == theList->head)
            {
               theList->head = cur->next;
            }
            if(cur == theList->tail)
            {
                theList->tail = prev;
            }
            if(prev != NULL)
            {
                prev->next = cur->next;
            }
            free(cur);
            return;
        }
    }
}

背后的含义是cur->data == data什么？

由于我的数据是generic(void*),这对于任何原始类型和任何结构类型意味着什么？

例如,考虑员工结构:

struct employee
{
    char name[20];
    float wageRate;
};

cur->data …

我已经多次看到并使用了 C++，特别是在各种线程实现中。我想知道这样做是否有任何陷阱/问题？当我们强制转换为 void* 并再次返回时，有什么方法可能会遇到错误或未定义的条件吗？如果有这些问题，我们应该如何解决？

谢谢你。

我正在使用这个无序的地图:

typedef unordered_map <char, void (*)()> Keymap;
Keymap keys;

并尝试填写:

void assign(char key, void (*value)())
{
    if (keys[key] == NULL)
        keys.insert(Keymap::value_type(key, value));
    else
        keys[key] = value;
}

指示:

keys.insert(Keymap::value_type(key, value));

将char插入键中但值未初始化(NULL),因此我有一个带有('s',NULL)的映射而不是('s',function_pointer).

指令键[key] = value; 工作正常.

错误在哪里？

我需要实现一个指向typedef指针的简单动态指针数组.
每次用户请求时使用realloc,数组大小将增加sizeof(指针).
所以我拥有的是:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef void* node;

void printmem(node* a, int c) {
    int i;
    for (i = 0; i < c; ++i)
    {
        printf("%d\t\t%p\n", i, a[i]);
    }
}

int main(void) {
    node* nodes = NULL;
    int i = 0, count = 20;

    for (i = 0; i < count; ++i)
    {
        nodes = realloc(nodes, sizeof(node));
    }
    printf("Done reallocating\n");
    printmem(nodes, i);
    // free(a);
    return 0;   
}

这给出了以下输出:

Done reallocating
0       (nil)
1       (nil)
2       (nil) …

我需要比较voidC中两个指针的值。在下面的代码中，我让控制台打印出它们是不同的。看来比较的是这两个void指针所包含的地址。

我怎样才能让这个代码比较值（即1 == 1的）的void指针和打印"same"？

int main(void)
{
    int i = 1;
    int j = 1;
    void *pi = &i;
    void *pj = &j;
    if (pi == pj) {
        printf("same.\n");
    } else {
        printf("different.\n");
    }
    return 0;
}

讨论

我知道将void指针强制转换为其他类型指针的正确方法是使用static_cast.(例如,

void *vptr;
...
foo* fptr = static_cast<foo*>(vptr);

)

我所拥有的是一对void指针(即std::pair<void*, void*>),我想把它转换成一对其他类型的指针(例如std::pair<foo*, bar*>).

我能想到的最天真的方法是:

std::pair<void*, void*> vpr;
...
std::pair<foo*, bar*> fbpr = std::make_pair(static_cast<foo*>(vpr.first), static_cast<bar*>(vpr.second));

或者从C++ 11开始:

std::pair<void*, void*> vpr;
...
auto fbpr = std::make_pair(static_cast<foo*>(vpr.first), static_cast<bar*>(vpr.second));

题

这种铸造有更整洁,更优雅或更有效的方式吗？

我首先写了这个程序,它递归地计算pi并在误差值足够小时停止.

 #include <stdio.h>`
 #include <stdlib.h>
 #include <math.h>

int threads=1;
double error=0.000001;
double func(double);


struct args{
         double l;
         double r;
         double fl; 
         double fr; 
         double area;};

double quad(struct args*);

int main(int argc, char *argv[]) {

    struct args* res = (struct args*)malloc(sizeof(struct args));
    res->l=0;
    res->r=1;
    res->fl=1;
    res->fr=0;
    res->area=0;

    double ans=quad(res);
    free(res);

    ans=ans*4;

    printf("pi=%f\n",ans);


}


double func(double x){
        x=(1-(x*x));
        x=sqrt(x);
        return x;
    }


double quad(struct args* arg){
    double m=(arg->l+arg->r)/2;
    double fm=func(m);
    double larea=(arg->fl+fm)*(m-arg->l)/2;
    double rarea = (fm+arg->fr)*(arg->r-m)/2;

    struct args* arg1 = (struct args*)malloc(sizeof(struct …

对于类似风险的游戏,我有一个每个区域的结构,每个区域都需要有一个部队可以从母区移入的相关区域列表.

从理论上讲,它看起来像

typedef struct {
    char* name;
    region_t* connections;
} region_t;

但是,这当然是不可能的,因为在解析器到达类型region_t*之前region_t不存在.因此我选择使用void*代替region_t*.

typedef struct {
    char* name;
    void* connections;
} region_t;

MiddleEast.connections = malloc(6 * sizeof(void*));
MiddleEast.connections = &SouthernEurope;
MiddleEast.(connections + 1) = &Egypt;

使用region_ts MiddleEast,SouthernEurope和Egypt,我可以Southern Europe成功设置第一个连接,但是当我尝试设置为时.(connections + 1),&Egypt我得到了编译器错误

error: expected identifier before ‘(’ token

如何正确访问下一个内存地址？