[C] Text an eine beliebige Position schreiben

Mainzl0r

Cadet 3rd Year
Registriert
Nov. 2003
Beiträge
47
Also ich muss mit C ein Programm schreiben und will nun einen text an einer beliebige Stelle schreiben können.
In C++ gibt es ne funktion, die das kann.. aber die funktioniert ja in C nicht.

Wäre schön, wenn mir da wer helfen kann!

mfg
Mainzl0r
 
Ich will dir die Aufgabe nicht lösen - aber hier ein tipp:
substring von 0 bis X + belieber Text + substring von X bis anzahl zeichen im string
 
Definiere "Text an einer beliebigen Stelle schreiben können". Meinst du die Ausgabe auf dem Bildschirm?

Wenn ja - das geht mit reinem C / C++ garnicht. Du musst uns verraten unter welchem Betriebssystem du arbeitest und dann eine entsprechende Funktion selbigens aufrufen. Ich vermute mal, Windows mit Konsole?
 
Ja es geht um Windows XP und Konsole!
Und es soll in der Konsole an eine belibige Position vom Programm her eine Textausgabe erfolgen.

Mit dem substring bin ich noch nicht weitergekommen.

mfg Mainzl0r

edit: Mit c++ geht das!!!
und zwar mit folgender Funktion:
Code:
 void Funktionen::gotoxy(int x,int y)
	{
	static HANDLE hStdout;
	COORD dwCursorPos={x,y};
	hStdout=GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleCursorPosition(hStdout, dwCursorPos);
	}

Aber eben diese Funktion geht in C nicht
 
Zuletzt bearbeitet:
Wenn man in der Online Hilfe die Funktion SetConsoleCursorPosition eingibt kommt folgendes Beispielprogramm. Und das ist C.
Ausserdem ist das doch eine Win32 API Funktion, warum sollte die also in C nicht gehen?

MfG

Arnd

Code:
#include <windows.h> 
 
void NewLine(void); 
void ScrollScreenBuffer(HANDLE, INT); 
 
HANDLE hStdout, hStdin; 
CONSOLE_SCREEN_BUFFER_INFO csbiInfo; 
 
void main(void) 
{ 
    LPSTR lpszPrompt1 = "Type a line and press Enter, or q to quit: ";
    LPSTR lpszPrompt2 = "Type any key, or q to quit: ";
    CHAR chBuffer[256]; 
    DWORD cRead, cWritten, fdwMode, fdwOldMode; 
    WORD wOldColorAttrs; 

    // Get handles to STDIN and STDOUT. 

    hStdin = GetStdHandle(STD_INPUT_HANDLE); 
    hStdout = GetStdHandle(STD_OUTPUT_HANDLE); 
    if (hStdin == INVALID_HANDLE_VALUE || hStdout == INVALID_HANDLE_VALUE) 
    {
        MessageBox(NULL, "GetStdHandle", "Console Error", MB_OK);
        return;
    }

    // Save the current text colors. 

    if (! GetConsoleScreenBufferInfo(hStdout, &csbiInfo)) 
    {
        MessageBox(NULL, "GetConsoleScreenBufferInfo", "Console Error", MB_OK); 
        return;
    }

    wOldColorAttrs = csbiInfo.wAttributes; 

    // Set the text attributes to draw red text on black background. 

    if (! SetConsoleTextAttribute(hStdout, FOREGROUND_RED|FOREGROUND_INTENSITY))
    {
        MessageBox(NULL, "SetConsoleTextAttribute", "Console Error", MB_OK);
        return;
    }

    // Write to STDOUT and read from STDIN by using the default 
    // modes. Input is echoed automatically, and ReadFile 
    // does not return until a carriage return is typed. 
    // 
    // The default input modes are line, processed, and echo. 
    // The default output modes are processed and wrap at EOL. 

    while (1) 
    { 
        if (! WriteFile( 
            hStdout,              // output handle 
            lpszPrompt1,          // prompt string 
            lstrlen(lpszPrompt1), // string length 
            &cWritten,            // bytes written 
            NULL) )               // not overlapped 
        {
            MessageBox(NULL, "WriteFile", "Console Error", MB_OK); 
            return;
        }

        if (! ReadFile( 
            hStdin,    // input handle 
            chBuffer,  // buffer to read into 
            255,       // size of buffer 
            &cRead,    // actual bytes read 
            NULL) )    // not overlapped 
        break; 
        if (chBuffer[0] == 'q') break; 
    } 

    // Turn off the line input mode, and echo the input mode. 

    if (! GetConsoleMode(hStdin, &fdwOldMode)) 
    {
        MessageBox(NULL, "GetConsoleMode", "Console Error", MB_OK); 
        return;
    }

    fdwMode = fdwOldMode & 
        ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT); 
    if (! SetConsoleMode(hStdin, fdwMode)) 
    {
        MessageBox(NULL, "SetConsoleMode", "Console Error", MB_OK); 
        return;
    }

    // Without line and echo input modes, ReadFile returns 
    // when any input is available. Carriage returns must 
    // be handled, and WriteFile is used to echo input. 

    NewLine();

    while (1) 
    { 
        if (! WriteFile( 
            hStdout,              // output handle 
            lpszPrompt2,          // prompt string 
            lstrlen(lpszPrompt2), // string length 
            &cWritten,            // bytes written 
            NULL) )               // not overlapped 
        {
            MessageBox(NULL, "WriteFile", "Console Error", MB_OK);
            return;
        }

        if (! ReadFile(hStdin, chBuffer, 1, &cRead, NULL)) 
            break; 
        if (chBuffer[0] == '\r')
            NewLine();
        else if (! WriteFile(hStdout, chBuffer, cRead, 
            &cWritten, NULL)) break;
        else
            NewLine();
        if (chBuffer[0] == 'q') break; 
    } 

    // Restore the original console mode. 

    SetConsoleMode(hStdin, fdwOldMode);

    // Restore the original text colors. 

    SetConsoleTextAttribute(hStdout, wOldColorAttrs);
}

// The NewLine function handles carriage returns when the processed 
// input mode is disabled. It gets the current cursor position 
// and resets it to the first cell of the next row. 
 
void NewLine(void) 
{ 
    if (! GetConsoleScreenBufferInfo(hStdout, &csbiInfo)) 
    {
        MessageBox(NULL, "GetConsoleScreenBufferInfo", "Console Error", MB_OK); 
        return;
    }

    csbiInfo.dwCursorPosition.X = 0; 

    // If it is the last line in the screen buffer, scroll 
    // the buffer up. 

    if ((csbiInfo.dwSize.Y-1) == csbiInfo.dwCursorPosition.Y) 
    { 
        ScrollScreenBuffer(hStdout, 1); 
    } 

    // Otherwise, advance the cursor to the next line. 

    else csbiInfo.dwCursorPosition.Y += 1; 
 
    if (! SetConsoleCursorPosition(hStdout, 
        csbiInfo.dwCursorPosition)) 
    {
        MessageBox(NULL, "SetConsoleCursorPosition", "Console Error", MB_OK); 
        return;
    }
} 

void ScrollScreenBuffer(HANDLE h, INT x)
{
    SMALL_RECT srctScrollRect, srctClipRect;
    CHAR_INFO chiFill;
    COORD coordDest;

    srctScrollRect.Left = 0;
    srctScrollRect.Top = 1;
    srctScrollRect.Right = csbiInfo.dwSize.X - x; 
    srctScrollRect.Bottom = csbiInfo.dwSize.Y - x; 
 
    // The destination for the scroll rectangle is one row up. 
 
    coordDest.X = 0; 
    coordDest.Y = 0; 
 
    // The clipping rectangle is the same as the scrolling rectangle. 
    // The destination row is left unchanged. 
 
    srctClipRect = srctScrollRect; 
 
    // Set the fill character and attributes. 
 
    chiFill.Attributes = FOREGROUND_RED|FOREGROUND_INTENSITY; 
    chiFill.Char.AsciiChar = ' '; 
 
    // Scroll up one line. 
 
    ScrollConsoleScreenBuffer( 
        h,               // screen buffer handle 
        &srctScrollRect, // scrolling rectangle 
        &srctClipRect,   // clipping rectangle 
        coordDest,       // top left destination cell 
        &chiFill);       // fill character and color 
}
 
Zuletzt bearbeitet:
Zurück
Oben