具有void *的Pthread结构参数

Question

Hy,

I was wondering if something like this is possible, without using heap(malloc/calloc) Suppose I have a struct like this:

typedef struct {
  void* par1_;
  void* par2_;
}parameters;

and another one for position:

typedef struct {
  short x;
  short y;
}position;

This is a function that gets called by the thread.

void* car(void* arg)
{
   parameters car_type = *((parameters*) arg);
   int first_par = *(int*)&car_type.par1_;
   int second_par = *(int*)&car_type.par2_;   // can I do this?
   //if yes how do I extract now values from position struct "pos.x and pos.y" 
}

From my main thread I want to mark position in the struct "position", assign that struct to the second parametar "par2_", and than send that to my function car.

int main()
{
  parameters pars;
  position pos;

  pos.x = 44;
  pos.y = 25;

  pars.par1_ = (void*) CAR_TYPE; // Global Variable
  pars.par2_ = &pos;   // not sure about this?

  pthread_t tid;
  pthread_create(&tid, NULL, car, (void*) &pars);

  pthread_join(tid, NULL);

I'm sorry if this is a stupid question. Obviously I'm new to all this. Once again, I do not want to use heap. This is minimal example of my program.

Answer 1

I think you want something more like this;

void* car(void* arg)
{
   parameters car_type = *((parameters*) arg);
   int first_par = car_type.par1_; // This is CAR_TYPE is it really an int?
   position *second_par = (position *)car_type.par2_; 

   second_par->x, second_par->y;
}

Although you might just want to change your parameters struct to include the types you really want.

typedef struct {
  int par1_;
  position* par2_;
}parameters;
void* car(void* arg)
{
   parameters car_type = *((parameters*) arg);
   int first_par = car_type.par1_; // This is CAR_TYPE is it really an int?
   car_type.par2_->x; //access like this
}

Answer 2

Not sure what you're asking, so I'll give you standard advice that seems like it pertains to the situation.

Lifetime

Be very careful when passing pointers to stack memory. Always keep these three things in mind:

1. What will use the pointer?
   What will it be used for? Which functions will end up with it? You'll need to know this to deal with the next two points.
2. Where will the pointer be stored?
   If the pointer never leaves the stack, it's fine. If the pointer gets stored in heap memory, which has a chance of outliving the stack frame, alarm bells. If the pointer outlives the stack frame, scary unexpected data corruption is par for the course. Do not allow that to happen.
3. When will the pointer be used?
   Anything in or called by the stack frame in which the memory is first used is OK. Anything above that, and the memory is not yours to play with. Make sure that you never ever EVER EVER EVER return a pointer to stack memory you've just got.

To reiterate:

Do:

#include <stdio.h>

int main(int argc, char *argv[]) {
    int nums = {12, 630, 43, 0};
    printf("%d", sum(nums));
}

int sum(int *num_pointer) {
    int count = 0;
    for (; *num_pointer; num_pointer += 1) {
        add(&count, *num_pointer);
    }
    return count;
}

void add(int *a, int b) {
    *a += b;
}

Don't:

int main(int argc, char *argv[]) {
    print_int(get_int(7));
}

int *get_int(int value) {
    return &value;
}

void print_int(int *num) {
    printf("%d", *num);
}

---

Also, don't type-cast when you don't have to. It's a big sign pointing towards bad program design; consider revising it.