Путаница между "int array [int]" и "int * array"

Question

int array[100];

int *array;

Так что я немного путаюсь с различиями между int array[100] против int * array.

По существу, когда я делаю int array[100] (100 это просто пример int), я просто зарезервировал место в памяти для 100 дюймов, но я могу сделать int * array, и я не указал никакой тип размера для этого массива, но я все еще могу сделать array[9999] = 30, и это все равно будет иметь смысл.

Так в чем же разница между этими двумя?

Answer 1

Некоторые моменты, которые вы можете найти полезными:

• Через int arr[N] вы указываете массив типа int, который может хранить N целые числа. Чтобы получить информацию о том, сколько памяти занимает массив, вы можете использовать оператор sizeof. Просто умножьте количество элементов в массиве на размер типа: N*sizeof(int).
• Имя массива указывает на первый элемент в массиве, например, *arr совпадает с arr[0], также вы можете спросить, почему a [5] == 5 [a] .
• Неинициализированный массив нестатической длительности хранения заполняется неопределенными значениями.
• Размер массива может быть известен во время выполнения, если вы напишите int arr[] = {1, 2} размер вычисляется компилятором.
• Доступ к несуществующему элементу может вызвать неопределенное поведение , что означает, что может произойти все что угодно, и в большинстве случаев вы получите значения мусора.

---

• Через int *array вы указываете указатель array типа int
• Если значение не назначено, указатель по умолчанию будет указывать на какой-то мусорный адрес.
• Если вы не выделяете память вообще или не выделяете ее полностью или не обращаетесь к несуществующему элементу, но пытаетесь использовать указатель в качестве массива, вы получите непредсказуемое поведение, как и ожидалось.
• После выделения памяти (когда указатель больше не нужен) память должна быть освобождена.

Answer 2

Без указания размера в int * array, array[9999] = 30 может вызвать ошибку сегментации, поскольку это может привести к доступу к недоступной памяти

Answer 3

Нетехническое объяснение:

Указатель содержание относится к адресу (который может быть или не быть действительным). Массив имеет адрес (который должен быть действительным, чтобы массив существовал).

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

Массив похож на ваш дом - он где-то существует, поэтому имеет адрес. Правильно адресованные вещи отправляются туда.

Короче говоря:

Указатель содержит адрес.

Массив имеет адрес.

So

int *array;

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

Когда у вас тогда есть

array[9999] = 30;

вы пытаетесь установить 9999-е int значение , где array указывает на значение 30. Но вы не знаете, где array указывает, потому что вы не дали это фактическое значение.

И это неопределенное поведение.

Answer 4

int array[100] означает переменную array, которая сможет содержать 100 значений int, эта память будет выделена из стека.Переменная array будет иметь базовый адрес массива, а память будет выделена для нее.

Но в случае int *array, поскольку вы объявляете это как локальную переменную, переменная-указатель array будет иметь адрес для мусора.Поэтому, если вы сделаете array[9999], это может вызвать нарушение сегментации, поскольку вы пытаетесь получить доступ к области памяти для мусора вне вашей программы.

Answer 5

Указатель - это указатель , он указывает куда-то еще (как первый элемент массива).Компилятор не имеет никакой информации о том, куда он может указывать, или о размере данных, на которые он может указывать.

Массив - это, в общем, массив из нескольких последовательных элементов одного типа.Компилятор знает его размер, размер, который он всегда указывает (хотя иногда размер указывается только неявно).

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

Пример распада массива:

int array[10];

int *pointer = array;  // Here the symbol array decays to the expression &array[0]

// Now the variable pointer is pointing to the first element of array

Массивы не могут быть естественным образом переданы в функцию.Когда вы объявляете аргумент функции, такой как int arr[], компилятор будет переводить его как int *arr.

Вся эта информация и многое другое должны быть в любой хорошей книге, учебнике или классе.

Answer 6

Разница в том, что когда вы делаете int array[100], блок памяти 100 * sizeof(int) выделяется в стеке , но когда вы делаете int *array, вам нужно динамически распределять память (с помощью malloc функция например), чтобы использовать переменную array.Динамически выделяемая память находится в куче , а не стек .