Работа со структурой и стеком

[valerii353]

Для программирования на Си
Добрый день! Нужна Ваша помощь в поиске ошибки. Задание следующее:
Мы уже упоминали аппаратный стек, хранящий локальные переменные функций. Но вообще стеком можно назвать любую сущность, которая хранит элементы и поддерживает операции push и pop:
push добавляет элемент на вершину стека;
pop вынимает элемент с вершины стека.
Стек можно реализовать поверх массива: для этого достаточно хранить указатель на вершину стека внутри массива. Разумеется, такой стек будет ограничен размером массива, внутри которого он существует.
Для нескольких дальнейших заданий нам будет нужен такой стек внутри программы для хранения чисел, поэтому давайте реализуем его -- на основе уже имеющегося упакованного массива array_int.

У меня выскакивает ошибка смысл которой в следующей фразе: Popped value is different from pushed one
В этом задании не создается главная функция, мы просто отправляем написанные определения на ранее объявленные функции и нажимаем кнопку отправить.

/* Вы можете пользоваться следующими определениями:

struct maybe_int64 {int64_t value; bool valid;};
struct maybe_int64 some_int64(int64_t i);
const struct maybe_int64 none_int64 = { 0, false };
void maybe_int64_print( struct maybe_int64 i );


struct array_int {int64_t* data; size_t size;};
struct array_int array_int_create( size_t sz );

struct array_int array_int_create( size_t sz ) {
return (struct array_int) { .data = malloc( sizeof( int64_t ) * sz ), .size = sz };
}

int64_t* array_int_last( struct array_int a );
struct maybe_int64 array_int_get( struct array_int a, size_t i );
bool array_int_set( struct array_int a, size_t i, int64_t value );
void array_int_print( struct array_int array );
void array_int_free( struct array_int* a );

*/

struct stack {
size_t count;
struct array_int data;
};

// Количество элементов в стеке
size_t stack_count( const struct stack* s );


// Создаем и деинициализируем стек
struct stack stack_create( size_t size );
void stack_destroy( struct stack* s );

// Стек полный
bool stack_is_full( const struct stack * s);
// Стек пустой
bool stack_is_empty( const struct stack * s);

// Поместить значение в стек
bool stack_push( struct stack* s, int64_t value );

// Вынуть значение с вершины стека. Может вернуть none_int64
struct maybe_int64 stack_pop( struct stack* s );

void stack_print( const struct stack* s ) {
for (size_t i = 0; i < stack_count( s ); i = i + 1 ) {
print_int64( array_int_get( s->data, i).value );
printf(" ");
}
}
size_t stack_count( const struct stack* s ){
return s->count;
}

struct stack stack_create( size_t size ){
struct stack st;
st.data.data=0;
st.data.size=0;
st.count=0;
if(!size) return st;
st.data = array_int_create(size);
st.count=size/sizeof(size_t);
return st;
}
void stack_destroy(struct stack* s){
if(s){
array_int_free(&s->data);
free(s);
}
s=0;
}
bool stack_is_empty (const struct stack * s) { return s->count == 0; }
bool stack_is_full( const struct stack * s) { return !stack_is_empty(s) && (s->count >= (s->data.size - 1)); }
bool stack_push( struct stack* s, int64_t value ){
if (stack_is_full(s)) return false;
else {
s->data.data[s->count] = value;
s->count++;
return true;
}
}
struct maybe_int64 stack_pop( struct stack* s ){
int64_t tmp = 0;
bool val = false;
if(!stack_is_empty(s)){
s->count--;
tmp=s->data.data[s->count];
// s->data.data[s->count]=0;
free(&s->data.data[s->count]);
val = true;
return (struct maybe_int64) { .value=tmp, .valid=val};
}
else return none_int64;
}