Wie kann ich Elemente in einer Struktur hinzufügen, ohne Variablen

Question

Erstellen ich eine Struktur bin mit einem String zu speichern und eine ganze Zahl wie folgt:

struct movement { 
    char *direction; 
    int steps; 
}; 

ich Elemente in die Struktur, indem Sie diese

struct movement m1= { "right",20 }; 
struct movement m2= { "left" ,10 }; 

hinzufügen

Das Endergebnis, das ich versuche zu erreichen, ist Benutzereingaben zu sammeln (zB "Right 20"), und speichern Sie es in der Struktur. Wie kann ich eine unbekannte Anzahl von Benutzereingaben in die Struktur ohne die Verwendung von Variablen (m1, m2 usw.) speichern, da ich nicht weiß, wie viele Elemente es am Ende gibt.

Answer 1

Verwenden Sie eine verkettete Liste. Es ist eine rekursive Datenstruktur, die großartig für das ist, was Sie wollen.

Hier ist ein Beispiel Code, den ich vor einiger Zeit geschrieben, die helfen könnten:

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

/* basic linked list structure */ 
typedef struct node node_t; 

struct node { 
    char *direction; 
    int steps; 
    node_t *next; 
}; 

/* pointers to the head and tail of the list */ 
typedef struct { 
    node_t *head; 
    node_t *foot; 
} list_t; 

list_t *initialize_list(void); 
list_t *insert_nodes(list_t *list, char *direction, int steps); 
void free_list(list_t *list); 
node_t *generate_node(void); 
void print_list(list_t *list); 
void exit_if_null(void *ptr, const char *msg); 

int 
main(int argc, char const *argv[]) { 
    list_t *list; 

    /* empty list created */ 
    list = initialize_list(); 

    /* inserting information one a time */ 
    list = insert_nodes(list, "right", 20); 
    list = insert_nodes(list, "left", 10); 

    print_list(list); 

    /* freeing list at the end */ 
    free_list(list); 
    list = NULL; 

    return 0; 
} 

/* function to insert information into a node */ 
list_t 
*insert_nodes(list_t *list, char *direction, int steps) { 

    /* called generate_node() to create a new node */ 
    node_t *new; 
    new = generate_node(); 

    /* puts steps information into node */ 
    new->steps = steps; 

    /* allocates space for direction string */ 
    /* this is needed because *direction is a pointer */ 
    new->direction = malloc(strlen(direction)+1); 

    /* copies direction info into node */ 
    strcpy(new->direction, direction); 

    /* inserting information at the tail of the list */ 
    new->next = NULL; 

    if (list->foot == NULL) { 
     /* first insertion into list */ 
     list->head = list->foot = new; 
    } else { 
     list->foot->next = new; 
     list->foot = new; 
    } 

    /* returns modified list */ 
    return list; 
} 

.* function which generates new nodes */ 
node_t 
*generate_node(void) { 
    node_t *newnode; 

    /* create space for new node */ 
    newnode = malloc(sizeof(*newnode)); 
    exit_if_null(newnode, "Allocation"); 

    /* initialize node info to nothing */ 
    newnode->direction = NULL; 
    newnode->steps = 0; 

    return newnode; 
} 

/* creates the empty linked list */ 
list_t 
*initialize_list(void) { 
    list_t *list; 

    create space for list */ 
    list = malloc(sizeof(*list)); 
    exit_if_null(list, "Allocation"); 

    /* set pointers to NULL */ 
    /* We don't want them pointing at anything yet */ 
    list->head = list->foot = NULL; 

    return list; 
} 

/* function which prints entire list */ 
void 
print_list(list_t *list) { 

    /* start at the head of the list */ 
    node_t *curr = list->head; 

    while (curr) { 
     printf("%s %d\n", curr->direction, curr->steps); 

     /* steps through the list */ 
     curr = curr->next; 
    } 
} 

/* function which frees nodes */ 
void 
free_list(list_t *list) { 
    node_t *curr, *prev; 

    /* start at beginning of list */ 
    curr = list->head; 

    /* frees nodes one at a time */ 
    while(curr) { 
     prev = curr; 
     curr = curr->next; 
     free(prev); 
    } 

    /* frees entire list */ 
    free(list); 
} 

/* function which checks malloc(), and whether enough space was allocated */ 
void 
exit_if_null(void *ptr, const char *msg) { 
    if (!ptr) { 
     printf("Unexpected null pointer: %s\n", msg); 
     exit(EXIT_FAILURE); 
    } 
} 

Answer 2

Verwenden Sie eine LinkedList, um eine unbegrenzte Anzahl von Bewegungen zu speichern. Erstellen Sie für jede Bewegung einen Knoten in der verknüpften Liste und aktualisieren Sie den nächsten Zeiger.

struct node { 
    struct movement m; 
    node* next; 
} 

Answer 3

es nicht so klingt, wenn Sie wirklich „Speichern von Werten in die Struktur“ wollen, stattdessen wollen Sie eine Folge von unabhängigen Struktur Instanzen speichern; eine für jede Benutzereingabe.

Die drei grundlegenden Möglichkeiten, dies zu tun sind:

• Ein Array, dessen Größe auswählen, die Sie bei der Kompilierung-Zeit. Es sollte nicht zu schwer sein, es „groß genug“ zu machen für einen vernünftigen Eingang
• Ein Array, dessen Größe festgelegt Sie (und dann wachsen) zur Laufzeit
• eine verknüpfte Liste von Strukturinstanzen

Welches zu bevorzugen ist hängt davon ab, was Sie für am einfachsten halten. Wenn es möglich ist, ist ein statisches Erscheinungsbild immer am einfachsten. Sie können ganz einfach auf globaler Ebene so etwas wie

struct movement movements[10000]; 

haben, dies kostet nur etwa 120 KB auf einem 64-Bit-System. Beachten Sie jedoch, dass dies nicht Speicher für die direction Strings enthält; wenn diejenigen, immer von „rechts“ gewählt und „links“ (und vielleicht auch „nach oben“/„nach unten“ auch) könnte man es als Aufzählungs repräsentiert statt:

enum direction { DIRECTION_LEFT = 0, DIRECTION_RIGHT, DIRECTION_UP, DIRECTION_DOWN }; 

Dies wird die Struktur „self-contained machen "und (auf 64-Bit-Systemen) kleiner, da die Aufzählung kleiner als ein Zeiger ist.

Dynamisch wachsen ein Array mit ist nicht zu schwer, Sie könnten das leicht suchen, wie es oft verwendet wird.