Определение массива C / C ++

Это не "более правильно" или "менее корректно". Это либо есть исключающий не является правильным. В частности, это работает на C, но не в C++.

Вы объявляете динамические массивы. Лучший способ объявить динамические массивы как

int *arr;  // int * type is just for simplicity
arr = malloc(n*sizeof(int*));  

это связано с тем, что массивы переменной длины разрешены только на C99, и вы не можете использовать это в c89/90.

Если вы знаете SIZE во время компиляции:

int ar[SIZE];

Если вы этого не сделаете:

std::vector<int> ar;

Я не хочу видеть malloc любом месте вашего кода C++. Тем не менее, вы в корне верны, и для C это то, что вы сделали бы:

int* ptr = malloc(sizeof(int) * SIZE);
/* ... */
free(ptr);

Массивы переменной длины - это расширение GCC, которое позволяет:

int ar[n];

но у меня были проблемы, когда VLA были отключены, но GCC не смог обнаружить, что я пытался их использовать. Наступает Хаос. Просто избегайте этого.

В (pre-C99) C и C++ все типы имеют статический размер. Это означает, что массивы должны быть объявлены с размером, который является постоянным и известен компилятору.

Теперь многие компиляторы C++ предлагают массивы с динамическим размером как нестандартное расширение, и C99 явно разрешает их. Поэтому int b[n], скорее всего, будет работать, если вы попробуете его. Но в некоторых случаях это не будет, и компилятор не ошибается в этих случаях.

Оба правильные. используемая вами декларация зависит от вашего кода.

Первая декларация, т.е. int a[size]; создает массив с фиксированным размером 20 элементов. Это полезно, когда вы знаете точный размер массива, который будет использоваться в коде. например, вы генерируете таблицу числа n до 20-го числа.

Второе объявление позволяет вам создать массив требуемого размера. Это полезно, когда вам понадобится массив разных размеров, каждый раз, когда код выполняется, например, вы хотите сгенерировать серию фибоначчи до n. В этом случае размер массива должен быть n для каждого значения n. Итак, скажем, что у вас есть n = 5, в этом случае int a [20] потеряет память, потому что для серии фибоначчи будут использоваться только первые пять слотов, а остальные будут пустыми. Аналогично, если n = 25 то ваш массив int a[20] станет слишком маленьким.

Я думаю, что metod1 может быть немного быстрее, но оба они верны в C.

В C++ сначала будет работать, но если вы хотите использовать вторую, вы должны использовать:

 int size = 5;
 int * array = new int[size];

и не забудьте удалить его:

 delete [] array;

Я думаю, это дает вам больше возможностей для использования во время кодирования.

Если вы используете malloc или другое динамическое распределение, чтобы получить указатель. Вы будете использовать как p + n..., но если вы используете массив, вы можете использовать array[n]. Кроме того, указав указатель, вам нужно его освободить; но массив не нужно free.

И в C++ мы могли бы определить пользовательский класс для выполнения таких вещей, а в STL существует std :: vector, который делает массив-вещи и многое другое.

Разница, если вы определяете массив с помощью malloc, заключается в том, что вы можете передавать размер массива динамически, т.е. Во время выполнения. Вы вводите значение, которое ваша программа имеет во время выполнения. Еще одно отличие состоит в том, что массивы, созданные с использованием malloc, выделяются в кучу. Таким образом, они сохраняются в функциональных вызовах, в отличие от статических массивов.

example-

       #include<stdio.h>
       #include<stdlib.h>
       int main()
       {
           int n;
           int *a;
           scanf("%d",&n);
           a=(int *)malloc(n*sizeof(int));
           return 0;
       }