Я вже кілька разів бачив, як стверджується, що наступний код заборонений стандартом С ++:

int array[5];
int *array_begin = &array[0];
int *array_end = &array[5];

Чи є &array[5]законний код C ++ у цьому контексті?

Я хотів би отримати відповідь із посиланням на Стандарт, якщо це можливо.

Також було б цікаво дізнатись, чи відповідає він стандарту C. І якщо це не стандартний C ++, чому було прийнято рішення ставитися до нього інакше, ніж array + 5або &array[4] + 1?

Ваш приклад легальний, але лише тому, що ви насправді не використовуєте вказівник поза межами.

Давайте розглянемо спочатку вказівники поза межами (бо саме так я спочатку інтерпретував ваше запитання, перш ніж помітив, що в прикладі замість цього використовується покажчик "минулий кінець"):

Загалом, вам навіть не дозволяється створювати вказівник поза межами. Покажчик повинен вказувати на елемент у масиві або на кінець . Більше ніде.

Вказівнику навіть не дозволено існувати, а це означає, що ви, очевидно, також не можете його розменовувати.

Ось що має сказати стандарт на цю тему:

5,7: 5:

Коли вираз, який має інтегральний тип, додається або віднімається від покажчика, результат має тип операнда покажчика. Якщо операнд вказівника вказує на елемент об'єкта масиву, а масив досить великий, результат вказує на зміщення елемента від вихідного елемента таким чином, що різниця індексів результуючого та вихідного елементів масиву дорівнює інтегральному вираженню. Іншими словами, якщо вираз P вказує на i-й елемент об'єкта масиву, вирази (P) + N (еквівалентно N + (P)) та (P) -N (де N має значення n) вказують відповідно до i + n-го та i-n-го елементів об'єкта масиву за умови їх існування. Більше того, якщо вираз P вказує на останній елемент об'єкта масиву, вираз (P) +1 вказує один минулий останній елемент об'єкта масиву, а якщо вираз Q вказує один минулий останній елемент об'єкта масиву, вираз (Q) -1 вказує на останній елемент об'єкта масиву . Якщо і операнд покажчика, і результат вказують на елементи одного і того ж об'єкта масиву або одного з останніх елементів об'єкта масиву, обчислення не повинно виробляти перевищення;в іншому випадку поведінка не визначена .

(курсив мій)

Звичайно, це для оператора +. Тож, щоб бути впевненим, ось що говорить стандарт про підписку на масив:

5.2.1: 1:

Вираз E1[E2]ідентичний (за визначенням)*((E1)+(E2))

Звичайно, є очевидне застереження: ваш приклад насправді не показує вказівник поза межами. він використовує вказівник "один за кінцем", який відрізняється. Вказівник може існувати (як сказано вище), але стандарт, наскільки я бачу, нічого не говорить про його розмежування. Найближче, що я можу знайти - 3.9.2: 3:

[Примітка: наприклад, адреса, що стоїть за кінцем масиву (5.7), буде вважатися такою, що вказує на непов’язаний об’єкт типу елемента масиву, який може знаходитись за цією адресою. —Кінець примітки]

Мені здається, що це означає, що так, ви можете законно переорієнтувати його, але результат читання чи написання до місця не вказаний.

Дякуємо ilproxyil за виправлення останнього біта тут, відповідь на останню частину вашого запитання:

• array + 5насправді нічого не розмежовує, він просто створює вказівник на той, що минув кінець array.
• &array[4] + 1dereferences array+4(що абсолютно безпечно), бере адресу цього значення і додає до цієї адреси одну, що призводить до одноразового вказівника (але цей вказівник ніколи не отримує посилання.
• &array[5] dereferences array + 5 (що, наскільки я бачу, є законним і призводить до "непов’язаного об’єкта типу елемента масиву", як було сказано вище), а потім приймає адресу цього елемента, що також здається досить законним.

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

Так, це законно. З проекту стандарту C99 :

Пункт 6.5.5.1, пункт 2:

Вираз постфікса, за яким слідує вираз у квадратних дужках, []є підписаним позначенням елемента масиву. Визначення індексу оператора [] є те , що E1[E2]ідентично (*((E1)+(E2))). Через правила перетворення, які застосовуються до двійкового +оператора, if E1є об'єктом масиву (еквівалентно покажчиком на початковий елемент об'єкта масиву) і E2є цілим числом, E1[E2]позначає E2-й елемент E1(відлік від нуля).

§ 6.5.5.2, абзац 3 (наголос на моєму):

Унарний &оператор видає адресу свого операнда. Якщо операнд має тип '' тип '', результат має тип '' вказівник на тип ''. Якщо операнд є результатом унарного *оператора, ні цей оператор, ні &оператор не обчислюються, і результат такий, ніби обидва пропущені, за винятком того, що обмеження для операторів все ще застосовуються, і результат не є значенням. Подібним чином, якщо операнд є результатом []оператора, не обчислюється ні оператор &, ні одинарність, *що випливає з [], і результат виглядає так, ніби &оператор було видалено, а []оператор змінено на +оператор. В іншому випадку результат є покажчиком на об’єкт або функцію, позначену його операндом.

Пункт 6.5.5, пункт 8:

Коли вираз, який має цілочисельний тип, додається або віднімається від покажчика, результат має тип операнда вказівника. Якщо операнд вказівника вказує на елемент об’єкта масиву, а масив досить великий, результат вказує на зміщення елемента від вихідного елемента таким чином, що різниця індексів результуючого та вихідного елементів масиву дорівнює цілому виразу. Іншими словами, якщо вираз Pвказує на i-th елемент об'єкта масиву, вирази (P)+N(еквівалентно, N+(P)) та (P)-N(де Nмає значення n) вказують відповідно на i+n-th та i−n-th елементи об'єкта масиву за умови існувати. Більше того, якщо виразPвказує на останній елемент об’єкта масиву, вираз (P)+1вказує один минулий останній елемент об’єкта масиву, а якщо вираз Qвказує один минулий останній елемент об’єкта масиву, вираз (Q)-1вказує на останній елемент об’єкта масиву. Якщо і операнд вказівника, і результат вказують на елементи одного і того ж об'єкта масиву або одного з останніх елементів об'єкта масиву, обчислення не повинно спричинити переповнення; в іншому випадку поведінка не визначена. Якщо результат вказує один за останнім елементом об'єкта масиву, він не повинен використовуватися як операнд одинарного *оператора, який обчислюється.

Зверніть увагу, що стандарт явно дозволяє вказівникам спрямовувати один елемент за кінець масиву, за умови, що вони не розмежовуються . За 6.5.2.1 та 6.5.3.2 вираз &array[5]еквівалентний &*(array + 5), що еквівалентно (array+5), який вказує один за другим кінцем масиву. Це не призводить до припинення користування (відповідно до 6.5.3.2), тому це є законним.

Це є законним.

Відповідно до документації gcc для C ++ , &array[5]це законно. І в C ++, і в C ви можете безпечно звернутися до елемента поза кінцем масиву - ви отримаєте дійсний вказівник. Отже, &array[5]як вираз є законним.

Однак спроба перенаправлення покажчиків на нерозподілену пам'ять все ще невизначена, навіть якщо вказівник вказує на дійсну адресу. Отже, спроба розшифрувати посилання на покажчик, згенерований цим виразом, все ще є невизначеною поведінкою (тобто незаконною), хоча сам вказівник є дійсним.

На практиці, я думаю, це, як правило, не спричиняє аварії.

Редагувати: До речі, загалом саме так реалізується ітератор end () для контейнерів STL (як вказівник на минулий кінець), тож це досить гарне свідчення законності практики.

Редагувати: О, зараз я бачу, що ви насправді не питаєте, чи є вказівник на цю адресу законним, але чи є законним саме такий спосіб отримання вказівника. Я відкладу на це питання іншим відповідачам.

Я вважаю, що це законно, і це залежить від конверсії "lvalue to rvalue". Останній рядок Основного випуску 232 має таке:

Ми погодились, що підхід у стандарті здається нормальним: p = 0; * р; не є по суті помилкою. Перетворення lvalue-to-rvalue призведе до невизначеної поведінки

Хоча це дещо інший приклад, він показує, що '*' не призводить до перетворення lvalue в rvalue і тому, враховуючи, що вираз є безпосереднім операндом '&', який очікує lvalue, тоді поведінка визначена.

Я не вважаю, що це незаконно, але я вважаю, що поведінка & array [5] не визначена.

• 5.2.1 [expr.sub] E1 [E2] ідентичний (за визначенням) * ((E1) + (E2))

• 5.3.1 Оператор [expr.unary.op] unary * ... результат - значення l, що посилається на об'єкт або функцію, на яку вказує вираз.

На даний момент у вас невизначена поведінка, оскільки вираз ((E1) + (E2)) насправді не вказував на об'єкт, а стандарт дійсно говорить, яким має бути результат, якщо це не так.

• 1.3.12 [defns.undefined] Невизначена поведінка також може очікуватися, коли цей Міжнародний стандарт опускає опис будь-якого явного визначення поведінки.

Як зазначалося в інших місцях, array + 5і &array[0] + 5є дійсними і чітко визначеними способами отримання покажчика за кінцем масиву.

На додаток до наведених вище відповідей, я зазначу оператор & може бути замінений для занять. Отже, навіть якщо він був дійсним для POD, це, мабуть, не є гарною ідеєю робити для об’єкта, який, як ви знаєте, не є дійсним (так само, як спочатку перевизначення оператора & ()).

Це законно:

int array[5];
int *array_begin = &array[0];
int *array_end = &array[5];

Розділ 5.2.1 Передплата Вираз E1 [E2] ідентичний (за визначенням) fi ((E1) + (E2))

Отже, цим можна сказати, що array_end теж еквівалентний:

int *array_end = &(*((array) + 5)); // or &(*(array + 5))

Розділ 5.3.1.1 Одинарний оператор '*': Одинарний * оператор виконує опосередкування: вираз, до якого він застосовується, повинен бути покажчиком на тип об'єкта або покажчиком на тип функції, а результат - значення l, що відноситься до об'єкта або функція, на яку вказує вираз. Якщо тип виразу "вказівник на Т", то результат результату - "Т." [Примітка: вказівник на неповний тип (відмінний від cv void) може бути розменований. Отримане таким чином значення lvalue можна використовувати обмежено (наприклад, для ініціалізації посилання); це значення l не слід перетворювати на значення r, див. 4.1. - кінцева примітка]

Важлива частина вищезазначеного:

'результат - значення lvalue, що посилається на об'єкт або функцію'.

Одинарний оператор '*' повертає значення lvalue, яке посилається на int (без дефеференції). Потім одинарний оператор '&' отримує адресу значення.

Доки не буде знято посилання на вказівник поза межами, тоді операція повністю охоплюється стандартом і визначається вся поведінка. Отож, прочитавши вище, цілком законно.

Той факт, що багато алгоритмів STL залежать від чітко визначеної поведінки, є свого роду натяком на те, що комітет стандартів вже це зробив, і я впевнений, що є щось, що явно це охоплює.

У розділі коментарів нижче подано два аргументи:

(будь ласка, прочитайте: але це довго, і ми в кінцевому підсумку троллі)

Аргумент 1

це є незаконним через пункт 5 розділу 5.7

Коли вираз, який має інтегральний тип, додається або віднімається від покажчика, результат має тип операнда покажчика. Якщо операнд вказівника вказує на елемент об'єкта масиву, а масив досить великий, результат вказує на зміщення елемента від вихідного елемента таким чином, що різниця індексів результуючого та вихідного елементів масиву дорівнює інтегральному вираженню. Іншими словами, якщо вираз P вказує на i-й елемент об'єкта масиву, вирази (P) + N (еквівалентно N + (P)) та (P) -N (де N має значення n) вказують відповідно до i + n-го та i - n-го елементів об'єкта масиву за умови їх існування. Більше того, якщо вираз P вказує на останній елемент об'єкта масиву, вираз (P) +1 вказує один минулий останній елемент об'єкта масиву, і якщо вираз Q вказує один за останнім елементом об'єкта масиву, вираз (Q) -1 вказує на останній елемент об'єкта масиву. Якщо і операнд покажчика, і результат вказують на елементи одного і того ж об'єкта масиву або одного з останніх елементів об'єкта масиву, обчислення не повинно викликати переповнення; в іншому випадку поведінка не визначена.

І хоча розділ є актуальним; він не демонструє невизначеної поведінки. Всі елементи масиву, про які ми говоримо, знаходяться або в масиві, або поза кінцем (що добре визначено в наведеному вище абзаці).

Аргумент 2:

Другий аргумент, представлений нижче, - *це оператор де-посилання.
І хоча це загальний термін, який використовується для опису оператора '*'; цього терміну навмисно уникають у стандарті, оскільки термін "відміна посилання" не є чітко визначеним з точки зору мови та того, що це означає для базового обладнання.

Хоча доступ до пам'яті після закінчення масиву, безумовно, невизначений. Я не впевнений у unary * operatorдоступі до пам'яті (читання / запис у пам'ять) у цьому контексті (не так, як це визначає стандарт). У цьому контексті (як визначено стандартом (див. 5.3.1.1)) unary * operatorповертається a lvalue referring to the object. На моє розуміння мови, це не доступ до основної пам'яті. Потім результат цього виразу негайно використовується unary & operatorоператором, який повертає адресу об'єкта, на який посилається lvalue referring to the object.

Наведено багато інших посилань на Вікіпедію та неканонічні джерела. Все, що я вважаю неактуальним. С ++ визначається стандартом .

Висновок:

Я хочу визнати, що є багато частин стандарту, які я, можливо, не враховував, і може довести свої помилки вище. НЕ наведено нижче. Якщо ви покажете мені стандартне посилання, яке показує, що це UB. я буду

1. Залиште відповідь.
2. Якщо поставити всі шапки, це дурне, і я помиляюся, щоб усі читали.

Це не аргумент:

Не все у всьому світі визначається стандартом С ++. Відкрий свій розум.

Робочий проект ( n2798 ):

"Результат унарного & оператора - це вказівник на його операнд. Операндом має бути значення l або кваліфікований ідентифікатор. У першому випадку, якщо тип виразу" T ", тип результату" вказівник на Т. ”" (стор. 103)

масив [5] не є кваліфікованим ідентифікатором, наскільки я можу зрозуміти (список на стор. 87); здається, що найближчим є ідентифікатор, але хоча масив є ідентифікатором, масив [5] - ні. Це не значення l, оскільки «Значення l означає значення об’єкта або функції» (с. 76). array [5], очевидно, не є функцією, і не гарантується посилання на дійсний об'єкт (оскільки масив + 5 знаходиться після останнього виділеного елемента масиву).

Очевидно, що це може працювати в певних випадках, але це не дійсний C ++ або безпечний.

Примітка: Дозволено додавати, щоб отримати один за масивом (стор. 113):

"якщо вираз P [покажчик] вказує на останній елемент об'єкта масиву, вираз (P) +1 вказує один за останнім елементом об'єкта масиву, а якщо вираз Q вказує один за останнім елементом масиву об'єкт масиву, вираз (Q) -1 вказує на останній елемент об'єкта масиву. Якщо і операнд покажчика, і результат вказують на елементи одного і того ж об'єкта масиву або одного з останніх елементів об'єкта масиву, оцінка не повинен виробляти надлишок "

Але це не законно робити це за допомогою &.

Навіть якщо це законно, чому відходити від конвенції? масив + 5 і так коротший, і на мій погляд, читабельніший.

Редагувати: якщо ви хочете, щоб це було симетрично, ви можете писати

int* array_begin = array; 
int* array_end = array + 5;

Це має бути невизначеною поведінкою з наступних причин:

1. Спроба отримати доступ до зовнішніх елементів призводить до невизначеної поведінки. Отже, стандарт не забороняє реалізацію, що створює виняток у такому випадку (тобто межі перевірки реалізації перед доступом до елемента). Якби це & (array[size])було визначено як begin (array) + sizeтаке, реалізація, що видає виняток у разі необмеженого доступу, більше не відповідала б стандарту.

2. Це неможливо зробити, end (array)якщо масив не є масивом, а скоріше довільним типом колекції.

Стандарт С ++, 5.19, параграф 4:

Вираз адресної константи - це вказівник на значення lvalue .... Покажчик повинен бути створений явно, використовуючи унарний & оператор ... або використовуючи вираз типу масиву (4.2) ... Оператор підписки [] ... може бути використаний при створенні виразу адресної константи, але значення об'єкта не має доступу до використання цих операторів. Якщо використовується оператор підписки, один з його операндів повинен бути інтегральним постійним виразом.

Мені здається, що & array [5] є законним C ++, будучи виразом адреси.

Якщо ваш приклад - НЕ загальний випадок, а конкретний, то це дозволено. Ви можете легально , AFAIK, пройти повз виділений блок пам'яті. Це не працює для загального випадку, однак, тобто, коли ви намагаєтесь отримати доступ до елементів далі на 1 від кінця масиву.

Щойно шукали C-Faq: текст посилання

Це цілком законно.

Клас шаблону vector <> зі stl робить саме це, коли ви викликаєте myVec.end (): він отримує вам вказівник (тут як ітератор), який спрямовує один елемент за кінець масиву.