自学教程：C++ FillConsoleOutputCharacter函数代码示例

int erase_to_eol( FILE* confp ){    CONSOLE_SCREEN_BUFFER_INFO  csbi;    HANDLE  hStdErr;    DWORD   dwCellsWritten;    COORD   ptConsole;    int     cons_fd;    if ( !confp )    {        errno = EINVAL;        return -1;    }    if ( ! _isatty( cons_fd = fileno( confp ) ) )    {        errno = EBADF;        return -1;    }    hStdErr = (HANDLE) _get_osfhandle( cons_fd );    ASSERT( hStdErr && INVALID_HANDLE_VALUE != hStdErr );    VERIFY( GetConsoleScreenBufferInfo( hStdErr, &csbi ) );    ptConsole = csbi.dwCursorPosition;    VERIFY( FillConsoleOutputAttribute( hStdErr, csbi.wAttributes, csbi.dwSize.X - ptConsole.X, ptConsole, &dwCellsWritten ) );    VERIFY( FillConsoleOutputCharacter( hStdErr,     ' ',          csbi.dwSize.X - ptConsole.X, ptConsole, &dwCellsWritten ) );    return 0;}

voidconsole_widget_NT_t::draw(){	if (console == NULL) {		COORD c = {0, 0};		DWORD z;		if (!FillConsoleOutputCharacter		    (buffer, blank.Char.AsciiChar, size.X * size.Y, c, &z))			co_debug("FillConsoleOutputCharacter() error 0x%lx",				 GetLastError());		if (!FillConsoleOutputAttribute		    (buffer, blank.Attributes, size.X * size.Y, c, &z))			co_debug("FillConsoleOutputAttribute() error 0x%lx",				 GetLastError());		return;	}	co_console_cell_t *cell = console->screen;	CHAR_INFO *ci = screen;	int count = size.X * size.Y;	do {		ci->Attributes = cell->attr;		(ci++)->Char.AsciiChar = (cell++)->ch;	} while (--count);	SMALL_RECT r = region;	COORD c = {0, 0};	if (!WriteConsoleOutput(buffer, screen, size, c, &r))		co_debug("WriteConsoleOutput() error 0x%lx", GetLastError());}

void clear_console(void){#if !defined WINCE  HANDLE Hand;  CONSOLE_SCREEN_BUFFER_INFO Info;  unsigned long Written;  static COORD Home = { 0, 0 };  Hand = GetStdHandle(STD_OUTPUT_HANDLE);  if (Hand == INVALID_HANDLE_VALUE)    return;  if(!GetConsoleScreenBufferInfo(Hand, &Info))    return;  if(!FillConsoleOutputCharacter(Hand, ' ',                                 Info.dwSize.X * Info.dwSize.Y, Home,                                 &Written))    return;  if(!FillConsoleOutputAttribute(Hand, Info.wAttributes,                                 Info.dwSize.X * Info.dwSize.Y, Home,                                 &Written))    return;  SetConsoleCursorPosition(Hand, Home);#endif}

void insline(){    int y=wherey() ;    HANDLE hScreen = GetStdHandle(STD_OUTPUT_HANDLE) ;    CONSOLE_SCREEN_BUFFER_INFO Info ;    GetConsoleScreenBufferInfo(hScreen, &Info) ;    {        COORD dwBufferSize={Info.dwSize.X, Info.dwSize.Y - y} ;        COORD dwBufferCoord={0,0} ;        COORD coord={0, y-1} ; // pour FillConsoleOutputCharacter        CHAR_INFO Buffer[dwBufferSize.Y][dwBufferSize.X] ;        DWORD dwWritten;        SMALL_RECT ReadRegion[2] ;        ReadRegion[0].Left = 0 ;        ReadRegion[0].Right = Info.dwSize.X-1 ;        ReadRegion[0].Top = y-1 ;        ReadRegion[0].Bottom = Info.dwSize.Y-2 ;            ReadConsoleOutput(hScreen, (CHAR_INFO*)Buffer, dwBufferSize, dwBufferCoord, ReadRegion) ;        ReadRegion[0].Top = y ;        ReadRegion[0].Bottom = Info.dwSize.Y-1 ;        WriteConsoleOutput(hScreen, (CHAR_INFO*)Buffer, dwBufferSize, dwBufferCoord, ReadRegion) ;        FillConsoleOutputCharacter (hScreen, ' ', Info.dwSize.X, coord, &dwWritten); // Effacer ligne        FillConsoleOutputAttribute (hScreen, Info.wAttributes, Info.dwSize.X, coord, &dwWritten);    }    }

// Initializes windows console.bool CSimWindow::InitWindow(){	// Set up console window	WORD wAttributes;	COORD pos;	SMALL_RECT consoleWindowDim;	CONSOLE_SCREEN_BUFFER_INFO bufferInfo;	unsigned long int temp;	// Get console handles	hSimOutput = GetStdHandle(STD_OUTPUT_HANDLE);	hSimInput = GetStdHandle(STD_INPUT_HANDLE);	if(hSimOutput == INVALID_HANDLE_VALUE  || hSimInput == INVALID_HANDLE_VALUE) {		printf("ERROR: Couldn't get console I/O handles./n");		return false;	}	// Save current console info	GetConsoleScreenBufferInfo(hSimOutput, &bufferInfo);	oldBufferSize = bufferInfo.dwSize;	oldWindowSize = bufferInfo.srWindow;	oldAttributes = bufferInfo.wAttributes;	// Set console title	SetConsoleTitle("Emu86 Simulator");	// Set console to small size for buffer change:	consoleWindowDim.Bottom = 0;	consoleWindowDim.Top = 0;	consoleWindowDim.Left = 0;	consoleWindowDim.Right = 0;	SetConsoleWindowInfo(hSimOutput, TRUE, &consoleWindowDim);	// Set buffer size	pos.X = SIM_CONSOLE_BUFFER_WIDTH;	pos.Y = SIM_CONSOLE_BUFFER_HEIGHT;	SetConsoleScreenBufferSize(hSimOutput, pos);	// Set console size	consoleWindowDim.Bottom = SIM_CONSOLE_HEIGHT - 1;	consoleWindowDim.Top = 0;	consoleWindowDim.Left = 0;	consoleWindowDim.Right = SIM_CONSOLE_WIDTH - 1;	SetConsoleWindowInfo(hSimOutput, TRUE, &consoleWindowDim);	// Clear console, set to black, white text	pos.X = 0;	pos.Y = 0;	wAttributes = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;	FillConsoleOutputAttribute(hSimOutput, wAttributes, SIM_CONSOLE_BUFFER_WIDTH * SIM_CONSOLE_BUFFER_HEIGHT, pos, &temp);	FillConsoleOutputCharacter(hSimOutput, ' ', SIM_CONSOLE_BUFFER_WIDTH * SIM_CONSOLE_BUFFER_HEIGHT, pos, &temp);	// Move curor to top left	SetConsoleCursorPosition(hSimOutput, pos);	return true;}

void RefreshScreen(void){    DWORD    dummy;    COORD    Home = {0, 0};    FillConsoleOutputCharacter(hConsoleOut, ' ',       csbiInfo.dwSize.X * csbiInfo.dwSize.Y,       Home, &dummy);}

void mp_hal_erase_line_from_cursor(uint n_chars_to_erase) {    assure_conout_handle();    CONSOLE_SCREEN_BUFFER_INFO info;    GetConsoleScreenBufferInfo(con_out, &info);    DWORD written;    FillConsoleOutputCharacter(con_out, ' ', n_chars_to_erase, info.dwCursorPosition, &written);    FillConsoleOutputAttribute(con_out, info.wAttributes, n_chars_to_erase, info.dwCursorPosition, &written);}

JNIEXPORT void JNICALL Java_com_yifanlu_Josh_Josh_FILLCONSOLEOUTPUTCHARACTER  (JNIEnv *env, jclass jcls, jlong pointer, jchar character, jint length, jint x, jint y){    HANDLE hConsole = pointerToHandle(pointer);	COORD location = { x , y };	FillConsoleOutputCharacter(hConsole, character, length, location, NULL);}	

int main(int argc, char *argv[]){  HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);  CONSOLE_SCREEN_BUFFER_INFO bInfo;  GetConsoleScreenBufferInfo(hOut, &bInfo);  COORD pos = {0, 0};  FillConsoleOutputCharacter(hOut, '@', bInfo.dwSize.X / 2 * bInfo.dwSize.Y, pos, NULL);  CloseHandle(hOut);}

void mp_hal_erase_line_from_cursor() {    assure_conout_handle();    CONSOLE_SCREEN_BUFFER_INFO info;    GetConsoleScreenBufferInfo(con_out, &info);    const short len = info.dwSize.X - info.dwCursorPosition.X;    DWORD written;    FillConsoleOutputCharacter(con_out, ' ', len, info.dwCursorPosition, &written);    FillConsoleOutputAttribute(con_out, info.wAttributes, len, info.dwCursorPosition, &written);}

void Graphics::clearScreen(){	DWORD d;	CONSOLE_SCREEN_BUFFER_INFO csbi;	GetConsoleScreenBufferInfo(_console, &csbi);	auto size = csbi.dwSize.X * csbi.dwSize.Y;	FillConsoleOutputAttribute(_console, csbi.wAttributes, size, { 0, 0 }, &d);	FillConsoleOutputCharacter(_console, L' ', size, { 0, 0 }, &d);}

void Console::Clear(void) const{	ScreenBufferInfo	info(*this);		// Screen buffer information	DWORD				result;				// Result from fill operation	// Fill the console with space characters using the current attibutes; move cursor to 0,0 afterwards	if(!FillConsoleOutputCharacter(m_stdout, _T(' '), info.dwSize.X * info.dwSize.Y, { 0, 0 }, &result)) throw Win32Exception();	if(!FillConsoleOutputAttribute(m_stdout, info.wAttributes, info.dwSize.X * info.dwSize.Y, { 0, 0 }, &result)) throw Win32Exception();	if(!SetConsoleCursorPosition(m_stdout, { 0, 0 })) throw Win32Exception();}

static void eraseEol(struct current *current){    COORD pos;    DWORD n;    pos.X = (SHORT) current->x;    pos.Y = (SHORT) current->y;    FillConsoleOutputCharacter(current->outh, ' ', current->cols - current->x, pos, &n);}

void clib::cls(){    _COORD st;    unsigned long bw;    st.X = 0;    st.Y = 0;    FillConsoleOutputAttribute(screen_,fgc_|bgc_,80*50,st,&bw);    FillConsoleOutputCharacter(screen_,32,80*50,st,&bw);    SetConsoleCursorPosition(screen_,st);}

void ClearLine(void) {	CONSOLE_SCREEN_BUFFER_INFO s;	HANDLE out = GetTermInfo(&s);	COORD pos = { 0, s.dwCursorPosition.Y };	DWORD n;	FillConsoleOutputCharacter(out, ' ', s.dwSize.X, pos, (LPDWORD)(&n));	SetConsoleCursorPosition(out, pos);}

/*	Cleans the screen with the given start point and len.	*/VOID ClsXYXCount(INT x,INT y,INT Width,INT Count){	INT i;	DWORD cCharsWritten;	//	Start point of cleaning the screen.    COORD coordScreen = {x,y};    //	Filling the given position with blanks.	for(i=0;i < Count;i++){		FillConsoleOutputCharacter( hConsole, (WCHAR) ' ',(Width), coordScreen, &cCharsWritten );		++coordScreen.Y;	}}

static void clearScreen(struct current *current) {    COORD topleft = {0, 0};    DWORD n;    FillConsoleOutputCharacter(current->outh, ' ',            current->cols * current->rows, topleft, &n);    FillConsoleOutputAttribute(current->outh,            FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN,            current->cols * current->rows, topleft, &n);    SetConsoleCursorPosition(current->outh, topleft);}

void Screen::fillChar (int x, int y, int c, int count){    DWORD charsWritten;    if (count <= 0)	throw AppException (WHERE, ERR_INTERNAL);    COORD coord;    coord.X = (SHORT) x;    coord.Y = (SHORT) y;    if (FillConsoleOutputCharacter (mScreenBuf, c, count, coord, &charsWritten) != TRUE)	throw AppException (WHERE, ERR_WINDOWS_FMT, "FillConsoleOutputCharacter", GetLastError ());}

void clrscr() {	HANDLE hConsole = GetStdHandle( STD_OUTPUT_HANDLE );	COORD coordScreen = { 0, 0 };	CONSOLE_SCREEN_BUFFER_INFO csbi;	GetConsoleScreenBufferInfo( hConsole, &csbi );	DWORD dwConSize = csbi.dwSize.X * csbi.dwSize.Y;	DWORD cCharsWritten;	FillConsoleOutputCharacter( hConsole, (TCHAR) ' ', dwConSize, coordScreen, &cCharsWritten );	GetConsoleScreenBufferInfo( hConsole, &csbi );	FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten );	SetConsoleCursorPosition( hConsole, coordScreen );}

voidClearScreen (void){    COORD coordOrg = {0, 0};    DWORD dwWritten = 0;    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);    if (INVALID_HANDLE_VALUE != hConsole)        FillConsoleOutputCharacter(hConsole, ' ', 80 * 50, coordOrg, &dwWritten);    MoveCursor(0, 0);    return;}

void clearScreen(){    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);    CONSOLE_SCREEN_BUFFER_INFO csbi;    GetConsoleScreenBufferInfo(hConsole, &csbi);    DWORD dwConSize = csbi.dwSize.X * csbi.dwSize.Y;    COORD upperLeft = { 0, 0 };    DWORD dwCharsWritten;    FillConsoleOutputCharacter(hConsole, TCHAR(' '), dwConSize, upperLeft,							   &dwCharsWritten);    SetConsoleCursorPosition(hConsole, upperLeft);}

// clear the console windowvoid Clear(HANDLE hOut){	CONSOLE_SCREEN_BUFFER_INFO bufInfo;	static COORD const zero = { 0, 0 };	DWORD written;	DWORD size;	GetConsoleScreenBufferInfo(hOut, &bufInfo);	size = bufInfo.dwSize.X * bufInfo.dwSize.Y;	FillConsoleOutputCharacter(hOut, 0, size, zero, &written);	FillConsoleOutputAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE, size, zero, &written);	SetConsoleCursorPosition(hOut, zero);}

NTSTATUS kuhl_m_standard_cls(int argc, wchar_t * argv[]){	HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);	COORD coord = {0, 0};	DWORD count;	CONSOLE_SCREEN_BUFFER_INFO csbi;	GetConsoleScreenBufferInfo(hStdOut, &csbi);	FillConsoleOutputCharacter(hStdOut, L' ', csbi.dwSize.X * csbi.dwSize.Y, coord, &count);	SetConsoleCursorPosition(hStdOut, coord);	return STATUS_SUCCESS;}

// draw the field// argument - width and height of the field// resizes console window for no reason// prints instructions how to interactvoid drawTable(COORD size){	DWORD cWritten;	HANDLE con = GetStdHandle(STD_OUTPUT_HANDLE);	CONSOLE_CURSOR_INFO     cursorInfo;	GetConsoleCursorInfo(con, &cursorInfo);	cursorInfo.bVisible = false;	SetConsoleCursorInfo(con, &cursorInfo);		HWND console = GetConsoleWindow();	RECT r;	GetWindowRect(console, &r);	MoveWindow(console, r.left, r.top, 800, 480, TRUE);	FillConsoleOutputCharacter(con, '+', 1, { 0, 3 }, &cWritten);	FillConsoleOutputCharacter(con, '+', 1, { size.X, 3 }, &cWritten);	FillConsoleOutputCharacter(con, '-', size.X - 1, { 1, 3 }, &cWritten);	FillConsoleOutputCharacter(con, '_', 4, { 3, 1 }, &cWritten);	for (int i = 0; i < size.Y; ++i)	{		if (i != 3)		{			FillConsoleOutputCharacter(con, '|', 1, { 0, i }, &cWritten);			FillConsoleOutputCharacter(con, '|', 1, { size.X, i }, &cWritten);		}	}	print({size.X + 2, 1}, "COWS AND BULLS");	print({size.X + 2, 3}, "0-9 - add digit");	print({size.X + 2, 4}, "Backspace - remove last digit");	print({size.X + 2, 5}, "Enter - confirm");	print({size.X + 2, 6}, "Esc - quit");}

// Erases everything from the cursor position to the endbool Console::eraseFromCursorToEnd(void){	cout.flush();	findCursorPos();	DWORD numCharactersWritten;	COORD consoleCoords = {xPos, yPos};	FillConsoleOutputCharacter(consoleHandle, ' ', (25 - yPos) * 80 + (80 - xPos), consoleCoords, &numCharactersWritten);	FillConsoleOutputAttribute(consoleHandle, consoleInfo.wAttributes, (25 - yPos) * 80 + (80 - xPos), consoleCoords, &numCharactersWritten);	setCursorPos(xPos, yPos);	cout.flush();		return true;}

static void clrscr_impl(CPCHANDLE handle){    CONSOLE_SCREEN_BUFFER_INFO csbi;    BOOL bOK = GetConsoleScreenBufferInfo(handle->impl->hConOut, &csbi);    if (bOK)    {        const COORD coordScreen = {0, 0}; /* location to start the attribute fill */        DWORD dw = 0;        bOK = SetConsoleCursorPosition(handle->impl->hConOut, coordScreen);        FillConsoleOutputCharacter(handle->impl->hConOut, ' ', csbi.dwSize.X * csbi.dwSize.Y, coordScreen, &dw);        SetConsoleCursorPosition(handle->impl->hConOut, coordScreen);    }}

void clrscr(){	HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);	COORD coord = {0, 0};	DWORD count;	CONSOLE_SCREEN_BUFFER_INFO csbi;	GetConsoleScreenBufferInfo(hStdOut, &csbi);	FillConsoleOutputCharacter(hStdOut, ' ', csbi.dwSize.X * csbi.dwSize.Y, coord, &count);	SetConsoleCursorPosition(hStdOut, coord);}

/*--------------------------------------------------------------------------*/void clrscr_nw(void){	COORD coord;	DWORD written;	CONSOLE_SCREEN_BUFFER_INFO info;	coord.X = 0;	coord.Y = 0;	GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);	FillConsoleOutputCharacter (GetStdHandle(STD_OUTPUT_HANDLE), ' ',		info.dwSize.X * info.dwSize.Y, coord, &written);	TermSetPosition(0, 0);}

// clear console screenvoid ClearScreen() {	COORD coordScreen = { 0, 0 };	DWORD cCharsWritten;	CONSOLE_SCREEN_BUFFER_INFO csbi;	DWORD dwConSize;	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);	GetConsoleScreenBufferInfo(hConsole, &csbi);	dwConSize = csbi.dwSize.X * csbi.dwSize.Y;	FillConsoleOutputCharacter(hConsole, TEXT(' '), dwConSize, coordScreen, &cCharsWritten);	GetConsoleScreenBufferInfo(hConsole, &csbi);	FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten);	SetConsoleCursorPosition(hConsole, coordScreen);}

static void sdEraseEOL( void ){	if( GetConsoleScreenBufferInfo( sConsoleHandle, &sScreenInfo ) )	{		COORD savedXY;		int numNeeded;		DWORD count;		savedXY.X = sScreenInfo.dwCursorPosition.X;		savedXY.Y = sScreenInfo.dwCursorPosition.Y;		numNeeded = sScreenInfo.dwSize.X - savedXY.X;		FillConsoleOutputCharacter(			sConsoleHandle, ' ', numNeeded, savedXY, &count );	}}