Скачать или смотреть Proper Way to Do Arithmetic Between Pointers in C

In this guide, we explore the proper method for performing arithmetic between pointers in C. Learn why certain operations may lead to undefined behavior and how to safely compare memory addresses.
---
This video is based on the question https://stackoverflow.com/q/64626546/ asked by the user 'samuelbrody1249' ( https://stackoverflow.com/u/12283168/ ) and on the answer https://stackoverflow.com/a/64626828/ provided by the user 'Eric Postpischil' ( https://stackoverflow.com/u/298225/ ) 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: Proper way to do arithmetic between pointers

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 write me at vlogize [AT] gmail [DOT] com.
---
Understanding Pointer Arithmetic in C

When working with C programming, pointer arithmetic can be a powerful but often misunderstood tool. One common question that arises is: What is the proper way to find the difference between two memory addresses? This question leads us to delve into the intricacies of pointer manipulation and the requirements specified by the C standard.

The Problem

Consider the following code snippet:

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

The commented line suggests attempting to subtract pointers to first_local_int and second_local_int. However, this raises an important concern: Is this operation valid according to the C standard?

Pointer Subtraction According to the C Standard

The C standard has specific guidelines regarding pointer arithmetic. According to the C 2018 standard (6.5.6.9), when you subtract two pointers, they must point to elements of the same array or one past the last element of the array object. If this condition is violated, as it is in the above example, the behavior is undefined.

Here's what the standard specifies:

Clause on Array Objects: When two pointers are subtracted, the pointers should either point to elements of the same array or to the location just after the last element of that array.

Undefined Behavior: Violating this requirement leads to undefined behavior, as per paragraph 4.2 of the standard.

Why Undefined Behavior Exists

The main reason for this limitation is that the C compiler can place variables in various locations in memory. Factors influencing memory location include:

Compiler Optimization: The compiler may arrange variables based on factors such as declaration order or internal data structures, leading to objects being placed far apart in memory.

Memory Alignment: Some compilers optimize memory alignment and may introduce padding between variables, affecting their addresses.

Temporary Variables: The compiler may insert unnamed temporary variables that can also take up memory between your declared variables.

Potential Workaround: Adjacent Pointers

While the standard prohibits direct pointer arithmetic for non-array elements, there is some leeway if the variables are adjacent in memory. In such cases, we can safely check for adjacency by evaluating:

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

or the reverse:

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

If either expression evaluates to true, the two integers are adjacent in memory, fulfilling the criteria outlined in the C standard.

Summary of Key Points:

Pointer arithmetic should only be performed on pointers that reference elements within the same array.

Subtracting pointers outside of an array context results in undefined behavior.

Checking for adjacency is possible through comparison operations, but distances cannot be reliably calculated outside of an array structure.

Conclusion

Understanding the proper way to perform arithmetic between pointers in C is crucial for developing safe and efficient code. Pointer arithmetic must be approached with caution, adhering to the guidelines set forth by the C standard to avoid undefined behaviors. When in doubt, remember to leverage array structures where needed for calculations involving memory addresses.

By following these principles, you can safely navigate the complex world of pointer arithmetic in C without stumbling into troublesome undefined behavior.