GoLang: why doesn't address-of operator work without a variable declaration-CodePudding

In Go, suppose I have a []byte of UTF-8 that I want to return as a string.

func example() *string {
   byteArray := someFunction()
   text := string(byteArray)
   return &text
}

I would like to eliminate the text variable, but Go doesn't support the following:

func example() *string {
   byteArray := someFunction()
   return &string(byteArray)
}

Is this second example syntax correct? And if so, why doesn't Go support it?

CodePudding user response：

Because the spec defines is that way:

For an operand x of type T, the address operation &x generates a pointer of type *T to x. The operand must be addressable, that is, either a variable, pointer indirection, or slice indexing operation; or a field selector of an addressable struct operand; or an array indexing operation of an addressable array. As an exception to the addressability requirement, x may also be a (possibly parenthesized) composite literal.

Notice that type conversions (what you are trying to do with string(byteArray)) are not included in this list.

CodePudding user response：

See Marc's answer for an official citation, but here's an intuitive reason for why Go doesn't support this.

Suppose the following code

var myString string
stringPointer := &myString
*stringPointer = "some new value"

Hopefully you know, this code will write some new value into myString. This is a basic use of pointers. Now consider the modified example (pretending that it is valid code):

var myBytes []byte
// modify myBytes...
stringPointer := &string(myString)
*stringPointer = "some new value"

The question is, where in the world (or computer) are we writing to?? Where is some new value going?

In order for the language to handle this correctly, the compiler would need some internal process to "promote" the temporary value to an invisible variable, and then take the address of that. This would be adding needless complexity to make some code slightly shorter, but create this confusing situation where we have pointers with no well defined location in the program. Instead of creating these confusing ghost-variables, the language delegates to the programmer to use their own variable as usual.