Срок действия кода

Question

Рассмотрим следующий код:

void populate(int *arr) 
{ 
    for(int j=0;j<4;++j) 
     arr[j]=0; 
} 

int main() 
{ 
    int array[2][2]; 
    populate(&array[0][0]); 
} 

Был обсужден вопрос об этом на местном сообществе ли код действителен или нет (Я должен упомянуть его имя?). Один парень говорил, что он вызывает UB, потому что он нарушает

C++ Standard ($ 5,7/5 [expr.add])

«Если оба указателя операнд и точка результат для элементов одного и того же объект массива или один за последним элементом объекта массива, оценка не должна приводить к переполнению; в противном случае поведение не определено. "

Но я не вижу ничего плохого в коде, код для меня совершенно нормально.

Итак, я просто хочу знать, действительно ли этот код действителен или нет? Я что-то упускаю?

Answer 1

Ваш array - это два массива int[2], а ваша функция populate() рассматривает его как единый массив int[4]. В зависимости от того, как компилятор решает выравнивать элементы array, это может быть недействительным.

В частности, когда j является 2, и вы пытаетесь получить доступ к arr[2], это выходит за рамки main «s array[0] и поэтому недействителен.

Answer 2

Это не всегда будет работать. C имеет массивы массивов, а не двумерные массивы. Субмассивы не всегда указываются как смежные в памяти (могут быть статические массивы, проверьте стандарт C/C++). В этом конкретном примере я подозреваю, что он работает правильно. Однако, если вы динамически выделили передаваемую память, вы, возможно, потерпите неудачу, потому что malloc (или новый) мог бы поставить подмассивы довольно далеко друг от друга.

Если вы хотите линейно спуститься по памяти «2d», вы можете построить 2D-аксессор против 1D-массива, и он будет работать нормально, и такие вещи, как memset, будут работать против массива 1D.

Answer 3

У вас есть массив массивов. array[1] следует за array[0] в памяти, потому что массивы смежны. Если p == array[0], то p[1] следует p[0], так как массивы смежны. Итак, вы правы: вся память для array смежна.

В изображениях array выглядит следующим образом.

+-----------------+-----------------+ 
|  [0]  |  [1]  | 
+-----------------+-----------------+ 

Теперь, давайте сломаем array[0] и array[1], они индивидуально выглядеть следующим образом:

+--------+--------+ 
| [0] | [1] |   
+--------+--------+ 

Итак, окончательная картина:

+--------+--------+--------+--------+ 
| [0][0] | [0][1] | [1][0] | [1][1] | 
+--------+--------+--------+--------+ 

Теперь вопрос, может вы получаете доступ к этой непрерывной памяти так, как вы. Ответ не гарантируется стандартом.Массивы смежны, но стандарт не позволяет индексировать то, как вы это делали. Другими словами:

&array[0][0]+2 == &array[1][0], но (&a[0][0] + 2) + 1 не определено, тогда как &a[1][0] + 1 действительно. Если это кажется странным, это так, но в соответствии с цитированием, которое вы опубликовали на стандарте, вам разрешено вычислять указатель, который находится либо внутри массива, либо не более одного за ним (без разыменования этого указателя «один минус») ,

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

См. Также this post on comp.lang.c.

Answer 4

В C все хранится в сегментах линейной памяти. Вы принимаете адрес a[0][0], который будет таким же, как адрес a[0], поэтому a[i][j] такой же, как a[i*ColSize+j], потому что все хранится линейно. Но если вы динамически распределяете память, это не сработает, потому что в это время все строки могут не храниться в смежном местоположении. то a[i][j] будет *(&a[i]+j).