Dynamische Speicherverwaltung

Und merk dir folgendes: Verwende den Stack wenn immer möglich (ohne das Programm einzuschränken).

@hbb: Der Stack ist nicht begrenzt, man kann theoretisch alles stackbasierend machen über Rekursion.

aHaSoOk schrieb:

Und merk dir folgendes: Verwende den Stack wenn immer möglich (ohne das Programm einzuschränken).

@hbb: Der Stack ist nicht begrenzt, man kann theoretisch alles stackbasierend machen über Rekursion.

hat nicht das os ein limit und bei überschreiten kommt ein stackoverflow?

SaHel

aHaSoOk schrieb:

Und merk dir folgendes: Verwende den Stack wenn immer möglich (ohne das Programm einzuschränken).

@hbb: Der Stack ist nicht begrenzt, man kann theoretisch alles stackbasierend machen über Rekursion.

Entweder steht da Unsinn oder ich stehe auf dem Schlauch... Stacks gibts doch nur via Hardware (begrenzt und via Assembler nutzbar) oder man muss es programmieren. Und wenn man es programmiert, ist man auf dynamische Speicherverwaltung angewiesen. Oder übersehe ich da was??
Hier ein Sample, das ich im Netz gefunden habe:

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

typedef struct
{
  unsigned int* esp;
  unsigned int size;
  unsigned int maxSize;
} Stack;

Stack * CreateStack( unsigned int maxSize );
void Push( Stack * stack, unsigned int value );
unsigned int Pop( Stack * stack );
void DestroyStack( Stack * stack );
int isEmpty (Stack *stack);
int isFull (Stack *stack);

int main ()
{

  Stack *s;
  int i;

  s = CreateStack (5);

  for (i = 0; i < 10; i++)
    if (!isFull (s))
      Push (s, i);

  for (i = 0; i < 10; i++)
    if (!isEmpty (s))
      printf ("Element %d: %u\n", i + 1, Pop (s));

  DestroyStack (s);

  return 0;

}

Stack * CreateStack( unsigned int maxSize )
{
  if( maxSize <= 0 )
    return 0;

  Stack * stack = (Stack*) malloc( sizeof( Stack ) );
  stack->maxSize = maxSize;
  stack->size = 0;
  stack->esp = (unsigned int *) malloc( maxSize * sizeof (unsigned int));

  return stack;
}

void Push( Stack * stack, unsigned int value )
{
  stack->esp[stack->size] = value;
  stack->size++;
}

unsigned int Pop( Stack * stack )
{
  stack->size--;
  return stack->esp[stack->size];
}

void DestroyStack( Stack * stack )
{
    free( stack->esp );
    free( stack );
    stack = NULL;
}

int isEmpty (Stack * s)
{
  return (s->size == 0);
}

int isFull (Stack * s)
{
  return (s->size == s->maxSize);
}

Oder gibt es da eine bessere Technik??

SeppJ

SaHel schrieb:

Stacks gibts doch nur via Hardware (begrenzt und via Assembler nutzbar) oder man muss es programmieren.

Da hast du etwas sehr sehr falsch verstanden.

SaHel

SeppJ schrieb:

SaHel schrieb:

Stacks gibts doch nur via Hardware (begrenzt und via Assembler nutzbar) oder man muss es programmieren.

Da hast du etwas sehr sehr falsch verstanden.

Dann kläre mich bitte auf ...

SeppJ

SaHel schrieb:

Dann kläre mich bitte auf ...

Naja, ist halt einfach nicht so. Stack im Programm hat nichts mit Hardware und Assembler zu tun. Ein Stack ist einfach eine Datenstruktur, nämlich die die dein Beispielprogramm zeigt.

Der Stack beim Programmieren ist genau so eine Datenstruktur die dein Programm für sich selber erzeugt um Funktionsaufrufe intern zurückverfolgen zu können. Das tut es, weil der Compiler entsprechenden Code für dich erzeugt.

Es gibt auch Konventionen wie dieser Code aussehen soll, damit man auch Code aufrufen kann der mit anderen Compilern erzeugt wurde. Diese Konventionen sind auch so beschaffen, dass die zugrundeliegende Hardware optimal ausgenutzt wird. Aber es gibt keinen Stack in der Hardware. Die Verwendung von Stack Datenstrukturen an sich und auch die (willkürlich) begrenzte Größe sind reine^* Softwaresache. Es macht bloß jeder, weil es ungeheuer praktisch ist.

^*: Da es so verbreitet ist, gibt es auf manchen Architekturen auch eine gewisse Hardwareunterstützung für solche Strukturen.

__-- schrieb:

aHaSoOk schrieb:

@hbb: Der Stack ist nicht begrenzt, man kann theoretisch alles stackbasierend machen über Rekursion.

hat nicht das os ein limit und bei überschreiten kommt ein stackoverflow?

Ja, das sind dann die praktischen Einschränkungen.

@SaHel: Folgendes Programm macht das gleiche wie deines:

void stack (int c, int n)
{
  if (c <= 0) return;
  stack (c - 1, n + 1);
  printf ("Element %d: %u\n", c, n);
} 

int main ()
{
  stack (5, 0);
}

Aber das meinte ich nicht mit dem Tipp "alles auf den Stack".
Es ging mir vielmehr darum, unnötiges malloc zu vermeiden.

GhostfaceChilla

Könnte mir noch jemand sagen was genau es mit calloc() und realloc() auf sich hat?
Komm da nicht so ganz durch ....

GhostfaceChilla

Wutz

aHaSoOk schrieb:

Und merk dir folgendes: Verwende den Stack wenn immer möglich (ohne das Programm einzuschränken).

@hbb: Der Stack ist nicht begrenzt, man kann theoretisch alles stackbasierend machen über Rekursion.

Totaler Schwachfug, noch unsinniger als JW.

Wutz

GhostfaceChilla schrieb:

Könnte mir noch jemand sagen was genau es mit calloc() und realloc() auf sich hat?
Komm da nicht so ganz durch ....

GhostfaceChilla

Ist es zuviel verlangt, eine von hunderten Quellen im Netz mit fertigen, wahlweise auch deutschen Beschreibungen zu diesen ANSI C Standardbibliotheksfunktionen zu befragen?