结构体是用户自定义的数据类型，允许用户存储不同的数据类型；在结构体中可以为不同项定义不同的数据类型。
C++ 结构体
语法：
struct 结构体名 { 结构体成员列表 };
三种定义结构体变量方式：
- [struct] 结构体名 变量名 （可省略struct）
- [struct] 结构体名 变量名 = { 成员1值， 成员2值 ...... } （可省略struct）
- 定义结构体时创建变量
#include<iostream>
#include<string>
using namespace std;
//结构体定义
//人类
struct Person
{
//姓名
string name;
//性别
string sex;
//年龄
int age;
} s3; //第三种创建结构体变量：结构体变量在定义时创建
//结构体成员输出
void print(Person s)
{
cout << "s1结构体：姓名：" << s.name << ", 性别：" << s.sex << ", 年龄：" << s.age << endl;
}
int main()
{
//第一种创建结构体变量：[struct] 结构体名 变量名; （可省略struct）
struct Person s1;
//成员赋值
s1.name = "Tracy";
s1.sex = "女";
s1.age = 20;
//成员输出
print(s1);
//第二种创建结构体变量： [struct] 结构体名 变量名 = { 成员1值， 成员2值 ...... } （可省略struct）
Person s2 = { "Felix", "男", 16 };
//成员输出
print(s2);
//第三种创建结构体变量：见结构体定义处
//成员赋值
s3.name = "Timo";
s3.sex = "女";
s3.age = 60;
//成员输出
print(s3);
system("pause");
return 0;
}
输出结果
s1结构体：姓名：Tracy, 性别：女, 年龄：20
s2结构体：姓名：Felix, 性别：男, 年龄：16
s3结构体：姓名：Timo, 性别：女, 年龄：60
Go语言结构体
语法：
type 结构体名 struct { 结构体成员列表 }
三种定义结构体变量方式：
- var 变量名 结构体名
- 变量名 := 结构体名{ 成员1值， 成员2值 ...}
- 变量名 := 结构体名{ 成员名1:值1，成员名2:值2，... }
package main
import "fmt"
//人类
type Person struct {
//姓名
name string
//性别
sex string
//年龄
age int
}
func main() {
//第一种创建结构体变量：var 变量名 结构体名
var s1 Person
//成员赋值
s1.name = "Tracy"
s1.sex = "女"
s1.age = 20
//成员输出
print(s1)
//第二种创建结构体变量：变量名 := 结构体名{ 成员1值， 成员2值 ...}
s2 := Person{ "Felix", "男", 16 }
//成员输出
print(s2)
//第三种创建结构体变量：变量名 := 结构体名{ 成员名1:值1，成员名2:值2，... }
s3 := Person{
name: "Timo",
age: 60,
sex: "女",
}
//成员输出
print(s3)
}
//结构体成员输出
func print(s Person) {
fmt.Printf("s1结构体：姓名：%s, 性别：%s, 年龄：%d\n", s.name, s.sex, s.age)
}
输出结果
2、结构体数组s1结构体：姓名：Tracy, 性别：女, 年龄：20
s1结构体：姓名：Felix, 性别：男, 年龄：16
s1结构体：姓名：Timo, 性别：女, 年龄：60
C++结构体数组
#include<iostream>
#include<string>
using namespace std;
//结构体定义
//人类
struct Person
{
//姓名
string name;
//性别
string sex;
//年龄
int age;
};
int main()
{
//结构体数组变量定义并初始化
struct Person s[3] = {
{ "Felix", "男", 16 },
{ "Tracy", "女", 20 },
{ "Timo", "男", 60 }
};
//结构体数组元素赋值
s[0].age = 17;
//成员输出
for (int i = 0;i < 3;i++) {
cout << "s结构体数组：姓名：" << s[i].name << ", 性别：" << s[i].sex << ", 年龄：" << s[i].age << endl;
}
system("pause");
return 0;
}
输出结果
s结构体数组：姓名：Felix, 性别：男, 年龄：17
s结构体数组：姓名：Tracy, 性别：女, 年龄：20
s结构体数组：姓名：Timo, 性别：男, 年龄：60
Go语言结构体数组
package main
import "fmt"
//人类
type Person struct {
//姓名
name string
//性别
sex string
//年龄
age int
}
func main() {
//结构体数组变量定义并初始化
var s [3]Person = [3]Person{
{ "Felix", "男", 16 },
{ "Tracy", "女", 20 },
{ "Timo", "男", 60 },
}
//结构体数组元素赋值
s[0].age = 17
//成员输出
for i := 0; i < 3; i++ {
fmt.Printf("s结构体数组：姓名：%s, 性别：%s, 年龄：%d\n", s[i].name, s[i].sex, s[i].age)
}
}
输出结果
3、 结构体指针s结构体数组：姓名：Felix, 性别：男, 年龄：17
s结构体数组：姓名：Tracy, 性别：女, 年龄：20
s结构体数组：姓名：Timo, 性别：男, 年龄：60
C++结构体指针
通过操作符 -> 访问结构体中的成员。
#include<iostream>
#include<string>
using namespace std;
//结构体定义
//人类
struct Person
{
//姓名
string name;
//性别
string sex;
//年龄
int age;
};
int main()
{
//结构体指针
Person* s = new Person;
cout << "s结构体指化针变量初始化值：" << s << endl;
cout << "s结构体指化针变量初始化成员值：姓名：" << s->name << ", 性别：" << s->sex << ", 年龄：" << s->age << endl;
//结构体指针元素赋值
s->name = "Tracy";
s->sex = "female";
s->age = 20;
//成员访问输出
cout << "s结构体指针：姓名：" << s->name << ", 性别：" << s->sex << ", 年龄：" << s->age << endl;
system("pause");
return 0;
}
输出结果
s结构体指化针变量初始化值：000001A95760DAB0
s结构体指化针变量初始化成员值：姓名：, 性别：, 年龄：-842150451
s结构体指针：姓名：Tracy, 性别：female, 年龄：20
Go语言结构体指针
结构体指针与结构体值类型一样，通过操作符 . 访问结构体中的成员。
package main
import (
"fmt"
)
//人类
type Person struct {
//姓名
name string
//性别
sex string
//年龄
age int
}
func main() {
//结构体指针
var s *Person
fmt.Println("s结构体指针变量初始值：", s)
//使用new初始化结构体指针
s = new(Person)
fmt.Println("s结构体指化针变量初始化值：", s)
//初始化后结构体成员为成员类型的零值
fmt.Printf("s结构体指化针变量初始化成员值：姓名：%s, 性别：%s, 年龄：%d\n", s.name, s.sex, s.age)
//成员赋值
s.name = "Tracy"
s.sex = "女"
s.age = 20
//成员访问输出
fmt.Printf("s结构体指针：姓名：%s, 性别：%s, 年龄：%d\n", s.name, s.sex, s.age)
}
输出结果
4、结构体嵌套s结构体指针变量初始值： <nil>
s结构体指化针变量初始化值： &{ 0}
s结构体指化针变量初始化成员值：姓名：, 性别：, 年龄：0
s结构体指针：姓名：Tracy, 性别：女, 年龄：20
C++结构体嵌套
#include<iostream>
#include<string>
using namespace std;
//结构体定义
//人类
struct Person
{
//姓名
string name;
//性别
string sex;
//年龄
int age;
};
//员工
struct Employee
{
//人类结构体
Person person;
//职位
string position;
};
int main()
{
//结构体嵌套
Employee employee;
//成员属性赋值
employee.person.name = "Tracy";
employee.person.sex = "女";
employee.person.age = 20;
employee.position = "软件开发工程师";
//成员访问输出
cout << "员工姓名：" << employee.person.name
<< "性别：" << employee.person.sex
<< "年龄：" << employee.person.age
<< "职位：" << employee.position << endl;
system("pause");
return 0;
}
输出结果
员工姓名：Tracy性别：女年龄：20职位：软件开发工程师
Go语言结构体嵌套
package main
import "fmt"
//人类
type Person struct {
//姓名
name string
//性别
sex string
//年龄
age int
}
//员工
type Employee struct {
//人类结构体
person Person
//职位
position string
}
func main() {
var employee = Employee{
person: Person{
name: "Tracy",
sex: "女",
age: 20,
},
position: "软件开发工程师",
}
//成员访问输出
fmt.Printf("员工姓名：%v， 性别：%v， 年龄：%v， 职位：%v",
employee.person.name, employee.person.sex, employee.person.age, employee.position)
}
输出结果
5、结构体作为参数员工姓名：Tracy， 性别：女， 年龄：20， 职位：软件开发工程师
结构体作为参数可以值传递，也可以地址传递。
C++ 结构体作为参数
#include<iostream>
#include<string>
using namespace std;
//结构体定义
//人类
struct Person
{
//姓名
string name;
//性别
string sex;
//年龄
int age;
};
//结构体作为值参数传递
void printPerson(Person s)
{
cout << "结构体值参数传递：姓名：" << s.name
<< ", 性别：" << s.sex
<< ", 年龄：" << s.age << endl;
s.name = "Tracy";
}
//结构体作为地址参数传递
void printPerson(Person *s)
{
cout << "结构体地址参数传递：姓名：" << s->name
<< ", 性别：" << s->sex
<< ", 年龄：" << s->age << endl;
s->name = "Tracy";
}
int main()
{
//结构体作为参数传递
Person person = { "Felix", "男", 16 };
//值参数传递
printPerson(person);
cout << "结构体值参数传递后成员无变化：姓名：" << person.name
<< ", 性别：" << person.sex
<< ", 年龄：" << person.age << endl;
//地址参数传递
printPerson(&person);
cout << "结构体值参数传递后成员有变化：姓名：" << person.name
<< ", 性别：" << person.sex
<< ", 年龄：" << person.age << endl;
system("pause");
return 0;
}输出结果
结构体值参数传递：姓名：Felix, 性别：男, 年龄：16
结构体值参数传递后成员无变化：姓名：Felix, 性别：男, 年龄：16
结构体地址参数传递：姓名：Felix, 性别：男, 年龄：16
结构体值参数传递后成员有变化：姓名：Tracy, 性别：男, 年龄：16
Go语言结构体作为参数
package main
import "fmt"
//人类
type Person struct {
//姓名
name string
//性别
sex string
//年龄
age int
}
func main() {
//结构体作为参数传递
person := Person{ "Felix", "男", 16 }
//值参数传递
printPerson(person)
fmt.Printf("结构体值参数传递：姓名：%s, 性别：%s, 年龄：%d\n",
person.name, person.sex, person.age)
//地址参数传递
printPerson2(&person)
fmt.Printf("结构体地址参数传递：姓名：%s, 性别：%s, 年龄：%d\n",
person.name, person.sex, person.age)
}
//结构体作为值参数传递
func printPerson(s Person) {
fmt.Printf("结构体值参数传递后成员无变化：姓名：%s, 性别：%s, 年龄：%d\n", s.name, s.sex, s.age)
s.name = "Tracy"
}
//结构体作为地址参数传递
func printPerson2(s *Person) {
fmt.Printf("结构体值参数传递后成员有变化：姓名：%s, 性别：%s, 年龄：%d\n", s.name, s.sex, s.age)
s.name = "Tracy"
}输出结果
6、结构体中const使用结构体值参数传递后成员无变化：姓名：Felix, 性别：男, 年龄：16
结构体值参数传递：姓名：Felix, 性别：男, 年龄：16
结构体值参数传递后成员有变化：姓名：Felix, 性别：男, 年龄：16
结构体地址参数传递：姓名：Tracy, 性别：男, 年龄：16
C++ 结构体中const使用
作为参数，使用const修饰，为防止误操作，修改成员值，如下代码第19行：
void printPerson(constPerson* s)
#include<iostream>
#include<string>
using namespace std;
//结构体定义
//人类
struct Person
{
//姓名
string name;
//性别
string sex;
//年龄
int age;
};
//结构体 const使用
void printPerson(const Person* s)
{
// s->name = "Tracy"; // 加const后，此处不能修改成员的值，为防止误操作
cout << "结构体地址参数传递：姓名：" << s->name
<< ", 性别：" << s->sex
<< ", 年龄：" << s->age << endl;
}
int main()
{
//结构体 const使用
Person person = { "Felix", "男", 16 };
//地址参数传递
printPerson(&person);
system("pause");
return 0;
}