指向C中结构的指针

Question

I have a structure (let's call it structure1 ) which holds a pointer to another structure ( structure2 ), this way.

typedef struct structure{
    structure2 *pointer
}structure;

structure structVariable;
structVariable.pointer = functionThatReturnsAPointerToStructure2Variable();

The thing is, as the program changes context (for example, when calling functions), the return value of the following code changes

structVariable.pointer->someAttribute

Any idea of why this might be happening? If you need more info please ask. Thanks!

MORE INFO

This is the real-deal

structure would be this

typedef struct CPU{
    int variableCounter;
    int instructionPointer;
    char *currentInstruction;
    t_list *dataDictionary_list;
    u_int32_t currentContext;
    PCB *assignedPCB;
    CPU_STATUS status;
}CPU;

And this is how I assign the pointer (PCB *pointer)

PCB *pcb_createFromScript(const char *script){
    t_medatada_program *metadata = metadatada_desde_literal(script);
    PCB *pcb = malloc(sizeof(PCB));

pcb->instructionCount = metadata->instrucciones_size;
pcb->tagCount = metadata->cantidad_de_etiquetas;
pcb->functionCount = metadata->cantidad_de_funciones;

int codeSegmentSize = strlen(script);
int tagIndexSize = 0;

if(metadata->etiquetas != 0){
    tagIndexSize = strlen(metadata->etiquetas);
}

int instructionIndexSize = metadata->instrucciones_size * sizeof(t_intructions);

pcb_getSegments(pcb,1024,codeSegmentSize,tagIndexSize,instructionIndexSize);

pcb->currentContext = pcb->stackSegment;

pcb->variableCounter = 0;

memory_write(pcb->codeSegment,0,codeSegmentSize,script);
memory_write(pcb->tagIndexSegment,0,tagIndexSize,metadata->etiquetas);
memory_write(pcb->instructionIndexSegment,0,instructionIndexSize,(void *)metadata->instrucciones_serializado);

pcb->uniqueId = (int) random();
return pcb;

}

And then I assign it this way (myCPU is global), that's why I call it inside cpu_getPCB without passing it as a parameter

cpu_getPCB(*dummyPCB);

void cpu_getPCB(PCB myPCB){
    myCPU.currentContext = myPCB.currentContext;
    myCPU.assignedPCB = &myPCB;
}

Answer 1

Here is some speculation.

If you are modifying the object that structVariable.pointer points to in some function, then when you try to read structVariable.pointer->someAttribute , that value will change to reflect to modification to the object.

Another possibility, as the other answer mentioned, is that structVariable.pointer is pointing to local memory (stack memory for a function) which can easily be overwritten on a new function call. That can be corrected by using malloc to do heap allocation instead of stack allocation.

---

Here is the first and most obvious issue. You are taking the address of a parameter and assigning it to myCPU.assignedPCB .

Since C is pass-by-value, you have copied it instead of capturing the original. Moreover, the parameter has the same lifetime as a local variable, and will go away when the function returns.

void cpu_getPCB(PCB myPCB){
    myCPU.currentContext = myPCB.currentContext;
    myCPU.assignedPCB = &myPCB;
}

You can fix it by passing a pointer instead, since you are in C and do not have access to the reference type.

void cpu_getPCB(PCB* myPCB){
    myCPU.currentContext = myPCB->currentContext;
    myCPU.assignedPCB = myPCB;
}

Answer 2

The "structure2 *pointer" will be pointing at a piece of memory that will disappear when you change context. Allocate the Structure2 variable and free it when it's no longer needed