定义:结构体属于用户自定义的类型,允许用户存储不同的数据类型。
语法:struct 结构体名{结构体成员列表};
通过结构体创建变量我们这里采用5种方式,其中,前4种方式本质相同
1、声明结构体 2、创建结构体 3、初始化
1、按顺序(声明--创建--初始化)
#include <iostream>
using namespace std;
//声明结构体
struct Student
{
string name;
int age;
float score;
};
int main()
{
struct Student s1;
s1.name = "tom";
s1.age = 12;
s1.score = 99;
cout << "name:" << s1.name << "age:" << s1.age << "score:" << s1.score << endl;
return 0;
}
2、使用关键字typedef,省略struct关键字
#include <iostream>
using namespace std;
//声明结构体
typedef struct Student {
string name;
int age;
float score;
};
int main() {
//创建的时候struct关键字可以省略
Student s1;
s1.name = "tom";
s1.age = 12;
s1.score = 99;
cout << "name:" << s1.name << "age:" << s1.age << "score:" << s1.score << endl;
return 0;
}
在我使用codeblocks时,是不用添加typedef关键字的,当我添加此关键字时,编译警告.但是我们使用C语言或者其他编译器时,是需要添加的,所以此处,我们需要了解一下(以下程序我们将不考虑此情况).
typedef用途:用来给现有的数据类型定义同义词的。
参考资料:c【转】C++ typedef用法小结_destiny若小羽的博客-CSDN博客
2.创建和初始化同时进行
#include <iostream>
using namespace std;
//声明结构体
struct Student {
string name;
int age;
float score;
};
int main()
{
struct Student s2 ={"jack", 15, 98};
cout << "name:" << s2.name << "age:" << s2.age << "score:" << s2.score << endl;
return 0;
}
3.声明和创建同时进行
#include <iostream>
using namespace std;
struct Student {
string name;
int age;
float score;
}s3;
int main()
{
s3.name = "bob";
s3.age = 19;
s3.score = 97;
cout << "name:" << s3.name << "age:" << s3.age << "score:" << s3.score << endl;
return 0;
}
4.声明,创建,初始化同时进行
#include <iostream>
using namespace std;
struct Student {
string name;
int age;
float score;
}s3={
"bob",
19,
97,
};
int main()
{
cout << "name:" << s3.name << "age:" << s3.age << "score:" << s3.score << endl;
return 0;
}
1-2-3
12-3
1-23
123
感觉挺有意思的,只要保证顺序不变,怎么结合都是无所谓的
5.匿名结构体,在定义时同时声明2个结构体变量,但不能在其它地方声明,因为我们无法得知该结构体的标识符,所以就无法通过标识符来声明变量。
#include<stdio.h>
struct {
int sNo;
char name[10];
}stu,stu1; //匿名结构体,同时定义了2个结构体变量
int main(){
scanf("%d",&stu.sNo);
scanf("%s",stu.name);
printf("%d\n",stu.sNo);
scanf("%d",&stu1.sNo);
scanf("%s",stu1.name);
printf("%d\n",stu1.sNo);
}
总结1:定义结构体时关键字是struct,不可省略
总结2:创建结构体变量时,关键字struct可以省略(注意上面我们叙述过原因)
总结3:结构体变量使用操作符"."访问成员
结构体数组
作用:将自定义的结构体放入到数组中方便维护。
语法:struct 结构体名 数组名[元素个数] = {{},{},...{}}
#include <iostream>
using namespace std;
struct Student {
string name;
int age;
float score;
}s3[]={
{"bob",19,97,},
{"ooa",20,88}
};
int main()
{
int i;
for(i=0;i<2;i++)
{
cout << "name:" << s3[i].name << "age:" << s3[i].age << "score:" << s3[i].score << endl;
}
return 0;
}
#include <iostream>
using namespace std;
struct Student {
string name;
int age;
float score;
};
int main()
{
int i;
Student s3[]={
{"bob",19,97,},
{"ooa",20,88}
};
for(i=0;i<2;i++)
{
cout << "name:" << s3[i].name << "age:" << s3[i].age << "score:" << s3[i].score << endl;
}
return 0;
}
#include <iostream>
using namespace std;
struct Student {
string name;
int age;
float score;
}s3[2];
int main()
{
int i;
s3[0].name="bob";
s3[0].age=19;
s3[0].score=97;
s3[1].name="ooa";
s3[1].age=20;
s3[1].score=88;
for(i=0;i<2;i++)
{
cout << "name:" << s3[i].name << "age:" << s3[i].age << "score:" << s3[i].score << endl;
}
return 0;
}
#include <iostream>
using namespace std;
struct Student {
string name;
int age;
float score;
};
int main()
{
int i;
Student s3[2];
s3[0].name="bob";
s3[0].age=19;
s3[0].score=97;
s3[1].name="ooa";
s3[1].age=20;
s3[1].score=88;
for(i=0;i<2;i++)
{
cout << "name:" << s3[i].name << "age:" << s3[i].age << "score:" << s3[i].score << endl;
}
return 0;
}
结构体指针
作用:通过指针访问结构体中的成员
- 利用操作符
->
可以通过结构体指针访问结构体属
#include <iostream>
using namespace std;
struct Student {
string name;
int age;
float score;
};
int main()
{
struct Student s = { "tom",12,99 };
//定义一个结构体指针
Student* p = &s;
//需要使用->来访问
cout << p->name << p->age << p->score << endl;
return 0;
}
四、结构体嵌套结构体
作用:结构体中的成员可以是另一个结构体
例如:每个老师辅导一个学员,一个老师的结构体中,记录一个学生的结构体
#include<iostream>
//** 例如:** 每个老师辅导一个学员,一个老师的结构体中,记录一个学生的结构体
using namespace std;
//全局变量声明区
//函数声明区
//学生结构体
struct student
{
//成员列表
string name; //姓名
int age; //年龄
int score; //分数
};
//教师结构体定义
struct teacher
{
//成员列表
int id; //职工编号
string name; //教师姓名
int age; //教师年龄
struct student stu; //子结构体 学生
};
int main()
{
struct teacher t1;
t1.id = 10000;
t1.name = "老王";
t1.age = 40;
t1.stu.name = "张三";
t1.stu.age = 18;
t1.stu.score = 100;
cout << "教师 职工编号:" << t1.id << " 姓名: " << t1.name << " 年龄: " << t1.age << endl;
cout << "辅导学员 姓名:" << t1.stu.name << " 年龄:" << t1.stu.age << " 考试分数: " << t1.stu.score << endl;
return 0;
}
总结:在结构体中可以定义另一个结构体作为成员,用来解决实际问题.
结构体做函数参数
作用:将结构体作为参数向函数中传递
传递的方式有三种:
- 值传递
- 地址传递
- 引用传递
#include<iostream>
using namespace std;
//全局变量声明区
//学生结构体定义
struct student
{
string name;
int age;
int score;
};
//函数声明
void printfStudent(student x);
void printfStudent2(student* x);
void printfStudent3(student &x);
int main()
{
student stu = { "张三", 18, 100 };
//值传递
printfStudent(stu);
cout << "主函数中 姓名:" << stu.name << " 年龄: " << stu.age << " 分数:" << stu.score << endl;
//地址传递
printfStudent2(&stu);
cout << "主函数中 姓名:" << stu.name << " 年龄: " << stu.age << " 分数:" << stu.score << endl;
//引用传递
printfStudent3(stu);
cout << "主函数中 姓名:" << stu.name << " 年龄: " << stu.age << " 分数:" << stu.score << endl;
return 0;
}
//值传递
void printfStudent(student x)
{
x.age = 28;
cout << "子函数中 姓名:" << x.name << " 年龄: " << x.age << " 分数:" << x.score << endl;
}
//地址传递
void printfStudent2(student* x)
{
x->age = 28;
cout << "子函数中 姓名:" << x->name << " 年龄: " << x->age << " 分数:" << x->score << endl;
}
void printfStudent3(student &x)
{
x.age=28;
cout << "子函数中 姓名:" << x.name << " 年龄: " << x.age << " 分数:" << x.score << endl;
}
六、结构体中const的使用场景
作用:用const防止误操作
#include <iostream>
using namespace std;
struct Student {
string name;
int age;
float score;
};
//值传递
void printStudent(const Student* stu) {
/*这里就不能进行修改了
stu->name = "jack";
stu->age = 22;
stu->score = 90;
*/
cout << "结构体中的stu信息:" << endl;
cout << stu->name << "," << stu->age << "," << stu->score << endl;
}
int main() {
struct Student stu = { "tom",12,99 };
struct Student* p = &stu;
cout << "未传入函数之前的结构体值:" << endl;
cout << stu.name << "," << stu.age << "," << stu.score << endl;
printStudent(p);
cout << "传入函数之后的结构体值:" << endl;
cout << stu.name << "," << stu.age << "," << stu.score << endl;
return 0;
}
只需要记住,用const修饰的数据类型就不能再进行更改。
枚举
一、定义
为了解决const每次只能声明一个符号常量,C++的enum提供l一种大量创建符号常量的方式。
语法:enum EnunName{type1,type2,type3,type4,......}
enum spectrum{red,orange,yellow,green,blue,violet,indigo,ultraviolet};
让spectrum成为新类型的名称,red等作为符号常量,对应整数值为0~7,这些常量叫做枚举量。
二、用法
可以用枚举名声明这种变量,实际上枚举更常被用来定义相关的符号常量,而不是新类型
spectrum band;
如果只是打算只使用常量,而不创建枚举类型的变量,则可以省略枚举类型名称,如下所示
enum {red,orange,yellow,green,blue,violet,indigo,ultraviolet};
1、在不进行强制类型转换的情况下,只能将定义枚举时使用的枚举值赋给这种枚举的变量
band =blue;//valid,blue is an enumerator
band=2000;//invalid,2000 not an enumerator
2、只定义了赋值运算符
band =orange; //valid
++band; //not valid
band=orange+red; //not valid
3、枚举量是整型,可被提升为int类型,但int类型不能自动转化为枚举类型
int color =blue; //valid
band=3; //invalid
color =3+red; //valid
4、在C++早期版本中,只能将int值(或提升为int的值)赋给枚举量,但这种限制取消了,因此可以使用long甚至long long类型的值。
三、设置枚举量的值
1、可以使用赋值运算符来显示地设置枚举量的值
enum bits{one=1,two=2,four=4,eight=8};
2、可以只显示地定义其中一些枚举量的值
enum bigstep{first,second=100,third};
这里,first在默认情况下为0。后面没有被初始化的枚举量的值将比其前面的枚举量大1,因此,third的值为101.
3、可以创建多个值相同的枚举量
enum {zero,null=0,one,numero_uno=1};
4、枚举的取值范围
每个枚举都有取值范围,通过强制类型转换,可以将取值范围中任何整数值赋给枚举变量,即使这个值不是枚举值。
enum bits{one=1,two=2,four=4,eight=8};
bits myflag;
myflag=bits(6);
其中6不是枚举值,但它位于枚举定义的取值范围内。
具体范围大小查即可。