swap two strings (Golang)

huangapple
go评论108阅读模式
英文:

swap two strings (Golang)

问题

这段代码没有起作用的原因是，Go语言中的函数参数传递是按值传递的，而不是按引用传递。在函数swap中，str1和str2是函数的局部变量，对它们的修改不会影响到main函数中的变量a和b。所以，即使在swap函数中交换了str1和str2的值，main函数中的a和b的值仍然保持不变。

要解决这个问题，你可以将swap函数的参数改为指针类型，这样就可以通过指针修改变量的值。修改后的代码如下：

  1. func swap(str1, str2 *string) {
  2.     tmp := *str1
  3.     *str1 = *str2
  4.     *str2 = tmp
  5. }
  7. func main() {
  8.     a := "World !"
  9.     b := "Hello"
  10.     swap(&a, &b)
  11.     fmt.Printf("a=%s\nb=%s\n", a, b)
  12. }

这样修改后，swap函数中的参数str1和str2是指向main函数中的变量a和b的指针，通过指针修改变量的值就可以实现字符串的交换。

英文:

I am currently learning Golang, and i decided to write few simple algorithm for learning the syntax. i hope it's not already answers but i didn't found it ..

I have a problem for swapping string

  1. func swap(str1, str2 string) {
  2. 	/*
  3. 	 * Also possible :
  4. 	 * str1, str2 = str2, str1
  5. 	 */
  6. 	// str1, str2 = str2, str1
  7. 	tmp := str1
  8. 	str1 = str2
  9. 	str2 = tmp
  10. }
  12. func main() {
  13. 	a := "World !"
  14. 	b := "Hello"
  15. 	swap(a, b)
  16. 	fmt.Printf("a=%s\nb=%s\n", a, b)
  17. }

Why this code didn't work ?

答案1

得分: 5

交换str1和str2不会改变a和b，因为它们是a和b的副本。使用指针：

  1. func swap(str1, str2 *string) {
  2.     *str1, *str2 = *str2, *str1
  3. }
  5. func main() {
  6.     a := "salut"
  7.     b := "les gens"
  8.     swap(&a, &b)
  9.     fmt.Printf("a=%s\nb=%s\n", a, b)
  10. }

点击此处查看示例代码

英文:

Swapping str1 and str2 doesn't change a and b, because they are copies of a and b. Use pointers:

  1. func swap(str1, str2 *string) {
  2. 	*str1, *str2 = *str2, *str1
  3. }
  5. func main() {
  6. 	a := "salut"
  7. 	b := "les gens"
  8. 	swap(&a, &b)
  9. 	fmt.Printf("a=%s\nb=%s\n", a, b)
  10. }

http://play.golang.org/p/Qw0t5I-XGT

答案2

得分: 2

这将是惯用的方式。

  1. package main
  3. import "fmt"
  5. func swap(a, b string)(string, string) {
  6.     return b, a
  7. }
  9. func main() {
  10.     f, s := swap("world" , "hello")
  11.     fmt.Println(f, s)
  12. }
英文:

This will be the idiomatic way.

  1. package main
  3. import "fmt"
  5. func swap(a, b string)(string, string) {
  6.     return b, a
  7. }
  9. func main() {
  10.     f, s := swap("world" , "hello")
  11.     fmt.Println(f, s)
  12. }

答案3

得分: 1

内置类型作为函数参数时，按值传递，但如果解引用的元素会修改原始值，例如切片（slice）和映射（map）。例如：

  1. package main
  3. import (
  4.     "bytes"
  5.     "fmt"
  6.     "strings"
  7. )
  9. func f_1(a int) {
  10.     a = 2
  11. }
  13. func f_1_1(a *int) {
  14.     *a = 2
  15. }
  17. func f_2(s string) {
  18.     s = "cba"
  19. }
  21. func f_2_1(s *string) {
  22.     *s = "cba"
  23. }
  25. func f_3(v []string) {
  26.     v[0] = "haha"
  27. }
  29. func f_3_1(v []string) {
  30.     v = nil
  31. }
  33. func f_3_2(v *[]string) {
  34.     *v = nil
  35. }
  37. func f_4(m map[int]int) {
  38.     m[1] = 3
  39.     m[3] = 1
  40. }
  42. func f_4_1(m map[int]int) {
  43.     m = nil
  44. }
  46. func f_4_2(m *map[int]int) {
  47.     *m = nil
  48. }
  50. func f_5(b []byte) {
  51.     b[0] = 0x40
  52. }
  54. func f_5_1(b []byte) {
  55.     b = bytes.Replace(b, []byte("1"), []byte("a"), -1)
  56. }
  58. func f_5_2(b *[]byte) {
  59.     *b = bytes.Replace(*b, []byte("1"), []byte("a"), -1)
  60. }
  62. type why struct {
  63.     s []string
  64. }
  66. func (ss why) SetV(s []string) {
  67.     ss.s = s
  68. }
  70. func (ss *why) SetP(s []string) {
  71.     ss.s = s
  72. }
  74. func (ss why) String() string {
  75.     return strings.Join(ss.s, ",")
  76. }
  78. func main() {
  79.     a := 1
  80.     s := "abc"
  81.     v := []string{"sd", "aa"}
  82.     m := map[int]int{1: 1, 2: 2, 3: 3}
  83.     f_1(a)
  84.     f_2(s)
  85.     f_3(v)
  86.     f_4(m)
  87.     fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
  88.     f_3_1(v)
  89.     f_4_1(m)
  90.     fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
  91.     f_1_1(&a)
  92.     f_2_1(&s)
  93.     f_3_2(&v)
  94.     f_4_2(&m)
  95.     fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
  96.     b := []byte("12145178")
  97.     f_5(b)
  98.     fmt.Printf("%s\n", b)
  99.     f_5_1(b)
  100.     fmt.Printf("%s\n", b)
  101.     f_5_2(&b)
  102.     fmt.Printf("%s\n", b)
  103.     ss := &why{}
  104.     ss.SetV([]string{"abc", "efg"})
  105.     fmt.Println(ss)
  106.     ss.SetP([]string{"abc", "efg"})
  107.     fmt.Println(ss)
  108. }

以上是一个Go语言的示例代码，演示了不同类型作为函数参数时的行为。

英文:

Built-in types as function arguments are passed by value, but if the elements for dereference will modify the original value, such as slice, map. e.g.

  1. package main
  2. import (
  3. "bytes"
  4. "fmt"
  5. "strings"
  6. )
  7. func f_1(a int) {
  8. a = 2
  9. }
  10. func f_1_1(a *int) {
  11. *a = 2
  12. }
  13. func f_2(s string) {
  14. s = "cba"
  15. }
  16. func f_2_1(s *string) {
  17. *s = "cba"
  18. }
  19. func f_3(v []string) {
  20. v[0] = "haha"
  21. }
  22. func f_3_1(v []string) {
  23. v = nil
  24. }
  25. func f_3_2(v *[]string) {
  26. *v = nil
  27. }
  28. func f_4(m map[int]int) {
  29. m[1] = 3
  30. m[3] = 1
  31. }
  32. func f_4_1(m map[int]int) {
  33. m = nil
  34. }
  35. func f_4_2(m *map[int]int) {
  36. *m = nil
  37. }
  38. func f_5(b []byte) {
  39. b[0] = 0x40
  40. }
  41. func f_5_1(b []byte) {
  42. b = bytes.Replace(b, []byte("1"), []byte("a"), -1)
  43. }
  44. func f_5_2(b *[]byte) {
  45. *b = bytes.Replace(*b, []byte("1"), []byte("a"), -1)
  46. }
  47. type why struct {
  48. s []string
  49. }
  50. func (ss why) SetV(s []string) {
  51. ss.s = s
  52. }
  53. func (ss *why) SetP(s []string) {
  54. ss.s = s
  55. }
  56. func (ss why) String() string {
  57. return strings.Join(ss.s, ",")
  58. }
  59. func main() {
  60. a := 1
  61. s := "abc"
  62. v := []string{"sd", "aa"}
  63. m := map[int]int{1: 1, 2: 2, 3: 3}
  64. f_1(a)
  65. f_2(s)
  66. f_3(v)
  67. f_4(m)
  68. fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
  69. f_3_1(v)
  70. f_4_1(m)
  71. fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
  72. f_1_1(&a)
  73. f_2_1(&s)
  74. f_3_2(&v)
  75. f_4_2(&m)
  76. fmt.Printf("%d,%s,%v,%v\n", a, s, v, m)
  77. b := []byte("12145178")
  78. f_5(b)
  79. fmt.Printf("%s\n", b)
  80. f_5_1(b)
  81. fmt.Printf("%s\n", b)
  82. f_5_2(&b)
  83. fmt.Printf("%s\n", b)
  84. ss := &why{}
  85. ss.SetV([]string{"abc", "efg"})
  86. fmt.Println(ss)
  87. ss.SetP([]string{"abc", "efg"})
  88. fmt.Println(ss)
  89. }

答案4

得分: 0

你可以这样写：

  1. a := "你好"
  2. b := "世界"
  3. a, b = b, a
英文:

you can write as that:

  1. a := "hello"
  2. b := "world"
  3. a, b = b, a

答案5

得分: 0

  1. package main
  3. import "fmt"
  5. func swap(a, b string) (string, string) {
  6.     return b, a
  7. }
  9. func main() {
  10.     fmt.Println(swap("Lang", "Go"))
  11. }
  1. package main
  3. import "fmt"
  5. func swap(a, b string) (string, string) {
  6.     return b, a
  7. }
  9. func main() {
  10.     fmt.Println(swap("Lang", "Go"))
  11. }
英文: 
  1. package main
  2. import "fmt"
  3. func swap(a,b string)(string, string){
  4. return b,a
  5. }
  6. func main(){
  7. fmt.Println(swap("Lang","Go"))
  8. }

huangapple
  • 本文由 发表于 2016年2月17日 01:34:12
  • 转载请务必保留本文链接：https://go.coder-hub.com/35439281.html
  • go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定