• C++ 学习（八）结构体、结构体数组、结构体指针、结构体嵌套、结构体作为参数、结构体中const使用

    1、结构体

    结构体是用户自定义的数据类型，允许用户存储不同的数据类型；在结构体中可以为不同项定义不同的数据类型。

    C++ 结构体

    语法：

    struct 结构体名 { 结构体成员列表 };

    三种定义结构体变量方式：

    1.  [struct]  结构体名  变量名 （可省略struct）
    2.  [struct]  结构体名  变量名 = { 成员1值， 成员2值 ...... }  （可省略struct）
    3.  定义结构体时创建变量
    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. //结构体定义
    6. //人类
    7. struct Person
    8. {
    9. 	//姓名
    10. 	string name;
    11. 	//性别
    12. 	string sex;
    13. 	//年龄
    14. 	int age;
    15. } s3; //第三种创建结构体变量：结构体变量在定义时创建
    16.  
    17. //结构体成员输出
    18. void print(Person s)
    19. {
    20. 	cout << "s1结构体：姓名：" << s.name << ", 性别：" << s.sex << ", 年龄：" << s.age << endl;
    21. }
    22.  
    23. int main()
    24. {
    25. 	//第一种创建结构体变量：[struct]  结构体名  变量名; （可省略struct）
    26. 	struct Person s1;
    27.  
    28. 	//成员赋值
    29. 	s1.name = "Tracy";
    30. 	s1.sex = "女";
    31. 	s1.age = 20;
    32.  
    33. 	//成员输出
    34. 	print(s1);
    35.  
    36. 	//第二种创建结构体变量： [struct]  结构体名  变量名 = { 成员1值， 成员2值 ...... }  （可省略struct）
    37. 	Person s2 = { "Felix", "男", 16 };
    38.  
    39. 	//成员输出
    40. 	print(s2);
    41.  
    42.  
    43. 	//第三种创建结构体变量：见结构体定义处
    44. 	//成员赋值
    45. 	s3.name = "Timo";
    46. 	s3.sex = "女";
    47. 	s3.age = 60;
    48.  
    49. 	//成员输出
    50. 	print(s3);
    51.  
    52. 	system("pause");
    53.  
    54. 	return 0;
    55. }

     输出结果

    s1结构体：姓名：Tracy, 性别：女, 年龄：20
    s2结构体：姓名：Felix, 性别：男, 年龄：16
    s3结构体：姓名：Timo, 性别：女, 年龄：60

    Go语言结构体

    语法：

    type 结构体名 struct { 结构体成员列表 } 

    三种定义结构体变量方式：

    1. var 变量名 结构体名
    2. 变量名 := 结构体名{ 成员1值， 成员2值 ...}
    3. 变量名 := 结构体名{ 成员名1:值1，成员名2:值2，... }
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. //人类
    6. type Person struct {
    7. 	//姓名
    8. 	name string
    9. 	//性别
    10. 	sex string
    11. 	//年龄
    12. 	age int
    13. }
    14.  
    15. func main() {
    16. 	//第一种创建结构体变量：var 变量名 结构体名
    17. 	var s1 Person
    18.  
    19. 	//成员赋值
    20. 	s1.name = "Tracy"
    21. 	s1.sex = "女"
    22. 	s1.age = 20
    23.  
    24. 	//成员输出
    25. 	print(s1)
    26.  
    27. 	//第二种创建结构体变量：变量名 := 结构体名{ 成员1值， 成员2值 ...}
    28. 	s2 := Person{ "Felix", "男", 16 }
    29.  
    30. 	//成员输出
    31. 	print(s2)
    32.  
    33. 	//第三种创建结构体变量：变量名 := 结构体名{ 成员名1:值1，成员名2:值2，... }
    34. 	s3 := Person{
    35. 		name: "Timo",
    36. 		age: 60,
    37. 		sex: "女",
    38. 	}
    39.  
    40. 	//成员输出
    41. 	print(s3)
    42. }
    43.  
    44. //结构体成员输出
    45. func print(s Person) {
    46. 	fmt.Printf("s1结构体：姓名：%s, 性别：%s, 年龄：%d\n", s.name, s.sex, s.age)
    47. }

     输出结果

    s1结构体：姓名：Tracy, 性别：女, 年龄：20
    s1结构体：姓名：Felix, 性别：男, 年龄：16
    s1结构体：姓名：Timo, 性别：女, 年龄：60

    2、结构体数组

    C++结构体数组

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. //结构体定义
    6. //人类
    7. struct Person
    8. {
    9. 	//姓名
    10. 	string name;
    11. 	//性别
    12. 	string sex;
    13. 	//年龄
    14. 	int age;
    15. };
    16.  
    17. int main()
    18. {
    19. 	//结构体数组变量定义并初始化
    20. 	struct Person s[3] = {
    21. 		{ "Felix", "男", 16 },
    22. 		{ "Tracy", "女", 20 },
    23. 		{ "Timo", "男", 60 }
    24. 	};
    25.  
    26. 	//结构体数组元素赋值
    27. 	s[0].age = 17;
    28.  
    29. 	//成员输出
    30. 	for (int i = 0;i < 3;i++) {
    31. 		cout << "s结构体数组：姓名：" << s[i].name << ", 性别：" << s[i].sex << ", 年龄：" << s[i].age << endl;
    32. 	}
    33.  
    34. 	system("pause");
    35.  
    36. 	return 0;
    37. }

    输出结果

    s结构体数组：姓名：Felix, 性别：男, 年龄：17
    s结构体数组：姓名：Tracy, 性别：女, 年龄：20
    s结构体数组：姓名：Timo, 性别：男, 年龄：60

    Go语言结构体数组

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. //人类
    6. type Person struct {
    7. 	//姓名
    8. 	name string
    9. 	//性别
    10. 	sex string
    11. 	//年龄
    12. 	age int
    13. }
    14.  
    15. func main() {
    16. 	//结构体数组变量定义并初始化
    17. 	var s [3]Person = [3]Person{
    18. 		{ "Felix", "男", 16 },
    19. 		{ "Tracy", "女", 20 },
    20. 		{ "Timo", "男", 60 },
    21. 	}
    22.  
    23. 	//结构体数组元素赋值
    24. 	s[0].age = 17
    25.  
    26. 	//成员输出
    27. 	for i := 0; i < 3; i++ {
    28. 		fmt.Printf("s结构体数组：姓名：%s, 性别：%s, 年龄：%d\n", s[i].name, s[i].sex, s[i].age)
    29. 	}
    30. }

    输出结果 

    s结构体数组：姓名：Felix, 性别：男, 年龄：17
    s结构体数组：姓名：Tracy, 性别：女, 年龄：20
    s结构体数组：姓名：Timo, 性别：男, 年龄：60

    3、 结构体指针

    C++结构体指针

    通过操作符 -> 访问结构体中的成员。

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. //结构体定义
    6. //人类
    7. struct Person
    8. {
    9. 	//姓名
    10. 	string name;
    11. 	//性别
    12. 	string sex;
    13. 	//年龄
    14. 	int age;
    15. };
    16.  
    17. int main()
    18. {
    19. 	//结构体指针
    20. 	Person* s  = new Person;
    21. 	cout << "s结构体指化针变量初始化值：" << s << endl;
    22. 	cout << "s结构体指化针变量初始化成员值：姓名：" << s->name << ", 性别：" << s->sex << ", 年龄：" << s->age << endl;
    23.  
    24. 	//结构体指针元素赋值
    25. 	s->name = "Tracy";
    26. 	s->sex = "female";
    27. 	s->age = 20;
    28.  
    29. 	//成员访问输出
    30. 	cout << "s结构体指针：姓名：" << s->name << ", 性别：" << s->sex << ", 年龄：" << s->age << endl;
    31.  
    32. 	system("pause");
    33.  
    34. 	return 0;
    35. }

    输出结果

    s结构体指化针变量初始化值：000001A95760DAB0
    s结构体指化针变量初始化成员值：姓名：, 性别：, 年龄：-842150451
    s结构体指针：姓名：Tracy, 性别：female, 年龄：20

    Go语言结构体指针

    第8讲-结构体与结构体数组
    ppt 0星 超过10%的资源 373KB
    下载

    结构体指针与结构体值类型一样，通过操作符 . 访问结构体中的成员。

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. //人类
    8. type Person struct {
    9. 	//姓名
    10. 	name string
    11. 	//性别
    12. 	sex string
    13. 	//年龄
    14. 	age int
    15. }
    16.  
    17. func main() {
    18. 	//结构体指针
    19. 	var s *Person
    20. 	fmt.Println("s结构体指针变量初始值：", s)
    21.  
    22. 	//使用new初始化结构体指针
    23. 	s = new(Person)
    24. 	fmt.Println("s结构体指化针变量初始化值：", s)
    25. 	//初始化后结构体成员为成员类型的零值
    26. 	fmt.Printf("s结构体指化针变量初始化成员值：姓名：%s, 性别：%s, 年龄：%d\n", s.name, s.sex, s.age)
    27.  
    28. 	//成员赋值
    29. 	s.name = "Tracy"
    30. 	s.sex = "女"
    31. 	s.age = 20
    32.  
    33. 	//成员访问输出
    34. 	fmt.Printf("s结构体指针：姓名：%s, 性别：%s, 年龄：%d\n", s.name, s.sex, s.age)
    35. }

     输出结果

    s结构体指针变量初始值：
    s结构体指化针变量初始化值： &{  0}
    s结构体指化针变量初始化成员值：姓名：, 性别：, 年龄：0
    s结构体指针：姓名：Tracy, 性别：女, 年龄：20

    4、结构体嵌套 

    C++结构体嵌套

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. //结构体定义
    6.  
    7. //人类
    8. struct Person
    9. {
    10. 	//姓名
    11. 	string name;
    12. 	//性别
    13. 	string sex;
    14. 	//年龄
    15. 	int age;
    16. };
    17.  
    18. //员工
    19. struct Employee
    20. {
    21. 	//人类结构体
    22. 	Person person;
    23. 	//职位
    24. 	string position;
    25. };
    26.  
    27. int main()
    28. {
    29. 	//结构体嵌套
    30. 	Employee employee;
    31.  
    32. 	//成员属性赋值
    33. 	employee.person.name = "Tracy";
    34. 	employee.person.sex = "女";
    35. 	employee.person.age = 20;
    36. 	employee.position = "软件开发工程师";
    37.  
    38. 	//成员访问输出
    39. 	cout << "员工姓名：" << employee.person.name
    40. 		<< "性别：" << employee.person.sex
    41. 		<< "年龄：" << employee.person.age
    42. 		<< "职位：" << employee.position << endl;
    43.  
    44. 	system("pause");
    45.  
    46. 	return 0;
    47. }

    输出结果

    员工姓名：Tracy性别：女年龄：20职位：软件开发工程师

    Go语言结构体嵌套

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. //人类
    6. type Person struct {
    7. 	//姓名
    8. 	name string
    9. 	//性别
    10. 	sex string
    11. 	//年龄
    12. 	age int
    13. }
    14.  
    15. //员工
    16. type Employee struct {
    17. 	//人类结构体
    18. 	person Person
    19. 	//职位
    20. 	position string
    21. }
    22.  
    23. func main() {
    24. 	var employee = Employee{
    25. 		person: Person{
    26. 			name: "Tracy",
    27. 			sex: "女",
    28. 			age: 20,
    29. 		},
    30. 		position: "软件开发工程师",
    31. 	}
    32.  
    33. 	//成员访问输出
    34. 	fmt.Printf("员工姓名：%v， 性别：%v， 年龄：%v， 职位：%v",
    35. 		employee.person.name, employee.person.sex, employee.person.age, employee.position)
    36. }

    输出结果

     员工姓名：Tracy， 性别：女， 年龄：20， 职位：软件开发工程师

    5、结构体作为参数

    文件中出现最多的前五个字母
    rar 0星 超过10%的资源 13KB
    下载

    结构体作为参数可以值传递，也可以地址传递。

    C++ 结构体作为参数

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. //结构体定义
    6. //人类
    7. struct Person
    8. {
    9. 	//姓名
    10. 	string name;
    11. 	//性别
    12. 	string sex;
    13. 	//年龄
    14. 	int age;
    15. };
    16.  
    17. //结构体作为值参数传递
    18. void printPerson(Person s)
    19. {
    20. 	cout << "结构体值参数传递：姓名：" << s.name 
    21. 		<< ", 性别：" << s.sex 
    22. 		<< ", 年龄：" << s.age << endl;
    23. 	s.name = "Tracy";
    24. }
    25.  
    26. //结构体作为地址参数传递
    27. void printPerson(Person *s)
    28. {
    29. 	cout << "结构体地址参数传递：姓名：" << s->name 
    30. 		<< ", 性别：" << s->sex 
    31. 		<< ", 年龄：" << s->age << endl;
    32. 	s->name = "Tracy";
    33. }
    34.  
    35. int main()
    36. {
    37. 	//结构体作为参数传递
    38. 	Person person = { "Felix", "男", 16 };
    39.  
    40. 	//值参数传递
    41. 	printPerson(person);
    42. 	cout << "结构体值参数传递后成员无变化：姓名：" << person.name 
    43. 		<< ", 性别：" << person.sex 
    44. 		<< ", 年龄：" << person.age << endl;
    45.  
    46. 	//地址参数传递
    47. 	printPerson(&person);
    48. 	cout << "结构体值参数传递后成员有变化：姓名：" << person.name
    49. 		<< ", 性别：" << person.sex
    50. 		<< ", 年龄：" << person.age << endl;
    51.  
    52. 	system("pause");
    53.  
    54. 	return 0;
    55. }

    输出结果

    结构体值参数传递：姓名：Felix, 性别：男, 年龄：16
    结构体值参数传递后成员无变化：姓名：Felix, 性别：男, 年龄：16
    结构体地址参数传递：姓名：Felix, 性别：男, 年龄：16
    结构体值参数传递后成员有变化：姓名：Tracy, 性别：男, 年龄：16

    Go语言结构体作为参数

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. //人类
    6. type Person struct {
    7. 	//姓名
    8. 	name string
    9. 	//性别
    10. 	sex string
    11. 	//年龄
    12. 	age int
    13. }
    14.  
    15. func main() {
    16. 	//结构体作为参数传递
    17. 	person := Person{ "Felix", "男", 16 }
    18.  
    19. 	//值参数传递
    20. 	printPerson(person)
    21. 	fmt.Printf("结构体值参数传递：姓名：%s, 性别：%s, 年龄：%d\n",
    22. 		person.name, person.sex, person.age)
    23.  
    24. 	//地址参数传递
    25. 	printPerson2(&person)
    26. 	fmt.Printf("结构体地址参数传递：姓名：%s, 性别：%s, 年龄：%d\n",
    27. 		person.name, person.sex, person.age)
    28.  
    29. }
    30.  
    31. //结构体作为值参数传递
    32. func printPerson(s Person) {
    33. 	fmt.Printf("结构体值参数传递后成员无变化：姓名：%s, 性别：%s, 年龄：%d\n", s.name, s.sex, s.age)
    34. 	s.name = "Tracy"
    35. }
    36.  
    37. //结构体作为地址参数传递
    38. func printPerson2(s *Person) {
    39. 	fmt.Printf("结构体值参数传递后成员有变化：姓名：%s, 性别：%s, 年龄：%d\n", s.name, s.sex, s.age)
    40. 	s.name = "Tracy"
    41. }

    输出结果

    结构体值参数传递后成员无变化：姓名：Felix, 性别：男, 年龄：16
    结构体值参数传递：姓名：Felix, 性别：男, 年龄：16
    结构体值参数传递后成员有变化：姓名：Felix, 性别：男, 年龄：16
    结构体地址参数传递：姓名：Tracy, 性别：男, 年龄：16

    6、结构体中const使用

    C++ 结构体中const使用

    作为参数，使用const修饰，为防止误操作，修改成员值，如下代码第19行：

    void printPerson(const Person* s)

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. //结构体定义
    6. //人类
    7. struct Person
    8. {
    9. 	//姓名
    10. 	string name;
    11. 	//性别
    12. 	string sex;
    13. 	//年龄
    14. 	int age;
    15. };
    16.  
    17. //结构体 const使用
    18. void printPerson(const Person* s)
    19. {
    20. 	// s->name = "Tracy"; // 加const后，此处不能修改成员的值，为防止误操作
    21. 	cout << "结构体地址参数传递：姓名：" << s->name
    22. 		<< ", 性别：" << s->sex
    23. 		<< ", 年龄：" << s->age << endl;
    24. }
    25.  
    26. int main()
    27. {
    28. 	//结构体 const使用
    29. 	Person person = { "Felix", "男", 16 };
    30.  
    31. 	//地址参数传递
    32. 	printPerson(&person);
    33.  
    34. 	system("pause");
    35.  
    36. 	return 0;
    37. }

    Go语言 结构体中没有const使用方法

  • 相关阅读:
    Matlab论文插图绘制模板第42期—气泡矩阵图（相关系数矩阵图）
    matlab 基操~
    【 Java架构师-技术专家 】慕课2、springboot基础回顾
    Go语言之return语句深入理解及defer、return的执行顺序
    数据结构--二叉树
    【C++】哈希思想的应用——位图、布隆过滤器和哈希切割
    Unity3D 在做性能优化时怎么准确判断是内存、CPU、GPU瓶颈详解
    【qt】Qt Creator 设计界面与结果不一致问题
    修复 Android 手机陷入恢复模式的 5 种方法
    SpringCloud
  • 原文地址：https://blog.csdn.net/ling1998/article/details/125904146