Thread: Rough cut stack manipulation

Ok just created this and have only done some real limited testing on it.
This was actually one time I wish'd for the C++ classes.

Would like to hear if anyone sees anything alarmily wrong with it. I haven't taken the time to try to optimise it yet but I will tomorrow

Thanks

Warning: 75 line program

Code:

#include <stdio.h>
#include <stdlib.h>
/* type define the stack */
typedef struct {
  void *ptr;
  void *lower;
  void *upper;
}Stack;

int stack_init(Stack *, size_t);
int push(Stack *, void *, size_t);
int pop(Stack *, void *, size_t);
int stack_destroy(Stack *);

int main(void){
  Stack stack;
  int x;
  if ( !stack_init(&stack, 100) )  {
    perror("Problem with initalizing the stack");
    return 1;
  }

  x = 5;
  printf("1) %d\n", x);
  push (&stack, &x, sizeof x);
  x = 100;
  printf("2) %d\n", x);
  pop (&stack, &x, sizeof x);
  printf("3) %d\n", x);

  if ( !stack_destroy(&stack) )  {
    perror("problem with destroying the stack");
  }
  return 0;
}

int stack_init(Stack *stack, size_t size){
  stack->lower = calloc (1, size);
  if ( stack->lower == NULL )
    return 0;
  stack->ptr = stack->upper = stack->ptr + size;
  return 1;
}

int stack_destroy(Stack *stack){
  if ( stack->lower == NULL)
    return 0;

  free(stack->lower);
  stack->lower = stack->ptr = stack->upper = NULL;
  return 1;
}

int push (Stack *stack, void *var, size_t size){
  int count;

  if ( !((stack->ptr - size) > stack->lower) )
    return 0;
  stack->ptr -= size;
  for ( count=0; count<size; count++)
    *(char *)((stack->ptr)+count) = *(char *)(var+count);
  return 1;
}

int pop ( Stack *stack, void *var, size_t size)
{
  int count;
  if ( ! ( (stack->ptr+size) <= stack->upper) )
    return 0;
  for ( count=0; count<size; count++)
    *(char *)(var+count) = *(char *)((stack->ptr)+count);
  stack->ptr += size;
  return 1;
}

Is there a type that will be a size of 1 regardless of of the system? I know char is most of the time, but Stroustrup stated in one of his books that its not guarnteed on all systems. For some reason I don't thats just a C++ thing.

If not I might have to go with a non ANSI solution.

Thanks for the memcpy suggestion.

I meant 1 byte. And as I mentioned:

The char type is supposed to be chosen by the implementation to be the most suitable type for holding and manipulating characters on a given computer; it is typically an 8-bit byte. Similarly, the int type is supposed to be chosen to be the most suitable for holding and manipulating integers on a given computer; it is typically a 4-byte (32 bit) word. It is unwise to assume more. For example, there are machines with 32 bit chars.

From: "The C++ Programming Language Third Edition"

From his wording I have to assume that is language independant.

Ok I see what you are saying. So on those systems each byte of ram will be equivlent to the size of the character.

Thanks for the clear up.