Динамическая длина массива в C [дубликат]

Если вы ищете объекты массива и не хотите откатывать свои собственные, попробуйте следующее:

1. Glib
2. Apache APR
3. NSPR

Ну, вы можете динамически выделить размер:

#include <stdio.h>

int main(int argc, char *argv[])
{
  int *array;
  int cnt;
  int i;

  /* In the real world, you should do a lot more error checking than this */
  printf("enter the amount\n");
  scanf("%d", &cnt);

  array = malloc(cnt * sizeof(int));

  /* do stuff with it */
  for(i=0; i < cnt; i++)
    array[i] = 10*i;

  for(i=0; i < cnt; i++)
    printf("array[%d] = %d\n", i, array[i]);

  free(array);

  return 0;
}

Вы можете использовать malloc для динамического распределения памяти (т. е. размер неизвестен до времени исполнения).

C - язык низкого уровня: вы должны вручную освободить память после ее использования; Если вы этого не сделаете, ваша программа будет страдать от утечек памяти.

UPDATE

Просто прочитайте свой комментарий к другому ответу.

Вы просите массив с динамически меняющимся размером.

Ну, C не имеет языковых / синтаксических возможностей для этого; вам нужно либо реализовать это самостоятельно, либо использовать библиотеку, которая уже реализовала его.

См. этот вопрос: Существует ли реализация автоматического масштабирования массива / динамического массива для C, которая поставляется с glibc?

Если вы новичок, возможно, вы еще не хотите иметь дело с malloc и free. Поэтому, если вы используете GCC, вы можете выделить массивы переменных размеров в стеке, просто указав размер как выражение.

Например:

#include <stdio.h>
void dyn_array(const unsigned int n) {
        int array[n];
        int i;

        for(i=0; i<n;i++) {
                array[i]=i*i;
        }
        for(i=0; i<n;i++) {
                printf("%d\n",array[i]);
        }
}
int main(int argc, char **argv) {
        dyn_array(argc);
        return 0;
}

Но имейте в виду что это нестандартное расширение, поэтому вы не должны рассчитывать на него, если важна переносимость.

Для чего-то подобного вам может понадобиться изучить структуры данных, такие как: Связанные списки (идеально подходит для этой ситуации) Различные деревья (двоичные деревья, кучи и т. д.) Стеки и amp; Queues

Но что касается создания экземпляра массива с переменным размером, это на самом деле невозможно.

Ближайшим к динамическому массиву является использование malloc и связанных с ним команд (delete, realloc, и т.д).

Но в этой ситуации использование команд, таких как malloc, может привести к необходимости расширения массива, дорогостоящей операции, когда вы инициализируете другой массив, а затем копируете в него старый массив. Списки и другие типы данных, как правило, намного лучше при изменении размера.

Вышеуказанные ответы верны, но есть одна коррекция, функция malloc () резервирует блок памяти указанного размера и возвращает указатель типа void *, который может быть введен в указатель любой формы. Синтаксис: ptr = (cast-type *) malloc (размер байта)

#include<stdio.h>
#include<cstdlib>
int main(int argc,char* argv[]){
int *arraySize,length;
scanf("%d",&length);
arraySize = (int*)malloc(length*sizeof(int));
for(int i=0;i<length;i++)
    arraySize[i] = i*2;
for(int i=0;i<length;i++)
    printf("arrayAt[%d]=%d\n",i,arraySize[i]);
free(arraySize);
}

Если вам нужна только структура данных, в которой вы можете изменить свой размер динамически, лучшим вариантом, который вы можете использовать, является связанный список. Вы можете добавить данные в список, динамически выделяя для него память, и это было бы намного проще!

Возможно, что-то вроде этого:

#include <stdio.h>
#include <stdlib.h>

/* An arbitrary starting size. 
   Should be close to what you expect to use, but not really that important */
#define INIT_ARRAY_SIZE 8

int array_size = INIT_ARRAY_SIZE;
int array_index = 0;
array = malloc(array_size * sizeof(int));

void array_push(int value) {
  array[array_index] = value;
  array_index++;
  if(array_index >= array_size) {
    array_size *= 2;
    array = realloc(array, array_size * sizeof(int));
  }
}

int main(int argc, char *argv[]) {
  int shouldBreak = 0;
  int val;
  while (!shouldBreak) {
    scanf("%d", &val);
    shouldBreak = (val == 0);
    array_push(val);
  }
}

Это вызовет номера и сохранит их в массиве, как вы просили. Он будет завершен при передаче с заданным значением 0.

Вы создаете функцию доступа array_push для добавления в ваш массив, вы вызываете realloc из этой функции, когда вы пробегаете пробел. Каждый раз вы удваиваете количество выделенного пространства. В лучшем случае вы выделите вдвое больше необходимой вам памяти, в худшем случае вы будете называть realloc log n раз, где n - окончательный размер предполагаемого массива.

Вы также можете проверить наличие ошибки после вызова malloc и realloc. Я не сделал этого выше.

Массивы, по определению, представляют собой структуры памяти фиксированного размера. Вы хотите вектор. Поскольку Standard C не определяет векторы, вы можете попытаться найти библиотеку или вручную перевернуть свой.

Вам нужно выполнить динамическое распределение: вы хотите, чтобы указатель на адрес памяти еще неранного размер. Читайте на malloc и realloc.

Да, абсолютно. C99 представил VLA или переменную длину массива. Некоторый простой код будет таким:

#include <stdio.h>

int main (void) {

    int arraysize;
    printf("How bid do you want your array to be?\n");
    scanf("%d",&arraysize);
    int ar[arraysize];  
    return 0;
}