B3680 [语言月赛202211] BAN-PICK

#include <iostream>
using namespace std;
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
// int main(){
//   int n,m;
//   cin>>n>>m;
//   vector<pair<long long,string>> ss;
//   vector<pair<long long,string >> sh;
//   for (int i = 0; i < n+m; i++){
//     string name;
//     char ch;
//     long long w;
//     cin>>name>>ch>>w;
//     if(ch == 'S'){
//       //ss.emplace_back(w,name);
//       ss.push_back(make_pair(w,name));
//     }else{
//       sh.emplace_back(w,name);
//     }
//   }
//   sort(ss.begin(),ss.end());
//   sort(sh.begin(),sh.end());
//   cout<<sh[sh.size()-3].second<<endl;//输出监管者角色
//   for(int i = ss.size()-6;i>=(int) ss.size()-9;i--){//这里的边界也要多注意
//     cout<<ss[i].second<<endl;
//   }
// }

int main(){
 int n,m;
 cin>>n>>m;
 vector<pair<long long ,string>> ss;
 vector<pair<long long ,string>> sh;
 for(int i = 0;i< m+n;i++){
  string name;
  char s;
  long long  w;
  cin>>name>>s>>w;
  if(s == 'S'){
   // ss.push_back(pair(w,name));//求生者阵营
    ss.emplace_back(w,name);
  }else{
   // sh.push_back(pair(w,name));//监管者阵营
   sh.emplace_back(w,name);
  }
 }
 sort(ss.begin(),ss.end());
 sort(sh.begin(),sh.end());//sort排序是升序
 reverse(ss.begin(),ss.end());
 reverse(sh.begin(),sh.end());
 cout<<sh[2].second<<endl;
 for (int i = 5; i < 9; i++){
   cout<<ss[i].second<<endl;
 }
 
}

B3680 [语言月赛202211] BAN-PICK

在大多数情况下，emplace_back 是一个更高效且更灵活的选择，能代替 push_back，但并不是所有场景下都推荐直接使用 emplace_back。以下是两者的使用原则和区别：

---

1. 什么时候可以用 emplace_back 替代 push_back？

可以替代的场景：

• 当你需要在容器中直接构造对象，而不是先构造临时对象再插入时。
• 对于需要调用构造函数的情况，例如插入 std::pair、std::tuple、自定义类对象等，emplace_back 更加高效。

例子：直接构造对象

#include <vector>
#include <string>
using namespace std;

int main() {
    vector<pair<int, string>> v;

    // 使用 emplace_back
    v.emplace_back(1, "Alice"); // 直接构造 pair<int, string>
    return 0;
}

这里，emplace_back(1, "Alice") 是直接调用了 pair 的构造函数。

如果用 push_back，需要创建一个临时对象：

v.push_back(make_pair(1, "Alice")); // 先创建一个临时 pair<int, string>

这样就多了一次临时对象的构造，效率略低。

---

2. emplace_back 并不总是比 push_back 好

尽管 emplace_back 比 push_back 更高效，但并不意味着它总是优于 push_back。以下场景下需要谨慎选择：

场景 1：已经有对象时

• 如果你已经有一个现成的对象，直接用 push_back 更合适。
• 因为 emplace_back 会重新构造一个对象，而 push_back 只需拷贝或移动对象。

例子：已有对象

pair<int, string> p(1, "Alice");
v.push_back(p); // 更加直观和合适

使用 emplace_back 也可以，但显得多余，因为它会尝试重新构造一个对象：

v.emplace_back(p); // 多此一举，因为已经有 p 了

---

场景 2：构造的参数过于复杂

• 如果你要传递的参数太多且不够直观，使用 emplace_back 会让代码变得难以阅读，而 push_back 更清晰。

例子：参数复杂的对象

vector<pair<int, string>> v;

// 使用 push_back，逻辑更加清晰
v.push_back(make_pair(1, "Alice"));

与之相比，emplace_back 的写法虽然有效，但对于初学者可能不太直观：

v.emplace_back(1, "Alice"); // 需要知道 pair 的构造规则

---

场景 3：原始数据需要显式创建时

• 如果你在插入前需要对数据进行一些操作，显式创建临时对象可能会更方便。

例子：需要额外操作

int id = 1;
string name = "Alice";
pair<int, string> temp = make_pair(id, name); // 创建一个临时对象
v.push_back(temp); // 更容易理解

使用 emplace_back 也可以：

v.emplace_back(id, name); // 跳过了临时对象

但对于复杂逻辑，显式创建对象有助于代码的可读性。

---

3. emplace_back 和 push_back 的对比总结

特性	push_back	emplace_back
核心功能	将已构造的对象插入容器	在容器中直接构造对象
是否拷贝/移动对象	需要拷贝或移动已构造的对象	无需拷贝或移动，直接构造
性能	比 emplace_back 稍慢（多一次拷贝）	更高效（避免临时对象）
使用直观性	对已有对象更直观	对需要构造的对象更简洁和高效
适用场景	已有完整对象或需要显式创建临时对象	插入需要构造的对象，尤其是复杂类型

---

4. 选择 push_back 或 emplace_back 的原则

优先选择 emplace_back 的情况

• 你希望在容器中直接构造对象（如 pair、tuple）。
• 插入的数据需要使用多个构造参数初始化。

优先选择 push_back 的情况

• 你已经有现成的对象。
• 插入的数据是简单的类型（如基本类型或现成的对象）。
• 为了提高代码的直观性，显式创建临时对象更容易理解。

---

例子对比

简单对象的插入

vector<int> v;

// 用 push_back 更合适
int x = 5;
v.push_back(x); // 插入已存在的对象

复杂对象的插入

vector<pair<int, string>> v;

// 用 emplace_back 更高效
v.emplace_back(1, "Alice"); // 直接构造 pair<int, string>

复杂逻辑时的显式操作

int id = 1;
string name = "Alice";
pair<int, string> temp(id, name); // 显式构造
v.push_back(temp); // 插入临时对象，更直观

---

总结

• 简化版结论：

  • 需要直接构造对象：优先使用 emplace_back。
  • 已经有现成对象：优先使用 push_back。

• 在大多数情况下，如果你使用的对象需要通过参数构造，emplace_back 是更高效的选择。但在一些特定场景下（例如你已经有了现成的对象或者为了代码直观性），push_back 依然是更好的选择。

所以，并不是 "凡是能用 push_back 的场景都用 emplace_back"，而是根据场景灵活选择，以效率和代码可读性为目标！

这行代码中的 (int) 是一个显式类型转换，用于将 ss.size() 从 size_t 类型（无符号整数类型）转换为 int 类型。下面是相关代码的分析：

for (int i = ss.size() - 6; i > (int) ss.size() - 9; i--) {
    cout << ss[i].second << endl;
}

---

1. 为什么需要 (int) 类型转换？

ss.size() 返回的是 size_t 类型

• std::vector::size() 函数返回值的类型是 size_t，这是一个无符号整数类型。
• size_t 通常是与平台相关的类型（在 32 位系统中是 unsigned int，在 64 位系统中是 unsigned long long），用来表示容器中元素的个数。

i 是一个 int 类型

• 在代码中，i 被定义为 int：

  for (int i = ss.size() - 6; i > (int) ss.size() - 9; i--) {
  

• 如果直接将 ss.size() 的返回值用于计算（如 ss.size() - 6），编译器可能会触发以下问题：

1. 有符号与无符号的混合运算警告

   • 当你将 size_t 和 int 类型混合使用时，编译器会产生警告，因为有符号类型和无符号类型的计算规则不同。
   • 如果 size_t 是较大的无符号数，而减法结果变成负值，会导致错误行为。

2. 避免负数变成无符号值

   • 如果 ss.size() 的值小于 6，比如 ss.size() = 5，计算 ss.size() - 6 的结果是 -1。
   • 问题：无符号类型不能表示负数，因此 -1 会被解释为一个非常大的无符号整数（例如在 64 位系统中是 2^64 - 1），这会导致程序逻辑错误。

通过 (int) 强制转换解决问题

• (int) 将 ss.size() 的返回值转换为 int 类型，从而可以安全地进行减法运算和比较。
• 即使结果是负数，也能被正确处理，因为 int 是有符号类型。

---

2. 为什么需要显式类型转换？

防止隐式类型转换导致问题

如果没有显式类型转换 (int)：

• 编译器可能会隐式地将 int 类型的 i 转换为 size_t（无符号类型），或者将 size_t 转换为 int。
• 这种隐式转换可能会导致：
  1. 运行时逻辑错误（例如，负数变成大正数）。
  2. 编译器警告（例如，有符号和无符号混合运算警告）。

通过显式类型转换 (int)，程序员明确告知编译器：我知道这里需要将 size_t 转换为 int，并且我确信这样是安全的。

---

3. 什么情况下 (int) 必须加？

需要进行有符号运算

当减法运算可能导致负值时，例如：

int x = ss.size() - 6; // 如果 ss.size() < 6，会导致 x 变成负值

需要和有符号变量比较

当 size_t 和 int 类型混用时，例如：

if (ss.size() - 6 > -9) { // 警告：无符号与有符号比较
}

显式转换可以避免警告：

if ((int)ss.size() - 6 > -9) {
}

防止编译器警告

• 很多编译器（如 g++ 和 clang）在有符号和无符号类型混用时会触发警告。显式类型转换是解决这些警告的最佳方式。

---

4. 示例代码演示 (int) 的作用

不加 (int) 的问题

假设我们有以下代码：

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {1, 2, 3, 4, 5}; // 大小为 5

    for (int i = v.size() - 6; i < 0; i++) {
        cout << v[i] << endl;
    }

    return 0;
}

结果

• 编译器可能会警告：comparison between signed and unsigned integer expressions。
• 如果 v.size() = 5，则 v.size() - 6 结果为 -1：
  • 如果 v.size() 是 size_t，则 -1 会被转换为一个非常大的无符号整数（例如 18446744073709551615 在 64 位系统上）。
  • 因此，循环条件永远不会成立，导致逻辑错误。

加上 (int)

改成以下代码：

for (int i = (int)v.size() - 6; i < 0; i++) {
    cout << v[i] << endl;
}

结果

• (int) 将 size_t 类型的返回值显式转换为 int，允许负数结果。
• 循环逻辑能够正确处理负值，不会导致逻辑错误或编译器警告。

---

5. (int) 的适用场景总结

你需要显式类型转换 (int) 的场景包括：

1. std::vector::size() 返回值参与减法计算，结果可能是负数。
2. 有符号类型（如 int）和无符号类型（如 size_t）之间进行比较或运算时。
3. 你需要避免编译器的有符号/无符号混合运算警告。

---

6. 补充知识：size_t 和 int 的区别

特性	size_t	int
定义	无符号整数类型	有符号整数类型
常见使用场景	存储数组或容器的大小	表示任意的整数
是否允许负值	不允许	允许
可能的问题	负值被转为大正数	如果超过范围会溢出
系统相关性	平台相关（32 位或 64 位系统）	通常为 32 位，跨平台一致

---

总结

在你的代码中：

for (int i = ss.size() - 6; i > (int)ss.size() - 9; i--) {
    cout << ss[i].second << endl;
}

• (int) 的作用是将 ss.size() 从 size_t 类型转换为 int 类型，确保减法结果可以是负数，并避免有符号和无符号类型混合运算的潜在问题。
• 如果不加 (int)，可能会导致逻辑错误（尤其当 ss.size() < 6 时）或编译器警告。

这是一种良好的编程实践，可以显式表达程序员的意图，确保程序行为符合预期。