MISRA C++:2023 Rule 8.18.1

An object or subobject must not be copied to an overlapping object

Since R2024b

Description

An object or subobject must not be copied to an overlapping object. ¹

Rationale

When you assign an object to another object with overlapping memory, the behavior is undefined.

The exceptions are:

• You assign an object to another object with exactly overlapping memory and compatible type.

• You copy one object to another with memmove.

Polyspace Implementation

As stated in the rule specification, the checker reports a violation when:

• A member of a union is copied to another member of the union.

• The source and destination arguments of memcpy point to the same array in a way that results in an overlapping copy.

Troubleshooting

If you expect a rule violation but Polyspace^® does not report it, see Diagnose Why Coding Standard Violations Do Not Appear as Expected.

Examples

Assignment of Union Members

void func (void) {
    union {
        short i;
        int j;
    } a = {0}, b = {1};
    
    a.j = a.i;   //Noncompliant
    a = b;       //Compliant
}

In this example, the rule is violated when a.i is assigned to a.j because the two variables have overlapping regions of memory.

Check Information

Group: Expressions

Category: Mandatory

PQL Name: std.misra_cpp_2023.R8_18_1

Version History

Introduced in R2024b

R2026a: Support for nested structures and classes

The rule checker more accurately identifies cases of overlapping memory that might occur within a nested struct or class.

R2025a: Support for std::array types and offsets using pointer arithmetic

The rule checker detects overlapping copy when:

• The source and destination of the copy are of type std::array.

• The source and destination of the copy point to the same array at different offsets, and the offset is done using addition to a pointer.

  For instance, the checker correctly recognizes that the following two copies are equivalent:

  void copyVals(char8_t param[]) {
      memcpy (&param[2], &param[3], 2); 
      memcpy (&param + 2, &param + 3, 2);
  }