启动《Minecraft》 · 系统调用库

程序不是孤岛。它需要与操作系统交互——读写文件、创建进程、网络通信、获取系统信息。C++ 标准库提供了一部分系统功能，但很多时候我们需要直接使用操作系统的 API。

让我们来看看如何用 C++ 与操作系统打交道——甚至，启动《Minecraft》。

---

C++17 文件系统库

在 C++17 之前，文件系统操作需要依赖平台特定的 API。现在我们有了标准的 <filesystem> 库：

#include <iostream>
#include <filesystem>

namespace fs = std::filesystem;

int main()
{
    // 当前路径
    std::cout << "Current path: " << fs::current_path() << std::endl;
    
    // 遍历目录
    for (const auto& entry : fs::directory_iterator("."))
    {
        std::cout << entry.path() << std::endl;
    }
    
    // 递归遍历
    for (const auto& entry : fs::recursive_directory_iterator("."))
    {
        if (entry.is_regular_file())
        {
            std::cout << entry.path() << " - " 
                      << entry.file_size() << " bytes" << std::endl;
        }
    }
    
    return 0;
}

文件操作

#include <filesystem>

namespace fs = std::filesystem;

void file_operations()
{
    // 创建目录
    fs::create_directory("new_folder");
    fs::create_directories("a/b/c");  // 递归创建
    
    // 复制文件
    fs::copy("source.txt", "dest.txt");
    fs::copy("source_dir", "dest_dir", fs::copy_options::recursive);
    
    // 移动/重命名
    fs::rename("old_name.txt", "new_name.txt");
    
    // 删除
    fs::remove("file.txt");
    fs::remove_all("directory");  // 递归删除
    
    // 检查存在性
    if (fs::exists("file.txt"))
    {
        std::cout << "File exists!" << std::endl;
    }
    
    // 文件信息
    auto size = fs::file_size("file.txt");
    auto time = fs::last_write_time("file.txt");
    
    // 路径操作
    fs::path p = "/home/user/documents/report.pdf";
    std::cout << "Filename: " << p.filename() << std::endl;
    std::cout << "Extension: " << p.extension() << std::endl;
    std::cout << "Parent: " << p.parent_path() << std::endl;
    std::cout << "Stem: " << p.stem() << std::endl;
}

---

进程管理

C++ 标准库没有进程管理功能，需要使用平台 API。

Windows 进程

#include <iostream>
#include <string>

#ifdef _WIN32
#include <windows.h>

bool launchProcess(const std::string& program, const std::string& args = "")
{
    STARTUPINFOA si = { sizeof(si) };
    PROCESS_INFORMATION pi;
    
    std::string cmdLine = program + " " + args;
    
    if (CreateProcessA(
        nullptr,                    // 应用程序名
        const_cast<char*>(cmdLine.c_str()),  // 命令行
        nullptr,                    // 进程安全属性
        nullptr,                    // 线程安全属性
        FALSE,                      // 继承句柄
        0,                          // 创建标志
        nullptr,                    // 环境变量
        nullptr,                    // 当前目录
        &si,                        // 启动信息
        &pi))                       // 进程信息
    {
        std::cout << "Process started, PID: " << pi.dwProcessId << std::endl;
        
        // 等待进程结束
        WaitForSingleObject(pi.hProcess, INFINITE);
        
        DWORD exitCode;
        GetExitCodeProcess(pi.hProcess, &exitCode);
        std::cout << "Exit code: " << exitCode << std::endl;
        
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
        
        return true;
    }
    
    return false;
}

// 启动 Minecraft！
void launchMinecraft()
{
    // Java 版
    launchProcess("javaw.exe", 
        "-Xmx2G -Xms1G -jar minecraft_launcher.jar");
    
    // 或者启动器
    launchProcess("C:\\Program Files\\Minecraft\\MinecraftLauncher.exe");
}

#endif

Linux/macOS 进程

#ifndef _WIN32
#include <unistd.h>
#include <sys/wait.h>
#include <cstring>

bool launchProcess(const char* program, char* const argv[])
{
    pid_t pid = fork();
    
    if (pid == 0)
    {
        // 子进程
        execvp(program, argv);
        // 如果 execvp 返回，说明出错了
        perror("execvp failed");
        _exit(1);
    }
    else if (pid > 0)
    {
        // 父进程
        std::cout << "Process started, PID: " << pid << std::endl;
        
        int status;
        waitpid(pid, &status, 0);
        
        if (WIFEXITED(status))
        {
            std::cout << "Exit code: " << WEXITSTATUS(status) << std::endl;
        }
        
        return true;
    }
    
    return false;
}

void launchMinecraft()
{
    char* args[] = {
        (char*)"java",
        (char*)"-Xmx2G",
        (char*)"-Xms1G",
        (char*)"-jar",
        (char*)"minecraft_launcher.jar",
        nullptr
    };
    launchProcess("java", args);
}

#endif

---

管道通信

与子进程进行通信：

#include <iostream>
#include <array>
#include <memory>
#include <string>

#ifdef _WIN32
#include <windows.h>

std::string executeCommand(const std::string& cmd)
{
    SECURITY_ATTRIBUTES sa = { sizeof(sa), nullptr, TRUE };
    HANDLE hRead, hWrite;
    
    CreatePipe(&hRead, &hWrite, &sa, 0);
    SetHandleInformation(hRead, HANDLE_FLAG_INHERIT, 0);
    
    STARTUPINFOA si = { sizeof(si) };
    si.dwFlags = STARTF_USESTDHANDLES;
    si.hStdOutput = hWrite;
    si.hStdError = hWrite;
    
    PROCESS_INFORMATION pi;
    
    std::string cmdLine = "cmd /c " + cmd;
    
    if (CreateProcessA(nullptr, const_cast<char*>(cmdLine.c_str()),
        nullptr, nullptr, TRUE, 0, nullptr, nullptr, &si, &pi))
    {
        CloseHandle(hWrite);
        
        std::string result;
        char buffer[4096];
        DWORD bytesRead;
        
        while (ReadFile(hRead, buffer, sizeof(buffer), &bytesRead, nullptr) && bytesRead > 0)
        {
            result.append(buffer, bytesRead);
        }
        
        WaitForSingleObject(pi.hProcess, INFINITE);
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
        CloseHandle(hRead);
        
        return result;
    }
    
    CloseHandle(hRead);
    CloseHandle(hWrite);
    return "";
}

#else

std::string executeCommand(const std::string& cmd)
{
    std::array<char, 128> buffer;
    std::string result;
    
    std::unique_ptr<FILE, decltype(&pclose)> pipe(
        popen(cmd.c_str(), "r"), pclose);
    
    if (!pipe)
        return "";
    
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr)
    {
        result += buffer.data();
    }
    
    return result;
}

#endif

int main()
{
    // 获取系统信息
#ifdef _WIN32
    std::cout << executeCommand("systeminfo") << std::endl;
#else
    std::cout << executeCommand("uname -a") << std::endl;
#endif
    
    return 0;
}

---

动态库加载

运行时加载共享库/DLL：

#include <iostream>

#ifdef _WIN32
#include <windows.h>

void loadDynamicLibrary()
{
    HMODULE hLib = LoadLibraryA("mylib.dll");
    
    if (hLib)
    {
        // 获取函数指针
        using FuncType = int(*)(int, int);
        FuncType myFunc = (FuncType)GetProcAddress(hLib, "my_function");
        
        if (myFunc)
        {
            int result = myFunc(10, 20);
            std::cout << "Result: " << result << std::endl;
        }
        
        FreeLibrary(hLib);
    }
}

#else
#include <dlfcn.h>

void loadDynamicLibrary()
{
    void* handle = dlopen("./libmylib.so", RTLD_LAZY);
    
    if (handle)
    {
        using FuncType = int(*)(int, int);
        FuncType myFunc = (FuncType)dlsym(handle, "my_function");
        
        if (myFunc)
        {
            int result = myFunc(10, 20);
            std::cout << "Result: " << result << std::endl;
        }
        
        dlclose(handle);
    }
    else
    {
        std::cerr << "Error: " << dlerror() << std::endl;
    }
}

#endif

---

环境变量

#include <iostream>
#include <cstdlib>

void environmentVariables()
{
    // 读取环境变量
    const char* path = std::getenv("PATH");
    if (path)
    {
        std::cout << "PATH: " << path << std::endl;
    }
    
    // 设置环境变量（C++标准没有，需要平台API）
#ifdef _WIN32
    _putenv("MY_VAR=my_value");
#else
    setenv("MY_VAR", "my_value", 1);
#endif
    
    // 验证
    std::cout << "MY_VAR: " << std::getenv("MY_VAR") << std::endl;
}

---

系统信息

#include <iostream>
#include <thread>

#ifdef _WIN32
#include <windows.h>

void getSystemInfo()
{
    SYSTEM_INFO si;
    GetSystemInfo(&si);
    
    std::cout << "Processor count: " << si.dwNumberOfProcessors << std::endl;
    std::cout << "Page size: " << si.dwPageSize << std::endl;
    
    MEMORYSTATUSEX mem = { sizeof(mem) };
    GlobalMemoryStatusEx(&mem);
    
    std::cout << "Total RAM: " << mem.ullTotalPhys / (1024 * 1024) << " MB" << std::endl;
    std::cout << "Available RAM: " << mem.ullAvailPhys / (1024 * 1024) << " MB" << std::endl;
    
    // 获取计算机名
    char computerName[MAX_COMPUTERNAME_LENGTH + 1];
    DWORD size = sizeof(computerName);
    GetComputerNameA(computerName, &size);
    std::cout << "Computer name: " << computerName << std::endl;
}

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

void getSystemInfo()
{
    // CPU 核心数
    std::cout << "Processor count: " << std::thread::hardware_concurrency() << std::endl;
    
    // 页面大小
    std::cout << "Page size: " << sysconf(_SC_PAGESIZE) << std::endl;
    
    // 内存信息
    struct sysinfo si;
    sysinfo(&si);
    
    std::cout << "Total RAM: " << si.totalram / (1024 * 1024) << " MB" << std::endl;
    std::cout << "Free RAM: " << si.freeram / (1024 * 1024) << " MB" << std::endl;
    
    // 主机名
    char hostname[256];
    gethostname(hostname, sizeof(hostname));
    std::cout << "Hostname: " << hostname << std::endl;
}

#endif

int main()
{
    // 标准方式获取核心数
    std::cout << "Hardware concurrency: " 
              << std::thread::hardware_concurrency() << std::endl;
    
    getSystemInfo();
    return 0;
}

---

网络编程基础

#include <iostream>
#include <string>
#include <cstring>

#ifdef _WIN32
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #pragma comment(lib, "ws2_32.lib")
    
    struct WSAInitializer
    {
        WSAInitializer() { WSADATA d; WSAStartup(MAKEWORD(2, 2), &d); }
        ~WSAInitializer() { WSACleanup(); }
    };
#else
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <netdb.h>
    #include <unistd.h>
    
    #define SOCKET int
    #define INVALID_SOCKET -1
    #define closesocket close
#endif

// 简单的 HTTP GET 请求
std::string httpGet(const std::string& host, const std::string& path)
{
#ifdef _WIN32
    WSAInitializer wsaInit;
#endif
    
    // 解析主机名
    struct addrinfo hints = {}, *result;
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    
    if (getaddrinfo(host.c_str(), "80", &hints, &result) != 0)
        return "";
    
    // 创建套接字
    SOCKET sock = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
    if (sock == INVALID_SOCKET)
    {
        freeaddrinfo(result);
        return "";
    }
    
    // 连接
    if (connect(sock, result->ai_addr, (int)result->ai_addrlen) != 0)
    {
        closesocket(sock);
        freeaddrinfo(result);
        return "";
    }
    
    freeaddrinfo(result);
    
    // 发送 HTTP 请求
    std::string request = "GET " + path + " HTTP/1.1\r\n"
                         "Host: " + host + "\r\n"
                         "Connection: close\r\n\r\n";
    
    send(sock, request.c_str(), (int)request.length(), 0);
    
    // 接收响应
    std::string response;
    char buffer[4096];
    int bytesReceived;
    
    while ((bytesReceived = recv(sock, buffer, sizeof(buffer) - 1, 0)) > 0)
    {
        buffer[bytesReceived] = '\0';
        response += buffer;
    }
    
    closesocket(sock);
    return response;
}

int main()
{
    std::string response = httpGet("example.com", "/");
    std::cout << response.substr(0, 500) << "..." << std::endl;
    return 0;
}

---

完整示例：启动 Minecraft

把前面的知识综合起来：

#include <iostream>
#include <filesystem>
#include <string>

#ifdef _WIN32
#include <windows.h>
#endif

namespace fs = std::filesystem;

class MinecraftLauncher
{
private:
    fs::path minecraftPath;
    fs::path javaPath;
    
public:
    MinecraftLauncher()
    {
        findMinecraft();
        findJava();
    }
    
    void findMinecraft()
    {
#ifdef _WIN32
        // 检查常见安装位置
        std::vector<fs::path> possiblePaths = {
            fs::path(std::getenv("APPDATA")) / ".minecraft",
            "C:/Program Files/Minecraft Launcher/MinecraftLauncher.exe",
            "C:/Program Files (x86)/Minecraft Launcher/MinecraftLauncher.exe"
        };
#else
        std::vector<fs::path> possiblePaths = {
            fs::path(std::getenv("HOME")) / ".minecraft",
            "/opt/minecraft"
        };
#endif
        
        for (const auto& path : possiblePaths)
        {
            if (fs::exists(path))
            {
                minecraftPath = path;
                std::cout << "Found Minecraft at: " << path << std::endl;
                return;
            }
        }
        
        std::cout << "Minecraft not found!" << std::endl;
    }
    
    void findJava()
    {
#ifdef _WIN32
        // 检查 JAVA_HOME
        const char* javaHome = std::getenv("JAVA_HOME");
        if (javaHome)
        {
            javaPath = fs::path(javaHome) / "bin" / "javaw.exe";
            if (fs::exists(javaPath))
            {
                std::cout << "Found Java at: " << javaPath << std::endl;
                return;
            }
        }
        
        // 检查 PATH 中的 java
        javaPath = "javaw.exe";
#else
        javaPath = "java";
#endif
    }
    
    void launch()
    {
        if (minecraftPath.empty())
        {
            std::cerr << "Cannot launch: Minecraft not found!" << std::endl;
            return;
        }
        
#ifdef _WIN32
        STARTUPINFOW si = { sizeof(si) };
        PROCESS_INFORMATION pi;
        
        std::wstring cmdLine = L"\"" + minecraftPath.wstring() + L"\"";
        
        if (CreateProcessW(
            nullptr,
            const_cast<wchar_t*>(cmdLine.c_str()),
            nullptr, nullptr, FALSE,
            0, nullptr, nullptr,
            &si, &pi))
        {
            std::cout << "Minecraft launched! PID: " << pi.dwProcessId << std::endl;
            CloseHandle(pi.hProcess);
            CloseHandle(pi.hThread);
        }
        else
        {
            std::cerr << "Failed to launch Minecraft!" << std::endl;
        }
#else
        std::string cmd = minecraftPath.string() + " &";
        system(cmd.c_str());
        std::cout << "Minecraft launched!" << std::endl;
#endif
    }
    
    void listSaves()
    {
        fs::path savesPath = minecraftPath / "saves";
        
        if (!fs::exists(savesPath))
        {
            std::cout << "No saves folder found!" << std::endl;
            return;
        }
        
        std::cout << "\nYour Minecraft worlds:" << std::endl;
        std::cout << "------------------------" << std::endl;
        
        for (const auto& entry : fs::directory_iterator(savesPath))
        {
            if (entry.is_directory())
            {
                auto levelDat = entry.path() / "level.dat";
                if (fs::exists(levelDat))
                {
                    auto size = 0ull;
                    for (const auto& f : fs::recursive_directory_iterator(entry))
                    {
                        if (f.is_regular_file())
                            size += f.file_size();
                    }
                    
                    std::cout << "- " << entry.path().filename().string()
                              << " (" << size / (1024 * 1024) << " MB)" << std::endl;
                }
            }
        }
    }
};

int main()
{
    MinecraftLauncher launcher;
    
    std::cout << "\nOptions:" << std::endl;
    std::cout << "1. Launch Minecraft" << std::endl;
    std::cout << "2. List saves" << std::endl;
    std::cout << "Choice: ";
    
    int choice;
    std::cin >> choice;
    
    switch (choice)
    {
        case 1:
            launcher.launch();
            break;
        case 2:
            launcher.listSaves();
            break;
        default:
            std::cout << "Invalid choice!" << std::endl;
    }
    
    return 0;
}

---

总结

功能	标准库	平台 API
文件系统	<filesystem> (C++17)	Win32/POSIX
进程管理	无	CreateProcess/fork
动态库	无	LoadLibrary/dlopen
网络	无	WinSock/BSD Socket
环境变量	getenv	_putenv/setenv
系统信息	thread::hardware_concurrency	平台 API

C++ 给了我们接触系统底层的能力。善用这种能力，你可以写出真正强大的应用程序——哪怕只是为了启动《Minecraft》！