Golang学习（用代码来学习）

type Circle struct {

	radius float64

	desc   string

}

//定义结构体里面的方法

func (c Circle) getArea() float64 {

	return 3.14 * c.radius * c.radius

}

//如果想要改变结构体里面的成员变量，就必须传入指针，否则的话是不生效的

func (c *Circle) setRadius(val float64) {

	c.radius = val

}

//因为没有传入指针，所以这里的Circle对象被拷贝了，因此不生效

func (c Circle) setRadiusFake(val float64) {

	c.radius = val

}

/*

方法学习，其实就是类似于类里面的函数，但是go没有类这个东西

*/

func method_test() {

	print_start_seperator("method_test");

	var cir Circle;

	cir.radius = 12;

	fmt.Printf("circle's area:%f \n", cir.getArea())

	cir.setRadius(10)

	fmt.Printf("after real setRadius[%f] circle's area:%f \n", cir.radius, cir.getArea())

	cir.setRadiusFake(20)

	fmt.Printf("after fake setRadius[%f] circle's area:%f \n", cir.radius, cir.getArea())

	print_end_seperator();

}

/**

没有指定大小，是切片，在go里面是指针传递

*/

func slice_func(arr []int) {

	for idx, val := range arr {

		fmt.Printf("[slice_func]idx:%d val:%d \t", idx, val)

	}

	fmt.Println("")

}

/**

指定了大小，是数组，在go里面是值传递

*/

func arr_func(arr [5]int) {

	for idx, val := range arr {

		fmt.Printf("[arr_func]idx:%d val:%d \t", idx, val)

	}

	fmt.Println("")

}

/**

修改array里面的值，由于数组是值传递，因此这里对原有的参数没有任何影响

*/

func change_arr(arr [5]int, val int) {

	for idx, _ := range arr {

		arr[idx] = val * 10

	}

}

/**

切片是指针传递，因此这里的修改对原有值会有影响

其实本质上这样的写法，切片也是值传递，只是因为在go中切片存储的结构体里面具体的数值是个指针，所以值传递

也只是拷贝了这部分指针的地址，修改的是同一片内存，go中的切片存储的方式如下：

type Slice struct{

arr *int

size int

cap int

}

*/

func change_slice(arr []int, val int) {

	for idx, _ := range arr {

		arr[idx] = val * 10

	}

}

/**

工具函数，打印数组

*/

func print_arr(arr [5]int) {

	for _, val := range arr {

		fmt.Printf("%d\t", val)

	}

	fmt.Println("")

}

/**

工具函数，打印切片

*/

func print_slice(arr []int) {

	if nil == arr {

		return

	}

	for _, val := range arr {

		fmt.Printf("%d\t", val)

	}

	fmt.Println("")

}

/**

工具函数，打印切片

*/

func print_slice_str(arr []string) {

	if nil == arr {

		return

	}

	for _, val := range arr {

		fmt.Printf("%s\t", val)

	}

	fmt.Println("")

}

/*

数组和切片学习，数组和切片在go中是两种完全不同的类型，不要搞混了。

*/

func array_slice_test() {

	print_start_seperator("array_slice_test")

	arr := []int{5, 4, 3, 2, 1}

	slice_func(arr)

	//没有指定大小的参数只能传给没有指定大小的函数

	//arr_func(arr)

	arr2 := [5]int{10, 9, 8, 7, 6}

	//slice_func(arr2)

	arr_func(arr2)

	//下面的数组虽然只是声明，因为指定了大小，所以默认初始化为0

	var arr3 [5]int

	for _, val := range arr3 {

		fmt.Printf("val:%d \t", val)

	}

	fmt.Println()

	//没有指定大小，是切片，在go里面和数组是完全不同的类型，所以arr3本质上是nil，for循环将不会执行

	var arr4 []int

	for _, val := range arr4 {

		fmt.Printf("%d", val)

		fmt.Println("I am not executed!!!!")

	}

	if nil == arr4 {

		fmt.Println("arr4 is a nil!!!!!!!!!!!!!")

	}

	//数组是值传递

	var arr5 [5]int = [5]int{0, 0, 0, 0, 0}

	change_arr(arr5, 15)

	fmt.Println("After changing the array...")

	print_arr(arr5)

	/**

	本质上切片也是值传递，只是因为在go中切片存储的结构体里面具体的数值是个指针，所以值传递

	也只是拷贝了这部分指针的地址，修改的是同一片内存，go中的切片存储的方式如下：

	type Slice struct{

	arr *int

	size int

	cap int

	}

	*/

	var arr6 []int = []int{0, 0, 0, 0, 0, 0, 0}

	change_slice(arr6, 15)

	fmt.Println("After changing the slice...")

	print_slice(arr6)

	//使用数组进行切片的初始化

	var arr7 = [5]string{"one", "two", "three", "four", "five"}

	slice1 := arr7[:]

	print_slice_str(slice1)

	slice1 = arr7[1:3]

	print_slice_str(slice1)

	//slice获取的是原来数组的一段数组引用，因此这里的修改会在原数组上面体现到

	slice1[0] = "new_two"

	fmt.Printf("After assign to slice. arr7:%s  slice1:%s\n", arr7, slice1) //After assign to slice. arr7:[one two new_two four five]  slice1:[two new_two]

	//此时如果修改原数组呢？

	arr7[1] = "newer_two"

	//此时切片也生效了，也就是说，他们始终引用的是同一片地址

	fmt.Printf("After assign to origin arr. arr7:%s  slice1:%s\n", arr7, slice1) //After assign to origin arr. arr7:[one newer_two three four five]  slice1:[newer_two three]

	//第一个参数为size，第二个参数为capacity

	var slice2 = make([]int, 3, 10)

	fmt.Printf("slice2.  size:%d  cap:%d\n", len(slice2), cap(slice2))

	//可以通过append来增加slice的数据，记住，这里要接受返回的值

	slice2 = append(slice2, 1)

	slice2 = append(slice2, 2, 3, 4)

	fmt.Printf("After append. slice2:%d\n", slice2) //[0 0 0 1 2 3 4]

	//注意append函数是生成了一个新得切片，原来得切片对象不会有任何改变

	slice2_bak := append(slice2, 10, 11, 12)

	fmt.Printf("After append. slice2:%d   slice2_bak:%d\n", slice2, slice2_bak) //After append. slice2:[0 0 0 1 2 3 4]   slice2_bak:[0 0 0 1 2 3 4 10 11 12]

	var slice3 = make([]int, len(slice2), cap(slice2))

	copy(slice3, slice2)

	fmt.Printf("After copy slice. slice3:%d\n", slice3)

	//注意，一定要指明slice的长度，否则copy将没有任何效果

	var slice4 []int

	copy(slice4, slice2)

	fmt.Printf("After copy slice. slice4:%d\n", slice4) //[]

	slice_append()

	print_end_seperator()

}

/**

slice里面一个需要注意的现象

*/

func slice_append() {

	//注意，这里指定了slice的cap为10

	slice := make([]int, 5, 10)

	for i := 0; i < 5; i++ {

		slice[i] = i

	}

	slice1 := slice

	slice_p := &slice

	fmt.Printf("slice:%d  slice1:%d   slice_p:%d\n", slice, slice1, *slice_p)

	fmt.Printf("slice's addr:%p \n", &slice)

	//接下来修改slice, 由于slice的cap为10，这里长度够，所以并没有申请新的内存，所以这里slice里面的数组地址没有变化，slice本身也不会变化

	slice = append(slice, 10, 11, 12)

	fmt.Printf("After append.  slice:%d  slice1:%d   slice_p:%d\n", slice, slice1, *slice_p)

	fmt.Printf("After append, slice's addr:%p \n", &slice)

	//注意，这里指定了slice的cap为6

	slice2 := make([]int, 5, 6)

	for i := 0; i < 5; i++ {

		slice2[i] = i

	}

	slice3 := slice2

	slice2_p := &slice2

	fmt.Printf("slice2:%d  slice3:%d   slice2_p:%d\n", slice2, slice3, *slice2_p)

	fmt.Printf("slice2's addr:%p \n", &slice2)

	//接下来修改slice, 由于slice的cap为6，长度不够了，所以会申请新的内存，此时注意，只是slice结构体里面的数组地址发生了变化

	//但是对于slice这个结构体本身，其地址并没有发生变化，所以看到的地址也没有变

	fmt.Printf("slice.size:%d   slice.cap:%d\n", len(slice2), cap(slice2))

	slice2 = append(slice2, 10, 11, 12, 13, 14, 15, 16, 17)

	fmt.Printf("After append.  slice2:%d  slice3:%d   slice2_p:%d\n", slice2, slice3, *slice2_p)

	fmt.Printf("After append, slice2's addr:%p \n", &slice2)

}
巴特西

Golang学习（用代码来学习） - 第二篇

最新文章

热门文章
