Why are Array Assignments Allowed Within Structs but Not for Standalone Arrays in C and C ?

Array Assignment in C and C : Exception for Structs and Philosophical Insights

In C and C , assigning arrays directly is prohibited, as exemplified by the following:

int num1[3] = {1,2,3};
int num2[3];
num2 = num1; // Error: invalid array assignment

However, an exception arises when arrays are components of structs:

struct myStruct { int num[3]; };
struct myStruct struct1 = {{1,2,3}};
struct myStruct struct2;
struct2 = struct1;

In this case, the arrays within structs can be assigned member-wise. This raises the question of why member-wise array assignment is supported for structs but not generally.

Evolutionary Rationale

The origins of the array behavior lie in the historical development of C. In B and BCPL, arrays were implicitly treated as untyped pointers. Structures in B required a special treatment to accommodate arrays, which led to arrays within structs being handled as compiler-tracked entities.

This necessitated disallowing array assignment in general, as it would have required a re-evaluation of the array's base pointer. To maintain compatibility, array assignment was disallowed even for arrays within structures.

Struct Assignment and Side Effect

When struct assignment was introduced in C, it was implemented as a simple memcpy of the struct's raw memory. This assignment behavior inadvertently extended to arrays within structs.

As struct assignment was already a part of the language, any attempt to change the array assignment behavior could have broken existing code. Consequently, array assignment within structs remains as an exception, albeit an unintended one.

Philosophical Perspective

From a language design perspective, it could be argued that arrays, unlike structs, were never intended as first-class citizens. Their functionality as pointers prioritized backwards compatibility over potential ergonomic benefits.

Moreover, introducing general array assignment would have introduced complications, such as the possibility of accidentally creating pointers and memory leaks.

Conclusion

The support for member-wise array assignment within structs is a historical artifact stemming from the early evolution of C. It has persisted due to compatibility concerns and serves as a reminder of the language's foundational design philosophy of prioritizing simplicity and backwards compatibility.

The above is the detailed content of Why are Array Assignments Allowed Within Structs but Not for Standalone Arrays in C and C ?. For more information, please follow other related articles on the PHP Chinese website!