C อาร์เรย์ที่เติบโตแบบไดนามิก

ฉันมีโปรแกรมที่อ่านรายการเอนทิตีในเกม "ดิบ" และฉันตั้งใจจะสร้างอาร์เรย์ที่มีหมายเลขดัชนี (int) ของเอนทิตีที่ไม่แน่นอนสำหรับการประมวลผลสิ่งต่างๆ ฉันต้องการหลีกเลี่ยงการใช้หน่วยความจำหรือ CPU มากเกินไปในการรักษาดัชนีดังกล่าว ...

วิธีแก้ปัญหาที่รวดเร็วและสกปรกที่ฉันใช้จนถึงตอนนี้คือการประกาศในฟังก์ชันการประมวลผลหลัก (โฟกัสเฉพาะที่) อาร์เรย์ที่มีขนาดของเอนทิตีเกมสูงสุดและจำนวนเต็มอื่นเพื่อติดตามจำนวนที่ถูกเพิ่มเข้าไปในรายการ สิ่งนี้ไม่น่าพอใจเนื่องจากทุกรายการมีอาร์เรย์มากกว่า 3,000 รายการซึ่งไม่มากนัก แต่รู้สึกว่าเป็นการสิ้นเปลืองเนื่องจากฉันจะใช้วิธีแก้ปัญหาได้ 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);

เช่นเดียวกับทุกสิ่งที่ดูน่ากลัวกว่าในตอนแรกวิธีที่ดีที่สุดในการเอาชนะความกลัวครั้งแรกคือการจมดิ่งลงไปในความรู้สึกไม่สบายตัวจากสิ่งที่ไม่รู้จัก ! บางครั้งก็เป็นเช่นนั้นที่เราเรียนรู้มากที่สุดหลังจากนั้น

น่าเสียดายที่มีข้อ จำกัด ในขณะที่คุณยังเรียนรู้ที่จะใช้ฟังก์ชันคุณไม่ควรสวมบทบาทเป็นครูเช่น ฉันมักจะอ่านคำตอบจากผู้ที่ดูเหมือนไม่รู้วิธีใช้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เพื่อระบุขนาดรายการของคุณ

เคล็ดลับที่มีประโยชน์อีกประการหนึ่งคือการจำไว้ว่า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 **เป็นอาร์กิวเมนต์แรกอาจดูเหมือนไม่ชัดเจนในทันที แต่ถ้าคุณคิดถึงอาร์กิวเมนต์ที่สองการเปลี่ยนแปลงใด ๆ ที่เกิดขึ้นvalueจากภายในpush_backจะไม่สามารถมองเห็นได้จากฟังก์ชันที่เราเรียกใช้ใช่ไหม เช่นเดียวกันกับอาร์กิวเมนต์แรกและเราจำเป็นต้องสามารถปรับเปลี่ยนของเราarrayได้ไม่ใช่แค่ที่นี่แต่อาจเป็นไปได้ในฟังก์ชันอื่น ๆ ที่เราส่งต่อให้ ...

arrayเริ่มจากการชี้ไปที่ความว่างเปล่า มันเป็นรายการว่างเปล่า การเริ่มต้นจะเหมือนกับการเพิ่มเข้าไป ตัวอย่างเช่น:

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

ปล. อย่าลืมว่าfree(array);เมื่อคุณทำเสร็จแล้ว!

มีสองตัวเลือกที่ฉันคิดได้

1. รายการที่เชื่อมโยง คุณสามารถใช้รายการที่เชื่อมโยงเพื่อสร้างอาร์เรย์ที่เติบโตแบบไดนามิกเช่นสิ่งของ แต่คุณจะไม่สามารถทำได้array[100]โดยไม่ต้องเดินผ่าน1-99ก่อน และมันอาจไม่สะดวกสำหรับคุณที่จะใช้เช่นกัน
2. อาร์เรย์ขนาดใหญ่ เพียงสร้างอาร์เรย์ที่มีพื้นที่เพียงพอสำหรับทุกสิ่ง
3. การปรับขนาดอาร์เรย์ สร้างอาร์เรย์ใหม่เมื่อคุณทราบขนาดและ / หรือสร้างอาร์เรย์ใหม่ทุกครั้งที่คุณไม่มีพื้นที่ว่างโดยมีระยะขอบบางส่วนและคัดลอกข้อมูลทั้งหมดไปยังอาร์เรย์ใหม่
4. การรวมรายการอาร์เรย์ที่เชื่อมโยง เพียงใช้อาร์เรย์ที่มีขนาดคงที่และเมื่อคุณหมดพื้นที่ให้สร้างอาร์เรย์ใหม่และเชื่อมโยงไปยังสิ่งนั้น (ควรติดตามอาร์เรย์และลิงก์ไปยังอาร์เรย์ถัดไปในโครงสร้าง)

ยากที่จะบอกว่าตัวเลือกใดดีที่สุดในสถานการณ์ของคุณ เพียงแค่สร้างอาร์เรย์ขนาดใหญ่ก็ถือเป็นวิธีแก้ปัญหาที่ง่ายที่สุดวิธีหนึ่งและไม่ควรให้ปัญหามากนักเว้นแต่จะมีขนาดใหญ่มาก

จากการออกแบบของMatteo Furlansเมื่อเขากล่าวว่า " การใช้อาร์เรย์แบบไดนามิกส่วนใหญ่ทำงานได้โดยเริ่มต้นด้วยอาร์เรย์ของขนาดเริ่มต้นบางส่วน (เล็ก) จากนั้นเมื่อใดก็ตามที่คุณไม่มีพื้นที่ว่างเมื่อเพิ่มองค์ประกอบใหม่ให้เพิ่มขนาดของอาร์เรย์เป็นสองเท่า " ความแตกต่างของ " งานระหว่างทำ " ด้านล่างคือขนาดไม่ได้เป็นสองเท่าโดยมีจุดมุ่งหมายเพื่อใช้เฉพาะสิ่งที่จำเป็น ฉันได้ละเว้นการตรวจสอบความปลอดภัยเพื่อความเรียบง่าย ... นอกจากนี้จากแนวคิดbrimboriumsฉันได้พยายามเพิ่มฟังก์ชันการลบลงในโค้ด ...

ไฟล์ 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 ที่อ้างถึงองค์ประกอบในอาร์เรย์ที่ใหญ่ที่สุด: หน่วยความจำทั้งหมด )

แทนที่จะให้ออบเจ็กต์ของคุณจัดเก็บหมายเลขรหัสทรัพยากรคุณสามารถทำให้วัตถุเหล่านั้นเก็บเป็นตัวชี้แทนได้ โดยพื้นฐานแล้วสิ่งเดียวกัน แต่มีประสิทธิภาพมากกว่าเนื่องจากเราหลีกเลี่ยงการเปลี่ยน "array + index" เป็น "pointer"

พอยน์เตอร์ไม่น่ากลัวถ้าคุณคิดว่ามันเป็นดัชนีอาร์เรย์สำหรับหน่วยความจำทั้งหมด (ซึ่งก็คือสิ่งที่เป็นจริง)

ในการสร้างอาร์เรย์ของรายการไม่ จำกัด ประเภทใด ๆ :

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(...)วิธีการที่ช่วยเสริมการจัดการเวกเตอร์ชั่วคราว