Quelle structure de données en C permettez-moi de stocker des lignes et appendez-vous facilement des lignes?

Je vous conseille d'utiliser une liste liée.

// Define your list like this
typedef struct node {
    int line; // To hold the line number
    char * data;
    struct node * next;
} node_t;

// To insert
node_t* insert(node_t *head, const char * data, int line) // n is line from beginning
{
    // Node to be inserted in given line
    node_t *newNode;

    // Allocating Memory
    newNode = malloc(sizeof(node_t));

    // Filling the Data to New Node
    newNode->data = malloc(strlen(data)+1); // Allocate memory to store data
    strcpy(newNode->data, data);
    newNode->line = line;
    newNode->next = NULL;

    // It might be our First Node in Linked List
    if(head == NULL) {

        //Address of New Node Becomes our head
        return (head = newNode);
    } 

    // Node Might be inserted At Head
    else if(line == 0) {
        // Joining previous Linked List After new Node
        newNode->next = head;

       // Address of New Node Becomes our head
        return (head = newNode);
    } 

    // Inserting At the line next to line
    else {

        // Pointer to store intermediate address of node
        // To be used in Traversing
        node_t * current = head;

        // Go through to insert at Nth line
        while(current != NULL) {

            node_t * next = current->next; //The next Node

            if((line >= current->line && line < next->line) || (line >= current->line && NULL == next->line)) { // Test if we are at some point between current line and next line or if there is no next

                // If we are, point newNode to the next node of current
                newNode->next = current->next;

                // Now point current towards our New Node
                current->next = newNode;

                // Return Head as soon as we have inserted our new node
                return head;
            }
            current = next; // Point current to the next node to continue
        }
    }
}

Suivissons les suivantes sur vos besoins:

1. pas fort temps réel. (c'est-à-dire que ce n'est pas pour la négociation à haute fréquence ou le contrôle des machines.)

2. Il fonctionne sur un PC relativement contemporain (RAM mesuré en GB, fréquence de la CPU dans GHz). En particulier, il ne fonctionne pas sur un système embarqué.

3. Les données sont pas plus de quelques mille lignes.

   Ensuite, vous pouvez utiliser presque toutes les structures de données que vous aimez; Cela ne comportera pas en ce qui concerne la mémoire ou le comportement du temps d'exécution.

   Par exemple, afin de trouver le point d'insertion dans une liste liée, juste itérer cette liste. Les PC sont assez rapides pour itérer des dizaines de milliers de fois avant de finir de clignoter.

   ou simplement allouer un tableau de 100 000 lignes de 80 caractères chacun. Pas de problème que ce soit. Ou d'un million de lignes. Toujours pas de problème. Ou de 10 millions de lignes, toujours pas de problème. Vous voyez mon point? (Dans une matrice, vous aurez besoin d'un marqueur pour marquer des lignes inutilisées. J'utiliserais une ligne de structure {bool utilisé; chargez le texte [80];} ou similaire. Vous pouvez également répondre à une longue durée. Lignes - et sauvegarder la mémoire - en ayant juste un membre char * texte et alloué de manière dynamique, ou définissant le texte sous forme de liste liée des morceaux liés.)

   Le choix se résume donc à ce qui est le plus facile à utiliser. pourrait être le tableau.