How Does Go\'s Array Modification Behavior Differ From C ?

Golang's Mysterious Array Modification: Slices vs. Arrays

Unlike in C , where arrays are inherently passed by reference, Go's behavior seems contradictory. To understand this apparent paradox, let's delve into the world of Golang's slices.

When arrays are declared in Go without specifying a fixed length, they become slices. These slices are mere descriptors that point to a section of an underlying array. When passed to functions, only the header (a pointer to the first element, length, and capacity) is copied.

Consequently, any modifications made to the slice in the function directly affect the original slice. This is because they both reference the same underlying array. This behavior resembles the pass-by-reference mechanism in C , even though arrays themselves are not explicitly passed by reference in Go.

To summarize, Go's distinction stems from the distinction between arrays and slices. Arrays are passed by value, while slices are passed by reference to the underlying array. For slices, any changes made in a function will be reflected in the original slice.

Further Reading for Deep Dive into Slices:

• [Go Slices: Usage and Internals](https://blog.golang.org/go-slices-usage-and-internals)
• [Arrays, Slices (and Strings): The Mechanics of 'append' ](https://blog.golang.org/slices)

Related Questions for Reference:

• [Why Have Arrays in Go?](https://stackoverflow.com/questions/453071/why-have-arrays-in-go)
• [Are Golang Slices Pass by Value?](https://stackoverflow.com/questions/15884824/are-golang-slices-pass-by-value)

The above is the detailed content of How Does Go\'s Array Modification Behavior Differ From C ?. For more information, please follow other related articles on the PHP Chinese website!