C動的に成長する配列

ゲーム内のエンティティの「生の」リストを読み取るプログラムがあり、さまざまなものを処理するために、エンティティの数が不定のインデックス番号（int）を保持する配列を作成するつもりです。そのようなインデックスを維持するためにメモリやCPUを使いすぎないようにしたい...

私がこれまでに使用した迅速で汚い解決策は、メインの処理関数（ローカルフォーカス）で、最大ゲームエンティティのサイズの配列と、リストに追加された数を追跡する別の整数を宣言することです。すべてのリストが3000個以上の配列を保持しているため、これは満足のいくものではありませんが、それは無駄ではありませんが、さまざまな関数に6〜7個のリストのソリューションを使用できるので無駄です。

これを実現するためのC（C ++またはC＃ではない）固有のソリューションは見つかりませんでした。ポインターを使用することはできますが、ポインターを使用するのは少し怖いです（唯一の可能な方法でない限り）。

配列が変更された場合、配列はローカル関数のスコープを離れません（関数に渡され、その後破棄されます）。

ポインターが唯一の解決策である場合、リークを回避するためにポインターを追跡するにはどうすればよいですか？

ポインターは使用できますが、使用するのが少し怖いです。

動的配列が必要な場合、ポインターをエスケープすることはできません。なんで怖いの？彼らは噛みません（あなたが注意している限り）。Cには組み込みの動的配列はありません。自分で作成する必要があります。C ++では、組み込みstd::vectorクラスを使用できます。C＃と他のほぼすべての高水準言語にも、動的配列を管理する類似のクラスがあります。

独自に作成する予定がある場合は、次のように始めます。ほとんどの動的配列の実装は、いくつかの（小さい）デフォルトサイズの配列から始めて、新しい要素を追加するときにスペースが足りなくなるたびに、配列のサイズ。以下の例でわかるように、それほど難しくはありません（簡潔にするために、安全チェックは省略しています）。

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

使い方は簡単です：

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

私が考えることができるいくつかのオプションがあります。

1. リンクリスト。リンクされたリストを使用して、動的に成長する配列を作成できます。しかしarray[100]、1-99最初にウォークスルーしなければ、これを行うことはできません。そして、あなたが使うのもそれほど便利ではないかもしれません。
2. 大きな配列。すべてのために十分なスペース以上のアレイを作成するだけです
3. 配列のサイズを変更しています。サイズがわかったらアレイを再作成するか、マージンを確保してスペースが不足するたびに新しいアレイを作成し、すべてのデータを新しいアレイにコピーします。
4. リンクリスト配列の組み合わせ。単純に固定サイズの配列を使用し、スペースがなくなったら、新しい配列を作成してそれにリンクします（構造体の配列と次の配列へのリンクを追跡することをお勧めします）。

どのオプションがあなたの状況に最適であるかを言うのは難しいです。もちろん、単純に大きな配列を作成することは最も簡単な解決策の1つであり、実際に大きくない限り、それほど大きな問題にはなりません。

当初よりも恐ろしいように見えるすべてのものと同様に、最初の恐怖を乗り越える最善の方法は は、未知の不快感に身浸す！結局のところ、それは私たちが最もよく学ぶような時です。

残念ながら、制限があります。関数の使い方をまだ学習している間は、たとえば教師の役割を引き受けないでください。よくある落とし穴であるにもかかわらず、エラー処理を省略していると偽って、使い方を知らないように見える人からの回答realloc（つまり、現在受け入れられている回答！）言及する必要があります。正しく使用する方法を説明する回答です。答えは、エラーチェックを実行するために、戻り値を別の変数に格納することです。realloc

関数を呼び出すたび、および配列を使用するたびに、ポインターを使用しています。変換は暗黙的に行われています。これは、恐らくもっと恐ろしいはずです。ほとんどの問題を引き起こすのは、目に見えないものだからです。たとえば、メモリリーク...

配列演算子はポインター演算子です。array[x]は本当にのショートカットであり*(array + x)、次のように分解できます：*および(array + x)。それが*あなたを混乱させるものである可能性が最も高いです。我々はさらに仮定して問題から付加を排除することができるxことが0、したがって、array[0]となる*array追加ため0値を変更しません...

...したがって、これは*arrayと同等であることがわかりarray[0]ます。どちらか一方を使いたい場所で使用でき、その逆も可能です。配列演算子はポインター演算子です。

malloc、reallocそして友達はあなたがずっと使ってきたポインタの概念を発明していません。これは、これを使用して他の機能を実装するだけです。これは、異なる形式のストレージ期間であり、サイズの大幅で動的な変更が必要な場合に最適です。

現在受け入れられている答えがStackOverflowに関する他の非常に根拠のあるアドバイスの粒度にも反すると同時に、このユースケースにぴったりとなるあまり知られていない機能を導入する機会を逃してしまうのは残念です：フレキシブル配列メンバー！それは実際にはかなり壊れた答えです... :(

を定義するときは、上限なしで、構造の最後でstruct配列を宣言します。例えば：

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

これにより、の配列をintと同じ割り当てに統合するcountことができ、このようにバインドすることは非常に便利です。

sizeof (struct int_list)はvalueサイズが0であるかのように動作するため、リストが空の構造体のサイズがわかります。reallocリストのサイズを指定するには、渡されたサイズに追加する必要があります。

もう1つの便利なヒントは、とrealloc(NULL, x)同等であることを覚えておくことmalloc(x)です。これを使用してコードを簡略化できます。例えば：

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 **最初の引数として使用することを選択した理由はすぐには明らかではないように思われるかもしれませんが、2番目の引数について考えるとvalue、内部から行われた変更は、push_back呼び出し元の関数からは見えません。同じことが最初の引数にも当てはまりますarray。ここだけでなく、他の関数でもを変更できるようにする必要があります...

array何も指さないところから始まります。空のリストです。それを初期化することは、それに追加することと同じです。例えば：

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

PS それが終わったら忘れないでくださいfree(array);！

上に構築さマッテオFurlans彼が言ったときに、デザインの「新しい要素を追加する際に最もダイナミックな配列の実装はいくつかの（小）デフォルトサイズの配列をオフに開始することで動作し、その後、あなたは、配列のサイズを2倍、スペースが不足したときに」。以下の「作業中」の違いは、サイズが2倍ではなく、必要なものだけを使用することです。また、簡単にするために安全チェックも省略しています... ブリムボリウムのアイデアに基づいて、コードに削除機能を追加しようとしました...

storage.hファイルは次のようになります...

#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ファイルは次のようになります...

#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は次のようになります...

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

続く建設的な批判を楽しみにしています...

あなたが言っているとき

不確定な数のエンティティのインデックス番号（int）を保持する配列を作成する

基本的には「ポインター」を使用していると言っていますが、これはメモリー全体のポインターではなく、配列全体のローカルポインターです。概念的にはすでに「ポインタ」（つまり、配列内の要素を参照するID番号）を使用しているので、通常のポインタ（つまり、最大の配列内の要素を参照するID番号：メモリ全体）を使用しないのはなぜですか）。

オブジェクトにリソースID番号を格納する代わりに、オブジェクトにポインタを格納させることができます。基本的には同じですが、「配列+インデックス」を「ポインタ」に変換することを避けるため、はるかに効率的です。

ポインタは、メモリ全体の配列インデックスと見なすと怖くない（これが実際のポインタです）。

あらゆる種類の無制限のアイテムの配列を作成するには：

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

そしてそれを使用する方法：

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

このベクトル/配列は、あらゆるタイプのアイテムを保持でき、サイズは完全に動的です。

ええと、要素を削除する必要がある場合は、除外する要素を省略した配列のコピーを作成します。

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

、、およびが一時ベクトルを処理するための補助メソッドgetElement2BRemove()であるcopy2TempVector( void* ...)と想定しfillFromTempVector(...)ます。