C array a crescita dinamica

Ho un programma che legge un elenco "grezzo" di entità in-game e intendo creare un array contenente un numero indice (int) di un numero indeterminato di entità, per elaborare varie cose. Vorrei evitare di usare troppa memoria o CPU per mantenere tali indici ...

Una soluzione rapida e sporca che uso finora è dichiarare, nella funzione di elaborazione principale (focus locale) l'array con una dimensione delle entità di gioco massime e un altro numero intero per tenere traccia di quanti sono stati aggiunti all'elenco. Questo non è soddisfacente, poiché ogni elenco contiene più di 3000 array, il che non è molto, ma sembra uno spreco, poiché potrò usare la soluzione per 6-7 elenchi per funzioni diverse.

Non ho trovato alcuna soluzione specifica C (non C ++ o C #) per raggiungere questo obiettivo. Posso usare i puntatori, ma ho un po 'paura di usarli (a meno che non sia l'unico modo possibile).

Gli array non lasciano l'ambito della funzione locale (devono essere passati a una funzione, quindi eliminati), nel caso in cui ciò cambi.

Se i puntatori sono l'unica soluzione, come posso tenerne traccia per evitare perdite?

Posso usare i puntatori, ma ho un po 'paura di usarli.

Se hai bisogno di un array dinamico, non puoi sfuggire ai puntatori. Perché hai paura però? Non mordono (finché stai attento, cioè). Non esiste un array dinamico integrato in C, dovrai solo scriverne uno tu stesso. In C ++, è possibile utilizzare la std::vectorclasse integrata . C # e quasi ogni altro linguaggio di alto livello hanno anche una classe simile che gestisce array dinamici per te.

Se hai intenzione di scrivere il tuo, ecco qualcosa per iniziare: la maggior parte delle implementazioni di array dinamici funzionano iniziando con un array di alcune dimensioni (piccole) predefinite, quindi ogni volta che rimani a corto di spazio quando aggiungi un nuovo elemento, raddoppia il dimensione dell'array. Come puoi vedere nell'esempio seguente, non è affatto difficile: (ho omesso i controlli di sicurezza per brevità)

typedef struct {
  int *array;
  size_t used;
  size_t size;
} Array;

void initArray(Array *a, size_t initialSize) {
  a->array = malloc(initialSize * sizeof(int));
  a->used = 0;
  a->size = initialSize;
}

void insertArray(Array *a, int element) {
  // a->used is the number of used entries, because a->array[a->used++] updates a->used only *after* the array has been accessed.
  // Therefore a->used can go up to a->size 
  if (a->used == a->size) {
    a->size *= 2;
    a->array = realloc(a->array, a->size * sizeof(int));
  }
  a->array[a->used++] = element;
}

void freeArray(Array *a) {
  free(a->array);
  a->array = NULL;
  a->used = a->size = 0;
}

Usarlo è altrettanto semplice:

Array a;
int i;

initArray(&a, 5);  // initially 5 elements
for (i = 0; i < 100; i++)
  insertArray(&a, i);  // automatically resizes as necessary
printf("%d\n", a.array[9]);  // print 10th element
printf("%d\n", a.used);  // print number of elements
freeArray(&a);

Ci sono un paio di opzioni che mi vengono in mente.

1. Lista collegata. È possibile utilizzare un elenco collegato per creare una matrice in modo dinamico come cosa. Ma non sarai in grado di farlo array[100]senza dover 1-99prima attraversare . E potrebbe non essere utile neanche per te.
2. Matrice di grandi dimensioni. Crea semplicemente un array con spazio più che sufficiente per tutto
3. Array di ridimensionamento. Ricreare l'array una volta che si conoscono le dimensioni e / o creare un nuovo array ogni volta che si esaurisce lo spazio con un certo margine e si copiano tutti i dati nel nuovo array.
4. Combinazione di array elenco collegato. Basta usare un array con una dimensione fissa e una volta esaurito lo spazio, creare un nuovo array e collegarsi a quello (sarebbe opportuno tenere traccia dell'array e del collegamento all'array successivo in uno struct).

È difficile dire quale opzione sarebbe la migliore nella tua situazione. La semplice creazione di un array di grandi dimensioni è ovviamente una delle soluzioni più semplici e non dovrebbe causare molti problemi a meno che non sia davvero di grandi dimensioni.

Come per tutto ciò che sembra più spaventoso all'inizio di quanto non fosse in seguito, il modo migliore per superare la paura iniziale è immergersi nel disagio dell'ignoto ! A volte è come quello che impariamo di più, dopo tutto.

Sfortunatamente, ci sono delle limitazioni. Mentre stai ancora imparando a usare una funzione, non dovresti assumere il ruolo di insegnante, per esempio. Leggo spesso le risposte di coloro che apparentemente non sanno come usare realloc(cioè la risposta attualmente accettata! ) Dicendo agli altri come usarlo in modo errato, a volte con il pretesto di aver omesso la gestione degli errori , anche se si tratta di una trappola comune che deve essere menzionato. Ecco una risposta che spiega come utilizzare realloccorrettamente . Si noti che la risposta memorizza il valore restituito in una variabile diversa per eseguire il controllo degli errori.

Ogni volta che si chiama una funzione e ogni volta che si utilizza un array, si utilizza un puntatore. Le conversioni si stanno verificando implicitamente, cosa che dovrebbe essere ancora più spaventosa, poiché sono le cose che non vediamo che spesso causano la maggior parte dei problemi. Ad esempio, perdite di memoria ...

Gli operatori di matrice sono operatori di puntatore. array[x]è davvero una scorciatoia per *(array + x), che può essere suddivisa in: *e (array + x). È molto probabile che *sia ciò che ti confonde. Possiamo eliminare ulteriormente l'aggiunta dal problema ipotizzando xessere 0, quindi, array[0]diventa *arrayperché l'aggiunta 0non cambierà il valore ...

... e quindi possiamo vedere che *arrayè equivalente a array[0]. Puoi usarne uno dove vuoi usare l'altro e viceversa. Gli operatori di matrice sono operatori di puntatore.

malloc, reallocE gli amici non inventano il concetto di un puntatore che hai utilizzato per tutto il tempo; usano semplicemente questo per implementare qualche altra caratteristica, che è una diversa forma di durata della memoria, più adatta quando desideri cambiamenti drastici e dinamici delle dimensioni .

È un peccato che la risposta attualmente accettata vada anche contro la consistenza di alcuni altri consigli molto fondati su StackOverflow e, allo stesso tempo, manca un'opportunità per introdurre una funzione poco nota che brilla proprio per questo caso: array flessibile membri! In realtà è una risposta piuttosto sbagliata ... :(

Quando si definisce il proprio struct, dichiarare l'array alla fine della struttura, senza alcun limite superiore. Per esempio:

struct int_list {
    size_t size;
    int value[];
};

Ciò ti consentirà di unire il tuo array intnella stessa allocazione del tuo counte averli associati in questo modo può essere molto utile !

sizeof (struct int_list)agirà come se valueavesse una dimensione di 0, quindi ti dirà la dimensione della struttura con un elenco vuoto . Devi ancora aggiungere le dimensioni passate reallocper specificare le dimensioni del tuo elenco.

Un altro suggerimento utile è ricordare che realloc(NULL, x)equivale a malloc(x), e possiamo usarlo per semplificare il nostro codice. Per esempio:

int push_back(struct int_list **fubar, int value) {
    size_t x = *fubar ? fubar[0]->size : 0
         , y = x + 1;

    if ((x & y) == 0) {
        void *temp = realloc(*fubar, sizeof **fubar
                                   + (x + y) * sizeof fubar[0]->value[0]);
        if (!temp) { return 1; }
        *fubar = temp; // or, if you like, `fubar[0] = temp;`
    }

    fubar[0]->value[x] = value;
    fubar[0]->size = y;
    return 0;
}

struct int_list *array = NULL;

Il motivo che ho scelto di usare struct int_list **come primo argomento potrebbe non sembrare immediatamente ovvio, ma se pensi al secondo argomento, eventuali modifiche apportate valuedall'interno push_backnon sarebbero visibili alla funzione da cui stiamo chiamando, giusto? Lo stesso vale per il primo argomento, e dobbiamo essere in grado di modificare il nostro array, non solo qui ma probabilmente anche in qualsiasi altra funzione / i lo passiamo a ...

arrayinizia indicando il nulla; è un elenco vuoto. Inizializzarlo equivale ad aggiungerlo. Per esempio:

struct int_list *array = NULL;
if (!push_back(&array, 42)) {
    // success!
}

PS Ricordati difree(array); quando hai finito!

Basandosi sul design di Matteo Furlans , quando ha affermato che "la maggior parte delle implementazioni di array dinamici funzionano iniziando con un array di alcune dimensioni (piccole) predefinite, quindi ogni volta che si esaurisce lo spazio quando si aggiunge un nuovo elemento, raddoppiare le dimensioni dell'array ". La differenza nel " lavoro in corso " di seguito è che non raddoppia in termini di dimensioni, mira a utilizzare solo ciò che è richiesto. Ho anche omesso i controlli di sicurezza per semplicità ... Basandomi anche sull'idea dei brimbori , ho provato ad aggiungere una funzione di cancellazione al codice ...

Il file storage.h è simile al seguente ...

#ifndef STORAGE_H
#define STORAGE_H

#ifdef __cplusplus
extern "C" {
#endif

    typedef struct 
    {
        int *array;
        size_t size;
    } Array;

    void Array_Init(Array *array);
    void Array_Add(Array *array, int item);
    void Array_Delete(Array *array, int index);
    void Array_Free(Array *array);

#ifdef __cplusplus
}
#endif

#endif /* STORAGE_H */

Il file storage.c assomiglia a questo ...

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

/* Initialise an empty array */
void Array_Init(Array *array) 
{
    int *int_pointer;

    int_pointer = (int *)malloc(sizeof(int));

    if (int_pointer == NULL)
    {       
        printf("Unable to allocate memory, exiting.\n");
        free(int_pointer);
        exit(0);
    }
    else
    {
        array->array = int_pointer; 
        array->size = 0;
    }
}

/* Dynamically add to end of an array */
void Array_Add(Array *array, int item) 
{
    int *int_pointer;

    array->size += 1;

    int_pointer = (int *)realloc(array->array, array->size * sizeof(int));

    if (int_pointer == NULL)
    {       
        printf("Unable to reallocate memory, exiting.\n");
        free(int_pointer);
        exit(0);
    }
    else
    {
        array->array = int_pointer;
        array->array[array->size-1] = item;
    }
}

/* Delete from a dynamic array */
void Array_Delete(Array *array, int index) 
{
    int i;
    Array temp;
    int *int_pointer;

    Array_Init(&temp);

    for(i=index; i<array->size; i++)
    {
        array->array[i] = array->array[i + 1];
    }

    array->size -= 1;

    for (i = 0; i < array->size; i++)
    {
        Array_Add(&temp, array->array[i]);
    }

    int_pointer = (int *)realloc(temp.array, temp.size * sizeof(int));

    if (int_pointer == NULL)
    {       
        printf("Unable to reallocate memory, exiting.\n");
        free(int_pointer);
        exit(0);
    }
    else
    {
        array->array = int_pointer; 
    } 
}

/* Free an array */
void Array_Free(Array *array) 
{
  free(array->array);
  array->array = NULL;
  array->size = 0;  
}

Il main.c assomiglia a questo ...

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

int main(int argc, char** argv) 
{
    Array pointers;
    int i;

    Array_Init(&pointers);

    for (i = 0; i < 60; i++)
    {
        Array_Add(&pointers, i);        
    }

    Array_Delete(&pointers, 3);

    Array_Delete(&pointers, 6);

    Array_Delete(&pointers, 30);

    for (i = 0; i < pointers.size; i++)
    {        
        printf("Value: %d Size:%d \n", pointers.array[i], pointers.size);
    }

    Array_Free(&pointers);

    return (EXIT_SUCCESS);
}

Attendo con ansia le critiche costruttive da seguire ...

Quando dici

crea un array contenente un numero indice (int) di un numero indeterminato di entità

in pratica stai dicendo che stai usando "puntatori", ma uno che è un puntatore locale a livello di array anziché un puntatore a livello di memoria. Dal momento che concettualmente stai già utilizzando i "puntatori" (ovvero i numeri ID che si riferiscono a un elemento in un array), perché non usi semplicemente i puntatori regolari (ovvero i numeri ID che si riferiscono a un elemento nell'array più grande: l'intera memoria ).

Invece che i tuoi oggetti memorizzino i numeri ID di una risorsa, puoi invece far loro memorizzare un puntatore. Praticamente la stessa cosa, ma molto più efficiente poiché evitiamo di trasformare "array + index" in un "puntatore".

I puntatori non fanno paura se li consideri come indice di array per l'intera memoria (che è quello che sono realmente)

Per creare un array di oggetti illimitati di qualsiasi tipo:

typedef struct STRUCT_SS_VECTOR {
    size_t size;
    void** items;
} ss_vector;


ss_vector* ss_init_vector(size_t item_size) {
    ss_vector* vector;
    vector = malloc(sizeof(ss_vector));
    vector->size = 0;
    vector->items = calloc(0, item_size);

    return vector;
}

void ss_vector_append(ss_vector* vec, void* item) {
    vec->size++;
    vec->items = realloc(vec->items, vec->size * sizeof(item));
    vec->items[vec->size - 1] = item;
};

void ss_vector_free(ss_vector* vec) {
    for (int i = 0; i < vec->size; i++)
        free(vec->items[i]);

    free(vec->items);
    free(vec);
}

e come usarlo:

// defining some sort of struct, can be anything really
typedef struct APPLE_STRUCT {
    int id;
} apple;

apple* init_apple(int id) {
    apple* a;
    a = malloc(sizeof(apple));
    a-> id = id;
    return a;
};


int main(int argc, char* argv[]) {
    ss_vector* vector = ss_init_vector(sizeof(apple));

    // inserting some items
    for (int i = 0; i < 10; i++)
        ss_vector_append(vector, init_apple(i));


    // dont forget to free it
    ss_vector_free(vector);

    return 0;
}

Questo vettore / array può contenere qualsiasi tipo di elemento ed è di dimensioni completamente dinamiche.

Bene, immagino che se hai bisogno di rimuovere un elemento, farai una copia dell'array che disprezza l'elemento da escludere.

// inserting some items
void* element_2_remove = getElement2BRemove();

for (int i = 0; i < vector->size; i++){
       if(vector[i]!=element_2_remove) copy2TempVector(vector[i]);
       }

free(vector->items);
free(vector);
fillFromTempVector(vector);
//

Supponi che getElement2BRemove(), copy2TempVector( void* ...)e fillFromTempVector(...)sono metodi ausiliari per gestire il vettore temp.