Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

cpp-debugging

/cpp-debugging

Prowadzi diagnozę awarii C++ związanych z czasem życia pamięci, niezdefiniowanym zachowaniem i natywnymi crashami, z symbolami, sanitizerami i debuggerami platformowymi przed poprawianiem objawów.

Licencja
MIT
Ostatnia zmiana repozytorium
25.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 25.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Prowadzi diagnozę awarii C++ związanych z czasem życia pamięci, niezdefiniowanym zachowaniem i natywnymi crashami, z symbolami, sanitizerami i debuggerami platformowymi przed poprawianiem objawów.

Oryginalny opis (EN)

Use when a C++ failure involves memory lifetime, undefined behavior, native crashes, or debugger-only state — debug with symbols, sanitizers, and platform-native debuggers before patching symptoms

Jak działa

  1. When to Use
  2. When NOT to Use
  3. Prerequisites
  4. Workflow
  5. Common Rationalizations
  6. Red Flags
  7. Verification
  8. Tips
  9. See Also
Sekcje z nagłówków SKILL.md, w oryginale · 187 linii, 990 słów
Podgląd SKILL.md
---
name: cpp-debugging
description: Use when a C++ failure involves memory lifetime, undefined behavior, native crashes, or debugger-only state — debug with symbols, sanitizers, and platform-native debuggers before patching symptoms
metadata:
  category: development
  agent_type: general-purpose
---

# C++ Debugging

`systematic-debugging` gives you the language-neutral method. This skill adds the
native C++ toolchain and runtime techniques that matter once the bug involves
crashes, corrupted memory, UB, or platform-specific debugger state.

## When to Use

- A C++ process crashes with a segmentation fault, access violation, or abort
- The bug depends on object lifetime, ownership, or move/copy behavior
- Behavior changes between debug and release builds
- AddressSanitizer, UndefinedBehaviorSanitizer, or a debugger is needed to see the failure clearly
- A native test hangs, deadlocks, or corrupts memory without a clear stack trace

## When NOT to Use

| Instead of cpp-debugging | Use |
|--------------------------|-----|
| You still do not have a stable reproduction or root-cause workflow | `systematic-debugging` |
| The failure is a build, compile, or link error | `fix-build-errors` |
| The issue is performance-only, not correctness | `performance-optimization` |

## Prerequisites

- A reproducible failing command, test, or executable
- A debug-capable build with symbols
- Access to the relevant debugger or sanitizer-enabled toolchain
- Enough context to tell whether the bug is runtime, lifetime, concurrency, or build-related

## Workflow

### 1. Rebuild for diagnosis, not speed

Start with a debuggable build before chasing the crash:

```powershell
# CMake
cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build --config Debug

# Clang/GCC direct build example
clang++ -std=c++20 -g -O0 -Wall -Wextra -Wpedantic main.cpp -o app.exe
```

Guidelines:

- enable symbols (`-g`, `/Zi`)
- reduce or disable optimization while reproducing (`-O0`, `/Od`)
- keep warnings enabled
- reproduce with the same inputs that fail in CI or production-like runs

### 2. Capture the exact failing surface

```powershell
# Run the failing binary or test under the same conditions each time
ctest --test-dir build --output-on-failure

# Or run the specific executable directly
.\build\app.exe
```

Record:

1. exact command line
2. failing input or fixture
3. crash signal or exit code
4. first bad log line, assertion, or stack frame

### 3. Inspect runtime state with a native debugger

Use the platform-native debugger your team standardizes on. Common flows:

```powershell
# GDB
gdb --args .\build\app.exe <args>
# (gdb) run
# (gdb) bt
# (gdb) frame 0
# (gdb) info locals
# (gdb) p suspiciousVariable

# LLDB
lldb -- .\build\app.exe <args>
# (lldb) run
# (lldb) bt
# (lldb) frame variable
```

Focus on:

- the first frame where state becomes invalid
- moved-from or already-destroyed objects
- container bounds and iterator validity
- null or dangling pointers
- cross-thread ordering when the state only fails under load

### 4. Turn on sanitizers early

Sanitizers catch the class of bugs that ordinary logging often hides.

```powershell
# Clang/GCC
cmake -S . -B build-asan `
  -DCMAKE_BUILD_TYPE=Debug `
  -DCMAKE_CXX_FLAGS="-fsanitize=address,undefined -fno-omit-frame-pointer"
cmake --build build-asan
ctest --test-dir build-asan --output-on-failure
```

If your toolchain supports it, enable the equivalent native flags on Windows as well
(for example MSVC AddressSanitizer in supported versions).

Use sanitizer output to answer:

- which access was invalid
- which allocation/free site owned the memory
- whether UB happened before the visible crash

### 5. Use core dumps or crash artifacts when the bug is post-mortem

If the crash only appears outside the current shell, collect the artifact and inspect it:

```text
- preserve the crashing binary and symbols
- keep the exact build that produced the dump
- load the dump in the matching debugger
- compare the crashing frame with the last known good run
```

Do not "fix" a crash dump by guessing from the top frame alone. Trace ownership and state backwards.

### 6. Fix the root cause and harden the boundary

Typical C++ root causes:

- lifetime mismatch between owner and borrower
- invalid iterator or reference after container mutation
- double free or use-after-free
- missing synchronization around shared mutable state
- undefined behavior surfaced by a newer compiler or optimizer

After the fix:

- rerun the failing reproduction
- rerun sanitizer-enabled tests
- add a regression test where practical
- check nearby code for the same lifetime or ownership pattern

## Common Rationalizations

| Rationalization | Reality |
|----------------|---------|
| "The debugger changes timing, so it is useless" | Timing-sensitive bugs still need debugger or sanitizer evidence. Use them to narrow the class of failure, then confirm in a normal run. |
| "Release-only crash means the optimizer is broken" | Most release-only failures are UB, data races, or lifetime bugs that debug mode accidentally masks. |
| "The stack trace is enough" | Native crashes often happen far from the real cause. Ownership history matters more than the final frame. |
| "I'll just add null checks" | Null checks do not fix dangling references, iterator invalidation, or races. |

## Red Flags

- The crash disappears when you add logging but no root cause is identified
- The only "fix" is changing optimization level
- You cannot say which object owns the failing memory
- The code mixes raw ownership, smart pointers, and borrowed references without clear boundaries
- No regression test or sanitizer rerun happened after the fix

## Verification

- [ ] A reproducible failing command or test exists
- [ ] A debug-symbol build was used during diagnosis
- [ ] Debugger or sanitizer output identifies the real failure class
- [ ] The final fix addresses ownership, bounds, synchronization, or UB at the source
- [ ] The targeted reproduction and relevant tests pass after the fix

## Tips

- Prefer smaller reproductions: isolate the failing target or test before debugging the whole system
- If the stack is noisy, break on the first thrown exception, failed assertion, or allocator error
- Compare debug and release compile flags when behavior diverges
- If the bug looks build-related after all, hand off to `fix-build-errors`

## See Also

- [`systematic-debugging`](../systematic-debugging/SKILL.md) — root-cause method before tool-specific work
- [`fix-build-errors`](../fix-build-errors/SKILL.md) — compile, link, and configuration failures
- [`tdd-workflow`](../tdd-workflow/SKILL.md) — add regression tests after the runtime bug is fixed

Wersje

W bazie nie ma innych skilli o nazwie cpp-debugging.

Migawka bazy z 13.11.2026 · wersja paczki 158dc4b1ac6f (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100c-systems
    Opisuje wzorce dla kodu systemowego w C: układ modułów, obsługę błędów, bezpieczeństwo pamięci, niezdefiniowane zachowania i pomiar wydajności, z sanitizerami i Valgrind.
  • 96c-cpp-code-audit
    Sprawdza kod w C i C++ pod kątem awarii, wycieków pamięci i niezdefiniowanego zachowania, na potrzeby przeglądu własnego kodu.
  • 100managing-metal-cpp-lifetimes
    Pilnuje zarządzania czasem życia obiektów Metal w metal-cpp: awarie przy release, use-after-free, wycieki, umiejscowienie autorelease pool, NS::TransferPtr kontra NS::RetainPtr oraz rzutowania mostkowe na granicy ARC i metal-cpp.
  • 92debugging
    Prowadzi przez debugowanie błędu w kodzie, gdy użytkownik prosi o diagnozę problemu.
  • 95lang-c
    Pisze i sprawdza przenośny kod C11, C17 i C23: zarządzanie pamięcią, niezdefiniowane zachowania, bufory, obsługę błędów i narzędzia analizy.
  • 90c-memory-safety
    Pomaga pisać w C z jawnymi konwencjami własności, dyscypliną granic tablic i sanitizerami w każdym uruchomieniu testów, także przy szukaniu uszkodzeń pamięci.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.