Stacks in C --- pop() function

Question

Мне нужно создать стек, в котором есть функция pop, которая выталкивает элементы из стека. Он должен быть записан в C и содержать две переменные float (float1, float2). Я не уверен, как это сделать, может кто-то поможет.

Answer 1

Используйте std :: stack. Вот documentation.

Answer 2

Если вам нужна помощь, лучшее, что я могу предложить, это задать вам вопросы. Чтобы писать поп-операции, нам нужна первая операция нажатия. Я прав? В противном случае, как бы вы что-то выскочили? Вам нужно нажать 2 поплавки в эту структуру, правильно? Если я скажу вам написать функцию push, которая сохраняет 2 поплавки, как бы вы могли написать такую ​​функцию?

Answer 3

Если вы пишете c, существует общий метод программирования. Вот пример следующим образом: голова

typedef void *ElementAddr; 
typedef void (*PfCbFree)(ElementAddr); 

typedef struct StackRecord 
{ 
     ElementAddr *array; 
     int  elemsize; 
     int  loglength; 
     int  alloclength; 
     PfCbFree freefn; 
} *Stack; 
/* Create a new stack */ 
Stack stack_create(int elemsize, PfCbFree freefn); 

/* Dispose the stack */ 
void stack_dispose(Stack stk); 

/* Make the given stack empty */ 
void stack_make_empty(Stack stk); 

/* Return true if the stack is empty */ 
int stack_is_empty(Stack stk); 

/* Insert a new element onto stack */ 
void stack_push(Stack stk, ElementAddr elemaddr); 

/* Delete the top element off the stack */ 
void stack_pop(Stack stk); 

/* Fetch the top element from the stack */ 
void stack_top(Stack stk, ElementAddr elemaddr); 

/* Fetch & Delete the top element from the stack */ 
void stack_top_and_pop(Stack stk, ElementAddr elemaddr); 

.cpp

#define MIN_STACK_SIZE (4) 

/* Create a new stack */ 
Stack 
stack_create(int elemsize, PfCbFree freefn) 
{ 
     Stack stk; 

     stk = malloc(sizeof(struct StackRecord)); 

     if (stk == NULL) { 
       fprintf(stderr, "Out of memory\n"); 
       exit(1); 
     } 

     stk->array = malloc(elemsize * MIN_STACK_SIZE); 
     if (stk->array == NULL) { 
       fprintf(stderr, "Out of memory\n"); 
       exit(1); 
     } 
     stk->elemsize = elemsize; 
     stk->loglength = 0; 
     stk->alloclength = MIN_STACK_SIZE; 
} 

/* Dispose the stack*/ 
void 
stack_dispose(Stack stk) 
{ 
     stack_make_empty(stk); 
     free(stk->array); 
     free(stk); 
} 

/* Make the given stack empty*/ 
void 
stack_make_empty(Stack stk) 
{ 
     if (stk->freefn) { 
       int i; 
       for (i = 0; i < stk->loglength; ++i) { 
         stk->freefn((char *)stk->array + 
            i * stk->elemsize); 
       } 
     } 
     stk->loglength = 0; 
} 

/* Return true if the stack is empty*/ 
int 
stack_is_empty(Stack stk) 
{ 
     return stk->loglength == 0; 
} 

static void 
stack_grow(Stack stk) 
{ 
     stk->alloclength *= 2; 
     stk->array = realloc(stk->array, 
          stk->alloclength * stk->elemsize); 
} 

/* Insert a new element onto stack */ 
void 
stack_push(Stack stk, ElementAddr elemaddr) 
{ 
     ElementAddr target; 
     if (stk->loglength == stk->alloclength) 
       stack_grow(stk); 
     target = (char *)stk->array + stk->loglength * stk->elemsize; 
     memcpy(target, elemaddr, stk->elemsize); 
     stk->loglength++; 
} 

/* Delete the top element off the stack */ 
void 
stack_pop(Stack stk) 
{ 
     ElementAddr target; 
     if (stack_is_empty(stk)) { 
       fprintf(stderr, "Empty stack\n"); 
       exit(1); 
     } 
     if (stk->freefn) { 
       target = (char *)stk->array + 
         (stk->loglength-1) * stk->elemsize; 
     stk->freefn(target); 
     } 
     stk->loglength--; 
} 

/* Fetch the top element from the stack */ 
void 
stack_top(Stack stk, ElementAddr elemaddr) 
{ 
     void *target = (char *)stk->array + 
         (stk->loglength-1) * stk->elemsize; 
     memcpy(elemaddr, target, stk->elemsize); 
} 

/* Fetch & Delete the top element from the stack */ 
void 
stack_top_and_pop(Stack stk, ElementAddr elemaddr) 
{ 
     ElementAddr target; 
     if (stack_is_empty(stk)) { 
       fprintf(stderr, "Empty stack\n"); 
       exit(1); 
     } 
     target = (char *)stk->array + 
       (stk->loglength-1) * stk->elemsize; 
     memcpy(elemaddr, target, stk->elemsize); 
     stk->loglength--; 
} 

Вы можете использовать его для любого типа данных. Здесь находится тестовый код

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include "generic-stack.h" 

void strfreefn(ElementAddr elemaddr) 
{ 
     free(*(char **)elemaddr); 
} 

int 
main(int argc, char **argv) 
{ 
     Stack int_stk, str_stk; 
     int i; 
     char *names[] = { 
       "C", "C++", "Jave", "C#", "Python", 
       "PHP", "Basic", "Objective C", "Matlab", "Golang" 
     }; 

     /* test integer stack */ 
     printf("Test integer stack\n"); 
     int_stk = stack_create(sizeof(int), NULL); 
     for (i = 0; i < 10; ++i) { 
       stack_push(int_stk, &i); 
     } 

     while (!stack_is_empty(int_stk)) { 
       int val; 
       stack_top_and_pop(int_stk, &val); 
       printf("%d\n", val); 
     } 

     stack_dispose(int_stk); 

     /* test string stack */ 
     printf("Test string stack\n"); 
     str_stk = stack_create(sizeof(char *), strfreefn); 
     for (i = 0; i < 10; ++i) { 
       char *copy = strdup(names[i]); 
       char *dest; 
       stack_push(str_stk, ©); 
     } 

     while (!stack_is_empty(str_stk)) { 
       char *dest; 
       stack_top_and_pop(str_stk, &dest); 
       printf("%s\n", dest); 
       free(dest); 
     } 
     stack_dispose(str_stk); 

     return 0; 
}