```c++
struct fraction {
  int numerator;
  int denominator;
};
struct fraction f1;
f1.numerator = 22;
f1.denominator = 7;


struct car {
  char* name;
  float price;
  int speed;
};
struct car saturn = {"Saturn SL/2", 16000.99, 175};
// or
struct car saturn = {.speed=172, .name="Saturn SL/2"};
// 修改属性值
saturn.speed = 168;


// struct 的数据类型声明语句与变量的声明语句合并
struct book {
  char title[500];
  char author[100];
  float value;
} b1;
// 省略类型名
struct {
  char title[500];
  char author[100];
  float value;
} b1;
// 声明变量的同时，对变量赋值
struct {
  char title[500];
  char author[100];
  float value;
} b1 = {"Harry Potter", "J. K. Rowling", 10.0},
  b2 = {"Cancer Ward", "Aleksandr Solzhenitsyn", 7.85};


// typedef命令可以为 struct 结构指定一个别名
typedef struct cell_phone {
  int cell_no;
  float minutes_of_charge;
} phone;
phone p = {5551234, 5};


// 指针变量也可以指向struct结构
struct book {
  char title[500];
  char author[100];
  float value;
}* b1;
// 或者写成两个语句
struct book {
  char title[500];
  char author[100];
  float value;
};
struct book* b1;


// struct 结构也可以作为数组成员
struct fraction {
  int numerator;
  int denominator;
};
struct fraction numbers[1000];
numbers[0].numerator = 22;
numbers[0].denominator = 7;
```

`struct foo`有三个属性，在 64 位计算机上占用的存储空间分别是：

- `int a`占 4 个字节，
- 指针`char* b`占 8 个字节，
- `char c`占 1 个字节。

它们加起来，一共是 13 个字节（4 + 8 + 1）。
但是实际上，`struct foo`会占用 24 个字节

```c++
struct foo {
  int a;
  char* b;
  char c;
};
printf("%d\n", sizeof(struct foo)); // 24

// 真实的结构
struct foo {
  int a;        // 4
  char pad1[4]; // 填充4字节
  char *b;      // 8
  char c;       // 1
  char pad2[7]; // 填充7字节
};
printf("%d\n", sizeof(struct foo)); // 24

// 存储空间递增的顺序，定义每个属性
struct foo {
  char c;
  int a;
  char* b;
};
printf("%d\n", sizeof(struct foo)); // 16
```

## struct 的复制

```c++
struct cat { char name[30]; short age; } a, b;

strcpy(a.name, "Hula");
a.age = 3;

b = a;
b.name[0] = 'M';

printf("%s\n", a.name); // Hula
printf("%s\n", b.name); // Mula
```

## struct 指针

```c++
#include <stdio.h>

struct turtle {
  char* name;
  char* species;
  int age;
};

void happy(struct turtle t) {
  t.age = t.age + 1;
}

int main() {
  struct turtle myTurtle = {"MyTurtle", "sea turtle", 99};
  happy(myTurtle);
  printf("Age is %i\n", myTurtle.age); // 输出 99
  return 0;
}
```

```c++
#include <stdio.h>

struct turtle {
  char* name;
  char* species;
  int age;
};

void happy(struct turtle* t) {
  (*t).age = (*t).age + 1;
}
// 或者使用箭头运算符
// ptr == &myStruct
// myStruct.prop == (*ptr).prop == ptr->prop
void happy(struct turtle* t) {
  t->age = t->age + 1;
}

int main() {
  struct turtle myTurtle = {"MyTurtle", "sea turtle", 99};
  happy(&myTurtle);
  printf("Age is %i\n", myTurtle.age); // 输出 99
  return 0;
}
```

## struct 的嵌套

```c++
struct species {
  char* name;
  int kinds;
};
struct fish {
  char* name;
  int age;
  struct species breed;
};

// 赋值
// 写法一
struct fish shark = {"shark", 9, {"Selachimorpha", 500}};

// 写法二
struct species myBreed = {"Selachimorpha", 500};
struct fish shark = {"shark", 9, myBreed};

// 写法三
struct fish shark = {
  .name="shark",
  .age=9,
  .breed={"Selachimorpha", 500}
};

// 写法四
struct fish shark = {
  .name="shark",
  .age=9,
  .breed.name="Selachimorpha",
  .breed.kinds=500
};

printf("Shark's species is %s", shark.breed.name);



struct name {
  char first[50];
  char last[50];
};
struct student {
  struct name name;
  short age;
  char sex;
} student1;

strcpy(student1.name.first, "Harry");
strcpy(student1.name.last, "Potter");
// or
struct name myname = {"Harry", "Potter"};
student1.name = myname;
```

### 链表结构

```c++
struct node {
  int data;
  struct node* next;
};

struct node* head;

// 生成一个三个节点的列表 (11)->(22)->(33)
head = malloc(sizeof(struct node));

head->data = 11;
head->next = malloc(sizeof(struct node));

head->next->data = 22;
head->next->next = malloc(sizeof(struct node));

head->next->next->data = 33;
head->next->next->next = NULL;

// 遍历这个列表
for (struct node *cur = head; cur != NULL; cur = cur->next) {
  printf("%d\n", cur->data);
}
```

## 位字段

```c++
struct {
  unsigned int ab:1;
  unsigned int cd:1;
  unsigned int ef:1;
  unsigned int gh:1;
} synth;

synth.ab = 0;
synth.cd = 1;
```

## 弹性数组成员

弹性成员的数组，必须是 `struct` 结构的最后一个属性。
另外，除了弹性数组成员，`struct` 结构必须至少还有一个其他属性。

```c++
struct vstring {
  int len;
  char chars[];
};
struct vstring* str = malloc(sizeof(struct vstring) + n * sizeof(char));
str->len = n;
```


c.md

一个结构体（struct）就是一组字段（field）。

```go
package main
import "fmt"
type Vertex struct {
  X int
  Y int
}
func main() {
  fmt.Println(Vertex{1, 2})
  fmt.Println(Vertex{X:1, Y:2})
}

// 结构体字段使用点号来访问。
package main
import "fmt"
type Vertex struct {
  X int
  Y int
}
func main() {
  v := Vertex{1, 2}
  v.X = 4
  fmt.Println(v.X)
}


// 如果我们有一个指向结构体的指针 p，
// 那么可以通过 (*p).X 来访问其字段 X。
//不过这么写太啰嗦了，所以语言也允许我们使用隐式间接引用，
//直接写 p.X 就可以。
package main
import "fmt"
type Vertex struct {
  X int
  Y int
}
func main() {
  v := Vertex{1, 2}
  p := &v
  // var p int = &v
  fmt.Println(p)
  fmt.Println(*p)
  p.X = 3
  // (*p).X = 3
  fmt.Println(v)
}
// &{1 2}
// {1 2}
// {3 2}


// 仅列出部分字段。（字段名的顺序无关。）
package main
import "fmt"
type Vertex struct {
  X, Y int
}
var (
  v1 = Vertex{1, 2}  // 创建一个 Vertex 类型的结构体
  v2 = Vertex{X: 1}  // Y:0 被隐式地赋予
  v3 = Vertex{}      // X:0 Y:0
  p  = &Vertex{1, 2} // 创建一个 *Vertex 类型的结构体（指针）
)
func main() {
  fmt.Println(v1, p, v2, v3)
}
// {1 2} &{1 2} {1 0} {0 0}


// struct的匿名字段
package main
import "fmt"
type Human struct {
  name string
  age int
  weight int
}

type Student struct {
  Human  // 匿名字段，那么默认Student就包含了Human的所有字段
  speciality string
}

func main() {
  // 我们初始化一个学生
  mark := Student{Human{"Mark", 25, 120}, "Computer Science"}

  // 我们访问相应的字段
  fmt.Println("His name is ", mark.name)
  fmt.Println("His age is ", mark.age)
  fmt.Println("His weight is ", mark.weight)
  fmt.Println("His speciality is ", mark.speciality)
  // 修改对应的备注信息
  mark.speciality = "AI"
  fmt.Println("Mark changed his speciality")
  fmt.Println("His speciality is ", mark.speciality)
  // 修改他的年龄信息
  fmt.Println("Mark become old")
  mark.age = 46
  fmt.Println("His age is", mark.age)
  // 修改他的体重信息
  fmt.Println("Mark is not an athlet anymore")
  mark.weight += 60
  fmt.Println("His weight is", mark.weight)
}


package main
import "fmt"
type Skills []string
type Human struct {
  name string
  age int
  weight int
}
type Student struct {
  Human  // 匿名字段，struct
  Skills // 匿名字段，自定义的类型string slice
  int    // 内置类型作为匿名字段
  speciality string
}
func main() {
  // 初始化学生Jane
  jane := Student{Human:Human{"Jane", 35, 100}, speciality:"Biology"}
  // 现在我们来访问相应的字段
  fmt.Println("Her name is ", jane.name)
  fmt.Println("Her age is ", jane.age)
  fmt.Println("Her weight is ", jane.weight)
  fmt.Println("Her speciality is ", jane.speciality)
  // 我们来修改他的skill技能字段
  jane.Skills = []string{"anatomy"}
  fmt.Println("Her skills are ", jane.Skills)
  fmt.Println("She acquired two new ones ")
  jane.Skills = append(jane.Skills, "physics", "golang")
  fmt.Println("Her skills now are ", jane.Skills)
  // 修改匿名内置类型字段
  jane.int = 3
  fmt.Println("Her preferred number is", jane.int)
}
```

```go
type Employee struct {
    ID        int
    Name      string
    Address   string
    DoB       time.Time
    Position  string
    Salary    int
    ManagerID int
}
var dilbert Employee

var employeeOfTheMonth *Employee = &dilbert
employeeOfTheMonth.Position += " (proactive team player)" // 相当于下一行
(*employeeOfTheMonth).Position += " (proactive team player)"

// 如果要在函数内部修改结构体成员的话，用指针传入是必须的
func AwardAnnualRaise(e *Employee) {
    e.Salary = e.Salary * 105 / 100
}

pp := &Point{1, 2} // 等价于下面两行
pp := new(Point)
*pp = Point{1, 2}
```

一个命名为 S 的结构体类型将不能再包含 S 类型的成员：
因为一个聚合的值不能包含它自身。
（该限制同样适应于数组。）
但是 S 类型的结构体可以包含\*S 指针类型的成员，
这可以让我们创建递归的数据结构，比如链表和树结构等。

```go
type tree struct {
    value       int
    left, right *tree
}
```

如果结构体的全部成员都是可以比较的，那么结构体也是可以比较的。
因此和其他可比较的类型一样，可以用于 map 的 key 类型

```go
type Point struct{ X, Y int }

p := Point{1, 2}
q := Point{2, 1}
fmt.Println(p.X == q.X && p.Y == q.Y) // "false"
fmt.Println(p == q)                   // "false"
```

Go 语言有一个特性让我们只声明一个成员对应的数据类型而不指名成员的名字；
这类成员就叫匿名成员。
匿名成员的数据类型必须是命名的类型或指向一个命名的类型的指针。

```go
type Point struct {
    X, Y int
}
type Circle struct {
    Center Point
    Radius int
}
type Wheel struct {
    Circle Circle
    Spokes int
}
var w Wheel
w.Circle.Center.X = 8
w.Circle.Center.Y = 8
w.Circle.Radius = 5
w.Spokes = 20

// 下面的代码中，Circle和Wheel各自都有一个匿名成员。
// 我们可以说Point类型被嵌入到了Circle结构体，
// 同时Circle类型被嵌入到了Wheel结构体。
type Circle struct {
    Point
    Radius int
}
type Wheel struct {
    Circle
    Spokes int
}

// 匿名成员Circle和Point都有自己的名字——就是命名的类型名字
// 但是这些名字在点操作符中是可选的。
var w Wheel
w.X = 8            // equivalent to w.Circle.Point.X = 8
w.Y = 8            // equivalent to w.Circle.Point.Y = 8
w.Radius = 5       // equivalent to w.Circle.Radius = 5
w.Spokes = 20

// 不幸的是，结构体字面值并没有简短表示匿名成员的语法，
// 因此下面的语句都不能编译通过：
w = Wheel{8, 8, 5, 20}                       // compile error: unknown fields
w = Wheel{X: 8, Y: 8, Radius: 5, Spokes: 20} // compile error: unknown fields

// 结构体字面值必须遵循形状类型声明时的结构，所以我们只能用下面的两种语法
w = Wheel{Circle{Point{8, 8}, 5}, 20}
w = Wheel{
    Circle: Circle{
        Point:  Point{X: 8, Y: 8},
        Radius: 5,
    },
    Spokes: 20, // NOTE: trailing comma necessary here (and at Radius)
}
fmt.Printf("%#v\n", w)
// Output:
// Wheel{Circle:Circle{Point:Point{X:8, Y:8}, Radius:5}, Spokes:20}
w.X = 42
fmt.Printf("%#v\n", w)
// Output:
// Wheel{Circle:Circle{Point:Point{X:42, Y:8}, Radius:5}, Spokes:20}
```

一个 struct 类型也可能会有多个匿名字段。

种类型的值便会拥有 Point 和 RGBA 类型的所有方法，
以及直接定义在 ColoredPoint 中的方法。
当编译器解析一个选择器到方法时，比如 p.ScaleBy，
它会首先去找直接定义在这个类型里的 ScaleBy 方法，
然后找被 ColoredPoint 的内嵌字段们引入的方法，
然后去找 Point 和 RGBA 的内嵌字段引入的方法，然后一直递归向下找。
如果选择器有二义性的话编译器会报错，比如你在同一级里有两个同名的方法。

```go
type ColoredPoint struct {
    Point
    color.RGBA
}
```

一个小 trick

```go
var (
    mu sync.Mutex // guards mapping
    mapping = make(map[string]string)
)

func Lookup(key string) string {
    mu.Lock()
    v := mapping[key]
    mu.Unlock()
    return v
}
```

改进后

```go
// 给新的变量起了一个更具表达性的名字：cache
// 因为sync.Mutex字段也被嵌入到了这个struct里，
// 其Lock和Unlock方法也就都被引入到了这个匿名结构中了
var cache = struct {
    sync.Mutex
    mapping map[string]string
}{
    mapping: make(map[string]string),
}


func Lookup(key string) string {
    cache.Lock()
    v := cache.mapping[key]
    cache.Unlock()
    return v
}
```

将一个 Go 语言中类似 movies 的结构体 slice 转为 JSON 的过程叫编组（marshaling）。
编组通过调用 json.Marshal 函数完成

```go
// Color成员的Tag还带了一个额外的omitempty选项，
// 表示当Go语言结构体成员为空或零值时不生成JSON对象（这里false为零值）。
type Movie struct {
    Title  string
    Year   int  `json:"released"`
    Color  bool `json:"color,omitempty"`
    Actors []string
}
var movies = []Movie{
    {Title: "Casablanca", Year: 1942, Color: false,
        Actors: []string{"Humphrey Bogart", "Ingrid Bergman"}},
    {Title: "Cool Hand Luke", Year: 1967, Color: true,
        Actors: []string{"Paul Newman"}},
    {Title: "Bullitt", Year: 1968, Color: true,
        Actors: []string{"Steve McQueen", "Jacqueline Bisset"}},
    // ...
}
data, err := json.Marshal(movies)
if err != nil {
    log.Fatalf("JSON marshaling failed: %s", err)
}
fmt.Printf("%s\n", data)

```

```json
[{"Title":"Casablanca","released":1942,"Actors":["Humphrey Bogart","Ingr
id Bergman"]},{"Title":"Cool Hand Luke","released":1967,"color":true,"Ac
tors":["Paul Newman"]},{"Title":"Bullitt","released":1968,"color":true,"
Actors":["Steve McQueen","Jacqueline Bisset"]}]
```

```go
// json.MarshalIndent函数将产生整齐缩进的输出
data, err := json.MarshalIndent(movies, "", "    ")
if err != nil {
    log.Fatalf("JSON marshaling failed: %s", err)
}
fmt.Printf("%s\n", data)
```

```json
[
  {
    "Title": "Casablanca",
    "released": 1942,
    "Actors": ["Humphrey Bogart", "Ingrid Bergman"]
  },
  {
    "Title": "Cool Hand Luke",
    "released": 1967,
    "color": true,
    "Actors": ["Paul Newman"]
  },
  {
    "Title": "Bullitt",
    "released": 1968,
    "color": true,
    "Actors": ["Steve McQueen", "Jacqueline Bisset"]
  }
]
```

编码的逆操作是解码，对应将 JSON 数据解码为 Go 语言的数据结构，
Go 语言中一般叫 unmarshaling，通过 json.Unmarshal 函数完成。

```go
var titles []struct{ Title string }
if err := json.Unmarshal(data, &titles); err != nil {
    log.Fatalf("JSON unmarshaling failed: %s", err)
}
fmt.Println(titles) // "[{Casablanca} {Cool Hand Luke} {Bullitt}]"
```

## 结构体嵌入

```go
package main
import "fmt"

type base struct {
    num int
}
func (b base) describe() string {
    return fmt.Sprintf("base with num=%v", b.num)
}

type container struct {
    base
    str string
}

func main() {
    co := container{
        base: base{
            num: 1,
        },
        str: "some name",
    }

    fmt.Printf("co={num: %v, str: %v}\n", co.num, co.str)
    fmt.Println("also num:", co.base.num)
    fmt.Println("describe:", co.describe())

    // 因为嵌入了 base ，在这里我们看到 container 也实现了 describer 接口
    type describer interface {
        describe() string
    }
    var d describer = co
    fmt.Println("describer:", d.describe())
}
```


go.md

结构体（structure，缩写成 struct）有 3 种类型

- 元组结构体（tuple struct），事实上就是具名元组而已。
- 经典的 C 语言风格结构体（C struct）。
- 单元结构体（unit struct），不带字段，在泛型中很有用。

```rust
#[derive(Debug)]
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        email,
        username,
        active: true,
        sign_in_count: 1,
    }
}

fn main() {
    let mut user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
    user1.email = String::from("anotheremail@example.com");
    println!("{:?}", user1);

    // 在这个例子中，我们在创建 user2 后不能再使用 user1，
    // 因为 user1 的 username 字段中的 String 被移到 user2 中。
    // 如果我们给 user2 的 email 和 username 都赋予新的 String 值，
    // 从而只使用 user1 的 active 和 sign_in_count 值，
    // 那么 user1 在创建 user2 后仍然有效。
    let user2 = User {
        email: String::from("another@example.com"),
        ..user1
    };
    println!("{:#?}", user2);
}
```

```sh
User { active: true, username: "someusername123", email: "anotheremail@example.com", sign_in_count: 1 }
User {
    active: true,
    username: "someusername123",
    email: "another@example.com",
    sign_in_count: 1,
}
```

```rust
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // 方法
    fn area(&self) -> u32 {
        self.width * self.height
    }
    // 带参数的方法
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
    // 关联函数（associated function）
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}
```

## 打印结构体

```rust
// 在结构体定义之前加上外部属性 #[derive(Debug)]
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 is {:?}", rect1);
}
```

```rust
// 使用 dbg! 宏
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let scale = 2;
    let rect1 = Rectangle {
        width: dbg!(30 * scale),
        height: 50,
    };

    dbg!(&rect1);
}
```

## 元组结构体（tuple struct）

```rust
// black 和 origin 值的类型不同，因为它们是不同的元组结构体的实例。
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}
```

## 类单元结构体（unit-like structs）

类单元结构体常常在你想要在某个类型上实现 `trait` 但不需要在类型中存储数据的时候发挥作用。

```rust
struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}
```
