void stackMemoryExample() {
    int a = 10; // 局部變量a存儲在棧內(nèi)存中
    // 函數(shù)執(zhí)行到這里時，a占用棧內(nèi)存
} // 函數(shù)結(jié)束，a的棧內(nèi)存自動釋放

void heapMemoryExample() {
    int* p = new int(20); // 在堆上分配一個int類型的內(nèi)存空間，并初始化為20
    // 使用p指向的內(nèi)存
    delete p; // 釋放堆內(nèi)存
}

void mallocFreeExample() {
    int* p = (int*)malloc(sizeof(int)); // 分配一個int類型大小的內(nèi)存塊
    if (p != nullptr) {
        *p = 30;
        // 使用p指向的內(nèi)存
        free(p); // 釋放內(nèi)存
    }
}

void simpleLeak() {
    int* ptr = new int;  // 分配了一個int型的內(nèi)存空間
    // 這里使用ptr進(jìn)行一些操作
    // 但最后沒有釋放內(nèi)存，造成內(nèi)存泄漏
}

void pointerReassignmentLeak() {
    int* ptr = new int(10);  // 分配內(nèi)存并初始化值為10
    ptr = new int(20);  // 重新賦值，之前分配的內(nèi)存丟失，造成泄漏
    delete ptr;  // 這里只能釋放第二次分配的內(nèi)存
}

void arrayLeak() {
    int* arr = new int[10];  // 分配一個包含10個int的數(shù)組
    // 對arr進(jìn)行操作
    delete arr;  // 錯誤！應(yīng)該使用delete[] arr; 造成內(nèi)存泄漏
}

void exceptionLeak() {
    int* ptr = new int;
    try {
        // 這里可能會拋出異常的代碼
        if (someCondition) {
            throw std::exception();
        }
    } catch (...) {
        // 沒有釋放ptr指向的內(nèi)存，造成泄漏
        throw;
    }
}

sudo apt - get install valgrind

sudo yum install valgrind

valgrind --leak - check = full --show - leak - kinds = all./test

==12345== Memcheck, a memory error detector
==12345== Copyright (C) 2002 - 2017, and GNU GPL'd, by Julian Seward et al.
==12345== Using Valgrind - 3.16.1 and LibVEX; rerun with - h for copyright info
==12345== Command:./test
==12345== 
==12345== HEAP SUMMARY:
==12345==     in use at exit: 20 bytes in 1 blocks
==12345==   total heap usage: 2 allocs, 1 frees, 72,724 bytes allocated
==12345== 
==12345== 20 bytes in 1 blocks are definitely lost in loss record 1 of 1
==12345==    at 0x483C583: operator new[](unsigned long) (vg_replace_malloc.c:431)
==12345==    by 0x10919E: main (test.cpp:5)
==12345== 
==12345== LEAK SUMMARY:
==12345==    definitely lost: 20 bytes in 1 blocks
==12345==    indirectly lost: 0 bytes in 0 blocks
==12345==      possibly lost: 0 bytes in 0 blocks
==12345==    still reachable: 0 bytes in 0 blocks
==12345==         suppressed: 0 bytes in 0 blocks
==12345== 
==12345== For lists of detected and suppressed errors, rerun with: - s
==12345== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

g++ -fsanitize = address -g -O1 your_code.cpp -o your_program

clang++ -fsanitize = address -g -O1 your_code.cpp -o your_program

=================================================================
==1234==ERROR: AddressSanitizer: heap - buffer - overflow on address 0x602000000014 at pc 0x000000400810 bp 0x7ffc779e47d0 sp 0x7ffc779e47c0
WRITE of size 4 at 0x602000000014 thread T0
#0 0x40080c in main /home/user/your_code.cpp:11
#1 0x7f9c6a8cdf38 in __libc_start_call_main../sysdeps/nptl/libc_start_call_main.h:58
#2 0x7f9c6a8ce004 in __libc_start_main_impl../csu/libc - start.c:409
#3 0x4006ac in _start (/home/user/your_program+0x4006ac)
0x602000000014 is located 0 bytes to the right of 20 - byte region [0x602000000000,0x602000000014)
allocated by thread T0 here:
#0 0x7f9c6aa96080 in malloc (/usr/lib64/libasan.so.6+0xa9080)
#1 0x4007b0 in main /home/user/your_code.cpp:10
#2 0x7f9c6a8cdf38 in __libc_start_call_main../sysdeps/nptl/libc_start_call_main.h:58
#3 0x7f9c6a8ce004 in __libc_start_main_impl../csu/libc - start.c:409
#4 0x4006ac in _start (/home/user/your_program+0x4006ac)
SUMMARY: AddressSanitizer: heap - buffer - overflow /home/user/your_code.cpp:11 in main
Shadow bytes around the buggy address:
0x100400000010: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x100400000020: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x100400000030: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x100400000040: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x100400000050: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
=>0x100400000060: fa fa fa fa fa fa fa fa fa fa 00 00[04]fa fa fa
0x100400000070: 00 00 00 fa fa fa fa fa fa fa fa fa fa fa fa fa
0x100400000080: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x100400000090: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x1004000000a0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x1004000000b0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
Shadow byte legend (one shadow byte represents 8 application bytes):
Addressable: 00
Partially addressable: 01 02 03 04 05 06 07
Heap left redzone: fa
Freed heap region: fd
Stack left redzone: f1
Stack mid redzone: f2
Stack right redzone: f3
Stack after return: f5
Stack use after scope: f8
Global redzone: f9
Global init order: f6
Poisoned by user: f7
Container overflow: fc
Array cookie: ac
Intra object redzone: bb
ASan internal: fe
Left alloca redzone: ca
Right alloca redzone: cb
Shadow gap: cc
==1234==ABORTING

gdb./your_program

(gdb) break main

(gdb) run

(gdb) p *pointer_variable

#include <stdio.h>
#include <stdlib.h>

void* my_malloc(size_t size) {
    void* ptr = malloc(size);
    printf("Allocated %zu bytes at %p\n", size, ptr);
    return ptr;
}

void my_free(void* ptr) {
    printf("Freeing memory at %p\n", ptr);
    free(ptr);
}

#include <mcheck.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    mtrace();  // 開始追蹤內(nèi)存分配
    setenv("MALLOC_TRACE", "trace.log", 1);  // 設(shè)置追蹤日志文件為trace.log

    int* ptr = (int*)malloc(10 * sizeof(int));
    // 其他操作
    // 這里故意不釋放ptr指向的內(nèi)存，制造內(nèi)存泄漏

    muntrace();  // 結(jié)束追蹤
    return 0;
}

mtrace./your_program trace.log

Memory not freed:
-----------------
   Address     Size     Caller
0x0804a008     0x28  at /home/user/your_program.c:10

#include <iostream>
#include <map>
#include <cstdlib>

struct MemoryBlock {
    const char* file;
    int line;
};

static std::map<void*, MemoryBlock> allocated_blocks;

void* operator new(size_t size, const char* file, int line) {
    void* ptr = std::malloc(size);
    if (ptr) {
        allocated_blocks[ptr] = {file, line};
    }
    return ptr;
}

void operator delete(void* ptr) noexcept {
    auto it = allocated_blocks.find(ptr);
    if (it != allocated_blocks.end()) {
        allocated_blocks.erase(it);
    }
    std::free(ptr);
}

// 使用自定義new
#define new new(__FILE__, __LINE__)

// 在程序結(jié)束時檢查未釋放的內(nèi)存
void check_memory_leaks() {
    if (!allocated_blocks.empty()) {
        std::cerr << "Memory leaks detected:" << std::endl;
        for (const auto& pair : allocated_blocks) {
            std::cerr << "  Block at " << pair.first << " allocated at " << pair.second.file << ":" << pair.second.line << std::endl;
        }
    }
}

#include <cstdlib>

int main() {
    int* ptr1 = new int;
    int* ptr2 = new int[10];

    // 這里故意不釋放ptr1和ptr2指向的內(nèi)存，制造內(nèi)存泄漏

    check_memory_leaks();  // 檢查內(nèi)存泄漏
    return 0;
}

void correctUsage() {
    int* ptr1 = new int;  // 分配一個int型內(nèi)存
    *ptr1 = 10;
    // 使用ptr1
    delete ptr1;  // 釋放內(nèi)存，完美匹配，不會泄漏

    int* ptr2 = new int[5];  // 分配包含5個int的數(shù)組內(nèi)存
    for (int i = 0; i < 5; ++i) {
        ptr2[i] = i;
    }
    // 使用ptr2
    delete[] ptr2;  // 釋放數(shù)組內(nèi)存，注意使用delete[]
}

void wrongUsage() {
    int* ptr1 = new int;
    *ptr1 = 20;
    // 這里忘記了delete ptr1，內(nèi)存泄漏！

    int* ptr2 = new int[3];
    for (int i = 0; i < 3; ++i) {
        ptr2[i] = i * 2;
    }
    delete ptr2;  // 錯誤！分配數(shù)組應(yīng)該用delete[]，這里會導(dǎo)致內(nèi)存泄漏
}

#include <iostream>
#include <memory>

void uniquePtrDemo() {
    std::unique_ptr<int> ptr(new int(10));  // 創(chuàng)建unique_ptr并指向一個int對象
    std::cout << *ptr << std::endl;  // 訪問對象的值
    // 當(dāng)ptr離開作用域時，它指向的int對象會被自動刪除，無需手動delete
}  // unique_ptr析構(gòu)，內(nèi)存自動釋放

std::unique_ptr<int> ptr1(new int(20));
std::unique_ptr<int> ptr2 = std::move(ptr1);  // 所有權(quán)從ptr1轉(zhuǎn)移到ptr2
if (!ptr1) {
    std::cout << "ptr1 is now empty." << std::endl;
}

#include <iostream>
#include <memory>

void sharedPtrDemo() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(30);  // 創(chuàng)建shared_ptr并指向一個int對象，引用計(jì)數(shù)為1
    std::shared_ptr<int> ptr2 = ptr1;  // ptr2共享ptr1的對象，引用計(jì)數(shù)加1變?yōu)?
    std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl;  // 輸出引用計(jì)數(shù)
    std::cout << "ptr2 use count: " << ptr2.use_count() << std::endl;
    // 當(dāng)ptr1和ptr2離開作用域時，引用計(jì)數(shù)減為0，對象自動被銷毀
}  // 引用計(jì)數(shù)為0，對象釋放

#include <iostream>
#include <memory>

class B;  // 前向聲明

class A {
public:
    std::shared_ptr<B> ptrB;
    ~A() {
        std::cout << "A destroyed." << std::endl;
    }
};

class B {
public:
    std::weak_ptr<A> ptrA;  // 使用weak_ptr避免循環(huán)引用
    ~B() {
        std::cout << "B destroyed." << std::endl;
    }
};

void weakPtrDemo() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->ptrB = b;
    b->ptrA = a;  // 這里使用weak_ptr，不會增加引用計(jì)數(shù)，避免循環(huán)引用
}  // a和b的引用計(jì)數(shù)都能正常減為0，對象被銷毀

std::shared_ptr<int> shared = std::make_shared<int>(40);
std::weak_ptr<int> weak = shared;
if (!weak.expired()) {  // 檢查對象是否已被銷毀
    std::shared_ptr<int> locked = weak.lock();  // 轉(zhuǎn)換為shared_ptr
    if (locked) {
        std::cout << *locked << std::endl;  // 訪問對象
    }
}

#include <iostream>
#include <fstream>

void nonRAIIFileHandling() {
    std::ifstream file("test.txt");
    if (file.is_open()) {
        // 處理文件
        // 假設(shè)這里發(fā)生異常
        throw std::runtime_error("Something went wrong");
    }
    file.close();  // 如果發(fā)生異常，這行代碼可能不會執(zhí)行，導(dǎo)致文件句柄未關(guān)閉
}

#include <iostream>
#include <fstream>

class FileHandler {
public:
    FileHandler(const std::string& filename) : file(filename) {
        if (!file.is_open()) {
            throw std::runtime_error("Could not open file: " + filename);
        }
    }

    ~FileHandler() {
        file.close();
    }

    std::ifstream& getFile() {
        return file;
    }

private:
    std::ifstream file;
};

void RAIIFileHandling() {
    try {
        FileHandler handler("test.txt");
        std::ifstream& file = handler.getFile();
        // 處理文件
        // 如果發(fā)生異常，handler的析構(gòu)函數(shù)會自動被調(diào)用，關(guān)閉文件句柄
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }
}

#include <iostream>
#include <vector>

class MemoryPool {
public:
    MemoryPool(size_t blockSize, size_t numBlocks)
        : blockSize(blockSize), numBlocks(numBlocks) {
        pool = new char[blockSize * numBlocks];
        freeList = pool;
        for (size_t i = 0; i < numBlocks - 1; ++i) {
            *(reinterpret_cast<char**>(freeList + i * blockSize)) = freeList + (i + 1) * blockSize;
        }
        *(reinterpret_cast<char**>(freeList + (numBlocks - 1) * blockSize)) = nullptr;
    }

    ~MemoryPool() {
        delete[] pool;
    }

    void* allocate() {
        if (!freeList) {
            // 內(nèi)存池已滿，可考慮擴(kuò)容
            return nullptr;
        }
        void* block = freeList;
        freeList = *(reinterpret_cast<char**>(freeList));
        return block;
    }

    void deallocate(void* ptr) {
        *(reinterpret_cast<char**>(ptr)) = freeList;
        freeList = reinterpret_cast<char*>(ptr);
    }

private:
    char* pool;
    char* freeList;
    size_t blockSize;
    size_t numBlocks;
};

int main() {
    MemoryPool pool(128, 10);  // 創(chuàng)建內(nèi)存池，每個塊大小為128字節(jié)，共10個塊
    void* ptr1 = pool.allocate();
    void* ptr2 = pool.allocate();
    // 使用ptr1和ptr2
    pool.deallocate(ptr1);
    pool.deallocate(ptr2);
    return 0;
}

#include <iostream>
#include <memory>

class B;  // 前向聲明

class A {
public:
    std::shared_ptr<B> ptrB;
    ~A() {
        std::cout << "A destroyed." << std::endl;
    }
};

class B {
public:
    std::shared_ptr<A> ptrA;
    ~B() {
        std::cout << "B destroyed." << std::endl;
    }
};

void circularReferenceProblem() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->ptrB = b;
    b->ptrA = a;  // 形成循環(huán)引用
}  // 這里a和b的引用計(jì)數(shù)都不會變?yōu)?，內(nèi)存泄漏

#include <iostream>
#include <memory>

class B;  // 前向聲明

class A {
public:
    std::shared_ptr<B> ptrB;
    ~A() {
        std::cout << "A destroyed." << std::endl;
    }
};

class B {
public:
    std::weak_ptr<A> ptrA;  // 使用weak_ptr避免循環(huán)引用
    ~B() {
        std::cout << "B destroyed." << std::endl;
    }
};

void solveCircularReference() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->ptrB = b;
    b->ptrA = a;  // 不再形成循環(huán)引用
}  // 這里a和b的引用計(jì)數(shù)能正常降為0，對象被銷毀

#include <iostream>
#include <cstring>

// 模擬數(shù)據(jù)庫連接結(jié)構(gòu)體
struct DatabaseConnection {
    char* connectionString;
    int connectionId;

    DatabaseConnection(const char* str, int id) {
        connectionString = new char[strlen(str) + 1];
        std::strcpy(connectionString, str);
        connectionId = id;
    }

    ~DatabaseConnection() {
        // 這里應(yīng)該釋放connectionString，但我們故意不釋放，以模擬內(nèi)存泄漏
        // delete[] connectionString;
    }
};

// 模擬獲取數(shù)據(jù)庫連接的函數(shù)
DatabaseConnection* getDatabaseConnection() {
    static int connectionCount = 0;
    const char* connectionStr = "mysql://localhost:3306/mydb";
    DatabaseConnection* conn = new DatabaseConnection(connectionStr, connectionCount++);
    return conn;
}

int main() {
    for (int i = 0; i < 10; ++i) {
        DatabaseConnection* conn = getDatabaseConnection();
        // 使用連接
        std::cout << "Using connection with ID: " << conn->connectionId << std::endl;
        // 這里沒有釋放連接，導(dǎo)致內(nèi)存泄漏
    }
    return 0;
}

g++ -g -o leak_demo leak_demo.cpp

valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes --verbose ./leak_demo

==30123== 56 bytes in 1 blocks are definitely lost in loss record 1 of 1
==30123==    at 0x483C583: operator new[](unsigned long) (vg_replace_malloc.c:431)
==30123==    by 0x1092B7: DatabaseConnection::DatabaseConnection(char const*, int) (leak_demo.cpp:12)
==30123==    by 0x10934F: getDatabaseConnection() (leak_demo.cpp:23)
==30123==    by 0x1093A6: main (leak_demo.cpp:30)

g++ -fsanitize=address -g -o asan_leak_demo leak_demo.cpp

./asan_leak_demo

=================================================================
==30234==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 56 byte(s) in 1 object(s) allocated from:
    #0 0x7f011d7b5b50 in operator new[](unsigned long) (/lib/x86_64-linux-gnu/libasan.so.5+0x10c2b3)
    #1 0x400b77 in DatabaseConnection::DatabaseConnection(char const*, int) (/home/user/leak_demo.cpp:12)
    #2 0x400c0f in getDatabaseConnection() (/home/user/leak_demo.cpp:23)
    #3 0x400c66 in main (/home/user/leak_demo.cpp:30)

SUMMARY: AddressSanitizer: 56 byte(s) leaked in 1 allocation(s).

#include <iostream>
#include <cstring>
#include <mcheck.h>

// 模擬數(shù)據(jù)庫連接結(jié)構(gòu)體
struct DatabaseConnection {
    char* connectionString;
    int connectionId;

    DatabaseConnection(const char* str, int id) {
        connectionString = new char[strlen(str) + 1];
        std::strcpy(connectionString, str);
        connectionId = id;
    }

    ~DatabaseConnection() {
        // 這里應(yīng)該釋放connectionString，但我們故意不釋放，以模擬內(nèi)存泄漏
        // delete[] connectionString;
    }
};

// 模擬獲取數(shù)據(jù)庫連接的函數(shù)
DatabaseConnection* getDatabaseConnection() {
    static int connectionCount = 0;
    const char* connectionStr = "mysql://localhost:3306/mydb";
    DatabaseConnection* conn = new DatabaseConnection(connectionStr, connectionCount++);
    return conn;
}

int main() {
    mtrace();
    for (int i = 0; i < 10; ++i) {
        DatabaseConnection* conn = getDatabaseConnection();
        // 使用連接
        std::cout << "Using connection with ID: " << conn->connectionId << std::endl;
        // 這里沒有釋放連接，導(dǎo)致內(nèi)存泄漏
    }
    muntrace();
    return 0;
}

export MALLOC_TRACE=mtrace.log
g++ -g -o mtrace_leak_demo mtrace_leak_demo.cpp
./mtrace_leak_demo

mtrace ./mtrace_leak_demo mtrace.log

Memory not freed:
-----------------
Address     Size     Caller
0x000055555575c6a0      0x38  at 0x7f011d7b5b50

addr2line -e./mtrace_leak_demo 0x7f011d7b5b50

#include <iostream>
#include <cstring>

// 模擬數(shù)據(jù)庫連接結(jié)構(gòu)體
struct DatabaseConnection {
    char* connectionString;
    int connectionId;

    DatabaseConnection(const char* str, int id) {
        connectionString = new char[strlen(str) + 1];
        std::strcpy(connectionString, str);
        connectionId = id;
    }

    ~DatabaseConnection() {
        delete[] connectionString;
    }
};

// 模擬獲取數(shù)據(jù)庫連接的函數(shù)
DatabaseConnection* getDatabaseConnection() {
    static int connectionCount = 0;
    const char* connectionStr = "mysql://localhost:3306/mydb";
    DatabaseConnection* conn = new DatabaseConnection(connectionStr, connectionCount++);
    return conn;
}

int main() {
    for (int i = 0; i < 10; ++i) {
        DatabaseConnection* conn = getDatabaseConnection();
        // 使用連接
        std::cout << "Using connection with ID: " << conn->connectionId << std::endl;
        delete conn; // 釋放連接
    }
    return 0;
}

valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes --verbose ./fixed_leak_demo

==30345== LEAK SUMMARY:
==30345==    definitely lost: 0 bytes in 0 blocks
==30345==    indirectly lost: 0 bytes in 0 blocks
==30345==      possibly lost: 0 bytes in 0 blocks
==30345==    still reachable: 0 bytes in 0 blocks
==30345==         suppressed: 0 bytes in 0 blocks