Скачать или смотреть Understanding the [] Subscript Operator Evaluation Order in C+ + 17 and MS Visual Studio 2022

Explore how the evaluation order of the subscript operator changed in C+ + 17, why MS Visual Studio 2022's compiler exhibits a runtime error for certain compound subscript expressions, and how to avoid this undefined behavior.
---
This video is based on the question https://stackoverflow.com/q/79503795/ asked by the user 'Vlad from Moscow' ( https://stackoverflow.com/u/2877241/ ) and on the answer https://stackoverflow.com/a/79503983/ provided by the user 'Vlad from Moscow' ( https://stackoverflow.com/u/2877241/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Run-time error using a compound subscripting expression compiled by the MS VS22 C+ + compiler

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to drop me a comment under this video.
---
Introduction

C+ + 17 introduced explicit sequencing rules for expressions, including the subscript operator []. However, some compilers, notably Microsoft Visual Studio 2022's C+ + compiler, still handle these expressions incorrectly, causing runtime errors in code that should be valid according to the standard.

This article explains the issue with complex subscript expressions, why the Microsoft compiler is problematic here, and how to avoid undefined behavior.



The Problem Explained

Consider the following code snippet:

[[See Video to Reveal this Text or Code Snippet]]

It uses a compound subscript expression:

(*p+ + - 1) produces an integer.

(--p, a) is a comma expression that evaluates to the array pointer a after decrementing p.

Then, (value)[a] is effectively *(value + a).

According to the C+ + 17 Standard, the left operand (E1) of E1[E2] is evaluated before the right operand (E2). However, MS Visual Studio 2022 compiles this code such that the right operand is evaluated first, causing pointer p to be decremented prematurely and ultimately leading to out-of-bounds access at runtime.



What Does the C+ + 17 Standard Say?

From C+ + 17—Section 8.2.1 Subscripting:

The expression E1[E2] is identical to *((E1) + (E2)), except that the expression E1 is sequenced before the expression E2.

This guarantees that any side effects or modifications to variables in E1 occur before E2 is evaluated.



The Compiler Bug

Microsoft's Visual Studio 2022 compiler does not honor this sequencing rule.

It evaluates the subscript's array or pointer operand (E2) before the integral operand (E1).

This leads to modifying the pointer p at the wrong sequence point, causing undefined behavior when accessing memory outside the array bounds.

This behavior contradicts the standard and results in runtime errors despite seemingly correct code.



Verifying the Issue

A quick way to observe the effect is to change the loop initialization:

[[See Video to Reveal this Text or Code Snippet]]

By starting from a + 1, you avoid the undefined access on the first iteration, but this effectively skips the first element and doesn't fix the underlying sequencing bug.



Best Practices and Workarounds

Avoid writing overly complex subscript expressions with side effects. Side-effect-heavy expressions can be hard to reason about and are prone to compiler quirks.

Split complex expressions into multiple statements. For example:

[[See Video to Reveal this Text or Code Snippet]]

Stay updated on compiler patches. Microsoft may fix this sequencing issue in future Visual Studio updates.

Test on multiple compilers and enable runtime checks. This helps catch undefined behavior early.



Summary

C+ + 17 requires that the left operand of operator[] be evaluated before the right.

MS Visual Studio 2022 currently violates this rule, causing runtime errors for some compound subscripts.

To avoid bugs, simplify your expressions and avoid side effects within subscript operands.

Understanding evaluation order and sequencing is crucial for writing reliable, standard-compliant C+ + code, especially when using complex expressions.