程序运行测时 与 GDB 调试

# ✅ 推荐：输入输出都重定向
time ./a < big.in > out.txt

# 输出示例：
# real    0m0.842s
# user    0m0.810s
# sys     0m0.028s

# ❌ 不推荐：输出直接刷到终端
# 若程序输出 100000 个数字，仅"打印到屏幕"就可能花掉几秒
./a < big.in

# 只关心时间、不关心输出内容时可以直接丢弃
time ./a < big.in > /dev/null

#include <bits/stdc++.h>
using namespace std;

int main() {
    // 需要计时的代码放在两行 clock() 之间
    clock_t begin = clock();

    volatile long long s = 0;
    for (int i = 0; i < 100000000; i++) s += i;   // 约 1e8 次加法

    clock_t end = clock();
    double sec = (double)(end - begin) / CLOCKS_PER_SEC;   // 换算成秒
    cout << "耗时：" << fixed << setprecision(3) << sec << " s" << endl;
    cout << "s = " << s << endl;
    return 0;
}

# 生成 n = 2000 的随机数据（用于测 n^3 的解法）
python3 -c "import random; n=2000; print(n); print(' '.join(str(random.randint(1,10**9)) for _ in range(n)))" > big.in

# 用最大数据实测（这一步必做）
g++ a.cpp -O2 -Wall -o a
time ./a < big.in > /dev/null
# real    0m9.517s        ← 远超 1s，必须换算法

# 对照：用 n = 100 的小数据测，几乎瞬间完成（但毫无参考价值）
python3 -c "import random; n=100; print(n); print(' '.join(str(random.randint(1,10**9)) for _ in range(n)))" > small.in
time ./a < small.in > /dev/null
# real    0m0.001s        ← 完全测不出问题

# 编译：加 -g 生成调试信息，用 -O0 保证行为与源码一致
g++ a.cpp -g -O0 -Wall -o a

# 启动 GDB（进入交互式命令行）
gdb ./a

# 也可以一步到位：直接带参数运行
gdb -q ./a
# -q 表示不打印版本信息（屏幕上少刷几行）

$ g++ a.cpp -g -O0 -Wall -o a
$ gdb -q ./a
Reading symbols from ./a...done.
(gdb) b 14                        # 在第 14 行设断点
Breakpoint 1 at 0x11a9: file a.cpp, line 14.
(gdb) r < in.txt                  # 运行并传入输入文件
Breakpoint 1, main () at a.cpp:14
14          s += a[i + 1];         # 程序停在这一行
(gdb) p i                         # 看 i 是多少
$1 = 10
(gdb) p n
$2 = 10
(gdb) p i + 1                     # 看下标会不会越界
$3 = 11                            ← n=10，下标 11 已经越界！
(gdb) bt                          # 看调用栈
#0  main () at a.cpp:14
(gdb) q                           # 退出

# 1. 查看当前限制（0 表示不产生 core 文件）
ulimit -c
# 0

# 2. 打开 core 文件生成（只对当前 shell 有效）
ulimit -c unlimited
# 若仍不生成，可能是 core_pattern 指向了系统统一目录，用下面命令查看
cat /proc/sys/kernel/core_pattern

# 3. 运行崩溃的程序（会生成 core 或 core.PID）
./a < in.txt
# Segmentation fault (core dumped)

# 4. 用 GDB 分析"死亡现场"：不需要重新运行程序
gdb ./a core
# (gdb) bt
# #0  main () at a.cpp:14      ← 直接告诉你崩在哪一行
# (gdb) info locals           ← 崩溃时刻所有局部变量的值
# (gdb) p i
# $1 = 100000

#include <bits/stdc++.h>
using namespace std;
const int N = 5;
int a[N];
int main() {
    int n; cin >> n;                 // 输入 5
    for (int i = 0; i <= n; i++) cin >> a[i];   // ❌ i 可以等于 n，越界
    long long s = 0;
    for (int i = 0; i < n; i++) s += a[i];
    cout << s << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;              // ✅ 按数据上界开，并留出余量
int a[MAXN + 5];                        // 再多开 5 个，应对 i+1 这类访问
int main() {
    ios::sync_with_stdio(0);
    int n; cin >> n;
    for (int i = 0; i < n; i++) cin >> a[i];   // ✅ i < n
    long long s = 0;
    for (int i = 0; i < n; i++) s += a[i];
    cout << s << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
    int n; cin >> n;                 // 输入 5
    int i = 1, s = 0;
    while (i <= n) {                 // ❌ i 永远出不去
        s += i;
        i++;                         // 每轮自增……
        if (i == 3) i = 1;           // ……但走到 3 又被"重置"回 1，死循环
    }
    cout << s << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
    ios::sync_with_stdio(0);
    int n; cin >> n;
    long long s = 0;
    for (int i = 1; i <= n; i++) {   // ✅ 用 for 保证每轮自增，不易漏写
        s += i;
        // 需要"重置"时，必须先无条件自增或改用显式推进
    }
    cout << s << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
    int n; cin >> n;
    int mx, mn;                     // ❌ 两个变量都没初始化
    for (int i = 0; i < n; i++) {
        int x; cin >> x;
        if (i == 0) { mx = mn = x; }
        else { mx = max(mx, x); mn = min(mn, x); }
    }
    cout << mx << " " << mn << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
    ios::sync_with_stdio(0);
    int n; cin >> n;
    // ✅ 用"哨兵值"初始化，保证即使 n=0 也有确定结果
    const long long INF = LLONG_MAX;
    long long mx = -INF, mn = INF;
    for (int i = 0; i < n; i++) {
        long long x; cin >> x;
        mx = max(mx, x);
        mn = min(mn, x);
    }
    if (n == 0) cout << "empty" << endl;   // 显式处理边界
    else        cout << mx << " " << mn << endl;
    return 0;
}

# 生成三项任务对应的最大规模数据并实测
python3 -c "import random;n=5000;print(n);print(' '.join(str(random.randint(1,10**9)) for _ in range(n)))" > t1.in
python3 -c "import random;n=2000;print(n);print(' '.join(str(random.randint(1,10**9)) for _ in range(n)))" > t2.in
python3 -c "import random;n=100000;print(n);print(' '.join(str(random.randint(1,10**9)) for _ in range(n)))" > t3.in

g++ sol.cpp -O2 -Wall -o sol

time ./sol < t1.in > /dev/null
# real    0m0.041s    → 与估算的 2.5e7 相符 ✅
time ./sol < t2.in > /dev/null
# real    0m8.912s    → 与估算的 8e9 相符，确认不可行 ❌
time ./sol < t3.in > /dev/null
# real    0m0.019s    → 轻松通过 ✅

#include <bits/stdc++.h>
using namespace std;
int main() {
    ios::sync_with_stdio(0);        // 解除与 C 标准库的同步，显著加速 cin
    cin.tie(0);                     // 解绑 cin/cout，避免每次读入都刷新 cout
    int n; cin >> n;
    long long s = 0;
    clock_t begin = clock();
    for (int i = 0; i < n; i++) { int x; cin >> x; s += x; }
    clock_t mid = clock();
    cout << s << "\n";              // ✅ 用 \n 而不是 endl
    clock_t end = clock();
    cerr << "读入+求和耗时：" << (double)(mid - begin) / CLOCKS_PER_SEC << " s\n";
    cerr << "输出耗时：" << (double)(end - mid) / CLOCKS_PER_SEC << " s\n";
    return 0;
}

g++ timing2.cpp -O2 -Wall -o timing2

# ①②③ 的数据来自"逐行输出模式"变体：在程序末尾再加一段
# for (int i = 0; i < n; i++) cout << i << "\n";
# 用来放大 IO 差异（n = 10^6 行输出）。单行输出的 timing2.cpp 本身差距没这么大。

# ① 输出到终端（最慢）
time ./timing2 < big.in
# real 2.310s  user 0.180s  sys 0.420s

# ② 输出到文件（推荐）
time ./timing2 < big.in > out.txt
# real 0.230s  user 0.180s  sys 0.020s

# ③ 丢弃输出（只测计算）
time ./timing2 < big.in > /dev/null
# real 0.185s  user 0.179s  sys 0.004s

# ④ 程序内部 clock() 报告（走 stderr，不污染输出）
./timing2 < big.in > /dev/null
# 读入+求和耗时：0.178 s
# 输出耗时：0.001 s

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
long long a[MAXN + 5];               // ✅ 全局大数组，按上界+余量开
int main() {
    ios::sync_with_stdio(0);
    int n; cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    long long cur = 0, best = LLONG_MIN;
    for (int i = 1; i <= n; i++) {
        cur = max(a[i], cur + a[i]);      // ✅ 只用 a[i]，不再访问 a[i+1]
        best = max(best, cur);
    }
    cout << best << endl;
    return 0;
}

#!/bin/bash
# 用法：bash check.sh a.cpp big.in
SRC="${1:-a.cpp}"; DATA="${2:-big.in}"; N="${SRC%.cpp}"

g++ "$SRC" -O2 -Wall -Wextra -std=c++17 -o "$N" || exit 1
g++ "$SRC" -g -O0 -fsanitize=address,undefined -o "${N}_san"

echo "=== 1. Sanitizer 检查（抓越界与 UB）==="
./"${N}_san" < "$DATA" > /dev/null
[ $? -ne 0 ] && echo "⚠️ 运行异常，请看上方 Sanitizer 报告"

echo "=== 2. 性能实测（看 real 是否超时）==="
time ./"$N" < "$DATA" > /dev/null

echo "=== 3. 崩溃则用 GDB 事后分析 ==="
ulimit -c unlimited
./"$N" < "$DATA" > /dev/null 2>&1 || \
  echo "提示：若生成了 core，可执行 gdb ./$N core 后输入 bt"

# 手段一：GDB 内中断
gdb -q ./a
(gdb) r < big.in
# 卡住后按 Ctrl+C，然后：
(gdb) bt                    # 看卡在哪个函数
(gdb) frame 0; p i          # 看当前帧的循环变量
(gdb) p i <= n              # 检查循环条件是否恒真

# 手段二：attach 到已运行的进程
./a < big.in &
# [1] 31415
gdb -p 31415 -q
(gdb) bt
# #0  main () at a.cpp:22    ← 卡在第 22 行
(gdb) p i
# $1 = 0                    ← 循环变量根本没变
(gdb) detach
(gdb) q
kill %1

(gdb) b 15 if i == 6
Breakpoint 1 at 0x1234: file a.cpp, line 15.
(gdb) r < in.txt
Breakpoint 1, main () at a.cpp:15
15              f[i] = f[i-1] + f[i-2];
(gdb) display i
1: i = 6
(gdb) display f[i-1]
2: f[i-1] = 32767          ← 一眼看出上一项是垃圾值
(gdb) n
16          }
2: f[i-1] = 32767
1: i = 6
(gdb) p f[0]@5             ← 一次打印数组前 5 个元素（GDB 的区间语法）
$1 = {0, 1, 1, 2, 3}       ← 只有 f[0..4] 被初始化，循环从 6 开始越过了 f[5]
(gdb) q

# 优化前：cin + endl + 未解绑
g++ slow.cpp -O2 -o slow && time ./slow < big.in > /dev/null
# real    0m1.412s

# 优化后：加 sync_with_stdio(0) + cin.tie(0) + \n
g++ fast.cpp -O2 -o fast && time ./fast < big.in > /dev/null
# real    0m0.518s

# 结论：算法没变，仅 IO 优化就快了 2.7 倍，已能通过