这个 Go 方法是否“分配新内存”？

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《这个 Go 方法是否“分配新内存”？》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

（我正在使用 donovan 和 kernighan 的go 编程语言学习 go。这个问题的答案对于其他人来说可能是显而易见的，但我很困惑，不知道从哪里开始。）

作为 gopl 中的练习，作者要求读者修改他们的 reverse 程序（该程序将 ints 的切片反转）“反转 []byte 切片的字符，该切片表示一个 utf-8 编码的字符串，就位”（93）。他们补充道：“你能在不分配新内存的情况下做到这一点吗？”

简而言之，我想问一下下面是否分配了新的内存。根据印刷声明的结果，我认为事实并非如此，但我不确定。另一种让我困惑的方法是：如果 rverse 方法原地反转，我希望它不会分配新的内存。因此，我假设我一定遗漏了一些东西，因为他们要求方法就位，然后添加不分配新内存的挑战。他们是在怂恿我避免做一些我做过的事吗？关于内存分配（在 go 中或一般情况下），是否有一些额外的技巧值得了解？

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    phrase := "Hello, 世界!"
    fmt.Printf("Before reverse:\tmemory address %p => phrase: %s\n", &phrase, phrase)
    phrase = string(reverseByRune([]byte(phrase)))
    fmt.Printf("After reverse:\tmemory address %p => phrase: %s\n", &phrase, phrase)
}

func reverseByRune(b []byte) []byte {
    for i := 0; i < len(b); {
        _, size := utf8.DecodeRune(b[i:])
        reverse(b[i : i+size])
        i += size
    }
    reverse(b)
    return b
}

func reverse(b []byte) []byte {
    for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
        b[i], b[j] = b[j], b[i]
    }
    return b
}

这是 on the go 演示：https://play.golang.org/p/qn7nyxlgoqn。

ps 我只能投票和接受一次，但如果有人想要额外的感谢，我会喜欢任何有关内存分配的链接（尤其是在 go 中）。

正确答案

编辑：问题中的实现可能也不会在堆上分配内存，但建议的修改仍然应该更有效一点。我最初以为问题中的代码来自书中，并且由于缺少本地编译器而无法检查内存分配。

这是一个我认为应该没有内存分配的实现。

https://play.golang.org/p/N4mkYoiIHvn

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    phrase := "hello, 世界!"
    fmt.printf("before reverse:\tmemory address %p => phrase: %s\n", &phrase, phrase)
    phrase = string(reversebyrune([]byte(phrase)))
    fmt.printf("after reverse:\tmemory address %p => phrase: %s\n", &phrase, phrase)
}

func reversebyrune(b []byte) []byte {
    reverse := func (i, j int) {
        for ; i < j; i, j = i+1, j-1 {
            b[i], b[j] = b[j], b[i]
        }
    }
    for i := 0; i < len(b); {
        _, size := utf8.decoderune(b[i:])
        reverse(i, i+size-1)
        i += size
    }
    reverse(0, len(b)-1)
    return b
}

reverse() 的原始实现需要内存来创建 b []byte 切片，并且也不需要返回值。虽然理论上可以通过从 reverse 中删除 return 来优化。然后编译器可以“猜测”没有人可以保留指向切片的指针，并且可以确保切片是在堆栈而不是堆上创建的。但这只是理论上的推测——我不确定 go 的编译器是否那么聪明。

建议的实现与原始实现相同，但在原始切片内。

当我们谈论“无内存分配”时，我们通常指的是函数内发生的情况，在本例中为 reversebyrune()。像 i 和 j 这样分配在堆栈上的局部变量不算在内，因为它们很便宜。

这可能是给定方法最有效的实现：

https://play.golang.org/p/YOOSZjIWKZ_r

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    phrase := []byte("Hello, 世界!")
    fmt.Printf("Before reverse:\tmemory address %p => phrase: %s\n", &phrase, string(phrase))
    reverseByRune(phrase)
    fmt.Printf("After reverse:\tmemory address %p => phrase: %s\n", &phrase, string(phrase))
}

func reverseByRune(b []byte) {
    for i := 0; i < len(b); {
        _, size := utf8.DecodeRune(b[i:])
        for k, p := i, i+size-1; k < p; k, p = k+1, p-1 {
            b[k], b[p] = b[p], b[k]
        }
        i += size
    }
    for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
        b[i], b[j] = b[j], b[i]
    }
}

但这太过分了！

好了，本文到此结束，带大家了解了《这个 Go 方法是否“分配新内存”？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！