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

最新推荐文章于 2024-06-05 11:24:56 发布
最新推荐文章于 2024-06-05 11:24:56 发布
阅读量2.1k 收藏 8
点赞数 1
分类专栏： C++ Golang 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ling1998/article/details/125904146
版权
Golang 同时被 2 个专栏收录
25 篇文章 1 订阅
订阅专栏
C++
21 篇文章 10 订阅
订阅专栏

1、结构体

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

C++ 结构体

语法：

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

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

  1.  [struct]  结构体名  变量名 （可省略struct）
  2.  [struct]  结构体名  变量名 = { 成员1值， 成员2值 ...... }  （可省略struct）
  3.  定义结构体时创建变量
#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 { 结构体成员列表 } 

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

  1. var 变量名 结构体名
  2. 变量名 := 结构体名{ 成员1值， 成员2值 ...}
  3. 变量名 := 结构体名{ 成员名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)
}

 输出结果

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

2、结构体数组

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)
	}
}

输出结果 

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

3、 结构体指针

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)
}

 输出结果

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

4、结构体嵌套 

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)
}

输出结果

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

5、结构体作为参数

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

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"
}

输出结果

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

6、结构体中const使用

C++ 结构体中const使用

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

void printPerson(const Person* 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;
}

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

瘦身小蚂蚁
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++结构体，基本概念，定义和使用，结构体嵌套结构体，结构体做函数参数，结构体const使用场景
weixin_46148876的博客
06-16 230
8结构体 8.1结构体基本概念 结构体属于用户自定义的数据类型，允许用户存储不同的数据类型 8.2结构体定义和使用 语法：struct 结构体名 { 结构体成员列表 }; 通过结构体创建变量的方式有三种： struct结构体名 变量名 struct结构体名 变量名 = { 成员1值，成员2值… } 定义结构体时顺便创建变量 示例： #include <iostream> #include <string> using namespace std; //1、创建学生数据类型 :
C++学习笔记26——结构体嵌套结构体，结构体做函数参数，结构体中const使用场景
weixin_49522114的博客
10-25 453
结构体嵌套结构体 作用：结构体中的成员可以是另一个结构体 例如：每个老师辅导一个学员，一个老师的结构体中记录一个学生的结构体 示例： #include <iostream> #include <string> using namespace std; //结构体嵌套结构体 //定义一个学生结构体：包括姓名 年龄 分数 struct student { //成员列表 string name; int age = 0; int score = 0; }; //定义
结构体嵌套，数组，指针
weixin_40805072的博客
06-09 4565
目录 一、结构体嵌套 二、结构体数组 三、结构体指针 四、传递结构体变量 五、传递结构体指针 六、动态申请结构体 一、结构体嵌套 下面再Book结构体中嵌套调用结构体Date #include<stdio.h> struct Date{ int year; int month; int day; }; struct Book{ char title[1...
【C++】结构体应用案例 1 - 结构体数组嵌套结构体数组
深入挖掘，筑基为先；知其然，知其所以然。
04-16 1399
结构体数组嵌套结构体数组的暴力美学 ！
【C语言】结构体类型的数组和指针（干货满满，建议收藏！！！）
最新发布
2301_81193162的博客
06-05 2731
这篇文章将讲述结构体类型的数组的定义、初始化、应用和结构体指针的使用。还会扩展scanf_s函数相关知识。
结构体内嵌套结构体数组
qq_38072307的博客
01-21 8481
#结构体嵌套结构体数组 定义了三个简单的结构体，分别为 a b c。结构体中嵌套一个结构体b,结构体b中嵌套结构体a的数组。 定义新的结构体指针时，需要分配空间。 //A code block void main() { c c1=(c)malloc(sizeof©); c1-&amp;amp;gt;m=0; c1-&amp;amp;gt;n=1; cout&amp;amp;lt;m&amp;amp;lt;n; c1-&amp;amp;gt;b1.z=2; cout&
结构体、结构体数组和结构体嵌套结构体的使用
qq_43630810的博客
09-28 3734
文章目录一、结构体的定义和使用1. 使用typedef的情况2.不使用typedef的情况二、结构体数组三、结构体嵌套结构体 一、结构体的定义和使用 结构体是存储不同类型的数据项 结构体是一种构造数据类型 结构体中的成员空间是独立的 为了访问结构的成员，我们使用成员访问运算符（.）。 结构体的定义形式： 1. 使用typedef的情况 格式一：此方法最为标准实用 typedef struct student { char name[10]; //姓名 int num
c++ new一个结构体_「C/C++」构造类型及应用：数组、结构体、共用体、枚举类型...
weixin_39776298的博客
11-28 550
3.1数组同类型、同性质、按顺序存放的一组数据集合，易于批量处理。3.1.1一维数组定义int 1.数组名为常量，指向首地址，由系统指定。2.数组长度为整型常量,但不能为03.上例取值image[0]-image[255]，取值可以修改。初始化int 输入for输出for3.1.2二维数组定义int 1.相比一维数组，二维数组按行存储，一行存完再存第二行，两个数字代表[行][列]。初始化int 输...
结构体中数组成员赋值
08-20
结构体中数组成员赋值 在 C 语言中，结构体是一种复杂的数据类型，它可以包含多种类型的成员变量，包括数组类型。数组成员是结构体中的一种常见成员类型，但是在给结构体中数组成员赋值时，需要注意一些重要的细节...
2.C++中的结构体-C管理进程代码-C++管理进程代码-C语言中的联合体.docx
11-23
C++中的结构体和管理进程代码详解 结构体是C++中的一种自定义数据类型，可以包含多个变量和函数成员。结构体的成员可以是变量、函数或其他结构体。结构体的定义使用struct关键字，后面跟着结构体的名称和成员列表。...
C++结构体参数与结构体指针参数区别Demo
04-30
- 在编写函数时，可以考虑使用`const`关键字来限制指针参数的修改权限，如`void processStructPtr(const MyStruct* s)`，这可以防止无意的修改并帮助编译器进行优化。 - C++11引入了右值引用，可以用来优化大对象...
C++结构体用法实例分析
09-03
总结来说，C++中的结构体提供了丰富的功能，包括默认构造函数、复制构造函数和运算符重载。默认构造函数用于初始化对象，复制构造函数用于创建对象的副本，而运算符重载则允许我们自定义操作符的行为，使代码更符合...
C++结构体里面string类型赋值问题
01-20
const string p=aaa; temp *q; q=(struct temp*)malloc(sizeof(struct temp)); q->s=p; } 　上述那种情况的赋值会导致程序中断 　需要用用new来分配内存，malloc不会调用结构函数 　结构体内的string不定长...
c++/c 数据结构 new
ChristinaXinny的博客
03-12 557
#include <stdio.h> #include <stdlib.h> #define MAXN 80 struct student { int id; char name[MAXN]; }; // 使用动态分配函数，创建一个长度为n的学生结构体数组 // 根据用户的输入为这n个学生赋值，并返回第一个元素地址 struct student *create(int n); // 根据id输出学生信息 void output(struct student *st
ctf中pwn题目总结
weixin_41038905的博客
11-16 4706
1.安装 pip install pwntools （python2） pip3 install pwntools （python3） 2.使用 Context设置 context是pwntools用来设置环境的功能。在很多时候，由于二进制文件的情况不同，我们可能需要进行一些环境设置才能够正常运行exp，比如有一些需要进行汇编，但是32的汇编和64的汇编不同，如果不设置context会导致一些问题。一般来说我们设置context只需要简单的一句话: context(os='linux', arch='amd
使用new来动态分配结构体数组
热门推荐
zhaowenke123的博客
07-19 1万+
在做程序练习时，由一组数据组成的成员，刚开始时，没想到用结构体的方法，傻乎乎的创建了多个vector类。每个vector类bian变量中存放一类数据。程序如下 vector&lt;int&gt; v1;     vector&lt;int&gt; v2;     while(cin&gt;&gt;n1&gt;&gt;n2)     {         v1.push_back(n1);     ...
结构体嵌套、结构体数组、结构体指针
靡不有初，鲜克有终。
02-29 1817
结构体嵌套： 将一个已经声明的结构体在另一个结构体内作为成员变量进行定义，并在外层结构体初始化的同时最自己进行行初始化，使用花括号包裹自身成员变量。 打印时注意为：结构体名称.结构体成员结构体.结构体成员结构体的成员 #include <stdio.h> struct Date { int year; int month; int day; }; struct Boo...
c++基础之new和delete（动态数组、动态结构体）
liuyingshudian的博客
01-17 3147
1. new和delete 1.1 基本概念 1.2 new和delete使用规则 1.3代码实例 #include <iostream> using namespace std; //new和delete运算符 int main() { //使用new 分配一个int类型的空间 int* p = new int; *p = 100; cout << *p << endl; //使用完了以后对内存进行释放 .
【C++】结构体嵌套结构体
深入挖掘，筑基为先；知其然，知其所以然。
04-11 3456
结构体嵌套结构体是一种数据组织方式，就像俄罗斯套娃一样，一个数据结构可以包含另一个数据结构。这种嵌套结构使得程序可以更加灵活地处理数据，从而更好地满足复杂的需求。类比生活中的套娃玩具，每一层套娃都有自己的特点和功能，而它们的组合则产生了更多的可能性和乐趣。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值