C dinamik olarak büyüyen dizi

Oyun içi varlıkların "ham" listesini okuyan bir programım var ve çeşitli şeyleri işlemek için belirsiz sayıda varlığın indeks numarasını (int) tutan bir dizi yapmak niyetindeyim. Bu tür dizinleri saklamak için çok fazla bellek veya CPU kullanmaktan kaçınmak istiyorum ...

Şimdiye kadar kullandığım hızlı ve kirli bir çözüm, ana işleme işlevinde (yerel odak) maksimum oyun varlıklarının boyutuna sahip bir dizi ve listeye kaç tane eklendiğini takip etmek için başka bir tamsayı bildirmektir. Her liste 3000'den fazla dizi içerdiğinden, bu tatmin edici değil, bu o kadar da değil, ama bir israf gibi geliyor, çünkü çözümü çeşitli işlevler için 6-7 liste için kullanabilirim.

Bunu başarmak için C'ye (C ++ veya C # değil) özel çözümler bulamadım. İşaretçileri kullanabilirim, ancak onları kullanmaktan biraz korkuyorum (mümkün olan tek yol bu değilse).

Bir şeyleri değiştirmesi durumunda, diziler yerel işlev kapsamını terk etmezler (bir işleve iletilirler, sonra atılırlar).

İşaretçiler tek çözümse, sızıntıları önlemek için bunları nasıl takip edebilirim?

İşaretçileri kullanabilirim, ancak onları kullanmaktan biraz korkuyorum.

Dinamik bir diziye ihtiyacınız varsa, işaretçilerden kaçamazsınız. Yine de neden korkuyorsun? Isırmazlar (dikkatli olduğunuz sürece, yani). C'de yerleşik dinamik dizi yoktur, sadece kendiniz bir tane yazmanız gerekir. C ++ 'da yerleşik std::vectorsınıfı kullanabilirsiniz. C # ve diğer tüm yüksek seviyeli dillerin de sizin için dinamik dizileri yöneten benzer bir sınıfı vardır.

Kendi yazınızı yazmayı planlıyorsanız, işte başlamanız için bir şey var: çoğu dinamik dizi uygulaması, bazı (küçük) varsayılan boyutta bir dizi ile başlayarak çalışır, daha sonra yeni bir öğe eklerken alanınız bittiğinde, dizinin boyutu. Aşağıdaki örnekte görebileceğiniz gibi, hiç de zor değil: (Kısalık için güvenlik kontrollerini atladım)

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;
}

Bunu kullanmak da çok basit:

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);

İlk başta daha sonra olduğundan daha korkunç görünen her şeyde olduğu gibi, ilk korkuyu aşmanın en iyi yolu kendinizi bilinmeyenin rahatsızlığına kaptırmaktır ! Ne de olsa bazen en çok öğrendiğimiz şeydir.

Maalesef sınırlamalar var. Hâlâ bir işlevi kullanmayı öğrenirken, örneğin bir öğretmen rolünü üstlenmemelisiniz. Görünüşe göre nasıl kullanılacağını bilmeyenlerin realloc(yani şu anda kabul edilen cevap! ) Başkalarına yanlış bir şekilde nasıl kullanacaklarını söyleyen cevaplarını sık sık okurum, bu yaygın bir tuzak olmasına rağmen, bazen hata işlemeyi ihmal ettikleri kisvesi altında. bahsetmesi gereken. İşte nasıl kullanılacağını açıklayan bir cevap değil reallocdoğru . Hata kontrolü yapmak için cevabın dönüş değerini farklı bir değişkene kaydettiğine dikkat edin .

Bir işlevi her çağırdığınızda ve bir diziyi her kullandığınızda, bir işaretçi kullanırsınız. Dönüşümler örtük olarak gerçekleşiyor, bu da daha da korkutucu olmalı, çünkü genellikle en çok soruna neden olan, görmediğimiz şeylerdir. Örneğin bellek sızıntıları ...

Dizi operatörleri işaretçi operatörleridir. array[x]gerçekten bir kısayol *(array + x)olup, şu şekilde ayrılabilir: *ve (array + x). Büyük ihtimalle *kafanızı karıştıran şey budur. Biz ayrıca varsayarak problemden eklenmesini ortadan kaldırabilir xolmak 0, böylece array[0]olur *arrayekleyerek çünkü 0değerini değiştirmeyecektir ...

... ve böylece bunun *arrayeşdeğer olduğunu görebiliriz array[0]. Birini kullanmak istediğiniz yerde kullanabilirsiniz ve bunun tersi de geçerlidir. Dizi operatörleri işaretçi operatörleridir.

malloc, reallocVe arkadaşlar yok icat Eğer baştan beri kullanıyorum bir işaretçi kavramını; bunu yalnızca , boyutta şiddetli, dinamik değişiklikler istediğinizde en uygun olan, farklı bir depolama süresi biçimi olan başka bir özelliği uygulamak için kullanırlar .

Şu anda kabul edilen cevap bu utanç verici , aynı zamanda bir ters geliyor StackOverflow'daki diğer bazı çok sağlam temellere dayanan tavsiye ve aynı zamanda, tam da bu USECASE parlar az bilinen bir özelliği tanıtmak için bir fırsat kaçırır: Esnek dizi üyeler! Bu aslında oldukça bozuk bir cevap ... :(

Dizinizi tanımladığınızda, üst sınır olmadan yapının sonundastruct dizinizi bildirin. Örneğin:

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

Bu, dizinizi kendinizle intaynı ayırmada birleştirmenize olanak tanır countve bunların bu şekilde bağlanması çok kullanışlı olabilir !

sizeof (struct int_list)value0 boyutuna sahipmiş gibi davranacak , bu yüzden size yapının boyutunu boş bir liste ile söyleyecektir . reallocListenizin boyutunu belirtmek için geçilen boyutu yine de eklemeniz gerekir .

Başka bir kullanışlı ipucu da realloc(NULL, x)bunun eşdeğer olduğunu hatırlamaktır malloc(x)ve bunu kodumuzu basitleştirmek için kullanabiliriz. Örneğin:

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;

struct int_list **İlk argüman olarak kullanmayı seçmemin nedeni hemen açık görünmeyebilir, ancak ikinci argümanı düşünürseniz value, içeriden yapılan herhangi bir değişiklik, push_backçağırdığımız fonksiyon tarafından görünmez, değil mi? Aynısı ilk argüman için de geçerli ve bizim arraysadece burada değil, aynı zamanda muhtemelen onu aktardığımız diğer fonksiyonlarda da değiştirebilmeliyiz ...

arrayhiçbir şeye işaret etmeye başlar; bu boş bir listedir. İlklendirmek, ona eklemekle aynı şeydir. Örneğin:

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

Not: İşinizfree(array); bittiğinde bunu unutmayın!

Aklıma gelen birkaç seçenek var.

1. Bağlantılı liste. Dinamik olarak büyüyen bir dizi benzeri şey yapmak için bağlantılı bir liste kullanabilirsiniz. Ama önce array[100]yürümek zorunda kalmadan yapamayacaksın 1-99. Ve kullanmak sizin için o kadar da kullanışlı olmayabilir.
2. Büyük dizi. Her şey için fazlasıyla yeterli alana sahip bir dizi oluşturun
3. Dizi yeniden boyutlandırılıyor. Diziyi, boyutunu öğrendikten ve / veya bir miktar marjla alanınız her bittiğinde yeni bir dizi oluşturduğunuzda yeniden oluşturun ve tüm verileri yeni diziye kopyalayın.
4. Bağlantılı Liste Dizisi kombinasyonu. Basitçe sabit boyutlu bir dizi kullanın ve alanınız tükendiğinde, yeni bir dizi oluşturun ve buna bağlantı verin (diziyi ve bir yapıdaki sonraki diziye olan bağlantıyı takip etmek akıllıca olacaktır).

Sizin durumunuzda hangi seçeneğin en iyi olacağını söylemek zor. Basitçe geniş bir dizi oluşturmak elbette en kolay çözümlerden biridir ve gerçekten büyük olmadığı sürece size fazla sorun çıkarmamalıdır.

Bina Matteo Furlans hakkındaki sözleri, tasarım " yeni bir öğe eklerken en dinamik dizi uygulamaları bazı (küçük) varsayılan boyutta bir dizi kapalı başlatarak işe, o zaman dizinin boyutunu iki katına, alanı tükendi zaman ". Aşağıdaki "devam eden çalışma " daki fark, boyut olarak iki katına çıkmaması, sadece gerekli olanı kullanmayı amaçlamasıdır. Ayrıca basitlik için güvenlik kontrollerini de atladım ... Ayrıca brimboriums fikrinden yola çıkarak , koda bir silme işlevi eklemeye çalıştım ...

Storage.h dosyası şuna benzer ...

#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 */

Storage.c dosyası şuna benzer ...

#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;  
}

Main.c şuna benzer ...

#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);
}

Yapıcı eleştiriyi takip etmek için sabırsızlanıyoruz ...

Söylediğin zaman

belirsiz sayıda varlığın dizin numarasını (int) tutan bir dizi yapmak

temelde "işaretçiler" kullandığınızı söylüyorsunuz, ancak bellek genişliğinde işaretçi yerine dizi çapında yerel işaretçi kullanıyorsunuz. Kavramsal olarak zaten "işaretçiler" (yani bir dizideki bir öğeyi ifade eden kimlik numaraları) kullandığınız için, neden yalnızca normal işaretçiler kullanmıyorsunuz (yani en büyük dizideki bir öğeye atıfta bulunan kimlik numaraları: tüm bellek ).

Nesnelerinizin bir kaynak kimlik numarası depolaması yerine, bunun yerine bir işaretçi depolamalarını sağlayabilirsiniz. Temelde aynı şey, ancak "dizi + indeksi" bir "işaretçi" ye dönüştürmekten kaçındığımız için çok daha verimli.

İşaretçiler, onları tüm bellek için dizi indeksi olarak düşünürseniz korkutucu değildir (gerçekte oldukları şey budur)

Her türden sınırsız öğe dizisi oluşturmak için:

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);
}

ve nasıl kullanılacağı:

// 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;
}

Bu vektör / dizi her tür öğeyi tutabilir ve boyut olarak tamamen dinamiktir.

Sanırım, bir öğeyi kaldırmanız gerekirse, dizinin, hariç tutulacak öğeyi küçümseyen bir kopyasını yapacaksınız.

// 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);
//

Varsayalım getElement2BRemove(), copy2TempVector( void* ...)ve fillFromTempVector(...)geçici vektörü işlemek için yardımcı yöntemlerdir.