Ok introducción rápida. Estoy haciendo una tarea en la memoria asignada dinámicamente. Necesitamos simular una CPU usando structs y dyn. Alabama. memoria. Estaba probando si mi pila funciona correctamente y no se desborda. Se supone que la pila es de 2 KiB, no se desbordó, pero al imprimir los números, pocas direcciones contienen otros números que no puse. Simplemente lo copiaré aquí, y me deshaceré de las listas de instrucciones, registros y demás, eso no es un problema y lo alargaría.

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

struct cpu {
    struct stack* memory;
};

struct stack {
    int32_t* values;
    int32_t* top;
};

void stackInit(struct stack* stack)
{
    stack->values = malloc(2048);
    stack->top = NULL;
}

void cpuInit (struct cpu* cpu)
{
    stackInit(cpu->memory); //initialize stack
}

void stackPush(struct stack* stack, int32_t value)
{
    if (stack->top == NULL){
        stack->top = stack->values;
        *(stack->top) = value;
    }
    else if (stack->top + sizeof(int32_t) < stack->values + 2048){
        stack->top += sizeof(int32_t);
        *(stack->top) = value;
    }
}

void cpuDebug(const struct cpu* cpu)
{    
    int32_t* auxpt = cpu->memory->top;

    if (cpu->memory->top != NULL)
        for (int32_t i = 0; auxpt >= cpu->memory->values; i++){ 

            printf("Value on the addr %d\n", *auxpt);
            printf("Address of auxpt: %p\n", ( void * )auxpt );
            auxpt -= sizeof(int32_t);
        }

    printf("\n");
}

int main()
{
    struct cpu Cpu;

    cpuInit(&Cpu);

    for (int32_t i = 0; i < 550; i++){
        stackPush(Cpu.memory,i);
    }

    cpuDebug(&Cpu);

    return 0;
}

Y la salida se ve así:

Value on the addr 133
Address of auxpt: 0x562640529880
Value on the addr 10
Address of auxpt: 0x562640529870
Value on the addr 544108298
Address of auxpt: 0x562640529860
Value on the addr 2016419898
Address of auxpt: 0x562640529850
Value on the addr 1919181889
Address of auxpt: 0x562640529840
Value on the addr 128
Address of auxpt: 0x562640529830
Value on the addr 127

¿Alguna idea de por qué está sucediendo esto? Gracias por adelantado

1
St4lker 31 mar. 2017 a las 17:56

2 respuestas

La mejor respuesta

Su struct cpu tiene un struct stack asociado, pero esa pila no es parte de la struct cpu; la CPU simplemente tiene un puntero a una pila separada. Nunca inicializa ese puntero, ni reserva memoria para la pila deseada. En particular, su función cpuInit() no hace esto, y su función stackInit() depende de que ya se haya hecho.

En general, suponiendo que cada CPU requiera solo una pila para su vida útil, sería mejor que la pila sea una parte integral de la CPU, para que no tenga que preocuparse por tales problemas de asignación:

struct cpu {
    struct stack memory;  // not a pointer
};

Una vez hecho esto, deberá cambiar la sintaxis con la que accede a los miembros de la pila a través de la CPU, y deberá estar atento a otras diferencias semánticas, pero siempre puede obtener un puntero a la pila cuando sea necesario (como como pasar a stackInit()) a través del operador &.

3
John Bollinger 31 mar. 2017 a las 15:16

Hombre, debe asignar la estructura de la pila antes de acceder a sus miembros ( valores y arriba ). Está accediendo a una memoria no mal asignada.

void stackInit(struct stack* stack)
{
    stack = malloc(sizeof(struct stack));
    stack->values = malloc(2048);
    stack->top = NULL;
}

Siguiendo los trucos señalados en los comentarios, una mejor solución podría ser:

void stackInit(struct stack** stack)
{
    (*stack) = (struct stack*)malloc(sizeof(struct stack));
    (*stack)->values = (int32_t*)malloc(2048);
    (*stack)->top = NULL;
}

void cpuInit(struct cpu* cpu)
{
    stackInit(&cpu->memory); //initialize stack
}

De esta manera, la persona que llama verá la memoria asignada en el contexto de Cpu.memory.

4
Pablo 31 mar. 2017 a las 15:47