Are pointer variables just integers with some operators or are they “symbolic”?

by

The first thing to say is that a sample of one test on one compiler generating code on one architecture is not the basis on which to draw a conclusion on the behaviour of the language.

c++ (and c) are general purpose languages created with the intention of being portable. i.e. a well formed program written in c++ on one system should run on any other (barring calls to system-specific services).

Once upon a time, for various reasons including backward-compatibility and cost, memory maps were not contiguous on all processors.

For example I used to write code on a 6809 system where half the memory was paged in via a PIA addressed in the non-paged part of the memory map. My c compiler was able to cope with this because pointers were, for that compiler, a ‘mystical’ type which knew how to write to the PIA.

The 80386 family has an addressing mode where addresses are organised in groups of 16 bytes. Look up FAR pointers and you’ll see different pointer arithmetic.

This is the history of pointer development in c++. Not all chip manufacturers have been “well behaved” and the language accommodates them all (usually) without needing to rewrite source code.

More Related Contents:

  1. Accessing inactive union member and undefined behavior?
  2. Is segmentation fault actual undefined behavior when we refer to a non-static data-member
  3. C++ delete – It deletes my objects but I can still access the data?
  4. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  5. Do I need to cast to unsigned char before calling toupper(), tolower(), et al.?
  6. May I treat a 2D array as a contiguous 1D array?
  7. Why does left shift operation invoke Undefined Behaviour when the left side operand has negative value?
  8. Why dereferencing a null pointer is undefined behaviour?
  9. Difference between Undefined Behavior and Ill-formed, no diagnostic message required
  10. Is passing a C++ object into its own constructor legal?
  11. Is a pointer with the right address and type still always a valid pointer since C++17?
  12. Is it legal to compare dangling pointers?
  13. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  14. Does not evaluating the expression to which sizeof is applied make it legal to dereference a null or invalid pointer inside sizeof in C++?
  15. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  16. Do all pointers have the same size in C++?
  17. So why is i = ++i + 1 well-defined in C++11?
  18. Why is f(i = -1, i = -1) undefined behavior?
  19. Does accessing a declared non-volatile object through a volatile reference/pointer confer volatile rules upon said accesses?
  20. Are non dereferenced iterators past the “one past-the-end” iterator of an array undefined behavior?
  21. Implementing a std::vector like container without undefined behavior
  22. Is pointer comparison undefined or unspecified behavior in C++?
  23. The behaviour of floating point division by zero
  24. Can branches with undefined behavior be assumed unreachable and optimized as dead code?
  25. Dangling references and undefined behavior
  26. When is it valid to access a pointer to a “dead” object?
  27. Is incrementing a null pointer well-defined?
  28. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  29. Observable behavior and undefined behavior — What happens if I don’t call a destructor?
  30. Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?

Leave a Comment