La création d'une pile de chaînes de caractères en C

Je veux avoir une pile qui prend des chaînes de caractères. Je veux être en mesure de push et pop de cordes à l'extérieur, ainsi que d'effacer l'ensemble de la pile. Je pense que C++ a quelques méthodes pour cela. Ce qui sur le C?

Si votre pile de copie de chaînes ou utiliser les pointeurs passés? Il est beaucoup plus facile avec juste de sauver les pointeurs, mais presque inutile, sauf si vous savez que vous travaillez avec des littéraux de chaîne et/ou char * pointeurs dont les chaînes ne vont pas changer, et les pointeurs ne va pas le devenir non valide lors de leur "stockage" sur la pile.
La pile doit copier les chaînes, parce que les chaînes d'origine peuvent être remplacés.
Rechercher strlen + malloc + strcpy. Si vous avez strdup, vous pouvez l'utiliser (pas en C ANSI, mais est POSIX.1), rendre les choses un peu plus facile pour vous. N'oubliez pas de free les cordes lorsque vous faites pop ou clear.

OriginalL'auteur neuromancer | 2009-12-17

  1. 8

    Quick-and-dirty non testé exemple. Utilise une liste liée individuellement structure, les éléments sont poussées sur et sauté par la tête de liste. 

    #include <stdlib.h>
#include <string.h>
/**
* Type for individual stack entry
*/
struct stack_entry {
char *data;
struct stack_entry *next;
}
/**
* Type for stack instance
*/
struct stack_t
{
struct stack_entry *head;
size_t stackSize;  //not strictly necessary, but
//useful for logging
}
/**
* Create a new stack instance
*/
struct stack_t *newStack(void)
{
struct stack_t *stack = malloc(sizeof *stack);
if (stack)
{
stack->head = NULL;
stack->stackSize = 0;
}
return stack;
}
/**
* Make a copy of the string to be stored (assumes  
* strdup() or similar functionality is not
* available
*/
char *copyString(char *str)
{
char *tmp = malloc(strlen(str) + 1);
if (tmp)
strcpy(tmp, str);
return tmp;
}
/**
* Push a value onto the stack
*/
void push(struct stack_t *theStack, char *value)
{
struct stack_entry *entry = malloc(sizeof *entry); 
if (entry)
{
entry->data = copyString(value);
entry->next = theStack->head;
theStack->head = entry;
theStack->stackSize++;
}
else
{
//handle error here
}
}
/**
* Get the value at the top of the stack
*/
char *top(struct stack_t *theStack)
{
if (theStack && theStack->head)
return theStack->head->data;
else
return NULL;
}
/**
* Pop the top element from the stack; this deletes both 
* the stack entry and the string it points to
*/
void pop(struct stack_t *theStack)
{
if (theStack->head != NULL)
{
struct stack_entry *tmp = theStack->head;
theStack->head = theStack->head->next;
free(tmp->data);
free(tmp);
theStack->stackSize--;
}
}
/**
* Clear all elements from the stack
*/
void clear (struct stack_t *theStack)
{
while (theStack->head != NULL)
pop(theStack);
}
/**
* Destroy a stack instance
*/
void destroyStack(struct stack_t **theStack)
{
clear(*theStack);
free(*theStack);
*theStack = NULL;
}

    Modifier

    Ce serait bien d'avoir un exemple de comment l'utiliser:

    int main(void)
{
struct stack_t *theStack = newStack();
char *data;
push(theStack, "foo");
push(theStack, "bar");
...
data = top(theStack);
pop(theStack);
...
clear(theStack);
destroyStack(&theStack);
...
}

    Vous pouvez déclarer les piles comme auto variables, plutôt que d'utiliser newStack() et destroyStack(), vous avez juste besoin de s'assurer qu'ils sont initialzed correctement, comme dans

    int main(void)
{
struct stack_t myStack = {NULL, 0};
push (&myStack, "this is a test");
push (&myStack, "this is another test");
...
clear(&myStack);
}

    Je suis juste l'habitude de créer des pseudo constructeurs/destructeurs pour tout.

    OriginalL'auteur John Bode

  2. 3

    Essayer GNU Obstacks.

    De Wikipedia:

    Dans le langage de programmation C, Obstack est une gestion de la mémoire GNU extension de la bibliothèque C standard. Un "obstack" est une "pile" de des "objets" (éléments de données) qui est gérée de manière dynamique.

    Exemple de Code à partir de Wikipedia:

    char *x;
void *(*funcp)();
x = (char *) obstack_alloc(obptr, size); /* Use the macro. */
x = (char *) (obstack_alloc) (obptr, size); /* Call the function. */
funcp = obstack_alloc; /* Take the address of the function. */

    De l'OMI, ce qui rend Obstacks spécial: Il n'a pas besoin malloc() ni free(), mais la mémoire peut être alloué dynamiquement». C'est comme alloca() sur les stéroïdes. Il est également disponible sur de nombreuses plates-formes, car il est une partie de la Bibliothèque C de GNU. En particulier sur les systèmes embarqués, il peut être plus judicieux d'utiliser Obstacks au lieu de malloc().

    OriginalL'auteur nalply

  3. 2

    Voir L'article de Wikipedia sur les piles.

    merci pour embellir le lien. Je ne pouvais pas le faire fonctionner...
    Vous êtes les bienvenus. 🙂

    OriginalL'auteur