Rust开发Windows控制台：如何用WinAPI/Kernel32阻止光标自动移动？

Absolutely! You can stop the console cursor from shifting right after printing characters by leveraging WinAPI functions—no default behavior is set in stone here. Let’s walk through two reliable approaches tailored for your Rust Windows console app:

Approach 1: Save and Restore Cursor Position #

This method is straightforward: capture the cursor’s position before outputting, print your character, then immediately reset the cursor back to its original spot.

Rust Code Example #

First, add the winapi crate to your Cargo.toml (enable the necessary features):

[dependencies]
winapi = { version = "0.3", features = ["consoleapi", "winbase", "wincon"] }

Then implement the logic:

use winapi::um::{
    consoleapi::GetConsoleScreenBufferInfo,
    winbase::GetStdHandle,
    wincon::{CONSOLE_SCREEN_BUFFER_INFO, COORD, STD_OUTPUT_HANDLE},
};
use std::ptr;

fn main() {
    // Get handle to standard output
    let stdout_handle = unsafe { GetStdHandle(STD_OUTPUT_HANDLE) };
    assert!(!stdout_handle.is_null(), "Failed to get stdout handle");

    // Capture current cursor position
    let mut csbi: CONSOLE_SCREEN_BUFFER_INFO = unsafe { std::mem::zeroed() };
    let success = unsafe { GetConsoleScreenBufferInfo(stdout_handle, &mut csbi) };
    assert!(success != 0, "Failed to read console buffer info");
    let original_pos = csbi.dwCursorPosition;

    // Print character (would normally move cursor)
    print!("@");

    // Reset cursor back to original coordinates
    let success = unsafe { winapi::um::wincon::SetConsoleCursorPosition(stdout_handle, original_pos) };
    assert!(success != 0, "Failed to reset cursor position");

    // Keep console open to test
    std::io::stdin().read_line(&mut String::new()).unwrap();
}

Approach 2: Directly Write to Console Buffer (No Cursor Movement) #

For a cleaner, more efficient solution, use WriteConsoleOutput to write your character directly to the desired screen buffer coordinate. This method doesn’t touch the cursor at all—it just updates the display, leaving the cursor exactly where it was.

Rust Code Example #

Using the same winapi crate setup:

use winapi::um::{
    winbase::GetStdHandle,
    wincon::{CHAR_INFO, COORD, SMALL_RECT, STD_OUTPUT_HANDLE, WriteConsoleOutputW},
};
use std::ptr;

fn main() {
    let stdout_handle = unsafe { GetStdHandle(STD_OUTPUT_HANDLE) };
    assert!(!stdout_handle.is_null(), "Failed to get stdout handle");

    // Target position (X=4, Y=4)
    let target_pos = COORD { X: 4, Y: 4 };

    // Define the character to write (Unicode '@') with default attributes
    let mut char_info = CHAR_INFO {
        UnicodeChar: '@' as u16,
        Attributes: 0x07, // White text on black background
    };

    // Define a 1x1 write region matching the target position
    let write_region = SMALL_RECT {
        Left: target_pos.X,
        Top: target_pos.Y,
        Right: target_pos.X,
        Bottom: target_pos.Y,
    };

    // Write directly to the console buffer
    let mut chars_written: u32 = 0;
    let success = unsafe {
        WriteConsoleOutputW(
            stdout_handle,
            &mut char_info,
            COORD { X: 1, Y: 1 }, // Size of the character buffer (1x1)
            COORD { X: 0, Y: 0 }, // Offset within the character buffer
            &mut write_region,
        )
    };
    assert!(success != 0, "Failed to write to console buffer");

    // Cursor remains at (4,4) unless manually adjusted
    std::io::stdin().read_line(&mut String::new()).unwrap();
}

Which Approach to Choose? #

• Approach 1 is great for quick modifications to existing code where you’re already using standard print functions. The only downside is a tiny potential cursor flicker (barely noticeable in most cases).
• Approach 2 is the better choice for performance-critical apps or when you want full control over the display without touching the cursor state at all. It’s completely flicker-free.

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