xlock.c: x11 lock system

原创 于 2025-09-07 23:36:57 发布 · 517 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #java #算法

xlock.c


#include <X11/Xlib.h>
#include <X11/Xft/Xft.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>
#include <security/pam_appl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <unistd.h>
#include <sys/mman.h>
#include <time.h>
#include <math.h>

// ================================================================================
// Configuration (adjust these as needed)
// ================================================================================
#define FONT_SIZE 28
#define HINT_FONT_SIZE 20
#define FONT_NAME "DejaVu Sans Mono"
#define MAX_PASSWORD_LEN 512
#define MAX_FAILED_ATTEMPTS 5
#define TARGET_FPS 60
#define FRAME_TIME_US (1000000 / TARGET_FPS)

// Colors (hex RGB)
#define COLOR_BG 0x000000        // Black background (fullscreen)
#define COLOR_INPUT_BG 0x282828  // Dark gray input box
#define COLOR_TEXT 0xFFFFFF      // White text
#define COLOR_PROMPT 0xFFCC00    // Amber prompt text
#define COLOR_ERROR 0xFF0000     // Red error text
#define COLOR_SUCCESS 0x00FF00   // Green success text
#define COLOR_SEPARATOR 0x505050 // Gray separator
#define COLOR_HINT 0x8A8A8A      // Light gray hints

// ================================================================================
// Global State
// ================================================================================
char password[MAX_PASSWORD_LEN] = {0};
size_t cursor = 0;
int input_len = 0;
int failed_attempts = 0;
bool is_locked = true;
bool show_help = false;
bool redraw_needed = true;

// X11 Resources
Display *dpy;
Window win;
GC gc;
Visual *vis;
Colormap cmap;
Pixmap backbuffer;
XftFont *main_font;
XftFont *hint_font;
int screen;
int screen_width, screen_height;

// Xft Colors
XftColor color_bg;
XftColor color_input_bg;
XftColor color_text;
XftColor color_prompt;
XftColor color_error;
XftColor color_success;
XftColor color_separator;
XftColor color_hint;

// ================================================================================
// PAM Authentication (unchanged)
// ================================================================================
static int pam_conv_callback(int num_msg, const struct pam_message **msg,
                             struct pam_response **resp, void *appdata_ptr)
{
    (void)appdata_ptr;
    *resp = calloc(num_msg, sizeof(struct pam_response));
    if (!*resp)
        return PAM_BUF_ERR;

    for (int i = 0; i < num_msg; i++)
    {
        if (msg[i]->msg_style == PAM_PROMPT_ECHO_OFF)
        {
            resp[i]->resp = strdup(password);
            resp[i]->resp_retcode = 0;
        }
    }
    return PAM_SUCCESS;
}

static bool verify_password()
{
    if (input_len == 0)
        return false;

    struct pam_conv conv = {pam_conv_callback, NULL};
    pam_handle_t *pam_handle = NULL;
    const char *username = getlogin();
    int ret = pam_start("login", username, &conv, &pam_handle);

    if (ret != PAM_SUCCESS)
    {
        fprintf(stderr, "PAM init failed: %s\n", pam_strerror(pam_handle, ret));
        pam_end(pam_handle, ret);
        return false;
    }

    ret = pam_authenticate(pam_handle, 0);
    pam_end(pam_handle, ret);

    if (ret == PAM_SUCCESS)
        return true;
    failed_attempts++;
    return false;
}

static void clear_password()
{
    memset(password, 0, sizeof(password));
    input_len = 0;
    cursor = 0;
    redraw_needed = true;
}

// ================================================================================
// X11 Initialization & Resources (MODIFIED FOR FULLSCREEN)
// ================================================================================
static bool init_colors()
{
    if (!XftColorAllocName(dpy, vis, cmap, "#000000", &color_bg))
        return false;
    if (!XftColorAllocName(dpy, vis, cmap, "#282828", &color_input_bg))
        return false;
    if (!XftColorAllocName(dpy, vis, cmap, "#FFFFFF", &color_text))
        return false;
    if (!XftColorAllocName(dpy, vis, cmap, "#FFCC00", &color_prompt))
        return false;
    if (!XftColorAllocName(dpy, vis, cmap, "#FF0000", &color_error))
        return false;
    if (!XftColorAllocName(dpy, vis, cmap, "#00FF00", &color_success))
        return false;
    if (!XftColorAllocName(dpy, vis, cmap, "#505050", &color_separator))
        return false;
    if (!XftColorAllocName(dpy, vis, cmap, "#8A8A8A", &color_hint))
        return false;
    return true;
}

static bool init_fonts()
{
    char main_font_str[256];
    snprintf(main_font_str, sizeof(main_font_str), "%s:pixelsize=%d", FONT_NAME, FONT_SIZE);
    main_font = XftFontOpenName(dpy, screen, main_font_str);
    if (!main_font)
    {
        fprintf(stderr, "Failed to load main font: %s\n", main_font_str);
        return false;
    }

    char hint_font_str[256];
    snprintf(hint_font_str, sizeof(hint_font_str), "%s:pixelsize=%d", FONT_NAME, HINT_FONT_SIZE);
    hint_font = XftFontOpenName(dpy, screen, hint_font_str);
    if (!hint_font)
    {
        fprintf(stderr, "Failed to load hint font: %s\n", hint_font_str);
        XftFontClose(dpy, main_font);
        return false;
    }
    return true;
}

// Helper to grab keyboard/mouse exclusively (blocks i3wm shortcuts)
static bool grab_input()
{
    // Grab keyboard (blocks all key events from reaching other windows)
    if (XGrabKeyboard(dpy, win, False, GrabModeAsync, GrabModeAsync, CurrentTime) != GrabSuccess)
    {
        fprintf(stderr, "Failed to grab keyboard (retrying...)\n");
        usleep(100000); // Retry after 100ms
        if (XGrabKeyboard(dpy, win, False, GrabModeAsync, GrabModeAsync, CurrentTime) != GrabSuccess)
        {
            fprintf(stderr, "Fatal: Could not grab keyboard\n");
            return false;
        }
    }

    // Grab mouse (blocks all mouse events)
    if (XGrabPointer(dpy, win, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
                     GrabModeAsync, GrabModeAsync, None, None, CurrentTime) != GrabSuccess)
    {
        fprintf(stderr, "Failed to grab pointer (retrying...)\n");
        usleep(100000);
        if (XGrabPointer(dpy, win, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
                         GrabModeAsync, GrabModeAsync, None, None, CurrentTime) != GrabSuccess)
        {
            fprintf(stderr, "Fatal: Could not grab pointer\n");
            XUngrabKeyboard(dpy, CurrentTime); // Cleanup
            return false;
        }
    }

    return true;
}

static bool init_x11()
{
    dpy = XOpenDisplay(NULL);
    if (!dpy)
    {
        fprintf(stderr, "Failed to open X display\n");
        return false;
    }

    screen = DefaultScreen(dpy);
    vis = DefaultVisual(dpy, screen);
    cmap = DefaultColormap(dpy, screen);
    screen_width = DisplayWidth(dpy, screen);   // Full screen width
    screen_height = DisplayHeight(dpy, screen); // Full screen height

    XSetWindowAttributes attr;
    attr.override_redirect = True; // Bypass window manager entirely
    attr.background_pixel = color_bg.pixel;
    attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask | PointerMotionMask;

    // Create FULLSCREEN window (covers entire screen)
    win = XCreateWindow(
        dpy, DefaultRootWindow(dpy),
        0, 0,                        // Top-left corner (covers entire screen)
        screen_width, screen_height, // Full screen dimensions
        0, DefaultDepth(dpy, screen),
        InputOutput, vis,
        CWOverrideRedirect | CWBackPixel | CWEventMask, &attr);

    // Set as fullscreen window (hints to window managers)
    Atom net_wm_state = XInternAtom(dpy, "_NET_WM_STATE", False);
    Atom net_wm_state_fullscreen = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);
    XChangeProperty(
        dpy, win, net_wm_state, XA_ATOM, 32,
        PropModeReplace, (unsigned char *)&net_wm_state_fullscreen, 1);

    // Create backbuffer for smooth rendering
    backbuffer = XCreatePixmap(dpy, win, screen_width, screen_height, DefaultDepth(dpy, screen));
    gc = XCreateGC(dpy, backbuffer, 0, NULL);
    if (!gc)
    {
        fprintf(stderr, "Failed to create GC\n");
        return false;
    }

    if (!init_colors() || !init_fonts())
        return false;

    XMapWindow(dpy, win);
    XSetInputFocus(dpy, win, RevertToParent, CurrentTime);
    XFlush(dpy);

    // Grab exclusive input (blocks i3wm shortcuts)
    if (!grab_input())
        return false;

    return true;
}

// ================================================================================
// Rendering Helpers (MODIFIED FOR FULLSCREEN LAYOUT)
// ================================================================================
static int text_width(const char *str, XftFont *font)
{
    if (!str || !*str)
        return 0;
    XGlyphInfo info;
    XftTextExtentsUtf8(dpy, font, (const FcChar8 *)str, strlen(str), &info);
    return info.width;
}

static void draw_rect(int x, int y, int w, int h, XftColor *color)
{
    XSetForeground(dpy, gc, color->pixel);
    XFillRectangle(dpy, backbuffer, gc, x, y, w, h);
}

static void draw_text(int x, int y, const char *str, XftColor *color, XftFont *font)
{
    if (!str || !*str)
        return;
    y += font->ascent; // Adjust for font ascent
    XftDraw *draw = XftDrawCreate(dpy, backbuffer, vis, cmap);
    XftDrawStringUtf8(draw, color, font, x, y, (const FcChar8 *)str, strlen(str));
    XftDrawDestroy(draw);
}

static void draw_cursor(int x, int y)
{
    y += main_font->ascent;
    draw_rect(x, y - main_font->height, 2, main_font->height, &color_text);
}

// ================================================================================
// Event Handling (unchanged)
// ================================================================================
static void handle_key_press(XKeyEvent *ev)
{
    if (!is_locked)
        return;

    KeySym keysym = XKeycodeToKeysym(dpy, ev->keycode, 0);
    char buf[32];
    int len = XLookupString(ev, buf, sizeof(buf), &keysym, NULL);
    bool ctrl_pressed = (ev->state & ControlMask) != 0;
    bool mod_pressed = (ev->state & Mod4Mask) != 0; // Block i3's mod key (usually Mod4)

    // Block all mod key combinations (critical for i3wm)
    if (mod_pressed)
        return;

    // Ctrl shortcuts
    if (ctrl_pressed)
    {
        switch (keysym)
        {
        case XK_a:
            cursor = 0;
            redraw_needed = true;
            return;
        case XK_e:
            cursor = input_len;
            redraw_needed = true;
            return;
        case XK_f:
            if (cursor < input_len)
            {
                cursor++;
                redraw_needed = true;
            }
            return;
        case XK_b:
            if (cursor > 0)
            {
                cursor--;
                redraw_needed = true;
            }
            return;
        case XK_d:
            if (cursor < input_len)
            {
                memmove(&password[cursor], &password[cursor + 1], MAX_PASSWORD_LEN - cursor - 1);
                input_len--;
                redraw_needed = true;
            }
            return;
        case XK_k:
            password[cursor] = '\0';
            input_len = cursor;
            redraw_needed = true;
            return;
        }
    }

    // Regular keys
    switch (keysym)
    {
    case XK_Escape:
        clear_password();
        return;
    case XK_Return:
    case XK_KP_Enter:
        if (verify_password())
            is_locked = false;
        else
            clear_password();
        redraw_needed = true;
        return;
    case XK_BackSpace:
        if (cursor > 0)
        {
            cursor--;
            memmove(&password[cursor], &password[cursor + 1], MAX_PASSWORD_LEN - cursor - 1);
            input_len--;
            redraw_needed = true;
        }
        return;
    case XK_Delete:
        if (cursor < input_len)
        {
            memmove(&password[cursor], &password[cursor + 1], MAX_PASSWORD_LEN - cursor - 1);
            input_len--;
            redraw_needed = true;
        }
        return;
    case XK_Right:
        if (cursor < input_len)
        {
            cursor++;
            redraw_needed = true;
        }
        return;
    case XK_Left:
        if (cursor > 0)
        {
            cursor--;
            redraw_needed = true;
        }
        return;
    case XK_Home:
        cursor = 0;
        redraw_needed = true;
        return;
    case XK_End:
        cursor = input_len;
        redraw_needed = true;
        return;
    case XK_F1:
        show_help = !show_help;
        redraw_needed = true;
        return;
    default:
        if (len > 0 && buf[0] >= 32 && buf[0] <= 126 && input_len < MAX_PASSWORD_LEN - 1)
        {
            memmove(&password[cursor + 1], &password[cursor], MAX_PASSWORD_LEN - cursor - 1);
            password[cursor++] = buf[0];
            input_len++;
            redraw_needed = true;
        }
    }
}

static void handle_events()
{
    XEvent ev;
    while (XPending(dpy) > 0 && is_locked)
    {
        XNextEvent(dpy, &ev);
        switch (ev.type)
        {
        case Expose:
            redraw_needed = true;
            break;
        case KeyPress:
            handle_key_press(&ev.xkey);
            break;
        case ButtonPress:
        case MotionNotify:
            redraw_needed = true;
            break; // Refresh on mouse movement
        }
    }
}

// ================================================================================
// Main Rendering (CENTERED UI IN FULLSCREEN)
// ================================================================================
static void render()
{
    if (!redraw_needed)
        return;

    // Clear fullscreen background
    draw_rect(0, 0, screen_width, screen_height, &color_bg);

    // Calculate centered UI dimensions
    const int popup_width = 800; // Keep input UI at a reasonable size
    const int popup_height = 300;
    const int popup_x = (screen_width - popup_width) / 2;   // Center horizontally
    const int popup_y = (screen_height - popup_height) / 2; // Center vertically

    // Draw semi-transparent overlay for the UI (optional but nicer)
    draw_rect(popup_x, popup_y, popup_width, popup_height, &color_bg);

    // Title
    const char *title = "Screen Locked";
    int title_x = popup_x + (popup_width - text_width(title, main_font)) / 2;
    draw_text(title_x, popup_y + 20, title, &color_text, main_font);

    // Input box
    int input_y = popup_y + 20 + FONT_SIZE + 20;
    draw_rect(popup_x + 20, input_y, popup_width - 40, FONT_SIZE + 12, &color_input_bg);

    // Prompt ("Password: ")
    const char *prompt = "Password: ";
    int prompt_x = popup_x + 28;
    draw_text(prompt_x, input_y + 6, prompt, &color_prompt, main_font);
    int prompt_w = text_width(prompt, main_font);

    // Password indicator (asterisks)
    char pass_indicator[MAX_PASSWORD_LEN + 1] = {0};
    memset(pass_indicator, '*', input_len);
    draw_text(prompt_x + prompt_w, input_y + 6, pass_indicator, &color_success, main_font);

    // Blinking cursor
    static double last_cursor_flip = 0;
    static bool cursor_visible = true;
    double now = (double)clock() / CLOCKS_PER_SEC;
    if (now - last_cursor_flip > 0.5)
    {
        cursor_visible = !cursor_visible;
        last_cursor_flip = now;
        redraw_needed = true;
    }
    if (cursor_visible)
    {
        char cursor_substr[MAX_PASSWORD_LEN];
        strncpy(cursor_substr, pass_indicator, cursor);
        cursor_substr[cursor] = '\0';
        int cursor_x = prompt_x + prompt_w + text_width(cursor_substr, main_font);
        draw_cursor(cursor_x, input_y + 6);
    }

    // Separator
    int separator_y = input_y + FONT_SIZE + 20;
    draw_rect(popup_x + 20, separator_y, popup_width - 40, 1, &color_separator);

    // Failed attempts
    if (failed_attempts > 0)
    {
        char fail_text[64];
        snprintf(fail_text, sizeof(fail_text), "Failed: %d/%d", failed_attempts, MAX_FAILED_ATTEMPTS);
        int fail_x = popup_x + (popup_width - text_width(fail_text, main_font)) / 2;
        draw_text(fail_x, separator_y + 15, fail_text, &color_error, main_font);

        if (failed_attempts >= MAX_FAILED_ATTEMPTS)
        {
            const char *block = "Temporarily Blocked";
            int block_x = popup_x + (popup_width - text_width(block, main_font)) / 2;
            draw_text(block_x, separator_y + 15 + FONT_SIZE, block, &color_error, main_font);
        }
    }

    // Help text (F1)
    if (show_help)
    {
        const char *help[] = {
            "ESC: Clear | Enter: Submit | F1: Hide Help",
            "Ctrl+A: Home | Ctrl+E: End | Ctrl+F/B: Left/Right",
            "Backspace: Delete | Ctrl+D: Delete Forward | Ctrl+K: Clear Rest"};
        int help_y = separator_y + 40;
        for (int i = 0; i < 3; i++)
        {
            int help_x = popup_x + (popup_width - text_width(help[i], hint_font)) / 2;
            draw_text(help_x, help_y + i * (HINT_FONT_SIZE + 10), help[i], &color_hint, hint_font);
        }
    }
    else
    {
        const char *hint = "Press F1 for help";
        int hint_x = popup_x + popup_width - 20 - text_width(hint, hint_font) - 5;
        draw_text(hint_x, popup_y + popup_height - 20 - HINT_FONT_SIZE, hint, &color_hint, hint_font);
    }

    // Swap buffers
    XCopyArea(dpy, backbuffer, win, gc, 0, 0, screen_width, screen_height, 0, 0);
    XFlush(dpy);
    redraw_needed = false;
}

// ================================================================================
// Cleanup (RELEASE GRABS)
// ================================================================================
static void cleanup()
{
    // Release input grabs
    XUngrabKeyboard(dpy, CurrentTime);
    XUngrabPointer(dpy, CurrentTime);

    // Securely clear password
    memset(password, 0, sizeof(password));

#ifdef __linux__
    munlock(password, sizeof(password));
#endif

    // Free X11 resources
    XftFontClose(dpy, main_font);
    XftFontClose(dpy, hint_font);

    XftColorFree(dpy, vis, cmap, &color_bg);
    XftColorFree(dpy, vis, cmap, &color_input_bg);
    XftColorFree(dpy, vis, cmap, &color_text);
    XftColorFree(dpy, vis, cmap, &color_prompt);
    XftColorFree(dpy, vis, cmap, &color_error);
    XftColorFree(dpy, vis, cmap, &color_success);
    XftColorFree(dpy, vis, cmap, &color_separator);
    XftColorFree(dpy, vis, cmap, &color_hint);

    XFreePixmap(dpy, backbuffer);
    XFreeGC(dpy, gc);
    XDestroyWindow(dpy, win);
    XCloseDisplay(dpy);
}

// ================================================================================
// Main
// ================================================================================
int main()
{
#ifdef __linux__
    if (mlock(password, sizeof(password)) != 0)
    {
        fprintf(stderr, "Warning: Could not lock password memory (run with sufficient privileges)\n");
    }
#endif

    if (!init_x11())
    {
        cleanup();
        return 1;
    }

    // Main loop
    struct timespec last_frame;
    clock_gettime(CLOCK_MONOTONIC, &last_frame);
    while (is_locked)
    {
        handle_events();
        render();

        // Throttle FPS
        struct timespec now;
        clock_gettime(CLOCK_MONOTONIC, &now);
        long elapsed = (now.tv_sec - last_frame.tv_sec) * 1000000 +
                       (now.tv_nsec - last_frame.tv_nsec) / 1000;
        if (elapsed < FRAME_TIME_US)
        {
            usleep(FRAME_TIME_US - elapsed);
        }
        last_frame = now;
    }

    cleanup();
    return 0;
}

build.sh

set -xe
gcc xlock.c -o xlock -lX11 -lXft -lpam `pkg-config --cflags --libs freetype2` -Wall -Wextra -Wno-deprecated-declarations -Wno-sign-compare
xfce休眠恢复后直接进入桌面的问题
oChapman的专栏
09-20 2072
在ubuntu8.04中安装xfce 4.4.2后，休眠恢复直接进入桌面，没有密码提示框。对休眠恢复过程不了解。搜索一下。来源：http://ubuntuforums.org/showpost.php?p=6938390&postcount=2解决方法：Just drop file 00custom-lock in /etc/pm/sleep.d/and set executabl
x11vnc ops
aristolto的专栏
03-09 5349
x11vnc: a VNC server for real X displaysHere are all of x11vnc command line options:% x11vnc -opts (see below for -help long descriptions) x11vnc: allow VNC connections to real X11 displays. 0.9...
在putty等远程命令行终端执行带有GUI图形界面的程序找不到$DISPLAY错误的解决办法，xserver相关
Jenny_yu1025的专栏
07-17 9773
一般在命令行执行需要界面的程序，一般都会报 display找不到，或者说你的￥DISPAY环境变量没置的错误。这时就要通过设置DISPLAY环境变量为一个存在的显示器，还有通过xhost/xauth来设置显示器的权项。（xhost是久的，一般推荐用xauth了吧，xauth的安全控制更好一些。） 情况1. [root@ ~]# /usr/lib/firefox-1.5.0.12/fire
comp.unix.aix faq -Part 2 of 5
q30的专栏
08-03 2791
Subject: 1.200: Some info about tape backupsFrom: Craig AndersonThe following supplements the information on rmt devices inInfoExplorer. It is based on my own personal experience with IBM tapedrives
Winlator XServer实现：Android上的X Window系统
gitblog_00703的博客
09-01 978
你是否曾经想过在Android设备上流畅运行Windows应用程序？传统的虚拟机方案资源消耗大、性能低下，而Winlator通过创新的X Server架构实现了这一看似不可能的任务。本文将深入解析Winlator如何将X Window系统移植到Android平台，为Windows应用提供原生级的运行体验。 通过阅读本文，你将获得： - X Server在Android上的完整实现架构 - 高性能...
.fvwm2rc
杀时间的专栏
11-06 1175
# this is a bare bones sample .fvwm2rc/system.fvwm2rc file for fvwm. # It should be customized before install. See other sample .fvwm2rc files # for hints, as well as pointers from the various links
Ubuntu系统常见问题整理（Part 2）
weixin_34233421的博客
06-07 204
23 ***文件名带空格的文件把文件名中间的空格加双引号。例: rm my"空格"file 进入或者执行文件名带空格文件的命令格式也一样 24 更改MAC地址00:1a:73:d7:3b:e2sudo ifconfig eth2 downsudo ifconfig eth2 hw ether XX:XX:XX:XX:XX:XXsudo ifconfig eth2 ...
OS + Linux RedHat / redhat 5 / redhat 6 / redhat 7
ayang1986的专栏
09-18 5930
转载: http://lindows.iteye.com/blog/456637 temp http://jzhua.iteye.com/blog/609293   http://rhel.ieesee.net/uingei/rhel-server-7.0-x86_64-dvd.iso http://download.downcc.com/bigfile/
linux etc xdg,Xdg-menu (简体中文)
weixin_34154352的博客
05-16 873
翻译状态：本文是 Xdg-menu 的翻译。上次翻译日期：2020-04-10。如果英文版本有所更改，则您可以帮助同步翻译。xdg-menu是一个为以下窗口管理器生成xdg桌面菜单的工具：KDE, Gnome, Xfce, Enlightenment已经与XDG兼容。安装菜单层次结构应用辅助功能配饰开发教育游戏图形互联网多媒体办公其他科学系统配置Xdg_menu依赖于三组信息来生成菜单：根菜单或换...
XLOCK.CPP
01-24
XLOCK.CPP是一个与C标准库源码紧密相关的文件，它的存在对于理解C语言底层操作与库函数的实现具有不可忽视的价值。XLOCK.CPP文件中通常包含了加密和安全相关功能的实现，比如在C标准库中与密码学和锁定机制相关的...
xlock和开发狗.zip
03-26
致远开发人员，本机都需要安装开发测试环境，苦于天天整客户服务器重启麻烦，为大家提供一个包可用的开发授权，7.0 8.0 各个版本都可以使用， 仅供学习交流，个人开发测试，严禁商业用途！
python开发的混淆加密软件xlock.exe
03-12
python开发的混淆加密软件， 允许用户通过改软件加密文档，并且有开放端口，加密数度快，每次加密随机码，不同，加解密码不同，可以添加加密算法，支持c重写
OD C卷 - 开源项目热度榜单
weixin_45228198的博客
09-07 201
自定义排序；
二叉树的前中后序遍历(迭代法)
最新发布
mrjieke6的博客
09-07 662
本文系统介绍了二叉树前序、中序和后序遍历的迭代实现方法。前序遍历采用栈结构，按;根→右→左 ;顺序入栈；中序遍历先全部左子树入栈再访问节点；后序遍历则通过修改前序遍历顺序为"根→右→左 ;后反转结果。三种遍历时间复杂度均为O(n)，空间复杂度最坏O(n)。与递归实现相比，迭代方法避免了栈溢出风险，处理大型树更稳定。每种遍历方式都配有详细代码解析、执行示例和复杂度分析，并讨论了实际应用场景，为掌握树结构操作提供了系统指导。
Java 和 Python 的执行方式有很大不同——Android学习
ban102055的博客
09-04 2569
特性PythonJava执行方式(解释执行)->(先编译后执行)是否需要编译否是环境需要 Python 解释器需要JDK(包含javac和java在Android Studio中不适用全自动，点击“Run”即可给你的建议：为了学习 Android 开发：直接使用。不要担心命令行，IDE 会帮你处理一切。专注于编写代码和理解 Android 的概念（如 Activity、生命周期）。为了单纯学习 Java 语法。
基于SpringBoot和uni-app开发的陪诊陪护软件系统源码
程序员创业中
09-06 1016
中国60岁以上人口已突破3.1亿，独居老人超1.3亿，而一线城市三甲医院日均门诊量超万人次。在这组数据背后，是无数家庭面临的困境：子女异地工作无法陪同父母就医，独居老人因不会操作智能设备在挂号机前徘徊，异地患者因不熟悉流程在医院迷路……当“就医”从个人事务演变为社会难题，陪诊陪护系统正以“专业服务+技术赋能”的双重模式，成为破解这一困局的关键。
Java 枚举通用接口设计与实现
sunnyday0426的博客
09-04 674
本文介绍了Java中枚举类型的通用接口设计方法。通过定义BaseEnumInterface接口，可以为枚举添加code和desc属性，并提供统一的静态操作方法，如根据code获取枚举实例、获取所有编码列表、验证编码有效性等。以GenderEnum为例，展示了枚举类如何实现该接口，并演示了通过接口提供的通用方法进行便捷操作。这种设计模式提高了代码复用性，使枚举操作更加规范统一。
Java内存区域与内存溢出
DKPT的博客
09-07 386
Java内存溢出的核心在于内存分配与回收失衡，需结合区域特性针对性解决。堆溢出最常见，需重点排查泄漏；方法区溢出多因动态类加载失控；直接内存溢出则需关注NIO使用。通过工具分析+代码优化+参数调优的组合策略，可显著降低OOM风险。二、内存溢出（OOM）类型与触发场景。三、内存溢出诊断与解决策略。一、Java内存区域划分。
第二章 Windows 核心概念通俗解析
YJlio的博客
09-03 1209
本文通俗解析了Windows核心概念，帮助理解Sysinternals工具背后的原理。主要内容包括：管理员权限与UAC机制、进程线程与作业的区别、用户模式与内核模式的切换、句柄的作用机制、应用隔离技术（MIC和App Container）、受保护进程特性、调用栈与符号的重要性，以及会话窗口机制和UIPI安全防护。通过生活化比喻和记忆口诀，将复杂的Windows内核原理转化为易于理解的知识点，为使用Sysinternals工具进行系统诊断提供理论基础。掌握这些核心概念能更准确地解读工具数据，快速定位系统问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值