如何在不依赖外部库仅用MinGW/GCC头文件的C/C++中绘制图形、渲染像素？

Absolutely you can! You don’t need any third-party libraries—you just leverage the system-level APIs that MinGW/GCC already has access to via its standard headers. Let’s break this down for the two most common platforms you’d use MinGW/GCC on: Windows and Linux.

Windows (MinGW) #

On Windows, MinGW includes the windows.h header out of the box, which gives you full access to the Win32 API. This is the native way to create windows and draw graphics, and it’s completely self-contained with MinGW.

How it works #

• Register a window class: This tells Windows how to handle your window (like its event procedure, default background, etc.).
• Create a window: Spawns the visible window on your desktop.
• Get a Device Context (HDC): Think of this as your drawing canvas—you use it to call all rendering functions.
• Draw pixels: Use the SetPixel() function to render individual pixels directly, or build up more complex shapes using higher-level Win32 GDI functions.

Minimal Example Code #

#include <windows.h>

// Window procedure handles system events (like paint requests or closing the window)
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
        case WM_PAINT: {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hwnd, &ps);
            
            // Draw a gradient grid of pixels
            for (int y = 0; y < 200; y++) {
                for (int x = 0; x < 200; x++) {
                    // Generate a color based on pixel position
                    COLORREF color = RGB(x % 256, y % 256, (x + y) % 256);
                    SetPixel(hdc, x + 50, y + 50, color);
                }
            }
            
            EndPaint(hwnd, &ps);
            return 0;
        }
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
        default:
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    const wchar_t CLASS_NAME[] = L"MinGW Pixel Draw Class";
    
    // Register our window class with Windows
    WNDCLASS wc = {0};
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = CLASS_NAME;
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    
    RegisterClass(&wc);
    
    // Create the actual window
    HWND hwnd = CreateWindowEx(
        0,
        CLASS_NAME,
        L"MinGW Pixel Renderer",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 300, 300,
        NULL, NULL, hInstance, NULL
    );
    
    if (hwnd == NULL) return 0;
    
    ShowWindow(hwnd, nCmdShow);
    
    // Main message loop to keep the window running
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    
    return msg.wParam;
}

Compile this with MinGW using:

g++ yourfile.cpp -o pixelrenderer.exe -luser32 -lgdi32

The -luser32 and -lgdi32 flags link against Windows system libraries (pre-installed with your OS, not external libraries you have to download).

Linux (GCC) #

On Linux, you can directly access the framebuffer—a low-level interface that lets you write pixel data directly to the screen. No external libraries needed; just standard C headers that come with GCC.

How it works #

• Open the framebuffer device: Typically located at /dev/fb0.
• Fetch screen info: Use ioctl() to get details like resolution, bit depth, and buffer size.
• Map the framebuffer to memory: Use mmap() to make the framebuffer accessible as a regular memory buffer.
• Write pixel data: Calculate each pixel’s position in the buffer and set its color value directly.

Minimal Example Code #

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/fb.h>

int main() {
    int fbfd = open("/dev/fb0", O_RDWR);
    if (fbfd == -1) {
        perror("Error opening framebuffer");
        return 1;
    }
    
    struct fb_var_screeninfo vinfo;
    if (ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo)) {
        perror("Error getting screen info");
        close(fbfd);
        return 1;
    }
    
    // Calculate total size of the framebuffer in bytes
    long int screensize = vinfo.xres * vinfo.yres * vinfo.bits_per_pixel / 8;
    
    // Map framebuffer to our process's memory space
    char *fbp = (char*)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED, fbfd, 0);
    if (fbp == MAP_FAILED) {
        perror("Error mapping framebuffer");
        close(fbfd);
        return 1;
    }
    
    // Draw a red square in the center of the screen
    int x0 = vinfo.xres / 2 - 100;
    int y0 = vinfo.yres / 2 - 100;
    for (int y = y0; y < y0 + 200; y++) {
        for (int x = x0; x < x0 + 200; x++) {
            // Calculate the pixel's position in the buffer
            long int location = (x + vinfo.xoffset) * (vinfo.bits_per_pixel / 8) +
                                (y + vinfo.yoffset) * vinfo.line_length;
            
            // Set pixel to red (this works for 32-bit color; adjust for other depths)
            if (vinfo.bits_per_pixel == 32) {
                *(unsigned int*)(fbp + location) = 0xFF0000; // RGB: Red=255, Green=0, Blue=0
            }
        }
    }
    
    // Cleanup resources
    munmap(fbp, screensize);
    close(fbfd);
    return 0;
}

Compile this with GCC using:

gcc yourfile.c -o pixelrenderer

Note: You’ll need to run this as root (or with appropriate file permissions) to access /dev/fb0.

Key Notes #

• Both methods use system-provided interfaces—no external libraries like SDL or OpenGL are required.
• MinGW/GCC includes all necessary headers (windows.h on Windows, standard POSIX headers on Linux) by default.
• You can build on these basics to draw lines, shapes, or even load raw image data directly into the buffer/device context.

内容的提问来源于stack exchange，提问作者goodlifetobesavecompenthusiast