Как узнать сколько оперативной памяти в системе в коде?

Определение объёма оперативной памяти в системе

В C/C++ можно получить информацию об объёме памяти несколькими способами, в зависимости от платформы.

Linux: /proc/meminfo

#include <fstream>
#include <string>
#include <sstream>

long long get_total_memory_linux() {
    std::ifstream meminfo("/proc/meminfo");
    std::string line;
    
    while (std::getline(meminfo, line)) {
        if (line.find("MemTotal:") == 0) {
            std::istringstream iss(line);
            std::string label;
            long long memory_kb;
            iss >> label >> memory_kb;
            return memory_kb * 1024;  // Преобразуем KB в байты
        }
    }
    return -1;
}

long long get_free_memory_linux() {
    std::ifstream meminfo("/proc/meminfo");
    std::string line;
    
    while (std::getline(meminfo, line)) {
        if (line.find("MemAvailable:") == 0) {
            std::istringstream iss(line);
            std::string label;
            long long memory_kb;
            iss >> label >> memory_kb;
            return memory_kb * 1024;
        }
    }
    return -1;
}

Cross-platform: sysconf() и sysinfo()

#include <unistd.h>
#include <sys/sysinfo.h>

// POSIX способ (Linux, macOS, Unix)
long long get_total_memory_posix() {
    long pages = sysconf(_SC_PHYS_PAGES);
    long page_size = sysconf(_SC_PAGE_SIZE);
    return pages * page_size;
}

long long get_available_memory_posix() {
    long available = sysconf(_SC_AVPHYS_PAGES);
    long page_size = sysconf(_SC_PAGE_SIZE);
    return available * page_size;
}

// Linux способ через sysinfo
long long get_total_memory_sysinfo() {
    struct sysinfo info;
    if (sysinfo(&info) == 0) {
        return (long long)info.totalram * info.mem_unit;
    }
    return -1;
}

long long get_free_memory_sysinfo() {
    struct sysinfo info;
    if (sysinfo(&info) == 0) {
        return (long long)info.freeram * info.mem_unit;
    }
    return -1;
}

Windows: GlobalMemoryStatusEx

#ifdef _WIN32
#include <windows.h>

long long get_total_memory_windows() {
    MEMORYSTATUSEX statex;
    statex.dwLength = sizeof(statex);
    
    if (GlobalMemoryStatusEx(&statex)) {
        return statex.ullTotalPhys;
    }
    return -1;
}

long long get_available_memory_windows() {
    MEMORYSTATUSEX statex;
    statex.dwLength = sizeof(statex);
    
    if (GlobalMemoryStatusEx(&statex)) {
        return statex.ullAvailPhys;
    }
    return -1;
}

double get_memory_usage_percent_windows() {
    MEMORYSTATUSEX statex;
    statex.dwLength = sizeof(statex);
    
    if (GlobalMemoryStatusEx(&statex)) {
        return statex.dwMemoryLoad;  // Процент использования (0-100)
    }
    return -1;
}
#endif

macOS: sysctl

#ifdef __APPLE__
#include <sys/sysctl.h>
#include <mach/mach.h>

long long get_total_memory_macos() {
    int mib[2] = {CTL_HW, HW_MEMSIZE};
    long long size;
    size_t len = sizeof(size);
    
    if (sysctl(mib, 2, &size, &len, nullptr, 0) == 0) {
        return size;
    }
    return -1;
}

long long get_free_memory_macos() {
    vm_statistics64_data_t stats;
    mach_msg_type_number_t count = HOST_VM_INFO64_COUNT;
    
    if (host_statistics64(mach_host_self(), HOST_VM_INFO64, 
                         (host_info64_t)&stats, &count) == KERN_SUCCESS) {
        return stats.free_count * PAGE_SIZE;
    }
    return -1;
}
#endif

Кроссплатформенное решение (C++17)

#include <iostream>
#include <iomanip>

class MemoryInfo {
public:
    static long long get_total_memory() {
#ifdef _WIN32
        return get_total_memory_windows();
#elif __APPLE__
        return get_total_memory_macos();
#else
        return get_total_memory_posix();
#endif
    }
    
    static long long get_available_memory() {
#ifdef _WIN32
        return get_available_memory_windows();
#elif __APPLE__
        return get_free_memory_macos();
#else
        return get_available_memory_posix();
#endif
    }
    
    static double get_memory_usage_percent() {
        long long total = get_total_memory();
        long long available = get_available_memory();
        return ((double)(total - available) / total) * 100.0;
    }
};

int main() {
    long long total = MemoryInfo::get_total_memory();
    long long available = MemoryInfo::get_available_memory();
    double usage_percent = MemoryInfo::get_memory_usage_percent();
    
    std::cout << "Total RAM: " << (total / 1024 / 1024 / 1024) << " GB" << std::endl;
    std::cout << "Available: " << (available / 1024 / 1024 / 1024) << " GB" << std::endl;
    std::cout << "Usage: " << std::fixed << std::setprecision(2) 
              << usage_percent << "%" << std::endl;
}

Проверка памяти процесса

#include <fstream>

long long get_process_memory_usage() {
    std::ifstream status("/proc/self/status");
    std::string line;
    
    while (std::getline(status, line)) {
        if (line.find("VmRSS:") == 0) {
            std::istringstream iss(line);
            std::string label;
            long long memory_kb;
            iss >> label >> memory_kb;
            return memory_kb * 1024;
        }
    }
    return -1;
}

// Linux способ через /proc/self/stat
unsigned long get_process_resident_memory() {
    std::ifstream stat("/proc/self/stat");
    unsigned long rss = 0;
    
    for (int i = 0; i < 23; ++i) {
        stat >> rss;
    }
    
    return rss * 4096;  // sysconf(_SC_PAGE_SIZE)
}

Практический пример с обработкой ошибок

#include <iostream>
#include <string>

void print_memory_info() {
    long long total = MemoryInfo::get_total_memory();
    long long available = MemoryInfo::get_available_memory();
    
    if (total == -1 || available == -1) {
        std::cerr << "Error: Unable to get memory information" << std::endl;
        return;
    }
    
    long long used = total - available;
    double percent = (double)used / total * 100.0;
    
    std::cout << "System Memory Status:" << std::endl;
    std::cout << "  Total: " << (total / 1024 / 1024) << " MB" << std::endl;
    std::cout << "  Used: " << (used / 1024 / 1024) << " MB" << std::endl;
    std::cout << "  Available: " << (available / 1024 / 1024) << " MB" << std::endl;
    std::cout << "  Usage: " << std::fixed << std::setprecision(1) 
              << percent << "%" << std::endl;
}

Вывод: Способ получения информации о памяти зависит от платформы, поэтому рекомендуется использовать кроссплатформенное решение с условной компиляцией или готовые библиотеки вроде Boost.System.