纯数据结构体

简单介绍

基础概念

作用：将多个类型聚合成一个整体成为一个新类型

1
2
3
4
5
6
7
8
9
10
11
12
13
struct Student{
    int score;
    string name;//成员变量
};
Student stu, stus[100];
Student* pstu = new Student;
//可以像普通类型一样声明定义的变量,单个变量或者数组都可以
struct Student{
    int score;
    string name;//成员变量
} stu, stus[10];//定义也可以直接在结构后面跟上变量名(匿名结构体)
//由于没有起名不可以正常的定义其他变量，但可以通过C++11增加的decltype关键字获取
//例如 decltype(Stu) stu2;

访问成员变量只需要用stu.score stu.name

使用举例eg

1
2
3
4
5
6
7
8
9
10
11
12
struct Student{
    int score;
    string name;
};
int n = 8;
Student* stus = new Student[8];
for(int i = 0;i < 8; ++ i){
    cin >> stus[i].score >> stus[i].name;
}
sort(stus, stus + n, [](Student &a, Student &b){
    return a.score < b.score;
});

结构体特性

1
2
3
4
struct A {}; //可以定义在全局
int main(){
	struct B {}; //可以定义在函数内(某个作用域内)
}

结构体的初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
struct Student {
    int score;
    string name;
};
Student a = {99, "小明"};
Student a = {99};
Student a{99};
auto a = Student{99};
Student a{.name = "小明"}
//可以直接进行赋值
student b = a;
student c;
c = a;

结构体的大小

会进行内存对齐而不是单纯相加

  • 以最大的类型作为宽度构建一个矩阵
  • 按定义顺序依次摆放
  • 每个数据只能拜访在其大小的倍数的位置
  • 一行摆不下就新起一行
  • 行×列就是实际大小

可能会有一定的空间浪费,但会加速计算机的访问;如果相避免可以按内存大小定义

符合结构以成员最大宽度,数组以类型为宽度

结构化绑定(C++17新增)

可以将结构体内的成员变量绑定到新的变量上

1
2
3
4
5
6
7
8
9
10
11
12
13
auto [score, name] = stu;
//必须绑定所有成员变量,不可以只绑定一部分,也可以使用&,避免产生数据拷贝
//新的变量名和成员变量不需要同名,只需要顺序对应上就行
auto& [s, n] = stu;
for(auto &[score, name] : arr){
    cin >> score >> name;
}
//如果只想使用某个变量则可以将不需要的变量这样写
auto& [s, n] = stu;
for(auto &[score, _] : arr){
    cin >> score;
}

C++新增简便方式

pair

pair : 可以把两个数据类型进行聚合

pair<int, string> a;由于没有命名,可以使用a.first a.second来访问

也支持pair<int,string> a{99, "小明"};和结构化绑定 auto &[f, s] = a;

如果用auto定义需要使用make_pair函数来设置初始值 —>auto b = make_pair(80, "jack");

只需要两个类型都支持大小比较pair也支持大小比较 a <=> b;(先比较第一个,如果相同再比较第二个)

1
2
3
4
5
6
int n = 8;
vector<pair<int, string>> stus(n);
for (auto& [s, f] : stus) {
    cin >> s >> f;
}
sort(stus.begin(), stus.end());

tuple

如果超过两个元素可以使用C++11提供的tuple

1
2
3
4
5
tuple<int, int, string> a{99, 7, "jack"};
auto&[score, id, name] = a;
auto b = make_tuple(80, 8, "mike");
a <=> b;
//访问成员变量时很麻烦,需写作 get<0>(a);之类的,因此通常先结构化绑定再操作

tie函数

绑定成员变量到已经定义的变量上,可以根据实际使用场景决定写法

1
2
3
4
5
6
int score, id;
string name;
pair<int, string> pis{99, "jack"};
tuple<int, int, string> tiis{80, 8 "mike"};
tie(score, name) = pis;
tie(score, id, name) = tiis;

vector补充

1
2
3
4
vector<pair<int, string>> vec;
vec.push_back(make_pair(99, 'jack'));
vec.push_back({95, "aly"});
vec.emplace_back(80, "mike");

对于符合类型最好用emplace_back函数

这个函数用于在容器的末尾就地构造一个新元素，而不是先复制或移动一个已存在的对象。emplace_back 通常用于性能优化，因为它避免了额外的复制或移动操作