C++ Debugging & Optimization: GDB, Valgrind, ASan, Move Semantics & Profiling (2025)

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

// Logic error: returns a*b instead of a+b
int add(int a, int b) { return a * b; }  // BUG: should be a+b

// Memory error: write beyond array bounds
void bufferOverflow() {
    int arr[5] = {};
    arr[10] = 42;  // BUG: out-of-bounds write (UB, caught by ASan)
}

// Memory leak: allocated but never freed
void memoryLeak() {
    int* p = new int(100);
    cout << *p << endl;
    // BUG: delete p; missing — caught by Valgrind / ASan
}

// Undefined behavior: signed integer overflow
void intOverflow() {
    int x = INT_MAX;
    x++;  // BUG: UB — caught by -fsanitize=undefined
    cout << x << endl;
}

int main() {
    cout << add(3, 5) << endl;  // prints 15 (not 8) — logic error
    return 0;
}

#include <iostream>
using namespace std;

int* findValue(int* arr, int n, int target) {
    for (int i = 0; i < n; i++)
        if (arr[i] == target) return &arr[i];
    return nullptr;  // not found
}

int main() {
    int data[] = {1, 3, 5, 7};
    int* result = findValue(data, 4, 99);  // 99 not in array → nullptr
    cout << *result << endl;  // BUG: dereferencing nullptr → SEGFAULT
    return 0;
}

$ g++ -g -O0 segfault_demo.cpp -o demo
$ gdb ./demo
(gdb) run

Program received signal SIGSEGV, Segmentation fault.
0x0000000000401198 in main () at segfault_demo.cpp:13
13          cout << *result << endl;

(gdb) backtrace
#0  0x0000000000401198 in main () at segfault_demo.cpp:13

(gdb) print result
$1 = (int *) 0x0     ← NULL pointer! That's the bug.

(gdb) quit

# Compile both versions
g++ -O0 -std=c++17 bench.cpp -o bench_O0
g++ -O2 -std=c++17 bench.cpp -o bench_O2
g++ -O3 -march=native -std=c++17 bench.cpp -o bench_O3

# Time each
time ./bench_O0   # ~2800ms
time ./bench_O2   # ~350ms  (8x faster)
time ./bench_O3   # ~280ms  (slightly more on numeric code)

#include <iostream>
#include <vector>
#include <chrono>
#include <string>
using namespace std;
using namespace std::chrono;

int main() {
    const int N = 100000;

    // 1. push_back with copy — creates temp, then copies into vector
    auto t1 = high_resolution_clock::now();
    vector<string> v1;
    v1.reserve(N);
    for (int i=0; i<N; i++) {
        string s = "hello_world_" + to_string(i);
        v1.push_back(s);   // copy
    }
    auto t2 = high_resolution_clock::now();

    // 2. push_back with std::move — transfer instead of copy
    vector<string> v2;
    v2.reserve(N);
    for (int i=0; i<N; i++) {
        string s = "hello_world_" + to_string(i);
        v2.push_back(move(s));  // move: O(1) instead of O(len)
    }
    auto t3 = high_resolution_clock::now();

    // 3. emplace_back — construct directly in vector, no temp at all
    vector<string> v3;
    v3.reserve(N);
    for (int i=0; i<N; i++)
        v3.emplace_back("hello_world_" + to_string(i));  // construct in-place
    auto t4 = high_resolution_clock::now();

    cout << "push_back (copy):   "
         << duration_cast<microseconds>(t2-t1).count() << " µs\n";
    cout << "push_back (move):   "
         << duration_cast<microseconds>(t3-t2).count() << " µs\n";
    cout << "emplace_back:       "
         << duration_cast<microseconds>(t4-t3).count() << " µs\n";
    return 0;
}

#include <iostream>
#include <vector>
#include <chrono>
#include <numeric>
using namespace std;
using namespace std::chrono;

const int N = 10000000;

// AoS (Array of Structures) — x,y,z,mass interleaved in memory
struct ParticleAoS { float x,y,z,mass; };

// SoA (Structure of Arrays) — each field contiguous
struct ParticlesSoA {
    vector<float> x,y,z,mass;
    ParticlesSoA(int n) { x.resize(n); y.resize(n); z.resize(n); mass.resize(n,1.0f); }
};

int main() {
    // 1. reserve() eliminates reallocations
    vector<int> slow, fast;
    // slow: no reserve — triggers O(log n) reallocations
    auto t1 = high_resolution_clock::now();
    for (int i=0; i<N; i++) slow.push_back(i);
    auto t2 = high_resolution_clock::now();
    fast.reserve(N);  // fast: pre-allocate — O(1) insertions
    for (int i=0; i<N; i++) fast.push_back(i);
    auto t3 = high_resolution_clock::now();
    cout << "Without reserve: " << duration_cast<milliseconds>(t2-t1).count() << "ms\n";
    cout << "With reserve:    " << duration_cast<milliseconds>(t3-t2).count() << "ms\n";

    // 2. SoA mass sum (cache-friendly: all masses contiguous)
    ParticlesSoA soa(N);
    auto t4 = high_resolution_clock::now();
    float totalSoA = accumulate(soa.mass.begin(), soa.mass.end(), 0.0f);
    auto t5 = high_resolution_clock::now();

    // 3. AoS mass sum (cache-unfriendly: mass scattered every 16 bytes)
    vector<ParticleAoS> aos(N, {0,0,0,1.0f});
    auto t6 = high_resolution_clock::now();
    float totalAoS = 0;
    for (auto& p : aos) totalAoS += p.mass;
    auto t7 = high_resolution_clock::now();

    cout << "SoA mass sum: " << duration_cast<milliseconds>(t5-t4).count() << "ms\n";
    cout << "AoS mass sum: " << duration_cast<milliseconds>(t7-t6).count() << "ms\n";
    return 0;
}

# ====== gprof (function-level timing) ======
g++ -O2 -pg prog.cpp -o prog     # compile with -pg
./prog                             # run to generate gmon.out
gprof ./prog gmon.out | head -40   # top functions by time

# ====== perf (Linux — no recompile needed) ======
perf record -g ./prog              # sample with call graph
perf report                        # interactive TUI report
perf stat ./prog                   # high-level counters (IPC, cache misses)

# ====== Valgrind callgrind (per-line counts) ======
valgrind --tool=callgrind ./prog
kcachegrind callgrind.out.*        # GUI call graph viewer

# ====== Quick: time the whole program ======
time ./prog                        # wall clock time
/usr/bin/time -v ./prog            # +memory, page faults