### Complete Memify Library Usage Example - C++

Source: https://context7.com/carlgwastaken/memify/llms.txt

A comprehensive example demonstrating initialization with a target process, module base address resolution, reading pointer chains, and performing continuous memory read/write operations. It also includes foreground window checks for conditional operations. Requires the memify library.

```cpp
#include "mem/memify.h"
#include <iostream>
#include <thread>
#include <chrono>

int main() {
    // Initialize with target process
    memify mem("cs2.exe");

    // Get module base address
    uintptr_t base = mem.GetBase("client.dll");
    if (!base) {
        std::cerr << "Failed to get module base" << std::endl;
        return 1;
    }

    std::cout << "Client base: 0x" << std::hex << base << std::endl;

    // Main loop
    while (true) {
        // Check if window is in foreground (for ESP/overlay use cases)
        if (!mem.InForeground("Counter-Strike 2")) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            continue;
        }

        // Read pointer from base + offset
        uintptr_t offset1 = mem.Read<uintptr_t>(base + 0x6969);

        // Validate pointer before dereferencing
        if (!offset1) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            continue;
        }

        // Read string pointer
        uintptr_t straddr = mem.Read<uintptr_t>(base + 0x69420);

        // Read string data into buffer
        if (straddr) {
            char buf[256] = {0};
            if (mem.ReadRaw(straddr, buf, sizeof(buf))) {
                std::cout << "String value: " << buf << std::endl;
            }
        }

        // Write value to memory
        mem.Write<uintptr_t>(base + 0x1337, 5);

        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }

    // Destructor automatically closes handle
    return 0;
}
```

--------------------------------

### Check if Process is Running - C++

Source: https://context7.com/carlgwastaken/memify/llms.txt

Verifies if a process with a specific name is currently running. It can be used to wait for a process to start before proceeding with operations. Depends on the memify library.

```cpp
#include "mem/memify.h"
#include <thread>
#include <chrono>

int main() {
    // Wait for process to start
    while (!memify("").ProcessIsOpen("game.exe")) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    // Now initialize with handle
    memify mem("game.exe");
    uintptr_t base = mem.GetBase("client.dll");

    // Main loop with process monitoring
    while (mem.ProcessIsOpen("game.exe")) {
        int value = mem.Read<int>(base + 0x1000);
        mem.Write<int>(base + 0x2000, value * 2);

        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }

    // Process closed, exit gracefully
    return 0;
}
```

--------------------------------

### Get module base address using memify in C++

Source: https://context7.com/carlgwastaken/memify/llms.txt

Retrieves base addresses of loaded modules within the target process for offset calculations. Supports querying main executable and DLL modules like client.dll or engine.dll. Returns 0 if module enumeration fails or module is not found in the process.

```cpp
#include "mem/memify.h"

int main() {
    memify mem("game.exe");

    // Get base address of main executable
    uintptr_t gameBase = mem.GetBase("game.exe");

    // Get base address of DLL module
    uintptr_t clientBase = mem.GetBase("client.dll");
    uintptr_t engineBase = mem.GetBase("engine.dll");

    if (clientBase == 0) {
        // Module not found or enumeration failed
        return 1;
    }

    // Use base address for offset calculations
    uintptr_t targetAddress = clientBase + 0x12345;

    return 0;
}
```

--------------------------------

### Initialize memify with multiple process names in C++

Source: https://context7.com/carlgwastaken/memify/llms.txt

Shows advanced initialization supporting fallback process names for version flexibility. Iterates through a vector of process names and attaches to the first match found. Useful for applications supporting multiple game versions or variants with automatic error handling.

```cpp
#include "mem/memify.h"
#include <vector>
#include <string>

int main() {
    // Try multiple process names in order
    std::vector<std::string> processes = {
        "game_v1.exe",
        "game_v2.exe",
        "game_beta.exe"
    };

    memify mem(processes);

    // Opens handle to first matching process found
    // Useful for games with multiple versions
    // Continues to next name if process found but handle fails

    return 0;
}
```

--------------------------------

### Initialize memify with single process name in C++

Source: https://context7.com/carlgwastaken/memify/llms.txt

Demonstrates basic initialization of the memify library with a single target process name. Automatically resolves NT API function pointers, finds process ID by name, and opens a handle with PROCESS_ALL_ACCESS. Returns error if handle acquisition fails; handle is automatically closed by destructor.

```cpp
#include "mem/memify.h"

int main() {
    // Initialize with target process name
    memify mem("notepad.exe");

    // The constructor automatically:
    // - Resolves NT API function pointers
    // - Finds process ID by name
    // - Opens handle with PROCESS_ALL_ACCESS
    // - Prints error if handle fails to open

    return 0;
}
// Handle automatically closed by destructor
```

--------------------------------

### Read Raw Data from Memory - C++

Source: https://context7.com/carlgwastaken/memify/llms.txt

Reads arbitrary size data, including strings and complex structures, into a buffer from a target process's memory. Requires the memify library and a valid process handle.

```cpp
#include "mem/memify.h"
#include <iostream>

int main() {
    memify mem("game.exe");
    uintptr_t base = mem.GetBase("client.dll");

    // Read string from memory
    uintptr_t namePtr = mem.Read<uintptr_t>(base + 0x1000);
    if (namePtr) {
        char nameBuf[256] = {0};
        if (mem.ReadRaw(namePtr, nameBuf, sizeof(nameBuf))) {
            std::cout << "Player name: " << nameBuf << std::endl;
        }
    }

    // Read array
    float positions[10];
    mem.ReadRaw(base + 0x2000, positions, sizeof(positions));

    // Read complex struct
    struct PlayerData {
        char name[32];
        int health;
        float position[3];
        int level;
    };
    PlayerData player;
    mem.ReadRaw(base + 0x3000, &player, sizeof(PlayerData));

    return 0;
}
```

--------------------------------

### Read typed memory values with memify in C++

Source: https://context7.com/carlgwastaken/memify/llms.txt

Demonstrates templated memory reading of various data types from process memory at specified base addresses plus offsets. Supports primitive types, pointers, pointer chains with multiple dereferences, and custom structs. Enables safe dereferencing with null checks for nested data structures.

```cpp
#include "mem/memify.h"

int main() {
    memify mem("game.exe");
    uintptr_t base = mem.GetBase("client.dll");

    // Read different data types
    int health = mem.Read<int>(base + 0x1000);
    float posX = mem.Read<float>(base + 0x2000);
    double score = mem.Read<double>(base + 0x3000);

    // Read pointers (addresses)
    uintptr_t playerPtr = mem.Read<uintptr_t>(base + 0x4000);

    // Dereference pointer chain
    if (playerPtr) {
        uintptr_t weaponPtr = mem.Read<uintptr_t>(playerPtr + 0x50);
        if (weaponPtr) {
            int ammo = mem.Read<int>(weaponPtr + 0x20);
        }
    }

    // Read struct members
    struct Vec3 { float x, y, z; };
    Vec3 position = mem.Read<Vec3>(base + 0x5000);

    return 0;
}
```

--------------------------------

### Write typed memory values with memify in C++

Source: https://context7.com/carlgwastaken/memify/llms.txt

Shows templated memory writing capabilities for modifying process memory at specified addresses. Supports writing primitives like integers and floats, pointer chains, and custom structs. Allows direct manipulation of game values like health, position coordinates, and boolean flags with proper pointer validation.

```cpp
#include "mem/memify.h"

int main() {
    memify mem("game.exe");
    uintptr_t base = mem.GetBase("client.dll");

    // Write different data types
    mem.Write<int>(base + 0x1000, 100);        // Set health to 100
    mem.Write<float>(base + 0x2000, 123.45f);  // Set position X
    mem.Write<bool>(base + 0x3000, true);      // Enable flag

    // Write to pointer chain
    uintptr_t playerPtr = mem.Read<uintptr_t>(base + 0x4000);
    if (playerPtr) {
        mem.Write<int>(playerPtr + 0x10, 999);  // Set player value
    }

    // Write struct
    struct Vec3 { float x, y, z; };
    Vec3 newPos = { 100.0f, 200.0f, 50.0f };
    mem.Write<Vec3>(base + 0x5000, newPos);

    return 0;
}
```

--------------------------------

### Detect Foreground Window - C++

Source: https://context7.com/carlgwastaken/memify/llms.txt

Checks if a window with a specific title is currently in the foreground. This is useful for applications that should only perform operations when their target window is active. Requires the memify library.

```cpp
#include "mem/memify.h"
#include <thread>
#include <chrono>

int main() {
    memify mem("game.exe");
    uintptr_t base = mem.GetBase("client.dll");

    while (true) {
        // Only perform operations when game window is active
        if (!mem.InForeground("Game Title")) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            continue;
        }

        // Window is focused, safe to read/write
        int health = mem.Read<int>(base + 0x1000);

        // Useful for overlay applications (ESP, status displays)
        // Prevents unnecessary operations when window not visible

        std::this_thread::sleep_for(std::chrono::milliseconds(16));
    }

    return 0;
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.