Simulieren einer Liste mit Array

Question

Guten Morgen! Ich muss ein struct-Array (globale Variable) behandeln, die eine Liste simuliert. In der Praxis muss ich jedes Mal, wenn ich eine Methode aufruft, die Größe des Arrays 1 erhöhen und es in die neue Struktur einfügen.

Da die Array-Größe ist statisch, ist meine Idee Zeiger wie folgt zu verwenden:

1. Die Struktur Array wird als Zeiger auf eine zweite Struktur Array deklariert.
2. Jedes Mal, wenn ich die Methode increaseSize() aufruft, wird der Inhalt des alten Arrays in ein neues n + 1-Array kopiert.
3. Der globale Array Zeiger auf ein neues Array

In der Theorie Punkt aktualisiert wird, scheint die Lösung einfach ... aber ich bin ein noob von c. Wo ist das falsch?

struct task { 
    char title[50]; 
    int execution; 
    int priority; 
    }; 

    struct task tasks = *p; 


int main() { 
    //he will call the increaseSize() somewhere... 
} 

void increaseSize(){ 

    int dimension = (sizeof(*p)/sizeof(struct task)); 

    struct task newTasks[dimension+1]; 

    for(int i=0; i<dimension; i++){ 

     newTasks[i] = *(p+i); 

    } 

    free(&p); 

    p = newTasks; 
} 

Answer 1

Sie vermischen sich ziemlich viel hier!

int dimension = (sizeof(*p)/sizeof(struct task)); 

p ein Zeiger ist, *p verweist auf eine struct task, sein sizeof(*p) wird so gleich sizeof(struct task) und Dimension wird 1 immer ...

Sie können nicht sizeof in dieser Situation verwenden. Sie müssen die Größe (Anzahl der Elemente) in einer separaten Variablen speichern.

struct task newTasks[dimension+1]; 

Dies wird ein neues Array, ja – aber mit Rahmen lokal für die aktuelle Funktion (so normal, wird es auf dem Stapel reserviert) erstellen. Dies bedeutet, dass das Array wieder aufgeräumt wird, sobald Sie Ihre Funktion verlassen.

Sie müssen das Array auf dem Heap erstellen. Sie müssen die malloc-Funktion für (oder calloc oder realloc) verwenden.

Zusätzlich empfehle ich, das Array nicht um 1 zu erhöhen, sondern seine Größe zu duplizieren. Sie müssen aber auch die Anzahl der darin enthaltenen Elemente speichern.

Putting alle zusammen:

struct task* p; 
size_t count; 
size_t capacity; 

void initialize() 
{ 
    count = 0; 
    capacity = 16; 
    p = (struct task*) malloc(capacity * sizeof(struct task)); 
    if(!p) 
     // malloc failed, appropriate error handling! 
} 

void increase() 
{ 
    size_t c = capacity * 2; 
    // realloc is very convenient here: 
    // if allocation is successful, it copies the old values 
    // to the new location and frees the old memory, so nothing 
    // so nothing to worry about except for allocation failure 
    struct task* pp = realloc(p, c * sizeof(struct task)); 
    if(pp) 
    { 
     p = pp; 
     capacity = c; 
    } 
    // else: apprpriate error handling 
} 

schließlich als Abschluss:

void push_back(struct task t) 
{ 
    if(count == capacity) 
     increase(); 
    p[count++] = t; 
} 

Entfernen von Elementen wird Ihnen links – Sie die nachfolgenden Elemente alle weniger zu einer Position kopieren müsste und dann Anzahl verringern