Передача динамического массива в функции в C

Попробуйте переделать его так, чтобы в него передавался указатель на указатель на массив, то есть ent **a. Тогда вы сможете обновить вызывающего абонента в новом местоположении массива.

Основная проблема здесь в том, что вы пытаетесь использовать realloc с выделенным стеком массивом. У тебя есть:

ent a[mSize];

Это автоматическое размещение в стеке. Если вы захотите использовать для этого realloc () позже, вы должны создать массив в куче с помощью malloc (), например:

ent *a = (ent*)malloc(mSize * sizeof(ent));

Чтобы библиотека malloc (и, следовательно, realloc () и т. д.) Знала о вашем массиве. Судя по всему, вы можете спутать C99 массивы переменной длины с истинным динамические массивы, поэтому убедитесь, что вы понимаете разницу, прежде чем пытаться это исправить.

На самом деле, если вы пишете динамические массивы на C, вы должны попытаться использовать дизайн в стиле ООП, чтобы инкапсулировать информацию о ваших массивах и скрыть ее от пользователя. Вы хотите объединить информацию (например, указатель и размер) о вашем массиве в структуру, а операции (например, выделение, добавление элементов, удаление элементов, освобождение и т. д.) - в специальные функции, которые работают с вашей структурой. Итак, у вас может быть:

typedef struct dynarray {
   elt *data;
   int size;
} dynarray;

И вы можете определить некоторые функции для работы с динамическими массивами:

// malloc a dynarray and its data and returns a pointer to the dynarray    
dynarray *dynarray_create();     

// add an element to dynarray and adjust its size if necessary
void dynarray_add_elt(dynarray *arr, elt value);

// return a particular element in the dynarray
elt dynarray_get_elt(dynarray *arr, int index);

// free the dynarray and its data.
void dynarray_free(dynarray *arr);

Таким образом, пользователю не нужно точно помнить, как распределять объекты или какой размер массива в настоящее время. Надеюсь, это поможет вам начать.

Вы передаете указатель массива по значению. Это означает следующее:

int main(int argc, char** argv) {
    ...
    ent *a; // This...
    ...
}

int addValues(ent *a, int mSize) {
    ...
    a = calloc(1, sizeof(ent); // ...is not the same as this
    //usual loop
    ...
}

поэтому изменение значения a в функции addValues не приводит к изменению значения a в main. Чтобы изменить значение a в main, вам нужно передать ссылку на него в addValues. В настоящий момент значение a копируется и передается в addValues. Чтобы передать ссылку на использование:

int addValues (int **a, int mSize)

и назовите это так:

int main(int argc, char** argv) {
    ...
    ent *a; // This...
    ...
    addValues (&a, mSize);
}

В addValues доступ к элементам такой:

(*a)[element]

и перераспределите массив следующим образом:

(*a) = calloc (...);

это хорошая причина использовать ООП. да, вы можете выполнять ООП на C, и это даже выглядит красиво, если все сделано правильно.

в этом простом случае вам не нужны ни наследование, ни полиморфизм, только концепции инкапсуляции и методов:

• определить структуру с длиной и указателем данных. возможно размер элемента.
• напишите функции получения / установки, которые работают с указателями на эту структуру.
• функция 'grow' изменяет указатель данных в структуре, но любой указатель структуры остается действительным.

Xahtep объясняет, как ваш вызывающий абонент может справиться с тем фактом, что realloc () может переместить массив в новое место. Пока вы это делаете, все будет в порядке.

realloc () может стать дорогим, если вы начнете работать с большими массивами. Вот тогда и пора задуматься об использовании других структур данных - связного списка, двоичного дерева и т. д.

Как указано, вы должны передать указатель на указатель, чтобы обновить значение указателя. Но я бы посоветовал изменить дизайн и избегать этой техники, в большинстве случаев ее можно и нужно избегать. Не зная, чего именно вы пытаетесь достичь, трудно предложить альтернативный дизайн, но я на 99% уверен, что это возможно по-другому. И как грустно Хавьер - думайте об объектах, и вы всегда получите лучший код.

Если вы изменили объявление переменной в основном на

ent *a = NULL;

код будет работать так, как вы предполагали, не освобождая выделенный стеком массив. Установка значения NULL работает, потому что realloc обрабатывает это так, как если бы пользователь вызвал malloc (size). Имейте в виду, что с этим изменением прототип addValue должен измениться на

int addValues(ent **a, int mSize)

и что код должен обрабатывать случай сбоя перераспределения. Например

while(....) { //Loop to add items to array
    tmp = realloc(*a, size*sizeof(ent));
    if (tmp) {
        *a = tmp;
    } else {
        // allocation failed. either free *a or keep *a and
        // return an error
    }
    //Add to array
    i++;
}

Я ожидал, что большинство реализаций realloc будут внутренне выделять вдвое больше памяти, если текущий буфер требует изменения размера, делая исходный код

size = size * 2;

ненужный.

Вы действительно обязаны использовать C? Это было бы отличным применением C++ "std :: vector", который представляет собой именно массив динамического размера (легко изменяемый с помощью одного вызова, который вам не нужно писать и отлаживать самостоятельно).