C mảng tăng trưởng động

Tôi có một chương trình đọc danh sách các thực thể trong trò chơi "thô" và tôi dự định tạo một mảng chứa số chỉ mục (int) của một số lượng thực thể không xác định, để xử lý nhiều thứ khác nhau. Tôi muốn tránh sử dụng quá nhiều bộ nhớ hoặc CPU để giữ các chỉ mục như vậy ...

Một giải pháp nhanh và bẩn mà tôi sử dụng cho đến nay là khai báo, trong hàm xử lý chính (tiêu điểm cục bộ) mảng có kích thước của các thực thể trò chơi tối đa và một số nguyên khác để theo dõi số lượng đã được thêm vào danh sách. Điều này không thỏa đáng, vì mỗi danh sách chứa hơn 3000 mảng, không nhiều, nhưng cảm thấy lãng phí, vì tôi có thể sử dụng giải pháp cho 6-7 danh sách cho các chức năng khác nhau.

Tôi chưa tìm thấy bất kỳ giải pháp cụ thể C (không phải C ++ hoặc C #) nào để đạt được điều này. Tôi có thể sử dụng con trỏ, nhưng tôi hơi sợ sử dụng chúng (trừ khi đó là cách khả thi duy nhất).

Các mảng không rời khỏi phạm vi chức năng cục bộ (chúng sẽ được chuyển đến một chức năng, sau đó loại bỏ), trong trường hợp thay đổi mọi thứ.

Nếu con trỏ là giải pháp duy nhất, làm thế nào tôi có thể theo dõi chúng để tránh rò rỉ?

Tôi có thể sử dụng con trỏ, nhưng tôi hơi sợ sử dụng chúng.

Nếu bạn cần một mảng động, bạn không thể thoát con trỏ. Tại sao bạn sợ? Họ sẽ không cắn (miễn là bạn cẩn thận, đó là). Không có mảng động tích hợp trong C, bạn sẽ phải tự viết một cái. Trong C ++, bạn có thể sử dụng std::vectorlớp tích hợp. C # và mọi ngôn ngữ cấp cao khác cũng có một số lớp tương tự quản lý các mảng động cho bạn.

Nếu bạn có kế hoạch tự viết, đây là thứ giúp bạn bắt đầu: hầu hết các triển khai mảng động đều hoạt động bằng cách bắt đầu với một mảng có kích thước mặc định (nhỏ), sau đó bất cứ khi nào bạn hết dung lượng khi thêm phần tử mới, hãy nhân đôi kích thước của mảng. Như bạn có thể thấy trong ví dụ dưới đây, điều đó không khó lắm: (Tôi đã bỏ qua kiểm tra an toàn cho sự ngắn gọn)

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

Sử dụng nó rất đơn giản:

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

Có một vài lựa chọn tôi có thể nghĩ ra.

1. Danh sách liên kết. Bạn có thể sử dụng một danh sách được liên kết để tạo ra một mảng tăng trưởng linh hoạt như điều. Nhưng bạn sẽ không thể làm array[100]mà không cần phải đi qua 1-99trước. Và nó có thể không hữu ích cho bạn để sử dụng.
2. Mảng lớn. Đơn giản chỉ cần tạo một mảng với không gian đủ cho tất cả mọi thứ
3. Thay đổi kích thước mảng. Tái tạo mảng một khi bạn biết kích thước và / hoặc tạo một mảng mới mỗi khi bạn hết dung lượng với một số lề và sao chép tất cả dữ liệu sang mảng mới.
4. Danh sách liên kết kết hợp mảng. Đơn giản chỉ cần sử dụng một mảng với kích thước cố định và một khi bạn hết dung lượng, hãy tạo một mảng mới và liên kết đến đó (sẽ là khôn ngoan khi theo dõi mảng và liên kết đến mảng tiếp theo trong một cấu trúc).

Thật khó để nói lựa chọn nào sẽ là tốt nhất trong tình huống của bạn. Đơn giản chỉ cần tạo một mảng lớn là một trong những giải pháp đơn giản nhất và không nên cung cấp cho bạn nhiều vấn đề trừ khi nó thực sự lớn.

Như với mọi thứ ban đầu có vẻ đáng sợ hơn so với sau này, cách tốt nhất để vượt qua nỗi sợ hãi ban đầu là đắm mình vào sự khó chịu của những điều chưa biết ! Rốt cuộc, đó là lúc chúng ta học hỏi nhiều nhất.

Thật không may, có những hạn chế. Trong khi bạn vẫn đang học cách sử dụng một chức năng, chẳng hạn, bạn không nên đảm nhận vai trò của một giáo viên. Tôi thường đọc câu trả lời từ những người dường như không biết cách sử dụng realloc(nghĩa là câu trả lời hiện đang được chấp nhận! ) Nói cho người khác biết cách sử dụng không chính xác, đôi khi theo giả định rằng họ đã bỏ qua việc xử lý lỗi , mặc dù đây là một lỗi phổ biến trong đó cần đề cập. Đây là một câu trả lời giải thích làm thế nào để sử dụng reallocchính xác . Hãy lưu ý rằng câu trả lời là lưu trữ giá trị trả về vào một biến khác để thực hiện kiểm tra lỗi.

Mỗi khi bạn gọi một hàm và mỗi khi bạn sử dụng một mảng, bạn đang sử dụng một con trỏ. Các chuyển đổi đang diễn ra ngầm, nếu có bất cứ điều gì thậm chí còn đáng sợ hơn, vì đó là những điều chúng ta không thấy thường gây ra nhiều vấn đề nhất. Ví dụ, rò rỉ bộ nhớ ...

Toán tử mảng là toán tử con trỏ. array[x]thực sự là một lối tắt cho *(array + x), có thể được chia thành: *và (array + x). Rất có thể đó *là điều khiến bạn bối rối. Chúng tôi cũng có thể loại bỏ việc bổ sung từ các vấn đề bằng cách giả sử xlà 0, do đó, array[0]trở thành *arrayvì thêm 0sẽ không thay đổi giá trị ...

... và do đó chúng ta có thể thấy điều đó *arraytương đương với array[0]. Bạn có thể sử dụng một nơi mà bạn muốn sử dụng cái khác và ngược lại. Toán tử mảng là toán tử con trỏ.

malloc, reallocVà bạn bè không phát minh ra khái niệm về một con trỏ mà bạn đã sử dụng tất cả cùng; họ chỉ sử dụng điều này để thực hiện một số tính năng khác, đây là một dạng thời lượng lưu trữ khác, phù hợp nhất khi bạn muốn thay đổi mạnh mẽ, năng động về kích thước .

Thật xấu hổ khi câu trả lời hiện đang được chấp nhận cũng đi ngược lại với một số lời khuyên rất có căn cứ khác về StackOverflow , đồng thời, bỏ lỡ một cơ hội để giới thiệu một tính năng ít được biết đến tỏa sáng cho chính xác usecase này: mảng linh hoạt các thành viên! Đó thực sự là một câu trả lời khá bị hỏng ... :(

Khi bạn xác định struct, khai báo mảng của bạn ở cuối cấu trúc, không có giới hạn trên. Ví dụ:

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

Điều này sẽ cho phép bạn hợp nhất mảng của bạn intthành phân bổ giống như của bạn countvà việc ràng buộc chúng như thế này có thể rất tiện lợi !

sizeof (struct int_list)sẽ hoạt động như thể valuecó kích thước bằng 0, vì vậy nó sẽ cho bạn biết kích thước của cấu trúc với một danh sách trống . Bạn vẫn cần thêm vào kích thước được truyền reallocđể xác định kích thước danh sách của bạn.

Một mẹo hữu ích khác là hãy nhớ rằng realloc(NULL, x)nó tương đương với malloc(x)và chúng ta có thể sử dụng điều này để đơn giản hóa mã của mình. Ví dụ:

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;

Lý do tôi chọn sử dụng struct int_list **làm đối số thứ nhất có vẻ không rõ ràng ngay lập tức, nhưng nếu bạn nghĩ về đối số thứ hai, mọi thay đổi được thực hiện valuetừ bên trong push_backsẽ không hiển thị đối với chức năng mà chúng ta đang gọi, phải không? Điều tương tự cũng xảy ra với đối số đầu tiên và chúng ta cần có thể sửa đổi array, không chỉ ở đây mà còn ở bất kỳ chức năng nào khác mà chúng ta chuyển nó sang ...

arraybắt đầu chỉ vào không có gì; nó là một danh sách trống Khởi tạo nó cũng giống như thêm vào nó. Ví dụ:

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

PS Hãy nhớfree(array); khi bạn hoàn thành nó!

Dựa trên thiết kế của Matteo Furlans , khi ông nói " hầu hết các triển khai mảng động hoạt động bằng cách bắt đầu với một mảng có kích thước mặc định (nhỏ), sau đó bất cứ khi nào bạn hết dung lượng khi thêm một phần tử mới, hãy tăng gấp đôi kích thước của mảng ". Sự khác biệt trong " công việc đang tiến triển " dưới đây là nó không tăng gấp đôi kích thước, nó chỉ nhằm mục đích sử dụng những gì được yêu cầu. Tôi cũng đã bỏ qua các kiểm tra an toàn vì đơn giản ... Ngoài ra, dựa trên ý tưởng của brimboriums , tôi đã cố gắng thêm chức năng xóa vào mã ...

Tệp Storage.h trông như thế này ...

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

Tệp Storage.c trông như thế này ...

#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 trông như thế này ...

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

Mong chờ những lời chỉ trích mang tính xây dựng để làm theo ...

Khi bạn nói

tạo một mảng chứa số chỉ mục (int) của số lượng thực thể không xác định

về cơ bản bạn đang nói rằng bạn đang sử dụng "con trỏ", nhưng một con trỏ là con trỏ cục bộ toàn mảng thay vì con trỏ trên toàn bộ nhớ. Vì về mặt khái niệm bạn đã sử dụng "con trỏ" (tức là số id liên quan đến một phần tử trong một mảng), tại sao bạn không sử dụng các con trỏ thông thường (tức là số id đề cập đến một phần tử trong mảng lớn nhất: toàn bộ bộ nhớ ).

Thay vì các đối tượng của bạn lưu trữ một số id tài nguyên, bạn có thể làm cho chúng lưu trữ một con trỏ thay thế. Về cơ bản điều tương tự, nhưng hiệu quả hơn nhiều vì chúng ta tránh biến "mảng + chỉ mục" thành "con trỏ".

Con trỏ không đáng sợ nếu bạn nghĩ chúng là chỉ số mảng cho toàn bộ bộ nhớ (đó là những gì chúng thực sự là)

Để tạo một mảng các mục không giới hạn thuộc bất kỳ loại nào:

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

và cách sử dụng nó:

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

Vectơ / mảng này có thể chứa bất kỳ loại vật phẩm nào và nó hoàn toàn năng động về kích thước.

Chà, tôi đoán nếu bạn cần loại bỏ một phần tử, bạn sẽ tạo một bản sao của mảng coi thường phần tử bị loại trừ.

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

Giả sử rằng getElement2BRemove(), copy2TempVector( void* ...)và fillFromTempVector(...)là các phương thức phụ trợ để xử lý vectơ tạm thời.