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 
", cir.getArea())

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

	cir.setRadiusFake(20)
	fmt.Printf("after fake setRadius[%f] circle's area:%f 
", 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
", 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
", 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
", len(slice2), cap(slice2))

	//    append   slice   ，  ，         
	slice2 = append(slice2, 1)
	slice2 = append(slice2, 2, 3, 4)
	fmt.Printf("After append. slice2:%d
", 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
", 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
", slice3)
	//  ，     slice   ，  copy       
	var slice4 []int
	copy(slice4, slice2)
	fmt.Printf("After copy slice. slice4:%d
", 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
", slice, slice1, *slice_p)
	fmt.Printf("slice's addr:%p 
", &slice)

	//     slice,   slice cap 10，     ，           ，    slice           ，slice       
	slice = append(slice, 10, 11, 12)
	fmt.Printf("After append.  slice:%d  slice1:%d   slice_p:%d
", slice, slice1, *slice_p)
	fmt.Printf("After append, slice's addr:%p 
", &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
", slice2, slice3, *slice2_p)
	fmt.Printf("slice2's addr:%p 
", &slice2)

	//     slice,   slice cap 6，     ，         ，    ，  slice               
	//    slice       ，          ，           
	fmt.Printf("slice.size:%d   slice.cap:%d
", 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
", slice2, slice3, *slice2_p)
	fmt.Printf("After append, slice2's addr:%p 
", &slice2)
}