主頁 > 後端開發 > Go語言基礎之結構體

Go語言基礎之結構體

2020-09-15 05:52:52 後端開發

Go語言中沒有“類”的概念，也不支持“類”的繼承等面向物件的概念，Go語言中通過結構體的內嵌再配合介面比面向物件具有更高的擴展性和靈活性，

型別別名和自定義型別

自定義型別

在Go語言中有一些基本的資料型別，如string、整型、浮點型、布爾等資料型別， Go語言中可以使用type關鍵字來定義自定義型別，

自定義型別是定義了一個全新的型別，我們可以基于內置的基本型別定義，也可以通過struct定義，例如：

//將MyInt定義為int型別
type MyInt int

通過Type關鍵字的定義，MyInt就是一種新的型別，它具有int的特性，

型別別名

型別別名是Go1.9版本添加的新功能，

型別別名規定：TypeAlias只是Type的別名，本質上TypeAlias與Type是同一個型別，就像一個孩子小時候有小名、乳名，上學后用學名，英語老師又會給他起英文名，但這些名字都指的是他本人，

type TypeAlias = Type

我們之前見過的rune和byte就是型別別名，他們的定義如下：

type byte = uint8
type rune = int32

型別定義和型別別名的區別

型別別名與型別定義表面上看只有一個等號的差異，我們通過下面的這段代碼來理解它們之間的區別，

//型別定義
type NewInt int

//型別別名
type MyInt = int

func main() {
	var a NewInt
	var b MyInt
	
	fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
	fmt.Printf("type of b:%T\n", b) //type of b:int
}

結果顯示a的型別是main.NewInt，表示main包下定義的NewInt型別，b的型別是int，MyInt型別只會在代碼中存在，編譯完成時并不會有MyInt型別，

結構體

Go語言中的基礎資料型別可以表示一些事物的基本屬性，但是當我們想表達一個事物的全部或部分屬性時，這時候再用單一的基本資料型別明顯就無法滿足需求了，Go語言提供了一種自定義資料型別，可以封裝多個基本資料型別，這種資料型別叫結構體，英文名稱struct， 也就是我們可以通過struct來定義自己的型別了，

Go語言中通過struct來實作面向物件，

結構體的定義

使用type和struct關鍵字來定義結構體，具體代碼格式如下：

type 型別名 struct {
    欄位名 欄位型別
    欄位名 欄位型別
    …
}

其中：

  • 型別名：標識自定義結構體的名稱，在同一個包內不能重復，
  • 欄位名：表示結構體欄位名，結構體中的欄位名必須唯一，
  • 欄位型別：表示結構體欄位的具體型別，

舉個例子，我們定義一個Person（人）結構體，代碼如下：

type person struct {
	name string
	city string
	age  int8
}

同樣型別的欄位也可以寫在一行，

type person1 struct {
	name, city string
	age        int8
}

這樣我們就擁有了一個person的自定義型別，它有name、city、age三個欄位，分別表示姓名、城市和年齡，這樣我們使用這個person結構體就能夠很方便的在程式中表示和存盤人資訊了，

語言內置的基礎資料型別是用來描述一個值的，而結構體是用來描述一組值的，比如一個人有名字、年齡和居住城市等，本質上是一種聚合型的資料型別

結構體實體化

只有當結構體實體化時，才會真正地分配記憶體，也就是必須實體化后才能使用結構體的欄位，

結構體本身也是一種型別，我們可以像宣告內置型別一樣使用var關鍵字宣告結構體型別，

var 結構體實體 結構體型別

基本實體化

舉個例子：

type person struct {
	name string
	city string
	age  int8
}

func main() {
	var p1 person
	p1.name = "沙河娜扎"
	p1.city = "北京"
	p1.age = 18
	fmt.Printf("p1=%v\n", p1)  //p1={沙河娜扎 北京 18}
	fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"沙河娜扎", city:"北京", age:18}
}

我們通過.來訪問結構體的欄位（成員變數）,例如p1.name和p1.age等，

匿名結構體

在定義一些臨時資料結構等場景下還可以使用匿名結構體，

package main
     
import (
    "fmt"
)
     
func main() {
    var user struct{Name string; Age int}
    user.Name = "小王子"
    user.Age = 18
    fmt.Printf("%#v\n", user)
}

創建指標型別結構體

我們還可以通過使用new關鍵字對結構體進行實體化，得到的是結構體的地址， 格式如下：

var p2 = new(person)
fmt.Printf("%T\n", p2)     //*main.person
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}

從列印的結果中我們可以看出p2是一個結構體指標，

需要注意的是在Go語言中支持對結構體指標直接使用.來訪問結構體的成員，

var p2 = new(person)
p2.name = "小王子"
p2.age = 28
p2.city = "上海"
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"小王子", city:"上海", age:28}

取結構體的地址實體化

使用&對結構體進行取地址操作相當于對該結構體型別進行了一次new實體化操作，

p3 := &person{}
fmt.Printf("%T\n", p3)     //*main.person
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"", city:"", age:0}
p3.name = "七米"
p3.age = 30
p3.city = "成都"
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"七米", city:"成都", age:30}

p3.name = "七米"其實在底層是(*p3).name = "七米"，這是Go語言幫我們實作的語法糖，

結構體初始化

沒有初始化的結構體，其成員變數都是對應其型別的零值，

type person struct {
	name string
	city string
	age  int8
}

func main() {
	var p4 person
	fmt.Printf("p4=%#v\n", p4) //p4=main.person{name:"", city:"", age:0}
}

使用鍵值對初始化

使用鍵值對對結構體進行初始化時，鍵對應結構體的欄位，值對應該欄位的初始值，

p5 := person{
	name: "小王子",
	city: "北京",
	age:  18,
}
fmt.Printf("p5=%#v\n", p5) //p5=main.person{name:"小王子", city:"北京", age:18}

也可以對結構體指標進行鍵值對初始化，例如：

p6 := &person{
	name: "小王子",
	city: "北京",
	age:  18,
}
fmt.Printf("p6=%#v\n", p6) //p6=&main.person{name:"小王子", city:"北京", age:18}

當某些欄位沒有初始值的時候，該欄位可以不寫，此時，沒有指定初始值的欄位的值就是該欄位型別的零值，

p7 := &person{
	city: "北京",
}
fmt.Printf("p7=%#v\n", p7) //p7=&main.person{name:"", city:"北京", age:0}

使用值的串列初始化

初始化結構體的時候可以簡寫，也就是初始化的時候不寫鍵，直接寫值：

p8 := &person{
	"沙河娜扎",
	"北京",
	28,
}
fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"沙河娜扎", city:"北京", age:28}

使用這種格式初始化時，需要注意：

  1. 必須初始化結構體的所有欄位，
  2. 初始值的填充順序必須與欄位在結構體中的宣告順序一致，
  3. 該方式不能和鍵值初始化方式混用，

結構體記憶體布局

結構體占用一塊連續的記憶體，

type test struct {
	a int8
	b int8
	c int8
	d int8
}
n := test{
	1, 2, 3, 4,
}
fmt.Printf("n.a %p\n", &n.a)
fmt.Printf("n.b %p\n", &n.b)
fmt.Printf("n.c %p\n", &n.c)
fmt.Printf("n.d %p\n", &n.d)

輸出：

n.a 0xc0000a0060
n.b 0xc0000a0061
n.c 0xc0000a0062
n.d 0xc0000a0063

【進階知識點】關于Go語言中的記憶體對齊推薦閱讀:在 Go 中恰到好處的記憶體對齊

面試題

請問下面代碼的執行結果是什么？

type student struct {
	name string
	age  int
}

func main() {
	m := make(map[string]*student)
	stus := []student{
		{name: "小王子", age: 18},
		{name: "娜扎", age: 23},
		{name: "大王八", age: 9000},
	}

	for _, stu := range stus {
		m[stu.name] = &stu
	}
	for k, v := range m {
		fmt.Println(k, "=>", v.name)
	}
}

建構式

Go語言的結構體沒有建構式，我們可以自己實作， 例如，下方的代碼就實作了一個person的建構式， 因為struct是值型別，如果結構體比較復雜的話，值拷貝性能開銷會比較大，所以該建構式回傳的是結構體指標型別，

func newPerson(name, city string, age int8) *person {
	return &person{
		name: name,
		city: city,
		age:  age,
	}
}

呼叫建構式

p9 := newPerson("張三", "沙河", 90)
fmt.Printf("%#v\n", p9) //&main.person{name:"張三", city:"沙河", age:90}

方法和接收者

Go語言中的方法（Method）是一種作用于特定型別變數的函式，這種特定型別變數叫做接收者（Receiver），接收者的概念就類似于其他語言中的this或者 self，

方法的定義格式如下：

func (接收者變數 接收者型別) 方法名(引數串列) (回傳引數) {
    函式體
}

其中，

  • 接收者變數：接收者中的引數變數名在命名時，官方建議使用接收者型別名的第一個小寫字母，而不是self、this之類的命名，例如，Person型別的接收者變數應該命名為 p，Connector型別的接收者變數應該命名為c等，
  • 接收者型別：接收者型別和引數類似，可以是指標型別和非指標型別，
  • 方法名、引數串列、回傳引數：具體格式與函式定義相同，

舉個例子：

//Person 結構體
type Person struct {
	name string
	age  int8
}

//NewPerson 建構式
func NewPerson(name string, age int8) *Person {
	return &Person{
		name: name,
		age:  age,
	}
}

//Dream Person做夢的方法
func (p Person) Dream() {
	fmt.Printf("%s的夢想是學好Go語言！\n", p.name)
}

func main() {
	p1 := NewPerson("小王子", 25)
	p1.Dream()
}

方法與函式的區別是，函式不屬于任何型別，方法屬于特定的型別，

指標型別的接收者

指標型別的接收者由一個結構體的指標組成，由于指標的特性，呼叫方法時修改接收者指標的任意成員變數，在方法結束后，修改都是有效的，這種方式就十分接近于其他語言中面向物件中的this或者self， 例如我們為Person添加一個SetAge方法，來修改實體變數的年齡，

// SetAge 設定p的年齡
// 使用指標接收者
func (p *Person) SetAge(newAge int8) {
	p.age = newAge
}

呼叫該方法：

func main() {
	p1 := NewPerson("小王子", 25)
	fmt.Println(p1.age) // 25
	p1.SetAge(30)
	fmt.Println(p1.age) 30
}

值型別的接收者

當方法作用于值型別接收者時，Go語言會在代碼運行時將接收者的值復制一份，在值型別接收者的方法中可以獲取接收者的成員值，但修改操作只是針對副本，無法修改接收者變數本身，

// SetAge2 設定p的年齡
// 使用值接收者
func (p Person) SetAge2(newAge int8) {
	p.age = newAge
}

func main() {
	p1 := NewPerson("小王子", 25)
	p1.Dream()
	fmt.Println(p1.age) // 25
	p1.SetAge2(30) // (*p1).SetAge2(30)
	fmt.Println(p1.age) // 25
}

什么時候應該使用指標型別接收者

  1. 需要修改接收者中的值
  2. 接收者是拷貝代價比較大的大物件
  3. 保證一致性，如果有某個方法使用了指標接收者，那么其他的方法也應該使用指標接收者，

任意型別添加方法

在Go語言中，接收者的型別可以是任何型別，不僅僅是結構體，任何型別都可以擁有方法， 舉個例子，我們基于內置的int型別使用type關鍵字可以定義新的自定義型別，然后為我們的自定義型別添加方法，

//MyInt 將int定義為自定義MyInt型別
type MyInt int

//SayHello 為MyInt添加一個SayHello的方法
func (m MyInt) SayHello() {
	fmt.Println("Hello, 我是一個int，")
}
func main() {
	var m1 MyInt
	m1.SayHello() //Hello, 我是一個int，
	m1 = 100
	fmt.Printf("%#v  %T\n", m1, m1) //100  main.MyInt
}

注意事項： 非本地型別不能定義方法，也就是說我們不能給別的包的型別定義方法，

結構體的匿名欄位

結構體允許其成員欄位在宣告時沒有欄位名而只有型別，這種沒有名字的欄位就稱為匿名欄位，

//Person 結構體Person型別
type Person struct {
	string
	int
}

func main() {
	p1 := Person{
		"小王子",
		18,
	}
	fmt.Printf("%#v\n", p1)        //main.Person{string:"北京", int:18}
	fmt.Println(p1.string, p1.int) //北京 18
}

匿名欄位默認采用型別名作為欄位名，結構體要求欄位名稱必須唯一，因此一個結構體中同種型別的匿名欄位只能有一個，

嵌套結構體

一個結構體中可以嵌套包含另一個結構體或結構體指標，

//Address 地址結構體
type Address struct {
	Province string
	City     string
}

//User 用戶結構體
type User struct {
	Name    string
	Gender  string
	Address Address
}

func main() {
	user1 := User{
		Name:   "小王子",
		Gender: "男",
		Address: Address{
			Province: "山東",
			City:     "威海",
		},
	}
	fmt.Printf("user1=%#v\n", user1)//user1=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山東", City:"威海"}}
}

嵌套匿名結構體

//Address 地址結構體
type Address struct {
	Province string
	City     string
}

//User 用戶結構體
type User struct {
	Name    string
	Gender  string
	Address //匿名結構體
}

func main() {
	var user2 User
	user2.Name = "小王子"
	user2.Gender = "男"
	user2.Address.Province = "山東"    //通過匿名結構體.欄位名訪問
	user2.City = "威海"                //直接訪問匿名結構體的欄位名
	fmt.Printf("user2=%#v\n", user2) //user2=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山東", City:"威海"}}
}

當訪問結構體成員時會先在結構體中查找該欄位，找不到再去匿名結構體中查找，

嵌套結構體的欄位名沖突

嵌套結構體內部可能存在相同的欄位名，這個時候為了避免歧義需要指定具體的內嵌結構體的欄位，

//Address 地址結構體
type Address struct {
	Province   string
	City       string
	CreateTime string
}

//Email 郵箱結構體
type Email struct {
	Account    string
	CreateTime string
}

//User 用戶結構體
type User struct {
	Name   string
	Gender string
	Address
	Email
}

func main() {
	var user3 User
	user3.Name = "沙河娜扎"
	user3.Gender = "男"
	// user3.CreateTime = "2019" //ambiguous selector user3.CreateTime
	user3.Address.CreateTime = "2000" //指定Address結構體中的CreateTime
	user3.Email.CreateTime = "2000"   //指定Email結構體中的CreateTime
}

結構體的“繼承”

Go語言中使用結構體也可以實作其他編程語言中面向物件的繼承，

//Animal 動物
type Animal struct {
	name string
}

func (a *Animal) move() {
	fmt.Printf("%s會動！\n", a.name)
}

//Dog 狗
type Dog struct {
	Feet    int8
	*Animal //通過嵌套匿名結構體實作繼承
}

func (d *Dog) wang() {
	fmt.Printf("%s會汪汪汪~\n", d.name)
}

func main() {
	d1 := &Dog{
		Feet: 4,
		Animal: &Animal{ //注意嵌套的是結構體指標
			name: "樂樂",
		},
	}
	d1.wang() //樂樂會汪汪汪~
	d1.move() //樂樂會動！
}

結構體欄位的可見性

結構體中欄位大寫開頭表示可公開訪問，小寫表示私有（僅在定義當前結構體的包中可訪問），

結構體與JSON序列化

JSON(JavaScript Object Notation) 是一種輕量級的資料交換格式，易于人閱讀和撰寫，同時也易于機器決議和生成，JSON鍵值對是用來保存JS物件的一種方式，鍵/值對組合中的鍵名寫在前面并用雙引號""包裹，使用冒號:分隔，然后緊接著值；多個鍵值之間使用英文,分隔，

//Student 學生
type Student struct {
	ID     int
	Gender string
	Name   string
}

//Class 班級
type Class struct {
	Title    string
	Students []*Student
}

func main() {
	c := &Class{
		Title:    "101",
		Students: make([]*Student, 0, 200),
	}
	for i := 0; i < 10; i++ {
		stu := &Student{
			Name:   fmt.Sprintf("stu%02d", i),
			Gender: "男",
			ID:     i,
		}
		c.Students = append(c.Students, stu)
	}
	//JSON序列化：結構體-->JSON格式的字串
	data, err := json.Marshal(c)
	if err != nil {
		fmt.Println("json marshal failed")
		return
	}
	fmt.Printf("json:%s\n", data)
	//JSON反序列化：JSON格式的字串-->結構體
	str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
	c1 := &Class{}
	err = json.Unmarshal([]byte(str), c1)
	if err != nil {
		fmt.Println("json unmarshal failed!")
		return
	}
	fmt.Printf("%#v\n", c1)
}

結構體標簽（Tag）

Tag是結構體的元資訊，可以在運行的時候通過反射的機制讀取出來， Tag在結構體欄位的后方定義，由一對反引號包裹起來，具體的格式如下：

`key1:"value1" key2:"value2"`

結構體標簽由一個或多個鍵值對組成，鍵與值使用冒號分隔，值用雙引號括起來，鍵值對之間使用一個空格分隔， 注意事項： 為結構體撰寫Tag時，必須嚴格遵守鍵值對的規則，結構體標簽的決議代碼的容錯能力很差，一旦格式寫錯，編譯和運行時都不會提示任何錯誤，通過反射也無法正確取值，例如不要在key和value之間添加空格，

例如我們為Student結構體的每個欄位定義json序列化時使用的Tag：

//Student 學生
type Student struct {
	ID     int    `json:"id"` //通過指定tag實作json序列化該欄位時的key
	Gender string //json序列化是默認使用欄位名作為key
	name   string //私有不能被json包訪問
}

func main() {
	s1 := Student{
		ID:     1,
		Gender: "男",
		name:   "沙河娜扎",
	}
	data, err := json.Marshal(s1)
	if err != nil {
		fmt.Println("json marshal failed!")
		return
	}
	fmt.Printf("json str:%s\n", data) //json str:{"id":1,"Gender":"男"}
}

練習題

  1. 使用“面向物件”的思維方式撰寫一個學生資訊管理系統，
    1. 學生有id、姓名、年齡、分數等資訊
    2. 程式提供展示學生串列、添加學生、編輯學生資訊、洗掉學生等功能

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/43084.html

標籤：Go

上一篇：Go語言基礎之包

下一篇：Go語言基礎之指標

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂