Typedef结构指针正确指向typedef结构（C）

Question

I am attempting to save a malloc'd ptr in a global ptr so I can use it in another function. Ideally I would a smarter data structure around the global, but for now I'm just trying to get the global ptr to work.

In my lwp.h file I have the following definitions:

typedef struct threadinfo_st *thread;
typedef struct threadinfo_st {
   tid_t         foo1
   unsigned long foo2
   size_t        foo3
   rfile         foo4
   thread        foo5
   thread        foo6
   thread        foo7
   thread        foo8
} context;

Using this thread struct, I have two functions in my lwp.c file. In the first function I construct a malloc'd thread and then copy the data to the global ptr. Then in the second function I attempt to dereference the global ptr to receive my initally created thread. To confirm I am doing this correctly, I print out the ptr addresses at each step. Unfortunately I cannot seem to regain my original address, thus all my data in the second function is shifted

static thread headThread = NULL;

void create(){
    thread newThread = (thread) malloc( sizeof(thread));
    assert(newThread != NULL)
    // Assign junk to newThread
    printf("newThread is at: %p, headThread is at: %p\n", &newThread, &headThread);
    headThread = newThread;
}

void start(){
    thread newThread = headThread;
    printf("newThread is at: %p, headThread is at: %p\n", &newThread, &headThread);
}

Calling create() then start() in main prints out:

 newThread is at: 0x7ffdf085c5e0, headThread is at: 0x601890
 newThread is at: 0x7ffdf085c5d8, headThread is at: 0x601890

Resulting in all my data in the start() function's newThread to be shifted.

I also tried the following:

static thread *headThread = NULL;

void create(){
    thread newThread = (thread) malloc( sizeof(thread));
    assert(newThread != NULL)
    // Assign junk to newThread
    printf("newThread is at: %p, headThread is at: %p\n", &newThread, &headThread);
    headThread = &newThread;
}

void start(){
    thread newThread = headThread;
    printf("newThread is at: %p, headThread is at: %p\n", &newThread, &headThread);
}

This prints out:

newThread is at: 0x7ffff6294130, headThread is at: 0x601890
newThread is at: 0x7ffff6294128, headThread is at: 0x601890

Does anyone know what exactly I am doing wrong in this scenario? Appreciate your help!

Answer 1

As melpomene correctly pointed out you are allocating a pointer to context (which you call thread), not the context itself.

Then, in both fucntions you are printing addresses of where those pointers are stored (not the pointers itself). So, for static object (headThread) they are the same, for auto object (newThread, which is allocated on the stack each time anew) they are different. What seems to be the problem here?

Answer 2

int both functions start() and create() you are printing the address of:

the global variable headThread which is &headThread=0x601890 and remain unchanged because its the same every time (global)

but the variable newThread is declared locally (in the stack) to each of the two functions.

newThread in start() is not that in create(), they have different addresses in memory (stack) 0x7ffff6294130 is not 0x7ffff6294128.

to get the malloced ptr do this:

printf("newThread is at: %p, headThread is at: %p\n", newThread, headThread);

then this is the correct one :

static thread headThread = NULL;

not this:

static thread *headThread = NULL;

finally correct malloc to be as this:

thread newThread = malloc( sizeof(threadinfo_st)); //better use calloc