How to Implement stack by function pointer and how to use it [closed]

by

No, function members cannot be declared in C structs (only in C++). The convention is to pass the struct pointer as the first argument in the functions when doing object oriented programming. Also, C++ really does the same thing, the “this” pointer is passed as the first argument, it is just hidden.

struct stack{
  int[10] data;
  int top;
};

void stack_init(struct stack* stack);          
int stack_isEmpty(struct stack* stack);           
int stack_isFull(struct stack* stack);            
void stack_push(struct stack* stack, int ivalue);
int stack_pop(struct stack* stack);

This part below may be more than what you are asking for but if you want the functions to be more “dynamic”, you can put function pointers in the struct to make them “changeable”, i.e. to simulate the virtual keyword in c++.

struct stack{
    int[10] data;
    int top;
    int (*isEmpty)(struct stack* stack);           
    int (*isFull)(struct stack* stack);            
    void (*push)(struct stack* stack, int ivalue);
    int (*pop)(struct stack* stack);
};

int stack_isEmpty1(struct stack* stack);           
int stack_isFull1(struct stack* stack);            
void stack_push1(struct stack* stack, int ivalue);
int stack_pop1(struct stack* stack);

void stack_init1(struct stack* stack)
{
    stack->isEmpty = &stack_isEmpty1;
    stack->isFull = &stack_isFull1;
    stack->push = &stack_push1;
    stack->pop = &stack_pop1;
    ...
}

int stack_isEmpty2(struct stack* stack);           
int stack_isFull2(struct stack* stack);            
void stack_push2(struct stack* stack, int ivalue);
int stack_pop2(struct stack* stack);

void stack_init2(struct stack* stack)
{
    stack->isEmpty = &stack_isEmpty2;
    stack->isFull = &stack_isFull2;
    stack->push = &stack_push2;
    stack->pop = &stack_pop2;
    ...
}

So now if you have 2 stack objects, initialized with stack_init1 and stack_init2 respectfully, they each will call their own sets of functions. Example:

struct stack* a, b;
stack_init1(a);
stack_init2(b);

/* This will call stack_isEmpty1*/
a->isEmpty(a);

/* This will call stack_isEmpty2*/
b->isEmpty(b);

More Related Contents:

  1. expected ‘void (**)(void *, const char *)’ but argument is of type ‘void (*)(void *, const char *)
  2. How do function pointers in C work?
  3. Getting a stack overflow exception when declaring a large array
  4. Why is the use of alloca() not considered good practice?
  5. Why doesn’t my program crash when I write past the end of an array?
  6. Stack smashing detected
  7. Understanding typedefs for function pointers in C
  8. Order of local variable allocation on the stack
  9. How can I use an array of function pointers?
  10. Does stack grow upward or downward?
  11. Function pointers and address of a function
  12. Stack allocation, padding, and alignment
  13. Checking available stack size in C
  14. How to format a function pointer?
  15. Why do I get a segfault in C from declaring a large array on the stack?
  16. How to get function’s name from function’s pointer in Linux kernel?
  17. In C, do braces act as a stack frame?
  18. What is the difference between a segmentation fault and a stack overflow?
  19. Why does the compiler allocate more than needed in the stack?
  20. What are function pointers used for, and how would I use them?
  21. Does Function pointer make the program slow?
  22. Determining Stack Space with Visual Studio
  23. Do threads have a distinct heap?
  24. C late binding with unknown arguments
  25. C isn’t that hard: void ( *( *f[] ) () ) ()
  26. Dynamic method dispatching in C
  27. Function pointer as an argument
  28. How to create a typedef for function pointers
  29. Returning function pointer type
  30. & operator optional in function pointer assignment

Leave a Comment