Werteübergabe funktioniert nicht

[Burdy2]

Hallo
Ich hab bei einem Prgramm das Problem, das aus für micht erklärbaren Gründen Werte nicht an Variablen übergeben werden.

Das Programm ist ein simpler Stapelspeicher, es wird ein Feld angelegt und dazu Feldgröße und Position gemerkt. Man kann entweder einen neuen Wert auf den Stapel legen oder den obersten ablesen.
Das Testprogramm stack_test erzeugt einen Stapel der größe 1, legt den Wert 1 drauf, nimmt ihn wieder runter und liest ihn dabei in die Variable value und Ende.
Es klappt aber nicht, dass der Wert 1, der auf den Stapel gelegt wird in Value eingelesen wird. Ich hab in der Funktion pop_stack jeweils vor und nach der Werteübergabe ein printf eingebaut, obwohl der Wert auf dem Stapel (stack->data[stack->position]) als 1 ausgegeben wird bleiben help und value auf dem Wert 0. Und wenn ich das printf aus push_stack auskommentiere (Zeile 41) wird auch plötzlich der Wert auf dem Stapel als 0 ausgegeben. Woran liegt das?

#include "double_stack.h"
#include <stdlib.h>
#include <stdio.h>

  void init_stack(struct Stack* stack,int size)
  {    
    stack->data=(double*)malloc(sizeof(double)*size);
    stack->size=size;
    stack->position=0;
  }

  void delete_stack(struct Stack* stack)
  { 
    stack->size=0;
    stack->position=0;
    free(stack->data);
  }

  int empty_stack(const struct Stack* stack)
  {
    if (stack->position == 0) {
      return true;
    } else {
      return false;
    }
  }

  int full_stack(const struct Stack* stack)
  {
    if (stack->position == stack->size) {
      return true;
    } else {
      return false;
    }
  }

  int push_stack(struct Stack* stack, double value) // Wert auf Stapel legen
  {
    if (!full_stack(stack)) {       
      (stack->data[stack->position]) = value;      
      printf("%f %f \n\n",value, stack->data[stack->position]);      
      (stack->position)++;
      return true;
    } else {
      return false;
    }
  }

  int pop_stack(struct Stack* stack, double* value) // Wert vom Stapel nehmen
  {
    double help;
    if(!empty_stack(stack)) {
      printf("%f %f \n",value, stack->data[stack->position]);
      help = (stack->data[stack->position]);
      *value = help;
      printf("%f %f %f \n",help, value, stack->data[stack->position]);      
      (stack->position)--;
      return true;
    } else {
      return false;
    }
  }

double_stack.c

#ifndef __STACK_H
#define __STACK_H
#define true  1 //we can use true instead of 1
#define false 0 //we can use false instead of 0

struct Stack    // the structure containing the state of the Stack
{
  int size;     // size of stack
  int position; // current position of top
  double* data; // array of size "size" of type data
};

void init_stack(struct Stack* stack, int size);
void delete_stack(struct Stack* stack);
int empty_stack(const struct Stack* stack);
int full_stack(const struct Stack* stack);
int push_stack(struct Stack* stack, double value);
int pop_stack(struct Stack* stack, double* value);
#endif

double_stack.h

#include "double_stack.h"
#include <assert.h>
#include <stdio.h>
int main()
{
  double value;
  struct Stack stack;
  init_stack(&stack,1);
  assert(empty_stack(&stack)==true);
  assert(push_stack(&stack,1)==true);
  assert(full_stack(&stack)==true);
  assert(pop_stack(&stack,&value)==true);
  assert(value==1);
  delete_stack(&stack);
  printf("Test Succeeded!\n");
  return 0;
}

stack_test.c

[NDEBUG]

Ich kann dein Programm gerad nicht testen, aber das hier sieht verdächtig nach Fehler aus:

int push_stack(struct Stack* stack, double value) // Wert auf Stapel legen
  {
    if (!full_stack(stack)) {      
      (stack->data[stack->position]) = value;      
      printf("%f %f \n\n",value, stack->data[stack->position]);      
      (stack->position)++; // hier inkrementiert du
      return true;         // d.h. stack->position zeigt nicht auf den aktuellen
    } else {               // Wert, sondern auf die nächste freie Position
      return false;
    }
  }

// ....

int pop_stack(struct Stack* stack, double* value) // Wert vom Stapel nehmen
  {
    double help;
    if(!empty_stack(stack)) {
      printf("%f %f \n",value, stack->data[stack->position]);
      help = (stack->data[stack->position]);  // hier versucht du die nächste
      *value = help;                          // freie stelle zu poppen
      printf("%f %f %f \n",help, value, stack->data[stack->position]);      
      (stack->position)--;
      return true;
    } else {
      return false;
    }
  }

Keine Ahnung ob es das ist, aber es sieht verdächtig aus.

[Burdy2]

Danke, das wars, ich hab mich einfach mit der Array-Position verhauen, die muss bei pop um einen reduziert werden.